max_diff - min_diff:\\n return [max_sum_index,min_sum_index,max_sum - min_sum ]\\n else:\\n return [max_diff_index,min_diff_index,max_diff - min_diff]\\n \\n \\n def minimumDistance(self, points: List[List[int]]) -> int:\\n listy = self.maxmanhattendist(points)\\n t = points[listy[0]]\\n points.pop(listy[0])\\n d = self.maxmanhattendist(points)\\n points.insert(listy[0], t)\\n \\n points.pop(listy[1])\\n d1 = self.maxmanhattendist(points)\\n if d[2] > d1[2]:\\n return d1[2]\\n else:\\n return d[2]\",\n \"runtime\": \"1184\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n\\n def get_embs(points):\\n emb1,emb2 = [],[]\\n for i, pt in enumerate(points):\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n return emb1, emb2\\n\\n def process_embs(emb1, emb2):\\n\\n def find_max_dst(emb):\\n min_val, max_val = min(emb), max(emb)\\n return max_val-min_val, (emb.index(min_val), emb.index(max_val))\\n\\n dst1, minmax_idxs1 = find_max_dst(emb1)\\n dst2, minmax_idxs2 = find_max_dst(emb2)\\n\\n if dst1>dst2:\\n return dst1, minmax_idxs1\\n else:\\n return dst2, minmax_idxs2\\n\\n emb1,emb2 = get_embs(points)\\n _, exclude = process_embs(emb1, emb2) \\n\\n maxdst0, _ = process_embs(emb1[:exclude[0]]+emb1[exclude[0]+1:], \\n emb2[:exclude[0]]+emb2[exclude[0]+1:])\\n\\n maxdst1, _ = process_embs(emb1[:exclude[1]]+emb1[exclude[1]+1:], \\n emb2[:exclude[1]]+emb2[exclude[1]+1:])\\n \\n return min(maxdst0 , maxdst1)\\n \",\n \"runtime\": \"1184\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n # Step 1: Compute the transformed coordinates u = x + y and v = x - y\\n u = [x + y for x, y in points]\\n v = [x - y for x, y in points]\\n \\n # Step 2: Find the min and max of u and v\\n u_min, u_max = min(u), max(u)\\n v_min, v_max = min(v), max(v)\\n \\n # Step 3: Find the indices of points that define these min/max values\\n u_min_idx, u_max_idx = u.index(u_min), u.index(u_max)\\n v_min_idx, v_max_idx = v.index(v_min), v.index(v_max)\\n \\n # Step 4: Calculate the maximum distances in u and v\\n def max_distance_without_point(skip_idx):\\n u_list = [u[i] for i in range(n) if i != skip_idx]\\n v_list = [v[i] for i in range(n) if i != skip_idx]\\n max_u_dist = max(u_list) - min(u_list)\\n max_v_dist = max(v_list) - min(v_list)\\n return max(max_u_dist, max_v_dist)\\n \\n # Step 5: Try removing the points that define the extremes in u and v\\n candidates = {u_min_idx, u_max_idx, v_min_idx, v_max_idx}\\n result = float('inf')\\n \\n for idx in candidates:\\n result = min(result, max_distance_without_point(idx))\\n \\n return result\",\n \"runtime\": \"1205\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n \\n def find_max(dsts):\\n if dsts[0]>dsts[1]:\\n return 0, dsts[0]\\n else:\\n return 1, dsts[1]\\n\\n dsts, extrems=get_embs(points)\\n if dsts[0]>dsts[1]:\\n exclude=extrems[0]\\n else:\\n exclude=extrems[1] \\n\\n ans=10**10\\n for idx in exclude:\\n dsts,_=get_embs(points, idx)\\n maxval=max(dsts)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"runtime\": \"1205\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n\\n def find_max_dst(emb):\\n min_val=min(emb)\\n max_val=max(emb)\\n return max_val-min_val, (emb.index(min_val), emb.index(max_val))\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find_max_dst(emb1)\\n dst2,extrem_idx2=find_max_dst(emb2)\\n\\n if dst1>dst2:\\n return dst1, extrem_idx1\\n else:\\n return dst2, extrem_idx2\\n\\n _, exclude=get_embs(points) \\n\\n maxdst0,_=get_embs(points, exclude[0])\\n maxdst1,_=get_embs(points, exclude[1])\\n \\n return min(maxdst0,maxdst1)\\n \",\n \"runtime\": \"1226\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n\\n def find(emb):\\n min_val=min(emb)\\n max_val=max(emb)\\n return max_val-min_val, set([emb.index(min_val), emb.index(max_val)])\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n if dst1>dst2:\\n return dst1, extrem_idx1\\n else:\\n return dst2, extrem_idx2\\n\\n _, exclude=get_embs(points) \\n\\n ans=10**10\\n for idx in exclude:\\n maxval,_=get_embs(points, idx)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"runtime\": \"1226\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n # build a point index list \\n pt_indices = [None, None, None, None]\\n # rather than deal with the time sink that is abs which leads to N^2 comparisons\\n # flatten your work into sets of min and max internal sums and differences of point coordinates\\n # keep the extrema and secondary extrama points for each \\n min_int_sums = [float('inf'), float('inf')]\\n min_int_diff = [float('inf'), float('inf')]\\n max_int_sums = [float('-inf'), float('-inf')]\\n max_int_diff = [float('-inf'), float('-inf')]\\n # and record your answer \\n answer = float('inf')\\n # enumerate your points \\n for point_index, point in enumerate(points): \\n # and for each point, get the internal sum and difference of the points\\n # this is because manhattan distance can be rewritten as \\n # the difference of the internal sum or difference of the points coordinates\\n point_sum = point[0] + point[1]\\n point_diff = point[0] - point[1]\\n # build a calculation map \\n calc_map_0 = [point_sum, min_int_sums, 'lt', 0]\\n calc_map_1 = [point_sum, max_int_sums, 'gt', 1]\\n calc_map_2 = [point_diff, min_int_diff, 'lt', 2]\\n calc_map_3 = [point_diff, max_int_diff, 'gt', 3]\\n # make a map of maps to lessen your writing \\n calc_maps = [calc_map_0, calc_map_1, calc_map_2, calc_map_3]\\n # for each map in the calculated map \\n for calc_map in calc_maps: \\n # get the value, the target, the comparator, and the pt_index_current associated\\n value = calc_map[0]\\n target = calc_map[1]\\n comparator_choice = calc_map[2]\\n pt_index_current = calc_map[3]\\n # based on that, conduct extrema matching as needed and record where needed \\n if comparator_choice == 'lt': \\n if value < target[0]: \\n pt_indices[pt_index_current] = point_index\\n target[1] = target[0]\\n target[0] = value \\n elif value < target[1]:\\n target[1] = value\\n else: \\n continue \\n else: \\n if value > target[0]: \\n pt_indices[pt_index_current] = point_index \\n target[1] = target[0]\\n target[0] = value\\n elif value > target[1]: \\n target[1] = value \\n else: \\n continue \\n\\n # when done with the above, loop over the point indices that you have gathered \\n for pt_index in pt_indices: \\n # since a point index may repeat, if it has repeated, you need to check for that \\n # on matches, you cannot use the extrema, but only the secondary\\n # why this is comes from a basis on euclidean geometry, related to computer graphics\\n min_int_sum_val = min_int_sums[1] if pt_index == pt_indices[0] else min_int_sums[0]\\n max_int_sum_val = max_int_sums[1] if pt_index == pt_indices[1] else max_int_sums[0]\\n min_int_dif_val = min_int_diff[1] if pt_index == pt_indices[2] else min_int_diff[0]\\n max_int_dif_val = max_int_diff[1] if pt_index == pt_indices[3] else max_int_diff[0]\\n # when done, you can find the answer as the min of self and max of two options, the minimax\\n answer = min(answer, max(max_int_sum_val - min_int_sum_val, max_int_dif_val - min_int_dif_val))\\n\\n # return answer when completed processing \\n return answer \\n \",\n \"runtime\": \"1247\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude={}):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i not in exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n \\n def find_max(dsts):\\n if dsts[0]>dsts[1]:\\n return 0, dsts[0]\\n else:\\n return 1, dsts[1]\\n\\n dsts, extrems=get_embs(points)\\n maxi, maxval=find_max(dsts)\\n exclude=extrems[maxi]\\n\\n ans=10**10\\n for idx in list(exclude):\\n dsts,_=get_embs(points, set([idx]))\\n maxi, maxval=find_max(dsts)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"runtime\": \"1247\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n\\n dsts, extrems=get_embs(points)\\n if dsts[0]>dsts[1]:\\n exclude=extrems[0]\\n else:\\n exclude=extrems[1] \\n\\n ans=10**10\\n for idx in exclude:\\n dsts,_=get_embs(points, idx)\\n maxval=max(dsts)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"runtime\": \"1268\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n\\n dsts, extrems=get_embs(points)\\n if dsts[0]>dsts[1]:\\n exclude=extrems[0]\\n else:\\n exclude=extrems[1] \\n\\n ans=10**10\\n for idx in exclude:\\n dsts,_=get_embs(points, idx)\\n maxval=max(dsts)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"runtime\": \"1268\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude={}):\\n emb1,emb2,emb3,emb4=[],[],[],[]\\n for i, pt in enumerate(points):\\n if i not in exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n \\n def find_max(dsts):\\n if dsts[0]>dsts[1]:\\n return 0, dsts[0]\\n else:\\n return 1, dsts[1]\\n\\n dsts, extrems=get_embs(points)\\n maxi, maxval=find_max(dsts)\\n exclude=extrems[maxi]\\n\\n ans=[]\\n for idx in list(exclude):\\n dsts,_=get_embs(points, set([idx]))\\n maxi, maxval=find_max(dsts)\\n ans.append(maxval)\\n \\n return min(ans)\\n \",\n \"runtime\": \"1288\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n \\n def get_max_dist(pts):\\n xpy = [(x + y, i) for i, (x, y) in enumerate(pts)]\\n xmy = [(x - y, i) for i, (x, y) in enumerate(pts)]\\n\\n i1, j1 = max(xpy)[1], min(xpy)[1]\\n res1 = abs(pts[i1][0] - pts[j1][0]) + abs(pts[i1][1] - pts[j1][1])\\n i2, j2 = max(xmy)[1], min(xmy)[1]\\n res2 = abs(pts[i2][0] - pts[j2][0]) + abs(pts[i2][1] - pts[j2][1])\\n\\n return (res1, i1, j1) if res1 > res2 else (res2, i2, j2)\\n\\n mx, i, j = get_max_dist(points)\\n\\n opt1, _, _ = get_max_dist(points[:i] + points[i+1:])\\n opt2, _, _ = get_max_dist(points[:j] + points[j+1:])\\n return min(opt1, opt2)\\n\",\n \"runtime\": \"1288\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n converted_points = deque([(x - y, x + y) for x, y in points])\\n \\n max_xs = []\\n max_ys = []\\n min_xs = []\\n min_ys = []\\n\\n for x, y in converted_points:\\n max_xs.append(x)\\n max_ys.append(y)\\n max_xs.sort(reverse=True)\\n max_ys.sort(reverse=True)\\n max_xs = max_xs[:2]\\n max_ys = max_ys[:2]\\n\\n min_xs.append(x)\\n min_ys.append(y)\\n min_xs.sort()\\n min_ys.sort()\\n min_xs = min_xs[:2]\\n min_ys = min_ys[:2]\\n\\n n = len(points)\\n result = math.inf\\n for i in range(n):\\n removed = converted_points.popleft()\\n max_x = max_xs[0] if removed[0] != max_xs[0] else max_xs[1]\\n max_y = max_ys[0] if removed[1] != max_ys[0] else max_ys[1]\\n min_x = min_xs[0] if removed[0] != min_xs[0] else min_xs[1]\\n min_y = min_ys[0] if removed[1] != min_ys[0] else min_ys[1]\\n result = min(result, max(max_x - min_x, max_y - min_y))\\n converted_points.append(removed)\\n return result\",\n \"runtime\": \"1309\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n arr_s, arr_t = [], []\\n for i, (x, y) in enumerate(points):\\n arr_s.append((x+y, i))\\n arr_t.append((y-x, i))\\n \\n arr_s.sort()\\n arr_t.sort()\\n ds0, dt0 = arr_s[-1][0] - arr_s[0][0], arr_t[-1][0] - arr_t[0][0]\\n ds1, ds2 = arr_s[-2][0] - arr_s[0][0], arr_s[-1][0] - arr_s[1][0]\\n dt1, dt2 = arr_t[-2][0] - arr_t[0][0], arr_t[-1][0] - arr_t[1][0]\\n idx_s_h, idx_s_t = arr_s[0][1], arr_s[-1][1]\\n idx_t_h, idx_t_t = arr_t[0][1], arr_t[-1][1]\\n \\n book = {(idx_s_h, idx_s_t): ds0, (idx_t_h, idx_t_t): dt0,\\n ('s', idx_s_h): ds1, ('s', idx_s_t): ds2, \\n ('t', idx_t_h): dt1, ('t', idx_t_t): dt2}\\n I = set([idx_s_h, idx_s_t, idx_t_h, idx_t_t])\\n \\n ans = float('inf')\\n for idx in I:\\n dist = 0\\n for key, val in book.items():\\n if idx not in key:\\n dist = max(dist, val)\\n ans = min(ans, dist)\\n return ans\",\n \"runtime\": \"1330\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n def get_max_i_j(points):\\n plus_max_i, plus_min_i, minus_max_i, minus_min_i = -1,-1,-1,-1\\n x_plus_y_max , x_plus_y_min = float('-inf'), float('inf')\\n x_minus_y_max, x_minus_y_min = float('-inf'), float('inf')\\n for i,point in enumerate(points):\\n x = point[0] \\n y = point[1]\\n if x + y > x_plus_y_max:\\n x_plus_y_max = x + y\\n plus_max_i = i\\n if x + y < x_plus_y_min:\\n x_plus_y_min = x + y\\n plus_min_i = i\\n if x - y > x_minus_y_max:\\n x_minus_y_max = x - y\\n minus_max_i = i\\n if x - y < x_minus_y_min:\\n x_minus_y_min = x - y\\n minus_min_i = i\\n if x_plus_y_max - x_plus_y_min > x_minus_y_max - x_minus_y_min:\\n return x_plus_y_max - x_plus_y_min, plus_max_i, plus_min_i\\n else:\\n return x_minus_y_max - x_minus_y_min, minus_max_i, minus_min_i\\n a , i, j = get_max_i_j( points0 )\\n ai, _, _ = get_max_i_j( points0[0:i] + points0[i+1:] )\\n aj, _, _ = get_max_i_j( points0[0:j] + points0[j+1:] )\\n return min(ai,aj)\",\n \"runtime\": \"1330\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n Given an array of points on a 2D plane, find the minimum \\n Manhattan distance between any two points by removing exactly one \\n point.\\n\\n Args:\\n points: List[List[int]], a list of integer coordinates of \\n points on a 2D plane.\\n\\n Returns:\\n int, the minimum possible value for maximum distance between\\n any two points by removing exactly one point.\\n \\\"\\\"\\\"\\n # Sort the points by their sum and difference (x + y) and (x - y), respectively\\n sorted_by_sum = sorted([(x + y, i) for i, (x, y) in enumerate(points)])\\n sorted_by_diff = sorted([(x - y, i) for i, (x, y) in enumerate(points)])\\n \\n # Initialize the minimum distance to infinity\\n min_distance = float('inf')\\n \\n # Find the indices of the leftmost, rightmost, topmost, and bottommost points\\n # in each sorted array\\n leftmost_sum_idx, rightmost_sum_idx = sorted_by_sum[0][1], sorted_by_sum[-1][1]\\n leftmost_diff_idx, rightmost_diff_idx = sorted_by_diff[0][1], sorted_by_diff[-1][1]\\n\\n # Iterate through the possible points to remove\\n for i in {leftmost_sum_idx, rightmost_sum_idx, leftmost_diff_idx, rightmost_diff_idx}:\\n # Calculate the distances between the leftmost and rightmost points in the sum sorted array\\n left_idx = 1 if i == leftmost_sum_idx else 0\\n right_idx = -2 if i == rightmost_sum_idx else -1\\n sum_distance = sorted_by_sum[right_idx][0] - sorted_by_sum[left_idx][0]\\n\\n # Calculate the distances between the topmost and bottommost points in the difference sorted array\\n bottom_idx = 1 if i == leftmost_diff_idx else 0\\n top_idx = -2 if i == rightmost_diff_idx else -1\\n diff_distance = sorted_by_diff[top_idx][0] - sorted_by_diff[bottom_idx][0]\\n\\n # Update the minimum distance with the maximum of the two distances\\n min_distance = min(min_distance, max(sum_distance, diff_distance))\\n\\n return min_distance\",\n \"runtime\": \"1351\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n \\n def maximum_manhattan(points):\\n add = {}\\n difference = {}\\n\\n for i in range(len(points)):\\n add[points[i][0] + points[i][1]] = points[i]\\n difference[points[i][0] - points[i][1]] = points[i]\\n \\n sorted_add = sorted(add.keys())\\n sorted_difference = sorted(difference.keys())\\n # print(sorted_add)\\n # difference.sort()\\n if (sorted_add[-1] - sorted_add[0]) > (-1*(sorted_difference[0] - sorted_difference[-1])):\\n return [sorted_add[-1] - sorted_add[0], add[sorted_add[-1]], add[sorted_add[0]]]\\n \\n return [-1*(sorted_difference[0] - sorted_difference[-1]), difference[sorted_difference[0]], difference[sorted_difference[-1]]]\\n \\n \\n \\n # res = max(add[sorted_add[-1]]-add[sorted_add[0]],-1*(difference[sorted_difference[0]]-difference[sorted_difference[-1]]))\\n\\n \\n \\n \\n res = maximum_manhattan(points)\\n # print(res)\\n # pot1 = maximum_manhattan(points.remove(res[1]))\\n \\n pot1 = points.copy()\\n pot1.remove(res[1])\\n \\n pot2 = points.copy()\\n pot2.remove(res[2])\\n # print(pot1)\\n \\n return min(maximum_manhattan(pot1)[0],maximum_manhattan(pot2)[0])\\n \\n \\n \",\n \"runtime\": \"1351\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n A = sorted([(x + y, i) for i, (x, y) in enumerate(points)])\\n B = sorted([(x - y, i) for i, (x, y) in enumerate(points)])\\n ans = float('inf')\\n a1, a2, b1, b2 = A[0][1], A[-1][1], B[0][1], B[-1][1]\\n for i in {a1, a2, b1, b2}:\\n al = 1 if i == a1 else 0\\n ar = -2 if i == a2 else -1\\n bl = 1 if i == b1 else 0\\n br = -2 if i == b2 else -1\\n ans = min(ans, max(A[ar][0] - A[al][0], B[br][0] - B[bl][0]))\\n return ans\",\n \"runtime\": \"1372\"\n },\n {\n \"code\": \"import numpy\\n\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n \\n def get_max_i_j(points):\\n p = [ xy[0] + xy[1] for xy in points]\\n m = [ xy[0] - xy[1] for xy in points]\\n pmin = numpy.argmin(p)\\n pmax = numpy.argmax(p)\\n\\n mmin = numpy.argmin(m)\\n mmax = numpy.argmax(m)\\n\\n i,j = 0,0\\n if p[pmax] - p[pmin] >= m[mmax] - m[mmin]:\\n i = pmax\\n j = pmin\\n else:\\n i = mmin\\n j = mmax\\n return max(p[pmax] - p[pmin], m[mmax] - m[mmin]), i,j\\n \\n a,i,j = get_max_i_j(points0)\\n #print(a,i,j)\\n bi, _, _ = get_max_i_j(points0[0:i]+points0[i+1:])\\n bj, _, _ = get_max_i_j(points0[0:j]+points0[j+1:])\\n\\n\\n return min(bi,bj)\",\n \"runtime\": \"1372\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def maxDist(points):\\n maxPlus, lpi = max((x + y, i) for i, (x, y) in enumerate(points))\\n minPlus, mpi = min((x + y, i) for i, (x, y) in enumerate(points))\\n minMinus, lmi = max((x - y, i) for i, (x, y) in enumerate(points))\\n maxMinus, mmi = min((x - y, i) for i, (x, y) in enumerate(points))\\n c1, c2 = abs(maxPlus - minPlus), abs(maxMinus - minMinus)\\n return (c1, lpi, mpi) if c1 > c2 else (c2, lmi, mmi)\\n v, i1, i2 = maxDist(points)\\n return min(maxDist(points[:i1] + points[i1+1:])[0], maxDist(points[:i2] + points[i2+1:])[0])\\n\\n\\n \",\n \"runtime\": \"1392\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n L = len(points)\\n\\n def helper(ignore_idx = -1):\\n sums = []\\n diffs = []\\n\\n for i,(x,y) in enumerate(points):\\n if i != ignore_idx:\\n sums.append((x + y, i))\\n diffs.append((x - y, i))\\n\\n sum_max = max(sums, key= lambda x: x[0])\\n sum_min = min(sums, key= lambda x: x[0])\\n diff_max = max(diffs, key= lambda x: x[0])\\n diff_min = min(diffs, key= lambda x: x[0])\\n\\n\\n val1 = sum_max[0] - sum_min[0] \\n val2 = diff_max[0] - diff_min[0]\\n if val1 > val2:\\n return (sum_min[1], sum_max[1], val1)\\n else:\\n return (diff_min[1], diff_max[1], val2)\\n\\n\\n idx1, idx2, _ = helper()\\n\\n val1 = helper(idx1)[2]\\n val2 = helper(idx2)[2]\\n\\n return min(val1, val2)\\n \\n\\n\\n\\n\\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"1413\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n \\n def get_max_i_j(points):\\n # points.sort(key=lambda x: x[0])\\n #print(points)\\n p = [ xy[0] + xy[1] for xy in points]\\n m = [ xy[0] - xy[1] for xy in points]\\n pmin = np.argmin(p)\\n pmax = np.argmax(p)\\n\\n mmin = np.argmin(m)\\n mmax = np.argmax(m)\\n\\n i,j = 0,0\\n if p[pmax] - p[pmin] >= m[mmax] - m[mmin]:\\n i = pmax\\n j = pmin\\n else:\\n i = mmin\\n j = mmax\\n return max(p[pmax] - p[pmin], m[mmax] - m[mmin]), i,j\\n \\n a,i,j = get_max_i_j(points0)\\n #print(a,i,j)\\n bi, _, _ = get_max_i_j(points0[0:i]+points0[i+1:])\\n bj, _, _ = get_max_i_j(points0[0:j]+points0[j+1:])\\n\\n\\n return min(bi,bj)\",\n \"runtime\": \"1413\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude={}):\\n emb1,emb2,emb3,emb4=[],[],[],[]\\n for i, pt in enumerate(points):\\n if i not in exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n emb3.append(-pt[1]+pt[0])\\n emb4.append(-pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n dst3,extrem_idx3=find(emb3)\\n dst4,extrem_idx4=find(emb4)\\n\\n res=[dst1, dst2, dst3, dst4]\\n extrem=[extrem_idx1, extrem_idx2, extrem_idx3, extrem_idx4]\\n\\n return res, extrem\\n \\n def find_max(res):\\n maxi,maxval=0,-10**10\\n for i,v in enumerate(res):\\n if v>maxval:\\n maxval=v\\n maxi=i\\n return maxi, maxval\\n\\n res, extrem=get_embs(points)\\n maxi, maxval=find_max(res)\\n exclude=extrem[maxi]\\n\\n ans=[]\\n for idx in list(exclude):\\n res,extrem=get_embs(points, set([idx]))\\n maxi, maxval=find_max(res)\\n ans.append(maxval)\\n \\n\\n\\n \\n return min(ans)\\n \",\n \"runtime\": \"1434\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n inf = 10**9\\n leftcoords,rightcoords = [],[]\\n for i,p in enumerate(points):\\n leftcoords.append((p[0]+p[1],i))\\n rightcoords.append((p[1]-p[0],i))\\n leftcoords.sort(); rightcoords.sort()\\n maxdist = float('inf')\\n for i in range(len(points)):\\n temp = leftcoords[-1][0]-leftcoords[0][0]\\n if leftcoords[0][1]==i: temp = min(temp, leftcoords[-1][0]-leftcoords[1][0])\\n elif leftcoords[-1][1]==i: temp = min(temp, leftcoords[-2][0]-leftcoords[0][0])\\n temp2 = rightcoords[-1][0]-rightcoords[0][0]\\n if rightcoords[0][1]==i: temp2 = min(temp2, rightcoords[-1][0]-rightcoords[1][0])\\n elif rightcoords[-1][1]==i: temp2 = min(temp2, rightcoords[-2][0]-rightcoords[0][0])\\n maxdist = min(maxdist, max(temp, temp2))\\n return maxdist\",\n \"runtime\": \"1434\"\n },\n {\n \"code\": \"class Solution:\\n def get_max_dist(self, points):\\n sum_arr = [x+y for x,y in points]\\n diff_arr = [x-y for x,y in points]\\n return max(max(sum_arr) - min(sum_arr), max(diff_arr) - min(diff_arr))\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n sum_arr = sorted(points, key = lambda x: x[0] + x[1])\\n diff_arr = sorted(points, key = lambda x: x[0] - x[1])\\n return min(self.get_max_dist(sum_arr[1:]), self.get_max_dist(sum_arr[:-1]), self.get_max_dist(diff_arr[1:]), self.get_max_dist(diff_arr[:-1]))\",\n \"runtime\": \"1455\"\n },\n {\n \"code\": \"inf = int(1e18)\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def dist(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:\\n x1, y1 = p1\\n x2, y2 = p2\\n return abs(x1 - x2) + abs(y1 - y2)\\n \\n def getFurtherestPair(arr: List[Tuple[int, int]]) -> int:\\n n = len(arr)\\n maxa = maxb = (-inf, (0, 0))\\n mina = minb = (inf, (0, 0))\\n for i in range(n):\\n x, y = arr[i]\\n a = x + y\\n b = x - y\\n\\n ap = (a, arr[i])\\n bp = (b, arr[i])\\n\\n maxa = max(maxa, ap)\\n mina = min(mina, ap)\\n maxb = max(maxb, bp)\\n minb = min(minb, bp)\\n\\n candidatePair1 = (maxa[1], mina[1])\\n candidatePair2 = (maxb[1], minb[1])\\n\\n if dist(*candidatePair1) < dist(*candidatePair2): return candidatePair2\\n else: return candidatePair1\\n \\n pts = [(p[0], p[1]) for p in points]\\n\\n ans = int(1e18)\\n for p in getFurtherestPair(pts):\\n # try to remove p\\n pts.remove(p)\\n newPair = getFurtherestPair(pts)\\n ans = min(ans, dist(*newPair))\\n pts.append(p)\\n \\n return ans\\n\",\n \"runtime\": \"1476\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n n = len(points)\\n minimumVal = float('inf')\\n\\n plus = []\\n minus = []\\n\\n # for each point, store (x+y) and (x-y)\\n for i,point in enumerate(points):\\n plus.append(ValueIndex(point[0] + point[1], i))\\n minus.append(ValueIndex(point[0] - point[1], i))\\n\\n plus.sort(key=lambda x: x.val)\\n minus.sort(key=lambda x: x.val)\\n\\n # now one by one remove each point and compute answer\\n for i in range(n):\\n # now we need to find the extreme values from points array after removing point i\\n maxPlus = plus[-2].val if plus[-1].idx == i else plus[-1].val\\n minPlus = plus[1].val if plus[0].idx == i else plus[0].val\\n maxMinus = minus[-2].val if minus[-1].idx == i else minus[-1].val\\n minMinus = minus[1].val if minus[0].idx == i else minus[0].val\\n\\n # maximum manhattan distance after removing point i\\n maxAfterRemovingOne = max(maxPlus - minPlus, maxMinus - minMinus)\\n\\n # update final answer\\n minimumVal = min(minimumVal, maxAfterRemovingOne)\\n\\n return minimumVal\\n\\n\\nclass ValueIndex:\\n def __init__(self, v, i):\\n self.val = v\\n self.idx = i\",\n \"runtime\": \"1497\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum = max(max_sum, summ)\\n min_sum = min(min_sum, summ)\\n max_diff = max(max_diff, diff)\\n min_diff = min(min_diff, diff)\\n \\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n \\n max_sum = [0, points[0][0] + points[0][1]]\\n min_sum = [0, points[0][0] + points[0][1]]\\n max_diff = [0, points[0][0] - points[0][1]]\\n min_diff = [0, points[0][0] - points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ > max_sum[1]:\\n max_sum = [n, summ]\\n if summ < min_sum[1]:\\n min_sum = [n, summ]\\n if diff > max_diff[1]:\\n max_diff = [n, diff]\\n if diff < min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a = float('inf')\\n \\n \\n for idx in index1:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"runtime\": \"1517\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum = max(max_sum, summ)\\n min_sum = min(min_sum, summ)\\n max_diff = max(max_diff, diff)\\n min_diff = min(min_diff, diff)\\n \\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n \\n max_sum = [0, points[0][0] + points[0][1]]\\n min_sum = [0, points[0][0] + points[0][1]]\\n max_diff = [0, points[0][0] - points[0][1]]\\n min_diff = [0, points[0][0] - points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ > max_sum[1]:\\n max_sum = [n, summ]\\n if summ < min_sum[1]:\\n min_sum = [n, summ]\\n if diff > max_diff[1]:\\n max_diff = [n, diff]\\n if diff < min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a = float('inf')\\n \\n \\n for idx in index1:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"runtime\": \"1517\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum= max(max_sum, summ)\\n min_sum =min(min_sum, summ)\\n max_diff =max(max_diff, diff)\\n min_diff =min(min_diff, diff)\\n \\n return max(max_sum -min_sum,max_diff- min_diff)\\n \\n \\n max_sum = [0,points[0][0]+ points[0][1]]\\n min_sum = [0,points[0][0]+points[0][1]]\\n max_diff = [0,points[0][0]-points[0][1]]\\n min_diff = [0, points[0][0]- points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ> max_sum[1]:\\n max_sum =[n, summ]\\n if summ<min_sum[1]:\\n min_sum = [n, summ]\\n if diff >max_diff[1]:\\n max_diff = [n, diff]\\n if diff<min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a =float('inf')\\n \\n \\n for idx in index1:\\n temp=points[:idx]+points[idx+1:]\\n a =min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx]+points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"runtime\": \"1538\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n inf = 10**9\\n leftcoords,rightcoords = [],[]\\n for i,p in enumerate(points):\\n leftcoords.append((p[0]+p[1],i))\\n rightcoords.append((p[1]-p[0],i))\\n leftcoords.sort(); rightcoords.sort()\\n maxdist = float('inf')\\n for i in range(len(points)):\\n temp = float('inf')\\n if leftcoords[0][1]==i: temp = min(temp, leftcoords[-1][0]-leftcoords[1][0])\\n elif leftcoords[-1][1]==i: temp = min(temp, leftcoords[-2][0]-leftcoords[0][0])\\n else: temp = min(temp, leftcoords[-1][0]-leftcoords[0][0])\\n temp2 = float('inf')\\n if rightcoords[0][1]==i: temp2 = min(temp2, rightcoords[-1][0]-rightcoords[1][0])\\n elif rightcoords[-1][1]==i: temp2 = min(temp2, rightcoords[-2][0]-rightcoords[0][0])\\n else: temp2 = min(temp2, rightcoords[-1][0]-rightcoords[0][0])\\n maxdist = min(maxdist, max(temp, temp2))\\n return maxdist\",\n \"runtime\": \"1580\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n\\n def calc(arr):\\n # get max dist in points given 1 is removed\\n mx = max(x + y for x, y in arr)\\n mn = min(x + y for x, y in arr)\\n mx2 = max(x - y for x, y in arr)\\n mn2 = min(x - y for x, y in arr)\\n\\n return max(mx - mn, mx2 - mn2)\\n\\n\\n arr1 = sorted(points, key=lambda z: z[0] + z[1])\\n arr2 = sorted(points, key=lambda z: z[0] - z[1])\\n\\n # optimal way to remove 1 point\\n best_option = min(calc(arr1[1:]), calc(arr1[:-1]), calc(arr2[1:]), calc(arr2[:-1]))\\n\\n return best_option\",\n \"runtime\": \"1580\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u+v for u, v in points)\\n mn_out = min(u+v for u, v in points)\\n\\n mx_in = max(u-v for u, v in points)\\n mn_in = min(u-v for u, v in points)\\n\\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n\\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n return min(max_man_dis)\",\n \"runtime\": \"1601\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n \\n def get_max_i_j(points):\\n points.sort(key=lambda x: x[0])\\n #print(points)\\n p = [ xy[0] + xy[1] for xy in points]\\n m = [ xy[0] - xy[1] for xy in points]\\n pmin = np.argmin(p)\\n pmax = np.argmax(p)\\n\\n mmin = np.argmin(m)\\n mmax = np.argmax(m)\\n\\n i,j = 0,0\\n if p[pmax] - p[pmin] >= m[mmax] - m[mmin]:\\n i = pmax\\n j = pmin\\n else:\\n i = mmin\\n j = mmax\\n return max(p[pmax] - p[pmin], m[mmax] - m[mmin]), i,j\\n \\n a,i,j = get_max_i_j(points0)\\n #print(a,i,j)\\n bi, _, _ = get_max_i_j(points0[0:i]+points0[i+1:])\\n bj, _, _ = get_max_i_j(points0[0:j]+points0[j+1:])\\n\\n\\n return min(bi,bj)\",\n \"runtime\": \"1601\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1622\"\n },\n {\n \"code\": \"def find(x):\\n mxs, a = max((u + v, i) for i, (u, v) in enumerate(x))\\n mns, b = min((u + v, j) for j, (u, v) in enumerate(x))\\n \\n mxd, c = max((u - v, i) for i, (u, v) in enumerate(x))\\n mnd, d = min((u - v, j) for j, (u, v) in enumerate(x))\\n \\n return max(mxs - mns, mxd - mnd), a, b, c, d\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n md, a, b, c, d = find(points)\\n return min(md, \\n find(points[:a]+points[a+1:])[0], \\n find(points[:b]+points[b+1:])[0],\\n find(points[:c]+points[c+1:])[0], \\n find(points[:d]+points[d+1:])[0]\\n )\",\n \"runtime\": \"1622\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n \\n \\n points.sort(key = lambda x: sum(x))\\n points_pos = list(map(sum, points))\\n d_pos = {}\\n for x in range(len(points)):\\n d_pos[x] = points_pos[x]\\n \\n \\n d_neg = {}\\n for i in range(len(points)):\\n d_neg[i] = points[i][0] - points[i][1]\\n points_neg = []\\n for u, v in d_neg.items():\\n points_neg.append([u, v]) \\n points_neg.sort(key = lambda x: x[1])\\n \\n ans = 10 ** 20\\n \\n for i in range(len(points)):\\n s, l = 0, len(points) - 1\\n if points_neg[s][0] == i:\\n s += 1\\n if points_neg[l][0] == i:\\n l -= 1 \\n neg_diff = abs( points_neg[l][1] - points_neg[s][1] )\\n pos_diff = abs( d_pos[ points_neg[l][0] ] - d_pos[ points_neg[s][0] ] )\\n\\n ans1 = max(neg_diff, pos_diff)\\n\\n\\n s, l = 0, len(points) - 1\\n if i == s:\\n s += 1\\n if i == l:\\n l -= 1\\n pos_diff = abs( points_pos[l] - points_pos[s] )\\n neg_diff = abs( d_neg[l] - d_neg[s] )\\n ans2 = max(pos_diff, neg_diff)\\n\\n fans = max(ans1, ans2)\\n ans = min(ans, fans)\\n\\n return ans\",\n \"runtime\": \"1642\"\n },\n {\n \"code\": \"def find(x):\\n mxs, a = max((u + v, i) for i, (u, v) in enumerate(x))\\n mns, b = min((u + v, j) for j, (u, v) in enumerate(x))\\n \\n mxd, c = max((u - v, i) for i, (u, v) in enumerate(x))\\n mnd, d = min((u - v, j) for j, (u, v) in enumerate(x))\\n \\n return max(mxs - mns, mxd - mnd), a, b, c, d\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n md, a, b, c, d = find(points)\\n return min(md, \\n find(points[:a]+points[a+1:])[0], \\n find(points[:b]+points[b+1:])[0],\\n find(points[:c]+points[c+1:])[0], \\n find(points[:d]+points[d+1:])[0]\\n )\",\n \"runtime\": \"1642\"\n },\n {\n \"code\": \"def find(x):\\n mxs, a = max((u + v, i) for i, (u, v) in enumerate(x))\\n mns, b = min((u + v, j) for j, (u, v) in enumerate(x))\\n \\n mxd, c = max((u - v, i) for i, (u, v) in enumerate(x))\\n mnd, d = min((u - v, j) for j, (u, v) in enumerate(x))\\n \\n return max(mxs - mns, mxd - mnd), a, b, c, d\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n md, a, b, c, d = find(points)\\n return min(md, \\n find(points[:a]+points[a+1:])[0], \\n find(points[:b]+points[b+1:])[0],\\n find(points[:c]+points[c+1:])[0], \\n find(points[:d]+points[d+1:])[0]\\n )\",\n \"runtime\": \"1663\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def helper(arr):\\n min_sum = min(x + y for x, y in arr)\\n max_sum = max(x + y for x, y in arr)\\n min_diff = min(x - y for x, y in arr)\\n max_diff = max(x - y for x, y in arr)\\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n min_x = sorted(points, key = lambda x : (x[0] + x[1]))\\n result = min(helper(min_x[1:]), helper(min_x[:-1]))\\n max_x = sorted(points, key = lambda x : (x[0] - x[1]))\\n result = min(result, helper(max_x[1:]), helper(max_x[:-1]))\\n\\n return result\",\n \"runtime\": \"1663\"\n },\n {\n \"code\": \"def calculate(points):\\n mxa = max(u+v for u,v in points)\\n mina = min(u+v for u,v in points)\\n mxb = max(u-v for u,v in points)\\n minb = min(u-v for u,v in points)\\n return max(mxa-mina, mxb-minb)\\n\\n\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n arr = []\\n points.sort(key = lambda x: x[0]+x[1])\\n arr.append(calculate(points[1:]))\\n arr.append(calculate(points[:-1]))\\n points.sort(key = lambda x: x[0]-x[1])\\n arr.append(calculate(points[1:]))\\n arr.append(calculate(points[:-1]))\\n print(arr)\\n return min(arr)\\n\\n\\n\",\n \"runtime\": \"1684\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n \\n def get_max_i_j(points):\\n points.sort(key=lambda x: x[0])\\n #print(points)\\n p = [ xy[0] + xy[1] for xy in points]\\n m = [ xy[0] - xy[1] for xy in points]\\n pmin = np.argmin(p)\\n pmax = np.argmax(p)\\n\\n mmin = np.argmin(m)\\n mmax = np.argmax(m)\\n\\n i,j = 0,0\\n if p[pmax] - p[pmin] >= m[mmax] - m[mmin]:\\n i = pmax\\n j = pmin\\n else:\\n i = mmin\\n j = mmax\\n return max(p[pmax] - p[pmin], m[mmax] - m[mmin]), i,j\\n \\n a,i,j = get_max_i_j(points0)\\n #print(a,i,j)\\n bi, _, _ = get_max_i_j(points0[0:i]+points0[i+1:])\\n bj, _, _ = get_max_i_j(points0[0:j]+points0[j+1:])\\n\\n\\n return min(bi,bj)\",\n \"runtime\": \"1705\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1705\"\n },\n {\n \"code\": \"\\nimport numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n \\n def get_max_i_j(points):\\n points.sort(key=lambda x: x[0])\\n #print(points)\\n p = [ xy[0] + xy[1] for xy in points]\\n m = [ xy[0] - xy[1] for xy in points]\\n pmin = np.argmin(p)\\n pmax = np.argmax(p)\\n\\n mmin = np.argmin(m)\\n mmax = np.argmax(m)\\n\\n i,j = 0,0\\n if p[pmax] - p[pmin] >= m[mmax] - m[mmin]:\\n i = pmax\\n j = pmin\\n else:\\n i = mmin\\n j = mmax\\n return max(p[pmax] - p[pmin], m[mmax] - m[mmin]), i,j\\n \\n a,i,j = get_max_i_j(points0)\\n #print(a,i,j)\\n bi, _, _ = get_max_i_j(points0[0:i]+points0[i+1:])\\n bj, _, _ = get_max_i_j(points0[0:j]+points0[j+1:])\\n\\n\\n return min(bi,bj)\",\n \"runtime\": \"1726\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1746\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1767\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def choose(points):\\n a = max(u+v for u, v in points)\\n b = min(u+v for u, v in points)\\n c = max(u-v for u, v in points)\\n d = min(u-v for u, v in points)\\n return max(a-b, c-d)\\n candidate = []\\n points.sort(key = lambda x: x[0] + x[1])\\n candidate.append(choose(points[1:]))\\n candidate.append(choose(points[:-1]))\\n points.sort(key = lambda x: x[0] - x[1])\\n candidate.append(choose(points[1:])) \\n candidate.append(choose(points[:-1]))\\n return min(candidate)\\n\\n\\n \",\n \"runtime\": \"1767\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1788\"\n },\n {\n \"code\": \"def calc(p):\\n s = []\\n p.sort(key=lambda x:x[0]+x[1])\\n s += [p[0]] + [p[-1]]\\n p.sort(key=lambda x:x[0]-x[1])\\n s += [p[0]] + [p[-1]]\\n dist = 0\\n for i in range(len(s)):\\n for j in range(i+1, len(s)):\\n dist = max(dist, abs(s[i][0]-s[j][0]) + abs(s[i][1]-s[j][1]))\\n return dist\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x:x[0]+x[1])\\n l = [calc(points[1:]), calc(points[:-1])]\\n points.sort(key=lambda x:x[0]-x[1])\\n l += [calc(points[1:]), calc(points[:-1])]\\n return min(l)\",\n \"runtime\": \"1809\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_distance, point1, point2 = self.get_max_distance(points)\\n missing1 = []\\n missing2 = []\\n found1 = False\\n found2 = False\\n for point in points:\\n if found1 or point != point1:\\n missing1.append(point)\\n if found2 or point != point2:\\n missing2.append(point)\\n if point == point1:\\n found1 = True\\n if point == point2:\\n found2 = True\\n #missing1 = [point for point in points if point != point1]\\n #missing2 = [point for point in points if point != point2]\\n option1, t1, t2 = self.get_max_distance(missing1)\\n option2, t1, t2 = self.get_max_distance(missing2)\\n return min(option1, option2)\\n\\n def partition(self, points, x_vals, y_vals):\\n n = len(points)\\n x_vals = sorted(x_vals)\\n y_vals = sorted(y_vals)\\n x_med = x_vals[n//2]\\n y_med = y_vals[n//2]\\n center = [x_med, y_med]\\n pick_top = True\\n pick_left = True\\n tl = []\\n tr = []\\n bl = []\\n br = []\\n for point in points:\\n is_left = False\\n is_top = False\\n if point[0] < x_med:\\n is_left = True\\n elif point[0] == x_med:\\n is_left = pick_left\\n pick_left = not pick_left\\n if point[1] > y_med:\\n is_top = True\\n elif point[1] == y_med:\\n is_top = pick_top\\n pick_top = not pick_top\\n if is_left and is_top:\\n tl.append(point)\\n elif is_left:\\n bl.append(point)\\n elif is_top:\\n tr.append(point)\\n else:\\n br.append(point)\\n return tl, tr, bl, br, center\\n\\n def get_max_distance(self, points, ignore_val = None):\\n if len(points) < 2:\\n return 0, None, None\\n if len(points) <= 4:\\n return self.get_max_distance_small(points)\\n x_vals = [p[0] for p in points]\\n y_vals = [p[1] for p in points]\\n max_distance = max(x_vals) - min(x_vals) + max(y_vals) - min(y_vals)\\n if ignore_val is not None and max_distance <= ignore_val:\\n #print(\\\"skipping: {}\\\".format(points))\\n return -1, None, None\\n tl, tr, bl, br, center = self.partition(points, x_vals, y_vals)\\n tl_dis, tl_p = self.get_max_distance_from(tl, center)\\n tr_dis, tr_p = self.get_max_distance_from(tr, center)\\n bl_dis, bl_p = self.get_max_distance_from(bl, center)\\n br_dis, br_p = self.get_max_distance_from(br, center)\\n if tl_dis + br_dis > tr_dis + bl_dis:\\n point1 = tl_p\\n point2 = br_p\\n max_distance = tl_dis + br_dis\\n else:\\n point1 = tr_p\\n point2 = bl_p\\n max_distance = tr_dis + bl_dis\\n top_points = tl + tr\\n left_points = tl + bl\\n right_points = tr + br\\n bottom_points = bl + br\\n for option in [top_points, left_points, right_points, bottom_points]:\\n new_distance, new1, new2 = self.get_max_distance(option, max_distance)\\n if new_distance > max_distance:\\n max_distance = new_distance\\n point1 = new1\\n point2 = new2\\n #print(\\\"max of {}: {}\\\".format(max_distance, points))\\n return max_distance, point1, point2\\n \\n \\n def get_max_distance_from(self, points, other):\\n max_distance = -1\\n point = None\\n for p in points:\\n cur_distance = abs(p[0]-other[0]) + abs(p[1]-other[1])\\n if cur_distance > max_distance:\\n max_distance = cur_distance\\n point = p\\n return max_distance, point\\n\\n def get_max_distance_small(self, points):\\n max_distance = -1\\n point1 = None\\n point2 = None\\n for p1 in points:\\n for p2 in points:\\n cur_distance = abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])\\n if cur_distance > max_distance:\\n max_distance = cur_distance\\n point1 = p1\\n point2 = p2\\n #print(\\\"max of {}: {}\\\".format(max_distance, points))\\n return max_distance, point1, point2\",\n \"runtime\": \"1830\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1851\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1871\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n\\n def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"runtime\": \"1871\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def helper(arr):\\n min_sum = min(x + y for x, y in arr)\\n max_sum = max(x + y for x, y in arr)\\n min_diff = min(x - y for x, y in arr)\\n max_diff = max(x - y for x, y in arr)\\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n # min_x = sorted(points, key = lambda x : (x[0], x[1]))\\n points.sort(key = lambda x: x[0] + x[1])\\n # print(helper(points[1:]), helper(points[:-1]))\\n result = min(helper(points[1:]), helper(points[:-1]))\\n # max_x = sorted(points, key = lambda x : (x[0], -x[1]))\\n points.sort(key = lambda x: x[0] - x[1])\\n result = min(result, helper(points[1:]), helper(points[:-1]))\\n # print(helper(max_x[1:]), helper(max_x[:-1]))\\n\\n return result\",\n \"runtime\": \"1892\"\n },\n {\n \"code\": \"def calc(points,p):\\n sum1=[]\\n diff1=[]\\n for j in range (0,len(points)):\\n if j==p:\\n continue\\n sum1.append([j,points[j][0]+points[j][1]])\\n diff1.append([j,points[j][0]-points[j][1]])\\n sum1.sort(key=lambda x:x[1])\\n diff1.sort(key=lambda x:x[1])\\n a=sum1[-1][1]-sum1[0][1]\\n b=diff1[-1][1]-diff1[0][1]\\n return max(a,b)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n summ=[]\\n diff=[]\\n for j in range (0,len(points)):\\n summ.append([j,points[j][0]+points[j][1]])\\n diff.append([j,points[j][0]-points[j][1]])\\n summ.sort(key=lambda x:x[1])\\n diff.sort(key=lambda x:x[1])\\n a=summ[-1][1]-summ[0][1]\\n b=diff[-1][1]-diff[0][1]\\n if a>b:\\n p1,p2=summ[0][0],summ[-1][0]\\n else:\\n p1,p2=diff[0][0],diff[-1][0]\\n return min(calc(points,p1),calc(points,p2))\\n\",\n \"runtime\": \"1913\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n plus,minus = SortedList(),SortedList()\\n for x,y in points:\\n plus.add(x+y)\\n minus.add(x-y)\\n ans = float('inf')\\n for x,y in points:\\n plus.remove(x+y)\\n minus.remove(x-y)\\n ans = min(ans,max(plus[-1] - plus[0],minus[-1] - minus[0]))\\n plus.add(x+y)\\n minus.add(x-y)\\n return ans\",\n \"runtime\": \"1934\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n sl1 = SortedList()\\n sl2 = SortedList()\\n for x, y in points:\\n sl1.add(x + y)\\n sl2.add(x - y)\\n ans = inf\\n for x, y in points:\\n sl1.remove(x + y)\\n sl2.remove(x - y)\\n ans = min(ans, max(sl1[-1] - sl1[0], sl2[-1] - sl2[0]))\\n sl1.add(x + y)\\n sl2.add(x - y)\\n return ans\",\n \"runtime\": \"1955\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":65,"string":"65"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def find(emb):\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\n for i, x in enumerate(emb):\n if x<min_val:\n extremmin_idx=set()\n extremmin_idx.add(i)\n min_val=x\n elif x==min_val:\n extremmin_idx.add(i)\n \n if x>max_val:\n extremmax_idx=set()\n extremmax_idx.add(i)\n max_val=x\n elif x==max_val:\n extremmax_idx.add(i)\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\n\n def get_embs(points, exclude=None):\n emb1,emb2=[],[]\n for i, pt in enumerate(points):\n if i!=exclude:\n emb1.append(pt[1]+pt[0])\n emb2.append(pt[1]-pt[0])\n\n dst1,extrem_idx1=find(emb1)\n dst2,extrem_idx2=find(emb2)\n\n if dst1>dst2:\n return dst1, extrem_idx1\n else:\n return dst2, extrem_idx2\n\n _, exclude=get_embs(points) \n\n ans=10**10\n for idx in exclude:\n maxval,_=get_embs(points, idx)\n ans=min(ans, maxval)\n \n return ans\n ","memory":"63400"},{"code":"class Solution:\n def manhattan(self, point1, point2):\n return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])\n def getMaxManhattanPoints(self, points, remove: int = -1):\n maxSum = float(\"-inf\")\n minSum = float(\"inf\")\n maxDiff = float(\"-inf\")\n minDiff = float(\"inf\")\n maxSumI = -1\n minSumI = -1\n maxDiffI = -1\n minDiffI = -1\n for i in range(len(points)):\n if i == remove:\n continue\n # Calculate the sum\n pointSum = points[i][0] + points[i][1]\n # Calculate the diff\n pointDiff = points[i][0] - points[i][1]\n if pointSum > maxSum:\n maxSum = pointSum\n maxSumI = i\n if pointSum < minSum:\n minSum = pointSum\n minSumI = i\n if pointDiff > maxDiff:\n maxDiff = pointDiff\n maxDiffI = i\n if pointDiff < minDiff:\n minDiff = pointDiff\n minDiffI = i\n if maxSum - minSum > maxDiff - minDiff:\n furthestPoints = (minSumI, maxSumI)\n else:\n furthestPoints = (minDiffI, maxDiffI)\n return furthestPoints\n def minimumDistance(self, points: List[List[int]]) -> int:\n # mDist = abs(x1 - x2) + abs(y1 - y2)\n # Remove 1 point that is the furthest distance from all the other points\n # Remove each point and calculate the max distance between any 2 points\n mi, mj = self.getMaxManhattanPoints(points)\n # Without mi\n gi, gj = self.getMaxManhattanPoints(points, mi)\n # Without mj\n hi, hj = self.getMaxManhattanPoints(points, mj)\n return min(self.manhattan(points[mi], points[mj]), \n self.manhattan(points[gi], points[gj]), \n self.manhattan(points[hi], points[hj]))\n","memory":"63500"},{"code":"def fun(points):\n mx_out = max(u+v for u, v in points)\n mn_out = min(u+v for u, v in points)\n\n mx_in = max(u-v for u, v in points)\n mn_in = min(u-v for u, v in points)\n\n return max(mx_out - mn_out, mx_in - mn_in)\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n max_man_dis = []\n\n points.sort(key = lambda x: x[0] + x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n\n points.sort(key = lambda x: x[0] - x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n\n return min(max_man_dis)","memory":"63600"},{"code":"def fun(points):\n mx_out = max(u + v for u, v in points)\n mn_out = min(u + v for u, v in points)\n \n mx_in = max(u - v for u, v in points)\n mn_in = min(u - v for u, v in points)\n \n return max(mx_out - mn_out, mx_in - mn_in)\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n max_man_dis = []\n \n points.sort(key = lambda x: x[0] + x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n\n points.sort(key = lambda x: x[0] - x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n \n return min(max_man_dis)","memory":"63700"},{"code":"def fun(points):\n mx_out = max(u + v for u, v in points)\n mn_out = min(u + v for u, v in points)\n \n mx_in = max(u - v for u, v in points)\n mn_in = min(u - v for u, v in points)\n \n return max(mx_out - mn_out, mx_in - mn_in)\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n max_man_dis = []\n \n points.sort(key = lambda x: x[0] + x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n\n points.sort(key = lambda x: x[0] - x[1])\n max_man_dis.append(fun(points[1:]))\n max_man_dis.append(fun(points[:-1]))\n \n return min(max_man_dis)","memory":"63800"},{"code":"def calculate(points):\n mxa = max(u+v for u,v in points)\n mina = min(u+v for u,v in points)\n mxb = max(u-v for u,v in points)\n minb = min(u-v for u,v in points)\n return max(mxa-mina, mxb-minb)\n\n\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n arr = []\n points.sort(key = lambda x: x[0]+x[1])\n arr.append(calculate(points[1:]))\n arr.append(calculate(points[:-1]))\n points.sort(key = lambda x: x[0]-x[1])\n arr.append(calculate(points[1:]))\n arr.append(calculate(points[:-1]))\n print(arr)\n return min(arr)\n\n\n","memory":"63900"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n n = len(points)\n \n # Step 1: Compute the transformed coordinates u = x + y and v = x - y\n u = [x + y for x, y in points]\n v = [x - y for x, y in points]\n \n # Step 2: Find the min and max of u and v\n u_min, u_max = min(u), max(u)\n v_min, v_max = min(v), max(v)\n \n # Step 3: Find the indices of points that define these min/max values\n u_min_idx, u_max_idx = u.index(u_min), u.index(u_max)\n v_min_idx, v_max_idx = v.index(v_min), v.index(v_max)\n \n # Step 4: Calculate the maximum distances in u and v\n def max_distance_without_point(skip_idx):\n u_list = [u[i] for i in range(n) if i != skip_idx]\n v_list = [v[i] for i in range(n) if i != skip_idx]\n max_u_dist = max(u_list) - min(u_list)\n max_v_dist = max(v_list) - min(v_list)\n return max(max_u_dist, max_v_dist)\n \n # Step 5: Try removing the points that define the extremes in u and v\n candidates = {u_min_idx, u_max_idx, v_min_idx, v_max_idx}\n result = float('inf')\n \n for idx in candidates:\n result = min(result, max_distance_without_point(idx))\n \n return result","memory":"64000"},{"code":"def manhattan_distance(p1, p2):\n return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])\n\ndef max_manhattan_distance(points):\n candidates = set()\n for a in [-1, 1]:\n for b in [-1, 1]:\n for c in [0, 1]:\n curr = (float('inf') if c == 0 else float('-inf'), -1)\n for i in range(len(points)):\n val = a * points[i][0] + b * points[i][1]\n if c == 0:\n curr = min(curr, (val, i))\n else:\n curr = max(curr, (val, i))\n candidates.add(curr[1])\n d = float('-inf')\n res = None\n for i in range(len(points)):\n for j in candidates:\n if manhattan_distance(points[i], points[j]) > d:\n d = manhattan_distance(points[i], points[j])\n res = (points[i], points[j])\n return res\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n a, b = max_manhattan_distance(points)\n res = manhattan_distance(a, b)\n points.remove(a)\n x, y = max_manhattan_distance(points)\n res = min(res, manhattan_distance(x, y))\n points.append(a)\n points.remove(b)\n x, y = max_manhattan_distance(points)\n res = min(res, manhattan_distance(x, y))\n points.append(a)\n return res","memory":"64099"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def find(emb):\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\n for i, x in enumerate(emb):\n if x<min_val:\n extremmin_idx=set()\n extremmin_idx.add(i)\n min_val=x\n elif x==min_val:\n extremmin_idx.add(i)\n \n if x>max_val:\n extremmax_idx=set()\n extremmax_idx.add(i)\n max_val=x\n elif x==max_val:\n extremmax_idx.add(i)\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\n\n def get_embs(points, exclude={}):\n emb1,emb2,emb3,emb4=[],[],[],[]\n for i, pt in enumerate(points):\n if i not in exclude:\n emb1.append(pt[1]+pt[0])\n emb2.append(pt[1]-pt[0])\n\n dst1,extrem_idx1=find(emb1)\n dst2,extrem_idx2=find(emb2)\n\n dsts=[dst1, dst2]\n extrems=[extrem_idx1, extrem_idx2]\n\n return dsts, extrems\n \n def find_max(dsts):\n if dsts[0]>dsts[1]:\n return 0, dsts[0]\n else:\n return 1, dsts[1]\n\n dsts, extrems=get_embs(points)\n maxi, maxval=find_max(dsts)\n exclude=extrems[maxi]\n\n ans=[]\n for idx in list(exclude):\n dsts,_=get_embs(points, set([idx]))\n maxi, maxval=find_max(dsts)\n ans.append(maxval)\n \n return min(ans)\n ","memory":"64200"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def find(emb):\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\n for i, x in enumerate(emb):\n if x<min_val:\n extremmin_idx=set()\n extremmin_idx.add(i)\n min_val=x\n elif x==min_val:\n extremmin_idx.add(i)\n \n if x>max_val:\n extremmax_idx=set()\n extremmax_idx.add(i)\n max_val=x\n elif x==max_val:\n extremmax_idx.add(i)\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\n\n def get_embs(points, exclude={}):\n emb1,emb2,emb3,emb4=[],[],[],[]\n for i, pt in enumerate(points):\n if i not in exclude:\n emb1.append(pt[1]+pt[0])\n emb2.append(pt[1]-pt[0])\n\n dst1,extrem_idx1=find(emb1)\n dst2,extrem_idx2=find(emb2)\n\n dsts=[dst1, dst2]\n extrems=[extrem_idx1, extrem_idx2]\n\n return dsts, extrems\n \n def find_max(dsts):\n if dsts[0]>dsts[1]:\n return 0, dsts[0]\n else:\n return 1, dsts[1]\n\n dsts, extrems=get_embs(points)\n maxi, maxval=find_max(dsts)\n exclude=extrems[maxi]\n\n ans=[]\n for idx in list(exclude):\n dsts,_=get_embs(points, set([idx]))\n maxi, maxval=find_max(dsts)\n ans.append(maxval)\n \n return min(ans)\n ","memory":"64200"},{"code":"class Solution:\n def get_max_dist(self, points):\n sum_arr = [x+y for x,y in points]\n diff_arr = [x-y for x,y in points]\n return max(max(sum_arr) - min(sum_arr), max(diff_arr) - min(diff_arr))\n def minimumDistance(self, points: List[List[int]]) -> int:\n sum_arr = sorted(points, key = lambda x: x[0] + x[1])\n diff_arr = sorted(points, key = lambda x: x[0] - x[1])\n return min(self.get_max_dist(sum_arr[1:]), self.get_max_dist(sum_arr[:-1]), self.get_max_dist(diff_arr[1:]), self.get_max_dist(diff_arr[:-1]))","memory":"64300"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n L = len(points)\n\n def helper(ignore_idx = -1):\n sums = []\n diffs = []\n\n for i,(x,y) in enumerate(points):\n if i != ignore_idx:\n sums.append((x + y, i))\n diffs.append((x - y, i))\n\n sum_max = max(sums, key= lambda x: x[0])\n sum_min = min(sums, key= lambda x: x[0])\n diff_max = max(diffs, key= lambda x: x[0])\n diff_min = min(diffs, key= lambda x: x[0])\n\n\n val1 = sum_max[0] - sum_min[0] \n val2 = diff_max[0] - diff_min[0]\n if val1 > val2:\n return (sum_min[1], sum_max[1], val1)\n else:\n return (diff_min[1], diff_max[1], val2)\n\n\n idx1, idx2, _ = helper()\n\n val1 = helper(idx1)[2]\n val2 = helper(idx2)[2]\n\n return min(val1, val2)\n \n\n\n\n\n\n \n\n\n \n ","memory":"64400"},{"code":"class Solution:\n def maxmanhattendist(self,points:List[List[int]]) -> int:\n max_sum = float('-inf')\n min_sum = float('inf')\n max_diff = float('-inf')\n min_diff = float('inf')\n min_diff_index = 0\n max_diff_index = 0\n max_sum_index = 0\n min_sum_index = 0\n for i in range(0,len(points)):\n summ = points[i][0] + points[i][1]\n diff = points[i][0] - points[i][1]\n if summ > max_sum:\n max_sum = summ\n max_sum_index = i\n if summ < min_sum:\n min_sum = summ\n min_sum_index = i\n if diff > max_diff:\n max_diff = diff\n max_diff_index = i\n if diff < min_diff:\n min_diff_index = i\n min_diff = diff\n if max_sum - min_sum > max_diff - min_diff:\n return [max_sum_index,min_sum_index,max_sum - min_sum ]\n else:\n return [max_diff_index,min_diff_index,max_diff - min_diff]\n \n \n def minimumDistance(self, points: List[List[int]]) -> int:\n listy = self.maxmanhattendist(points)\n t = points[listy[0]]\n points.pop(listy[0])\n d = self.maxmanhattendist(points)\n points.insert(listy[0], t)\n \n points.pop(listy[1])\n d1 = self.maxmanhattendist(points)\n if d[2] > d1[2]:\n return d1[2]\n else:\n return d[2]","memory":"64400"},{"code":"\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def calculatemanhattan(points: List[List[int]]) -> int:\n max_sum = min_sum = points[0][0] + points[0][1]\n max_diff = min_diff = points[0][0] - points[0][1]\n \n for i in points:\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n max_sum= max(max_sum, summ)\n min_sum =min(min_sum, summ)\n max_diff =max(max_diff, diff)\n min_diff =min(min_diff, diff)\n \n return max(max_sum -min_sum,max_diff- min_diff)\n \n \n max_sum = [0,points[0][0]+ points[0][1]]\n min_sum = [0,points[0][0]+points[0][1]]\n max_diff = [0,points[0][0]-points[0][1]]\n min_diff = [0, points[0][0]- points[0][1]]\n \n for n, i in enumerate(points):\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n \n if summ> max_sum[1]:\n max_sum =[n, summ]\n if summ<min_sum[1]:\n min_sum = [n, summ]\n if diff >max_diff[1]:\n max_diff = [n, diff]\n if diff<min_diff[1]:\n min_diff = [n, diff]\n \n index1 = [max_sum[0], min_sum[0]]\n index2 = [max_diff[0], min_diff[0]]\n \n \n a =float('inf')\n \n \n for idx in index1:\n temp=points[:idx]+points[idx+1:]\n a =min(a, calculatemanhattan(temp))\n \n \n for idx in index2:\n temp = points[:idx]+points[idx+1:]\n a = min(a, calculatemanhattan(temp))\n \n return a\n","memory":"64500"},{"code":"from typing import List\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def calculatemanhattan(points: List[List[int]]) -> int:\n max_sum = min_sum = points[0][0] + points[0][1]\n max_diff = min_diff = points[0][0] - points[0][1]\n \n for i in points:\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n max_sum = max(max_sum, summ)\n min_sum = min(min_sum, summ)\n max_diff = max(max_diff, diff)\n min_diff = min(min_diff, diff)\n \n return max(max_sum - min_sum, max_diff - min_diff)\n \n \n max_sum = [0, points[0][0] + points[0][1]]\n min_sum = [0, points[0][0] + points[0][1]]\n max_diff = [0, points[0][0] - points[0][1]]\n min_diff = [0, points[0][0] - points[0][1]]\n \n for n, i in enumerate(points):\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n \n if summ > max_sum[1]:\n max_sum = [n, summ]\n if summ < min_sum[1]:\n min_sum = [n, summ]\n if diff > max_diff[1]:\n max_diff = [n, diff]\n if diff < min_diff[1]:\n min_diff = [n, diff]\n \n index1 = [max_sum[0], min_sum[0]]\n index2 = [max_diff[0], min_diff[0]]\n \n \n a = float('inf')\n \n \n for idx in index1:\n temp = points[:idx] + points[idx+1:]\n a = min(a, calculatemanhattan(temp))\n \n \n for idx in index2:\n temp = points[:idx] + points[idx+1:]\n a = min(a, calculatemanhattan(temp))\n \n return a\n","memory":"64599"},{"code":"\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def calculatemanhattan(points: List[List[int]]) -> int:\n max_sum = min_sum = points[0][0] + points[0][1]\n max_diff = min_diff = points[0][0] - points[0][1]\n \n for i in points:\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n max_sum = max(max_sum, summ)\n min_sum = min(min_sum, summ)\n max_diff = max(max_diff, diff)\n min_diff = min(min_diff, diff)\n \n return max(max_sum - min_sum, max_diff - min_diff)\n \n \n max_sum = [0, points[0][0] + points[0][1]]\n min_sum = [0, points[0][0] + points[0][1]]\n max_diff = [0, points[0][0] - points[0][1]]\n min_diff = [0, points[0][0] - points[0][1]]\n \n for n, i in enumerate(points):\n summ = i[0] + i[1]\n diff = i[0] - i[1]\n \n if summ > max_sum[1]:\n max_sum = [n, summ]\n if summ < min_sum[1]:\n min_sum = [n, summ]\n if diff > max_diff[1]:\n max_diff = [n, diff]\n if diff < min_diff[1]:\n min_diff = [n, diff]\n \n index1 = [max_sum[0], min_sum[0]]\n index2 = [max_diff[0], min_diff[0]]\n \n \n a = float('inf')\n \n \n for idx in index1:\n temp = points[:idx] + points[idx+1:]\n a = min(a, calculatemanhattan(temp))\n \n \n for idx in index2:\n temp = points[:idx] + points[idx+1:]\n a = min(a, calculatemanhattan(temp))\n \n return a\n","memory":"64599"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def helper(arr):\n min_sum = min(x + y for x, y in arr)\n max_sum = max(x + y for x, y in arr)\n min_diff = min(x - y for x, y in arr)\n max_diff = max(x - y for x, y in arr)\n return max(max_sum - min_sum, max_diff - min_diff)\n \n min_x = sorted(points, key = lambda x : (x[0] + x[1]))\n result = min(helper(min_x[1:]), helper(min_x[:-1]))\n max_x = sorted(points, key = lambda x : (x[0] - x[1]))\n result = min(result, helper(max_x[1:]), helper(max_x[:-1]))\n\n return result","memory":"64700"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n transformed = [[x - y, x + y] for x, y in points]\n # Pre-calculate the minimum and maximum for both dimensions\n min_x = [p[0] for p in transformed]\n max_x = [p[0] for p in transformed]\n min_y = [p[1] for p in transformed]\n max_y = [p[1] for p in transformed]\n \n # Sort the lists so we can easily find the new min and max after excluding a point\n min_x.sort()\n max_x.sort(reverse=True)\n min_y.sort()\n max_y.sort(reverse=True)\n \n candidates = []\n \n for p in transformed:\n # Find the new min and max for x and y after excluding the current point p\n new_min_x = min_x[1] if min_x[0] == p[0] else min_x[0]\n new_max_x = max_x[1] if max_x[0] == p[0] else max_x[0]\n new_min_y = min_y[1] if min_y[0] == p[1] else min_y[0]\n new_max_y = max_y[1] if max_y[0] == p[1] else max_y[0]\n \n # Calculate the maximum distance for the current point\n max_dist = max(new_max_x - new_min_x, new_max_y - new_min_y)\n candidates.append(max_dist)\n \n # Return the minimum of the calculated maximum distances\n return min(candidates)","memory":"65000"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n sl1 = SortedList()\n sl2 = SortedList()\n for x, y in points:\n sl1.add(x + y)\n sl2.add(x - y)\n ans = inf\n for x, y in points:\n sl1.remove(x + y)\n sl2.remove(x - y)\n ans = min(ans, max(sl1[-1] - sl1[0], sl2[-1] - sl2[0]))\n sl1.add(x + y)\n sl2.add(x - y)\n return ans","memory":"65099"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n arr_s, arr_t = [], []\n for i, (x, y) in enumerate(points):\n arr_s.append((x+y, i))\n arr_t.append((y-x, i))\n \n arr_s.sort()\n arr_t.sort()\n ds0, dt0 = arr_s[-1][0] - arr_s[0][0], arr_t[-1][0] - arr_t[0][0]\n ds1, ds2 = arr_s[-2][0] - arr_s[0][0], arr_s[-1][0] - arr_s[1][0]\n dt1, dt2 = arr_t[-2][0] - arr_t[0][0], arr_t[-1][0] - arr_t[1][0]\n idx_s_h, idx_s_t = arr_s[0][1], arr_s[-1][1]\n idx_t_h, idx_t_t = arr_t[0][1], arr_t[-1][1]\n \n book = {(idx_s_h, idx_s_t): ds0, (idx_t_h, idx_t_t): dt0,\n ('s', idx_s_h): ds1, ('s', idx_s_t): ds2, \n ('t', idx_t_h): dt1, ('t', idx_t_t): dt2}\n I = set([idx_s_h, idx_s_t, idx_t_h, idx_t_t])\n \n ans = float('inf')\n for idx in I:\n dist = 0\n for key, val in book.items():\n if idx not in key:\n dist = max(dist, val)\n ans = min(ans, dist)\n return ans","memory":"65200"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n max_distance, point1, point2 = self.get_max_distance(points)\n missing1 = []\n missing2 = []\n found1 = False\n found2 = False\n for point in points:\n if found1 or point != point1:\n missing1.append(point)\n if found2 or point != point2:\n missing2.append(point)\n if point == point1:\n found1 = True\n if point == point2:\n found2 = True\n #missing1 = [point for point in points if point != point1]\n #missing2 = [point for point in points if point != point2]\n option1, t1, t2 = self.get_max_distance(missing1)\n option2, t1, t2 = self.get_max_distance(missing2)\n return min(option1, option2)\n\n def partition(self, points, x_vals, y_vals):\n n = len(points)\n x_vals = sorted(x_vals)\n y_vals = sorted(y_vals)\n x_med = x_vals[n//2]\n y_med = y_vals[n//2]\n center = [x_med, y_med]\n pick_top = True\n pick_left = True\n tl = []\n tr = []\n bl = []\n br = []\n for point in points:\n is_left = False\n is_top = False\n if point[0] < x_med:\n is_left = True\n elif point[0] == x_med:\n is_left = pick_left\n pick_left = not pick_left\n if point[1] > y_med:\n is_top = True\n elif point[1] == y_med:\n is_top = pick_top\n pick_top = not pick_top\n if is_left and is_top:\n tl.append(point)\n elif is_left:\n bl.append(point)\n elif is_top:\n tr.append(point)\n else:\n br.append(point)\n return tl, tr, bl, br, center\n\n def get_max_distance(self, points, ignore_val = None):\n if len(points) < 2:\n return 0, None, None\n if len(points) <= 4:\n return self.get_max_distance_small(points)\n x_vals = [p[0] for p in points]\n y_vals = [p[1] for p in points]\n max_distance = max(x_vals) - min(x_vals) + max(y_vals) - min(y_vals)\n if ignore_val is not None and max_distance <= ignore_val:\n #print(\"skipping: {}\".format(points))\n return -1, None, None\n tl, tr, bl, br, center = self.partition(points, x_vals, y_vals)\n tl_dis, tl_p = self.get_max_distance_from(tl, center)\n tr_dis, tr_p = self.get_max_distance_from(tr, center)\n bl_dis, bl_p = self.get_max_distance_from(bl, center)\n br_dis, br_p = self.get_max_distance_from(br, center)\n if tl_dis + br_dis > tr_dis + bl_dis:\n point1 = tl_p\n point2 = br_p\n max_distance = tl_dis + br_dis\n else:\n point1 = tr_p\n point2 = bl_p\n max_distance = tr_dis + bl_dis\n top_points = tl + tr\n left_points = tl + bl\n right_points = tr + br\n bottom_points = bl + br\n for option in [top_points, left_points, right_points, bottom_points]:\n new_distance, new1, new2 = self.get_max_distance(option, max_distance)\n if new_distance > max_distance:\n max_distance = new_distance\n point1 = new1\n point2 = new2\n #print(\"max of {}: {}\".format(max_distance, points))\n return max_distance, point1, point2\n \n \n def get_max_distance_from(self, points, other):\n max_distance = -1\n point = None\n for p in points:\n cur_distance = abs(p[0]-other[0]) + abs(p[1]-other[1])\n if cur_distance > max_distance:\n max_distance = cur_distance\n point = p\n return max_distance, point\n\n def get_max_distance_small(self, points):\n max_distance = -1\n point1 = None\n point2 = None\n for p1 in points:\n for p2 in points:\n cur_distance = abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])\n if cur_distance > max_distance:\n max_distance = cur_distance\n point1 = p1\n point2 = p2\n #print(\"max of {}: {}\".format(max_distance, points))\n return max_distance, point1, point2","memory":"65300"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def dist(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:\n x1, y1 = p1\n x2, y2 = p2\n return abs(x1 - x2) + abs(y1 - y2)\n \n def getFurtherestPair(arr: List[Tuple[int, int]]) -> int:\n n = len(arr)\n ass = []\n bss = []\n for i in range(n):\n x, y = arr[i]\n a = x + y\n b = x - y\n\n ass.append((a, arr[i]))\n bss.append((b, arr[i]))\n\n candidatePair1 = (max(ass)[1], min(ass)[1])\n candidatePair2 = (max(bss)[1], min(bss)[1])\n\n if dist(*candidatePair1) < dist(*candidatePair2): return candidatePair2\n else: return candidatePair1\n \n pts = [(p[0], p[1]) for p in points]\n\n ans = int(1e18)\n for p in getFurtherestPair(pts):\n # try to remove p\n pts.remove(p)\n newPair = getFurtherestPair(pts)\n ans = min(ans, dist(*newPair))\n pts.append(p)\n \n return ans\n","memory":"66000"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n def dist(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:\n x1, y1 = p1\n x2, y2 = p2\n return abs(x1 - x2) + abs(y1 - y2)\n \n def getFurtherestPair(arr: List[Tuple[int, int]]) -> int:\n n = len(arr)\n ass = []\n bss = []\n for i in range(n):\n x, y = arr[i]\n a = x + y\n b = x - y\n\n ass.append((a, arr[i]))\n bss.append((b, arr[i]))\n ass.sort()\n bss.sort()\n candidatePair1 = (ass[0][1], ass[-1][1])\n candidatePair2 = (bss[0][1], bss[-1][1])\n\n if dist(*candidatePair1) < dist(*candidatePair2): return candidatePair2\n else: return candidatePair1\n \n pts = [(p[0], p[1]) for p in points]\n\n ans = int(1e18)\n for p in getFurtherestPair(pts):\n # try to remove p\n pts.remove(p)\n\n newPair = getFurtherestPair(pts)\n ans = min(ans, dist(*newPair))\n\n pts.append(p)\n \n return ans\n","memory":"66700"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n plus,minus = SortedList(),SortedList()\n for x,y in points:\n plus.add(x+y)\n minus.add(x-y)\n ans = float('inf')\n for x,y in points:\n plus.remove(x+y)\n minus.remove(x-y)\n ans = min(ans,max(plus[-1] - plus[0],minus[-1] - minus[0]))\n plus.add(x+y)\n minus.add(x-y)\n return ans","memory":"66800"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n # traverse through points and picking them out temporarily one at a time\n count=len(points)\n ans=1e9\n\n #SortedList acting like multiset \n st1=SortedList()\n st2=SortedList()\n \n #modified coordinates as per leetcode hints\n \n #insert modified coordinates in the sorted List (or multiset if using C++)\n for pt in range(0,count):\n st1.add(points[pt][0]+ points[pt][1])\n st2.add(points[pt][0]-points[pt][1])\n\n\n for pt in range(0, count):\n x,y =points[pt]\n \n p1= x+y \n p2= x-y\n \n #Remove this point and obtain max distance among \n #other points without affecting original list of points\n st1.discard(p1)\n st2.discard(p2)\n # Since list is sorted so calculation of distance in this manner always result in positive outcomes \n \n # Getting max manhattan distance among current elements\n dist1= st1[len(st1)-1]- st1[0]\n dist2= st2[len(st2)-1]- st2[0]\n dist= max(dist1,dist2)\n \n #Update overall minimized max manhattan distance (on 1 element removal) in ans variable\n ans=min(ans,dist)\n # Reinsert the point \n st1.add(p1)\n st2.add(p2)\n \n\n return ans","memory":"67200"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n n = len(points)\n minimumVal = float('inf')\n\n plus = []\n minus = []\n\n # for each point, store (x+y) and (x-y)\n for i,point in enumerate(points):\n plus.append(ValueIndex(point[0] + point[1], i))\n minus.append(ValueIndex(point[0] - point[1], i))\n\n plus.sort(key=lambda x: x.val)\n minus.sort(key=lambda x: x.val)\n\n # now one by one remove each point and compute answer\n for i in range(n):\n # now we need to find the extreme values from points array after removing point i\n maxPlus = plus[-2].val if plus[-1].idx == i else plus[-1].val\n minPlus = plus[1].val if plus[0].idx == i else plus[0].val\n maxMinus = minus[-2].val if minus[-1].idx == i else minus[-1].val\n minMinus = minus[1].val if minus[0].idx == i else minus[0].val\n\n # maximum manhattan distance after removing point i\n maxAfterRemovingOne = max(maxPlus - minPlus, maxMinus - minMinus)\n\n # update final answer\n minimumVal = min(minimumVal, maxAfterRemovingOne)\n\n return minimumVal\n\n\nclass ValueIndex:\n def __init__(self, v, i):\n self.val = v\n self.idx = i","memory":"68700"},{"code":"class Solution:\n def minimumDistance(self, points: List[List[int]]) -> int:\n \n \n points.sort(key = lambda x: sum(x))\n points_pos = list(map(sum, points))\n d_pos = {}\n for x in range(len(points)):\n d_pos[x] = points_pos[x]\n \n \n d_neg = {}\n for i in range(len(points)):\n d_neg[i] = points[i][0] - points[i][1]\n points_neg = []\n for u, v in d_neg.items():\n points_neg.append([u, v]) \n points_neg.sort(key = lambda x: x[1])\n \n ans = 10 ** 20\n \n for i in range(len(points)):\n s, l = 0, len(points) - 1\n if points_neg[s][0] == i:\n s += 1\n if points_neg[l][0] == i:\n l -= 1 \n neg_diff = abs( points_neg[l][1] - points_neg[s][1] )\n pos_diff = abs( d_pos[ points_neg[l][0] ] - d_pos[ points_neg[s][0] ] )\n\n ans1 = max(neg_diff, pos_diff)\n\n\n s, l = 0, len(points) - 1\n if i == s:\n s += 1\n if i == l:\n l -= 1\n pos_diff = abs( points_pos[l] - points_pos[s] )\n neg_diff = abs( d_neg[l] - d_neg[s] )\n ans2 = max(pos_diff, neg_diff)\n\n fans = max(ans1, ans2)\n ans = min(ans, fans)\n\n return ans","memory":"73800"},{"code":"import numpy as np\nclass Solution:\n def minimumDistance(self, points0: List[List[int]]) -> int:\n def get_max_i_j(points):\n plus_max_i, plus_min_i, minus_max_i, minus_min_i = -1,-1,-1,-1\n x_plus_y_max , x_plus_y_min = float('-inf'), float('inf')\n x_minus_y_max, x_minus_y_min = float('-inf'), float('inf')\n for i,point in enumerate(points):\n x = point[0] \n y = point[1]\n if x + y > x_plus_y_max:\n x_plus_y_max = x + y\n plus_max_i = i\n if x + y < x_plus_y_min:\n x_plus_y_min = x + y\n plus_min_i = i\n if x - y > x_minus_y_max:\n x_minus_y_max = x - y\n minus_max_i = i\n if x - y < x_minus_y_min:\n x_minus_y_min = x - y\n minus_min_i = i\n if x_plus_y_max - x_plus_y_min > x_minus_y_max - x_minus_y_min:\n return x_plus_y_max - x_plus_y_min, plus_max_i, plus_min_i\n else:\n return x_minus_y_max - x_minus_y_min, minus_max_i, minus_min_i\n a , i, j = get_max_i_j( points0 )\n ai, _, _ = get_max_i_j( points0[0:i] + points0[i+1:] )\n aj, _, _ = get_max_i_j( points0[0:j] + points0[j+1:] )\n return min(ai,aj)","memory":"75900"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude=None):\\n emb1,emb2=[],[]\\n for i, pt in enumerate(points):\\n if i!=exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n if dst1>dst2:\\n return dst1, extrem_idx1\\n else:\\n return dst2, extrem_idx2\\n\\n _, exclude=get_embs(points) \\n\\n ans=10**10\\n for idx in exclude:\\n maxval,_=get_embs(points, idx)\\n ans=min(ans, maxval)\\n \\n return ans\\n \",\n \"memory\": \"63400\"\n },\n {\n \"code\": \"class Solution:\\n def manhattan(self, point1, point2):\\n return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])\\n def getMaxManhattanPoints(self, points, remove: int = -1):\\n maxSum = float(\\\"-inf\\\")\\n minSum = float(\\\"inf\\\")\\n maxDiff = float(\\\"-inf\\\")\\n minDiff = float(\\\"inf\\\")\\n maxSumI = -1\\n minSumI = -1\\n maxDiffI = -1\\n minDiffI = -1\\n for i in range(len(points)):\\n if i == remove:\\n continue\\n # Calculate the sum\\n pointSum = points[i][0] + points[i][1]\\n # Calculate the diff\\n pointDiff = points[i][0] - points[i][1]\\n if pointSum > maxSum:\\n maxSum = pointSum\\n maxSumI = i\\n if pointSum < minSum:\\n minSum = pointSum\\n minSumI = i\\n if pointDiff > maxDiff:\\n maxDiff = pointDiff\\n maxDiffI = i\\n if pointDiff < minDiff:\\n minDiff = pointDiff\\n minDiffI = i\\n if maxSum - minSum > maxDiff - minDiff:\\n furthestPoints = (minSumI, maxSumI)\\n else:\\n furthestPoints = (minDiffI, maxDiffI)\\n return furthestPoints\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n # mDist = abs(x1 - x2) + abs(y1 - y2)\\n # Remove 1 point that is the furthest distance from all the other points\\n # Remove each point and calculate the max distance between any 2 points\\n mi, mj = self.getMaxManhattanPoints(points)\\n # Without mi\\n gi, gj = self.getMaxManhattanPoints(points, mi)\\n # Without mj\\n hi, hj = self.getMaxManhattanPoints(points, mj)\\n return min(self.manhattan(points[mi], points[mj]), \\n self.manhattan(points[gi], points[gj]), \\n self.manhattan(points[hi], points[hj]))\\n\",\n \"memory\": \"63500\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u+v for u, v in points)\\n mn_out = min(u+v for u, v in points)\\n\\n mx_in = max(u-v for u, v in points)\\n mn_in = min(u-v for u, v in points)\\n\\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n\\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n return min(max_man_dis)\",\n \"memory\": \"63600\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"memory\": \"63700\"\n },\n {\n \"code\": \"def fun(points):\\n mx_out = max(u + v for u, v in points)\\n mn_out = min(u + v for u, v in points)\\n \\n mx_in = max(u - v for u, v in points)\\n mn_in = min(u - v for u, v in points)\\n \\n return max(mx_out - mn_out, mx_in - mn_in)\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_man_dis = []\\n \\n points.sort(key = lambda x: x[0] + x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n\\n points.sort(key = lambda x: x[0] - x[1])\\n max_man_dis.append(fun(points[1:]))\\n max_man_dis.append(fun(points[:-1]))\\n \\n return min(max_man_dis)\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"def calculate(points):\\n mxa = max(u+v for u,v in points)\\n mina = min(u+v for u,v in points)\\n mxb = max(u-v for u,v in points)\\n minb = min(u-v for u,v in points)\\n return max(mxa-mina, mxb-minb)\\n\\n\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n arr = []\\n points.sort(key = lambda x: x[0]+x[1])\\n arr.append(calculate(points[1:]))\\n arr.append(calculate(points[:-1]))\\n points.sort(key = lambda x: x[0]-x[1])\\n arr.append(calculate(points[1:]))\\n arr.append(calculate(points[:-1]))\\n print(arr)\\n return min(arr)\\n\\n\\n\",\n \"memory\": \"63900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n # Step 1: Compute the transformed coordinates u = x + y and v = x - y\\n u = [x + y for x, y in points]\\n v = [x - y for x, y in points]\\n \\n # Step 2: Find the min and max of u and v\\n u_min, u_max = min(u), max(u)\\n v_min, v_max = min(v), max(v)\\n \\n # Step 3: Find the indices of points that define these min/max values\\n u_min_idx, u_max_idx = u.index(u_min), u.index(u_max)\\n v_min_idx, v_max_idx = v.index(v_min), v.index(v_max)\\n \\n # Step 4: Calculate the maximum distances in u and v\\n def max_distance_without_point(skip_idx):\\n u_list = [u[i] for i in range(n) if i != skip_idx]\\n v_list = [v[i] for i in range(n) if i != skip_idx]\\n max_u_dist = max(u_list) - min(u_list)\\n max_v_dist = max(v_list) - min(v_list)\\n return max(max_u_dist, max_v_dist)\\n \\n # Step 5: Try removing the points that define the extremes in u and v\\n candidates = {u_min_idx, u_max_idx, v_min_idx, v_max_idx}\\n result = float('inf')\\n \\n for idx in candidates:\\n result = min(result, max_distance_without_point(idx))\\n \\n return result\",\n \"memory\": \"64000\"\n },\n {\n \"code\": \"def manhattan_distance(p1, p2):\\n return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])\\n\\ndef max_manhattan_distance(points):\\n candidates = set()\\n for a in [-1, 1]:\\n for b in [-1, 1]:\\n for c in [0, 1]:\\n curr = (float('inf') if c == 0 else float('-inf'), -1)\\n for i in range(len(points)):\\n val = a * points[i][0] + b * points[i][1]\\n if c == 0:\\n curr = min(curr, (val, i))\\n else:\\n curr = max(curr, (val, i))\\n candidates.add(curr[1])\\n d = float('-inf')\\n res = None\\n for i in range(len(points)):\\n for j in candidates:\\n if manhattan_distance(points[i], points[j]) > d:\\n d = manhattan_distance(points[i], points[j])\\n res = (points[i], points[j])\\n return res\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n a, b = max_manhattan_distance(points)\\n res = manhattan_distance(a, b)\\n points.remove(a)\\n x, y = max_manhattan_distance(points)\\n res = min(res, manhattan_distance(x, y))\\n points.append(a)\\n points.remove(b)\\n x, y = max_manhattan_distance(points)\\n res = min(res, manhattan_distance(x, y))\\n points.append(a)\\n return res\",\n \"memory\": \"64099\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude={}):\\n emb1,emb2,emb3,emb4=[],[],[],[]\\n for i, pt in enumerate(points):\\n if i not in exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n \\n def find_max(dsts):\\n if dsts[0]>dsts[1]:\\n return 0, dsts[0]\\n else:\\n return 1, dsts[1]\\n\\n dsts, extrems=get_embs(points)\\n maxi, maxval=find_max(dsts)\\n exclude=extrems[maxi]\\n\\n ans=[]\\n for idx in list(exclude):\\n dsts,_=get_embs(points, set([idx]))\\n maxi, maxval=find_max(dsts)\\n ans.append(maxval)\\n \\n return min(ans)\\n \",\n \"memory\": \"64200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def find(emb):\\n min_val, max_val, extremmax_idx, extremmin_idx=10**10, -10**10, set(), set()\\n for i, x in enumerate(emb):\\n if x<min_val:\\n extremmin_idx=set()\\n extremmin_idx.add(i)\\n min_val=x\\n elif x==min_val:\\n extremmin_idx.add(i)\\n \\n if x>max_val:\\n extremmax_idx=set()\\n extremmax_idx.add(i)\\n max_val=x\\n elif x==max_val:\\n extremmax_idx.add(i)\\n return max_val-min_val, extremmax_idx.union(extremmin_idx)\\n\\n def get_embs(points, exclude={}):\\n emb1,emb2,emb3,emb4=[],[],[],[]\\n for i, pt in enumerate(points):\\n if i not in exclude:\\n emb1.append(pt[1]+pt[0])\\n emb2.append(pt[1]-pt[0])\\n\\n dst1,extrem_idx1=find(emb1)\\n dst2,extrem_idx2=find(emb2)\\n\\n dsts=[dst1, dst2]\\n extrems=[extrem_idx1, extrem_idx2]\\n\\n return dsts, extrems\\n \\n def find_max(dsts):\\n if dsts[0]>dsts[1]:\\n return 0, dsts[0]\\n else:\\n return 1, dsts[1]\\n\\n dsts, extrems=get_embs(points)\\n maxi, maxval=find_max(dsts)\\n exclude=extrems[maxi]\\n\\n ans=[]\\n for idx in list(exclude):\\n dsts,_=get_embs(points, set([idx]))\\n maxi, maxval=find_max(dsts)\\n ans.append(maxval)\\n \\n return min(ans)\\n \",\n \"memory\": \"64200\"\n },\n {\n \"code\": \"class Solution:\\n def get_max_dist(self, points):\\n sum_arr = [x+y for x,y in points]\\n diff_arr = [x-y for x,y in points]\\n return max(max(sum_arr) - min(sum_arr), max(diff_arr) - min(diff_arr))\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n sum_arr = sorted(points, key = lambda x: x[0] + x[1])\\n diff_arr = sorted(points, key = lambda x: x[0] - x[1])\\n return min(self.get_max_dist(sum_arr[1:]), self.get_max_dist(sum_arr[:-1]), self.get_max_dist(diff_arr[1:]), self.get_max_dist(diff_arr[:-1]))\",\n \"memory\": \"64300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n L = len(points)\\n\\n def helper(ignore_idx = -1):\\n sums = []\\n diffs = []\\n\\n for i,(x,y) in enumerate(points):\\n if i != ignore_idx:\\n sums.append((x + y, i))\\n diffs.append((x - y, i))\\n\\n sum_max = max(sums, key= lambda x: x[0])\\n sum_min = min(sums, key= lambda x: x[0])\\n diff_max = max(diffs, key= lambda x: x[0])\\n diff_min = min(diffs, key= lambda x: x[0])\\n\\n\\n val1 = sum_max[0] - sum_min[0] \\n val2 = diff_max[0] - diff_min[0]\\n if val1 > val2:\\n return (sum_min[1], sum_max[1], val1)\\n else:\\n return (diff_min[1], diff_max[1], val2)\\n\\n\\n idx1, idx2, _ = helper()\\n\\n val1 = helper(idx1)[2]\\n val2 = helper(idx2)[2]\\n\\n return min(val1, val2)\\n \\n\\n\\n\\n\\n\\n \\n\\n\\n \\n \",\n \"memory\": \"64400\"\n },\n {\n \"code\": \"class Solution:\\n def maxmanhattendist(self,points:List[List[int]]) -> int:\\n max_sum = float('-inf')\\n min_sum = float('inf')\\n max_diff = float('-inf')\\n min_diff = float('inf')\\n min_diff_index = 0\\n max_diff_index = 0\\n max_sum_index = 0\\n min_sum_index = 0\\n for i in range(0,len(points)):\\n summ = points[i][0] + points[i][1]\\n diff = points[i][0] - points[i][1]\\n if summ > max_sum:\\n max_sum = summ\\n max_sum_index = i\\n if summ < min_sum:\\n min_sum = summ\\n min_sum_index = i\\n if diff > max_diff:\\n max_diff = diff\\n max_diff_index = i\\n if diff < min_diff:\\n min_diff_index = i\\n min_diff = diff\\n if max_sum - min_sum > max_diff - min_diff:\\n return [max_sum_index,min_sum_index,max_sum - min_sum ]\\n else:\\n return [max_diff_index,min_diff_index,max_diff - min_diff]\\n \\n \\n def minimumDistance(self, points: List[List[int]]) -> int:\\n listy = self.maxmanhattendist(points)\\n t = points[listy[0]]\\n points.pop(listy[0])\\n d = self.maxmanhattendist(points)\\n points.insert(listy[0], t)\\n \\n points.pop(listy[1])\\n d1 = self.maxmanhattendist(points)\\n if d[2] > d1[2]:\\n return d1[2]\\n else:\\n return d[2]\",\n \"memory\": \"64400\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum= max(max_sum, summ)\\n min_sum =min(min_sum, summ)\\n max_diff =max(max_diff, diff)\\n min_diff =min(min_diff, diff)\\n \\n return max(max_sum -min_sum,max_diff- min_diff)\\n \\n \\n max_sum = [0,points[0][0]+ points[0][1]]\\n min_sum = [0,points[0][0]+points[0][1]]\\n max_diff = [0,points[0][0]-points[0][1]]\\n min_diff = [0, points[0][0]- points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ> max_sum[1]:\\n max_sum =[n, summ]\\n if summ<min_sum[1]:\\n min_sum = [n, summ]\\n if diff >max_diff[1]:\\n max_diff = [n, diff]\\n if diff<min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a =float('inf')\\n \\n \\n for idx in index1:\\n temp=points[:idx]+points[idx+1:]\\n a =min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx]+points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"memory\": \"64500\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum = max(max_sum, summ)\\n min_sum = min(min_sum, summ)\\n max_diff = max(max_diff, diff)\\n min_diff = min(min_diff, diff)\\n \\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n \\n max_sum = [0, points[0][0] + points[0][1]]\\n min_sum = [0, points[0][0] + points[0][1]]\\n max_diff = [0, points[0][0] - points[0][1]]\\n min_diff = [0, points[0][0] - points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ > max_sum[1]:\\n max_sum = [n, summ]\\n if summ < min_sum[1]:\\n min_sum = [n, summ]\\n if diff > max_diff[1]:\\n max_diff = [n, diff]\\n if diff < min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a = float('inf')\\n \\n \\n for idx in index1:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"memory\": \"64599\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def calculatemanhattan(points: List[List[int]]) -> int:\\n max_sum = min_sum = points[0][0] + points[0][1]\\n max_diff = min_diff = points[0][0] - points[0][1]\\n \\n for i in points:\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n max_sum = max(max_sum, summ)\\n min_sum = min(min_sum, summ)\\n max_diff = max(max_diff, diff)\\n min_diff = min(min_diff, diff)\\n \\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n \\n max_sum = [0, points[0][0] + points[0][1]]\\n min_sum = [0, points[0][0] + points[0][1]]\\n max_diff = [0, points[0][0] - points[0][1]]\\n min_diff = [0, points[0][0] - points[0][1]]\\n \\n for n, i in enumerate(points):\\n summ = i[0] + i[1]\\n diff = i[0] - i[1]\\n \\n if summ > max_sum[1]:\\n max_sum = [n, summ]\\n if summ < min_sum[1]:\\n min_sum = [n, summ]\\n if diff > max_diff[1]:\\n max_diff = [n, diff]\\n if diff < min_diff[1]:\\n min_diff = [n, diff]\\n \\n index1 = [max_sum[0], min_sum[0]]\\n index2 = [max_diff[0], min_diff[0]]\\n \\n \\n a = float('inf')\\n \\n \\n for idx in index1:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n \\n for idx in index2:\\n temp = points[:idx] + points[idx+1:]\\n a = min(a, calculatemanhattan(temp))\\n \\n return a\\n\",\n \"memory\": \"64599\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def helper(arr):\\n min_sum = min(x + y for x, y in arr)\\n max_sum = max(x + y for x, y in arr)\\n min_diff = min(x - y for x, y in arr)\\n max_diff = max(x - y for x, y in arr)\\n return max(max_sum - min_sum, max_diff - min_diff)\\n \\n min_x = sorted(points, key = lambda x : (x[0] + x[1]))\\n result = min(helper(min_x[1:]), helper(min_x[:-1]))\\n max_x = sorted(points, key = lambda x : (x[0] - x[1]))\\n result = min(result, helper(max_x[1:]), helper(max_x[:-1]))\\n\\n return result\",\n \"memory\": \"64700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n transformed = [[x - y, x + y] for x, y in points]\\n # Pre-calculate the minimum and maximum for both dimensions\\n min_x = [p[0] for p in transformed]\\n max_x = [p[0] for p in transformed]\\n min_y = [p[1] for p in transformed]\\n max_y = [p[1] for p in transformed]\\n \\n # Sort the lists so we can easily find the new min and max after excluding a point\\n min_x.sort()\\n max_x.sort(reverse=True)\\n min_y.sort()\\n max_y.sort(reverse=True)\\n \\n candidates = []\\n \\n for p in transformed:\\n # Find the new min and max for x and y after excluding the current point p\\n new_min_x = min_x[1] if min_x[0] == p[0] else min_x[0]\\n new_max_x = max_x[1] if max_x[0] == p[0] else max_x[0]\\n new_min_y = min_y[1] if min_y[0] == p[1] else min_y[0]\\n new_max_y = max_y[1] if max_y[0] == p[1] else max_y[0]\\n \\n # Calculate the maximum distance for the current point\\n max_dist = max(new_max_x - new_min_x, new_max_y - new_min_y)\\n candidates.append(max_dist)\\n \\n # Return the minimum of the calculated maximum distances\\n return min(candidates)\",\n \"memory\": \"65000\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n sl1 = SortedList()\\n sl2 = SortedList()\\n for x, y in points:\\n sl1.add(x + y)\\n sl2.add(x - y)\\n ans = inf\\n for x, y in points:\\n sl1.remove(x + y)\\n sl2.remove(x - y)\\n ans = min(ans, max(sl1[-1] - sl1[0], sl2[-1] - sl2[0]))\\n sl1.add(x + y)\\n sl2.add(x - y)\\n return ans\",\n \"memory\": \"65099\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n arr_s, arr_t = [], []\\n for i, (x, y) in enumerate(points):\\n arr_s.append((x+y, i))\\n arr_t.append((y-x, i))\\n \\n arr_s.sort()\\n arr_t.sort()\\n ds0, dt0 = arr_s[-1][0] - arr_s[0][0], arr_t[-1][0] - arr_t[0][0]\\n ds1, ds2 = arr_s[-2][0] - arr_s[0][0], arr_s[-1][0] - arr_s[1][0]\\n dt1, dt2 = arr_t[-2][0] - arr_t[0][0], arr_t[-1][0] - arr_t[1][0]\\n idx_s_h, idx_s_t = arr_s[0][1], arr_s[-1][1]\\n idx_t_h, idx_t_t = arr_t[0][1], arr_t[-1][1]\\n \\n book = {(idx_s_h, idx_s_t): ds0, (idx_t_h, idx_t_t): dt0,\\n ('s', idx_s_h): ds1, ('s', idx_s_t): ds2, \\n ('t', idx_t_h): dt1, ('t', idx_t_t): dt2}\\n I = set([idx_s_h, idx_s_t, idx_t_h, idx_t_t])\\n \\n ans = float('inf')\\n for idx in I:\\n dist = 0\\n for key, val in book.items():\\n if idx not in key:\\n dist = max(dist, val)\\n ans = min(ans, dist)\\n return ans\",\n \"memory\": \"65200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n max_distance, point1, point2 = self.get_max_distance(points)\\n missing1 = []\\n missing2 = []\\n found1 = False\\n found2 = False\\n for point in points:\\n if found1 or point != point1:\\n missing1.append(point)\\n if found2 or point != point2:\\n missing2.append(point)\\n if point == point1:\\n found1 = True\\n if point == point2:\\n found2 = True\\n #missing1 = [point for point in points if point != point1]\\n #missing2 = [point for point in points if point != point2]\\n option1, t1, t2 = self.get_max_distance(missing1)\\n option2, t1, t2 = self.get_max_distance(missing2)\\n return min(option1, option2)\\n\\n def partition(self, points, x_vals, y_vals):\\n n = len(points)\\n x_vals = sorted(x_vals)\\n y_vals = sorted(y_vals)\\n x_med = x_vals[n//2]\\n y_med = y_vals[n//2]\\n center = [x_med, y_med]\\n pick_top = True\\n pick_left = True\\n tl = []\\n tr = []\\n bl = []\\n br = []\\n for point in points:\\n is_left = False\\n is_top = False\\n if point[0] < x_med:\\n is_left = True\\n elif point[0] == x_med:\\n is_left = pick_left\\n pick_left = not pick_left\\n if point[1] > y_med:\\n is_top = True\\n elif point[1] == y_med:\\n is_top = pick_top\\n pick_top = not pick_top\\n if is_left and is_top:\\n tl.append(point)\\n elif is_left:\\n bl.append(point)\\n elif is_top:\\n tr.append(point)\\n else:\\n br.append(point)\\n return tl, tr, bl, br, center\\n\\n def get_max_distance(self, points, ignore_val = None):\\n if len(points) < 2:\\n return 0, None, None\\n if len(points) <= 4:\\n return self.get_max_distance_small(points)\\n x_vals = [p[0] for p in points]\\n y_vals = [p[1] for p in points]\\n max_distance = max(x_vals) - min(x_vals) + max(y_vals) - min(y_vals)\\n if ignore_val is not None and max_distance <= ignore_val:\\n #print(\\\"skipping: {}\\\".format(points))\\n return -1, None, None\\n tl, tr, bl, br, center = self.partition(points, x_vals, y_vals)\\n tl_dis, tl_p = self.get_max_distance_from(tl, center)\\n tr_dis, tr_p = self.get_max_distance_from(tr, center)\\n bl_dis, bl_p = self.get_max_distance_from(bl, center)\\n br_dis, br_p = self.get_max_distance_from(br, center)\\n if tl_dis + br_dis > tr_dis + bl_dis:\\n point1 = tl_p\\n point2 = br_p\\n max_distance = tl_dis + br_dis\\n else:\\n point1 = tr_p\\n point2 = bl_p\\n max_distance = tr_dis + bl_dis\\n top_points = tl + tr\\n left_points = tl + bl\\n right_points = tr + br\\n bottom_points = bl + br\\n for option in [top_points, left_points, right_points, bottom_points]:\\n new_distance, new1, new2 = self.get_max_distance(option, max_distance)\\n if new_distance > max_distance:\\n max_distance = new_distance\\n point1 = new1\\n point2 = new2\\n #print(\\\"max of {}: {}\\\".format(max_distance, points))\\n return max_distance, point1, point2\\n \\n \\n def get_max_distance_from(self, points, other):\\n max_distance = -1\\n point = None\\n for p in points:\\n cur_distance = abs(p[0]-other[0]) + abs(p[1]-other[1])\\n if cur_distance > max_distance:\\n max_distance = cur_distance\\n point = p\\n return max_distance, point\\n\\n def get_max_distance_small(self, points):\\n max_distance = -1\\n point1 = None\\n point2 = None\\n for p1 in points:\\n for p2 in points:\\n cur_distance = abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])\\n if cur_distance > max_distance:\\n max_distance = cur_distance\\n point1 = p1\\n point2 = p2\\n #print(\\\"max of {}: {}\\\".format(max_distance, points))\\n return max_distance, point1, point2\",\n \"memory\": \"65300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def dist(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:\\n x1, y1 = p1\\n x2, y2 = p2\\n return abs(x1 - x2) + abs(y1 - y2)\\n \\n def getFurtherestPair(arr: List[Tuple[int, int]]) -> int:\\n n = len(arr)\\n ass = []\\n bss = []\\n for i in range(n):\\n x, y = arr[i]\\n a = x + y\\n b = x - y\\n\\n ass.append((a, arr[i]))\\n bss.append((b, arr[i]))\\n\\n candidatePair1 = (max(ass)[1], min(ass)[1])\\n candidatePair2 = (max(bss)[1], min(bss)[1])\\n\\n if dist(*candidatePair1) < dist(*candidatePair2): return candidatePair2\\n else: return candidatePair1\\n \\n pts = [(p[0], p[1]) for p in points]\\n\\n ans = int(1e18)\\n for p in getFurtherestPair(pts):\\n # try to remove p\\n pts.remove(p)\\n newPair = getFurtherestPair(pts)\\n ans = min(ans, dist(*newPair))\\n pts.append(p)\\n \\n return ans\\n\",\n \"memory\": \"66000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n def dist(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:\\n x1, y1 = p1\\n x2, y2 = p2\\n return abs(x1 - x2) + abs(y1 - y2)\\n \\n def getFurtherestPair(arr: List[Tuple[int, int]]) -> int:\\n n = len(arr)\\n ass = []\\n bss = []\\n for i in range(n):\\n x, y = arr[i]\\n a = x + y\\n b = x - y\\n\\n ass.append((a, arr[i]))\\n bss.append((b, arr[i]))\\n ass.sort()\\n bss.sort()\\n candidatePair1 = (ass[0][1], ass[-1][1])\\n candidatePair2 = (bss[0][1], bss[-1][1])\\n\\n if dist(*candidatePair1) < dist(*candidatePair2): return candidatePair2\\n else: return candidatePair1\\n \\n pts = [(p[0], p[1]) for p in points]\\n\\n ans = int(1e18)\\n for p in getFurtherestPair(pts):\\n # try to remove p\\n pts.remove(p)\\n\\n newPair = getFurtherestPair(pts)\\n ans = min(ans, dist(*newPair))\\n\\n pts.append(p)\\n \\n return ans\\n\",\n \"memory\": \"66700\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n plus,minus = SortedList(),SortedList()\\n for x,y in points:\\n plus.add(x+y)\\n minus.add(x-y)\\n ans = float('inf')\\n for x,y in points:\\n plus.remove(x+y)\\n minus.remove(x-y)\\n ans = min(ans,max(plus[-1] - plus[0],minus[-1] - minus[0]))\\n plus.add(x+y)\\n minus.add(x-y)\\n return ans\",\n \"memory\": \"66800\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n # traverse through points and picking them out temporarily one at a time\\n count=len(points)\\n ans=1e9\\n\\n #SortedList acting like multiset \\n st1=SortedList()\\n st2=SortedList()\\n \\n #modified coordinates as per leetcode hints\\n \\n #insert modified coordinates in the sorted List (or multiset if using C++)\\n for pt in range(0,count):\\n st1.add(points[pt][0]+ points[pt][1])\\n st2.add(points[pt][0]-points[pt][1])\\n\\n\\n for pt in range(0, count):\\n x,y =points[pt]\\n \\n p1= x+y \\n p2= x-y\\n \\n #Remove this point and obtain max distance among \\n #other points without affecting original list of points\\n st1.discard(p1)\\n st2.discard(p2)\\n # Since list is sorted so calculation of distance in this manner always result in positive outcomes \\n \\n # Getting max manhattan distance among current elements\\n dist1= st1[len(st1)-1]- st1[0]\\n dist2= st2[len(st2)-1]- st2[0]\\n dist= max(dist1,dist2)\\n \\n #Update overall minimized max manhattan distance (on 1 element removal) in ans variable\\n ans=min(ans,dist)\\n # Reinsert the point \\n st1.add(p1)\\n st2.add(p2)\\n \\n\\n return ans\",\n \"memory\": \"67200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n n = len(points)\\n minimumVal = float('inf')\\n\\n plus = []\\n minus = []\\n\\n # for each point, store (x+y) and (x-y)\\n for i,point in enumerate(points):\\n plus.append(ValueIndex(point[0] + point[1], i))\\n minus.append(ValueIndex(point[0] - point[1], i))\\n\\n plus.sort(key=lambda x: x.val)\\n minus.sort(key=lambda x: x.val)\\n\\n # now one by one remove each point and compute answer\\n for i in range(n):\\n # now we need to find the extreme values from points array after removing point i\\n maxPlus = plus[-2].val if plus[-1].idx == i else plus[-1].val\\n minPlus = plus[1].val if plus[0].idx == i else plus[0].val\\n maxMinus = minus[-2].val if minus[-1].idx == i else minus[-1].val\\n minMinus = minus[1].val if minus[0].idx == i else minus[0].val\\n\\n # maximum manhattan distance after removing point i\\n maxAfterRemovingOne = max(maxPlus - minPlus, maxMinus - minMinus)\\n\\n # update final answer\\n minimumVal = min(minimumVal, maxAfterRemovingOne)\\n\\n return minimumVal\\n\\n\\nclass ValueIndex:\\n def __init__(self, v, i):\\n self.val = v\\n self.idx = i\",\n \"memory\": \"68700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDistance(self, points: List[List[int]]) -> int:\\n \\n \\n points.sort(key = lambda x: sum(x))\\n points_pos = list(map(sum, points))\\n d_pos = {}\\n for x in range(len(points)):\\n d_pos[x] = points_pos[x]\\n \\n \\n d_neg = {}\\n for i in range(len(points)):\\n d_neg[i] = points[i][0] - points[i][1]\\n points_neg = []\\n for u, v in d_neg.items():\\n points_neg.append([u, v]) \\n points_neg.sort(key = lambda x: x[1])\\n \\n ans = 10 ** 20\\n \\n for i in range(len(points)):\\n s, l = 0, len(points) - 1\\n if points_neg[s][0] == i:\\n s += 1\\n if points_neg[l][0] == i:\\n l -= 1 \\n neg_diff = abs( points_neg[l][1] - points_neg[s][1] )\\n pos_diff = abs( d_pos[ points_neg[l][0] ] - d_pos[ points_neg[s][0] ] )\\n\\n ans1 = max(neg_diff, pos_diff)\\n\\n\\n s, l = 0, len(points) - 1\\n if i == s:\\n s += 1\\n if i == l:\\n l -= 1\\n pos_diff = abs( points_pos[l] - points_pos[s] )\\n neg_diff = abs( d_neg[l] - d_neg[s] )\\n ans2 = max(pos_diff, neg_diff)\\n\\n fans = max(ans1, ans2)\\n ans = min(ans, fans)\\n\\n return ans\",\n \"memory\": \"73800\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minimumDistance(self, points0: List[List[int]]) -> int:\\n def get_max_i_j(points):\\n plus_max_i, plus_min_i, minus_max_i, minus_min_i = -1,-1,-1,-1\\n x_plus_y_max , x_plus_y_min = float('-inf'), float('inf')\\n x_minus_y_max, x_minus_y_min = float('-inf'), float('inf')\\n for i,point in enumerate(points):\\n x = point[0] \\n y = point[1]\\n if x + y > x_plus_y_max:\\n x_plus_y_max = x + y\\n plus_max_i = i\\n if x + y < x_plus_y_min:\\n x_plus_y_min = x + y\\n plus_min_i = i\\n if x - y > x_minus_y_max:\\n x_minus_y_max = x - y\\n minus_max_i = i\\n if x - y < x_minus_y_min:\\n x_minus_y_min = x - y\\n minus_min_i = i\\n if x_plus_y_max - x_plus_y_min > x_minus_y_max - x_minus_y_min:\\n return x_plus_y_max - x_plus_y_min, plus_max_i, plus_min_i\\n else:\\n return x_minus_y_max - x_minus_y_min, minus_max_i, minus_min_i\\n a , i, j = get_max_i_j( points0 )\\n ai, _, _ = get_max_i_j( points0[0:i] + points0[i+1:] )\\n aj, _, _ = get_max_i_j( points0[0:j] + points0[j+1:] )\\n return min(ai,aj)\",\n \"memory\": \"75900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":28,"string":"28"}}},{"rowIdx":2432,"cells":{"question_id":{"kind":"number","value":3394,"string":"3,394"},"name":{"kind":"string","value":"minimum-array-end"},"content":{"kind":"string","value":"<p>You are given two integers <code>n</code> and <code>x</code>. You have to construct an array of <strong>positive</strong> integers <code>nums</code> of size <code>n</code> where for every <code>0 <= i < n - 1</code>, <code>nums[i + 1]</code> is <strong>greater than</strong> <code>nums[i]</code>, and the result of the bitwise <code>AND</code> operation between all elements of <code>nums</code> is <code>x</code>.</p>\n\n<p>Return the <strong>minimum</strong> possible value of <code>nums[n - 1]</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 3, x = 4</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">6</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><code>nums</code> can be <code>[4,5,6]</code> and its last element is 6.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 2, x = 7</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">15</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><code>nums</code> can be <code>[7,15]</code> and its last element is 15.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n, x <= 10<sup>8</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":38.11672441114066,"string":"38.116724"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["bit-manipulation"],"string":"[\n \"bit-manipulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19\", 0.6024], [\"22\", 0.6024], [\"23\", 0.6024], [\"26\", 1.2048], [\"27\", 0.6024], [\"28\", 0.6024], [\"29\", 1.2048], [\"30\", 5.4217], [\"31\", 3.012], [\"32\", 4.8193], [\"33\", 7.2289], [\"34\", 2.4096], [\"35\", 6.6265], [\"36\", 8.4337], [\"37\", 4.8193], [\"38\", 7.2289], [\"39\", 9.0361], [\"40\", 9.0361], [\"41\", 2.4096], [\"42\", 4.8193], [\"43\", 1.8072], [\"44\", 4.2169], [\"45\", 6.0241], [\"46\", 1.8072]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 0.6024], [\"16400\", 18.0723], [\"16500\", 45.1807]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n temp = bin(n - 1)[2:]\n newX = bin(x)[2:]\n for i in reversed(range(len(newX))):\n if newX[i] == '1':\n index = len(temp) - len(newX) + i + 1\n while index < 0:\n temp = '0' + temp\n index = index + 1\n temp = temp[:index] + '1' + temp[index:]\n return int(temp, 2)","runtime":"19"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n x = list(reversed((str(bin(x))[2:])))\n n = list(reversed(str(bin(n-1))[2:]))\n\n i = 0\n\n for m in n:\n while x[i] != \"0\":\n if i == len(x) - 1:\n x.append(\"0\")\n i += 1\n x[i] = m\n if i == len(x) - 1:\n x.append(\"0\")\n i += 1\n \n return(int(\"\".join(reversed(x)), 2))\n\n \n\n\n","runtime":"22"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n m = n - 1\n num = []\n \n # Convert m to binary and store in num\n while m > 0:\n num.append(m % 2)\n m //= 2\n\n bits = []\n \n # Convert x to binary and store in bits\n while x > 0:\n bits.append(x % 2)\n x //= 2\n\n j = 0\n # Replace 0 bits in bits with corresponding bits from num\n for i in range(len(bits)):\n if bits[i] == 1:\n continue\n if j < len(num):\n bits[i] = num[j]\n j += 1\n\n # Append remaining bits from num to bits\n while j < len(num):\n bits.append(num[j])\n j += 1\n\n # Convert binary list to integer\n ret = 0\n for j in range(len(bits)-1, -1, -1):\n ret = ret * 2 + bits[j]\n\n return ret","runtime":"23"},{"code":"from math import log\nclass Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1:\n return x\n x_bin_str = bin(x)[2:]\n no_of_zeros = 0\n set_positions = []\n for i in range(len(x_bin_str)-1, -1, -1):\n if x_bin_str[i] == \"1\":\n set_positions.append(i)\n else:\n no_of_zeros += 1\n \n no_of_bits = int(log(n-1, 2))\n starting_number = pow(2, no_of_bits)\n\n delta = (n-1) - starting_number \n bin_starting_number = bin(starting_number)[2:]\n rhs = ''\n lhs = bin_starting_number\n if delta:\n rhs = bin(delta)[2:]\n print(f\"delta_bin:{rhs}\")\n lhs = bin_starting_number[:len(bin_starting_number)-len(rhs)]\n to_merge = lhs + rhs\n if len(to_merge) > no_of_zeros:\n diff = len(to_merge) - no_of_zeros\n x_bin_str = ('0'* diff) + x_bin_str\n \n ptr = len(x_bin_str) -1\n x_bin_list = list(x_bin_str)\n\n \n for i in range(len(to_merge)-1, -1, -1):\n while(ptr >=0 and x_bin_list[ptr] != '0'):\n ptr -=1 \n if to_merge[i] == '1':\n x_bin_list[ptr] = '1'\n ptr -=1 \n \n return int(''.join(x_bin_list) , 2)\n\n\n ","runtime":"26"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n a = list(bin(n - 1)[2:])\n b = list(bin(x)[2:])\n for i in range(len(b) - 1, -1, -1):\n if b[i] == '0' and a:\n b[i] = a.pop()\n return int(''.join(a + b), 2)","runtime":"27"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n tmp = x\n ret = 0\n\n remain = n - 1\n\n current_base = 1\n while remain:\n current_bit = remain & 1\n remain >>= 1\n \n while tmp & 1:\n tmp >>= 1\n ret |= current_base\n current_base <<= 1\n \n\n tmp >>= 1\n if current_bit == 1:\n ret |= current_base\n current_base <<= 1\n \n while tmp:\n if tmp & 1:\n ret |= current_base\n tmp >>= 1\n current_base <<= 1\n \n return ret","runtime":"28"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n s = bin(n)[2:]\n y = list('0'*len(s) + bin(x)[2:])\n j = len(y)-1\n for i in reversed(range(len(s))):\n while y[j] == '1':\n j-=1\n if s[i] == '1':\n y[j] = '1'\n j -= 1\n \n print(y)\n return int(''.join(y),2)\n\n ","runtime":"29"},{"code":"class Solution:\n def minEnd(self, n: int, x: int, bit = 1) -> int:\n # Example: n = 14, x = 5\n\n n -= 1 # n bit x\n # --- --- ---\n while n: # 13 1 5\n # 13 2 5 \n while x & bit: # 6 4 7 \n bit*= 2 # 6 8 7\n # 3 16 7 \n if n & 1: x^= bit # 1 32 23\n n//= 2 # 0 64 55 <-- return 55\n bit*= 2\n\n return x ","runtime":"30"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n \n pos = 0\n n -= 1\n \n while n:\n\n bit = n & 1\n n = n >> 1\n # search for a zero bit\n while x & (1 << pos):\n pos += 1\n x = x ^ bit << pos\n pos += 1\n\n return x","runtime":"31"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1: return x\n get = bin(x)[2:]\n zeros = get.count(\"0\")\n ones, ones_z = divmod(n - 1, (int(\"1\" * zeros, 2) if zeros else 0) + 1)\n \n res, put = \"\", bin(ones_z)[2:]\n get = list(get)\n i, j = len(get) - 1, len(put) - 1\n print(put)\n while i >= 0:\n if get[i] == \"0\" and j >= 0:\n get[i] = put[j]\n j -= 1\n i -= 1\n \n return int(bin(ones)[2:] + \"\".join(get), 2)","runtime":"32"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1: return x\n get = bin(x)[2:]\n zeros = get.count(\"0\")\n ones, ones_z = divmod(n - 1, (int(\"1\" * zeros, 2) if zeros else 0) + 1)\n \n res, put = \"\", bin(ones_z)[2:]\n get = list(get)\n i, j = len(get) - 1, len(put) - 1\n while j >= 0 and i >= 0:\n if get[i] == \"0\":\n get[i] = put[j]\n j -= 1\n i -= 1\n \n return int(bin(ones)[2:] + \"\".join(get), 2)","runtime":"32"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1: return x\n get = bin(x)[2:]\n zeros = get.count(\"0\")\n ones, ones_z = divmod(n - 1, (int(\"1\" * zeros, 2) if zeros else 0) + 1)\n \n res, put = \"\", bin(ones_z)[2:]\n get = list(get)\n i, j = len(get) - 1, len(put) - 1\n print(put)\n while i >= 0:\n if get[i] == \"0\" and j >= 0:\n get[i] = put[j]\n j -= 1\n i -= 1\n \n return int(bin(ones)[2:] + \"\".join(get), 2)","runtime":"33"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n # length of the array is n \n # and of all elements is x \n # nums[i+1] > nums[i] \n #0 0 0 1 1 0 1 0 0 1 0 = x ===> the set bits must exist in all the elements \n # 0 1 1 1 \n # 1 1 1 1 \n length = 50\n arr = [0] * length\n for i in range(length):\n arr[length-i-1] = (x>>i)&1\n n = n - 1\n i = length - 1 \n while n:\n if arr[i] == 0:\n arr[i] = n % 2 \n n //= 2\n i -= 1\n result = 0 \n for i in range(length):\n result = result * 2 + arr[i]\n return int(result) \n \n ","runtime":"33"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n ans = x\n for i in range(31):\n if x >> i & 1 ^ 1:\n ans |= (n & 1) << i\n n >>= 1\n ans |= n << 31\n return ans","runtime":"34"},{"code":"class Solution:\n def minEnd(self, n, x):\n i,n = 0,n-1 \n\n while n:\n if (x>>i)&1 == 0:\n x = x|(n&1)<<i \n n = n>>1 \n i += 1 \n\n return x ","runtime":"35"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n tobin = format(x, 'b')\n count0 = 0\n for i in tobin:\n if i == '0':\n count0 += 1\n extra0 = 0\n while 2**(count0 + extra0) < n:\n extra0 += 1\n tobin = '0'*extra0 + tobin\n change = format(n-1, 'b')\n change = '0'*(extra0 + count0 - len(change)) + change\n index = 0\n out = []\n for i in range(len(tobin)):\n if tobin[i] == '0':\n out.append(change[index])\n index += 1\n else:\n out.append('1')\n return int(''.join(out), 2)\n\n return 0","runtime":"36"},{"code":"class Solution:\n def minEnd(self, n, x):\n i,n = 0,n-1 \n\n while n:\n if (x>>i)&1 == 0:\n x = x|(n&1)<<i \n n = n>>1 \n i += 1 \n\n return x ","runtime":"37"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n\n x_bin = bin(x)[2:]\n s = len(bin(10**20)[2:])\n nums = list(x_bin.zfill(s))\n \n zeroes = []\n for i in range(len(nums)):\n if nums[i] == '0':\n zeroes.append(i)\n\n bi = bin(n - 1)[2:][::-1]\n c = 0\n for index in zeroes[::-1]:\n if c >= len(bi):\n break\n nums[index] = bi[c]\n c += 1\n\n res = \"\".join(nums)\n return int(res, 2)","runtime":"38"},{"code":"class Solution:\n def minEnd(self, n: int, x: int, bit = 1) -> int:\n \n\n n -= 1 \n \n while n: \n \n while x & bit: \n bit*= 2 \n \n if n & 1: x^= bit \n n//= 2 \n bit*= 2\n\n return x ","runtime":"39"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n x_bin = bin(x)[2:]\n s = len(str(bin(10**20)))\n nums = list(x_bin.zfill(s))\n zeroes = []\n for i in range(len(nums)):\n if nums[i] == '0':\n zeroes.append(i)\n \n bi = bin(n-1)[2:][::-1]\n c = 0\n for index in zeroes[::-1]:\n if c >= len(bi):\n break\n nums[index] = bi[c]\n c+=1\n\n res = \"\".join(nums)\n return eval('0b'+res)","runtime":"40"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n i = j = 0\n # put jth bit of n into ith bit of x\n while n >> j:\n bit = n >> j & 1\n if x >> i & 1 == 0:\n x |= bit << i\n j += 1\n i += 1\n return x","runtime":"41"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n arr=[]\n for i in range(64):\n if(x&(1<<i)):\n continue\n arr.append(i)\n n-=1\n j=0\n ans=x\n for i in range(64):\n if(n&(1<<i)):\n ans|=(1<<arr[j])\n j+=1\n return ans\n ","runtime":"42"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n bits = []\n pow = 1\n for i in range(n.bit_length()):\n while pow & x: pow *= 2\n bits += [pow]\n pow *= 2\n output = x\n for i, pow in enumerate(bits):\n if 2**i & n: output += pow\n return output","runtime":"43"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n # list(bin(x)) -> ['0', 'b', '1', '0', '0']\n # list(bin(x)[2:]) -> ['1', '0', '0']\n x_bin = list(bin(x)[2:])\n n_bin = list(bin(n)[2:])\n\n # rightmost bit of n\n j = len(n_bin) - 1\n\n # Traverse in reverse, filling all n_bin bits into 0 bits in x\n for i in range(len(x_bin) - 1, -1, -1):\n # leave bits of 1 alone\n if x_bin[i] == \"1\": continue\n x_bin[i] = n_bin[j]\n \n # shift pointer to the left\n j -= 1\n \n # if there's no n_bin bit left\n if j == -1: break\n \n # add the remaining bits of n to the beginning of bits of x\n if j >= 0:\n x_bin = n_bin[0 : j + 1] + x_bin\n \n return int(\"\".join(x_bin), 2)","runtime":"44"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1: return x\n get = bin(x)[2:]\n zeros = get.count(\"0\")\n ones, ones_z = divmod(n - 1, (int(\"1\" * zeros, 2) if zeros else 0) + 1)\n \n res, put = \"\", bin(ones_z)[2:]\n get = list(get)\n i, j = len(get) - 1, len(put) - 1\n print(put)\n while i >= 0:\n if get[i] == \"0\" and j >= 0:\n get[i] = put[j]\n j -= 1\n i -= 1\n \n return int(bin(ones)[2:] + \"\".join(get), 2)","runtime":"45"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n if n == 1: return x\n get = bin(x)[2:]\n zeros = get.count(\"0\")\n ones, ones_z = divmod(n - 1, (int(\"1\" * zeros, 2) if zeros else 0) + 1)\n \n res, put = \"\", bin(ones_z)[2:]\n get = list(get)\n i, j = len(get) - 1, len(put) - 1\n while i >= 0:\n if get[i] == \"0\" and j >= 0:\n get[i] = put[j]\n j -= 1\n i -= 1\n \n return int(bin(ones)[2:] + \"\".join(get), 2)","runtime":"46"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n temp = bin(n - 1)[2:]\\n newX = bin(x)[2:]\\n for i in reversed(range(len(newX))):\\n if newX[i] == '1':\\n index = len(temp) - len(newX) + i + 1\\n while index < 0:\\n temp = '0' + temp\\n index = index + 1\\n temp = temp[:index] + '1' + temp[index:]\\n return int(temp, 2)\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n x = list(reversed((str(bin(x))[2:])))\\n n = list(reversed(str(bin(n-1))[2:]))\\n\\n i = 0\\n\\n for m in n:\\n while x[i] != \\\"0\\\":\\n if i == len(x) - 1:\\n x.append(\\\"0\\\")\\n i += 1\\n x[i] = m\\n if i == len(x) - 1:\\n x.append(\\\"0\\\")\\n i += 1\\n \\n return(int(\\\"\\\".join(reversed(x)), 2))\\n\\n \\n\\n\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n m = n - 1\\n num = []\\n \\n # Convert m to binary and store in num\\n while m > 0:\\n num.append(m % 2)\\n m //= 2\\n\\n bits = []\\n \\n # Convert x to binary and store in bits\\n while x > 0:\\n bits.append(x % 2)\\n x //= 2\\n\\n j = 0\\n # Replace 0 bits in bits with corresponding bits from num\\n for i in range(len(bits)):\\n if bits[i] == 1:\\n continue\\n if j < len(num):\\n bits[i] = num[j]\\n j += 1\\n\\n # Append remaining bits from num to bits\\n while j < len(num):\\n bits.append(num[j])\\n j += 1\\n\\n # Convert binary list to integer\\n ret = 0\\n for j in range(len(bits)-1, -1, -1):\\n ret = ret * 2 + bits[j]\\n\\n return ret\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"from math import log\\nclass Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1:\\n return x\\n x_bin_str = bin(x)[2:]\\n no_of_zeros = 0\\n set_positions = []\\n for i in range(len(x_bin_str)-1, -1, -1):\\n if x_bin_str[i] == \\\"1\\\":\\n set_positions.append(i)\\n else:\\n no_of_zeros += 1\\n \\n no_of_bits = int(log(n-1, 2))\\n starting_number = pow(2, no_of_bits)\\n\\n delta = (n-1) - starting_number \\n bin_starting_number = bin(starting_number)[2:]\\n rhs = ''\\n lhs = bin_starting_number\\n if delta:\\n rhs = bin(delta)[2:]\\n print(f\\\"delta_bin:{rhs}\\\")\\n lhs = bin_starting_number[:len(bin_starting_number)-len(rhs)]\\n to_merge = lhs + rhs\\n if len(to_merge) > no_of_zeros:\\n diff = len(to_merge) - no_of_zeros\\n x_bin_str = ('0'* diff) + x_bin_str\\n \\n ptr = len(x_bin_str) -1\\n x_bin_list = list(x_bin_str)\\n\\n \\n for i in range(len(to_merge)-1, -1, -1):\\n while(ptr >=0 and x_bin_list[ptr] != '0'):\\n ptr -=1 \\n if to_merge[i] == '1':\\n x_bin_list[ptr] = '1'\\n ptr -=1 \\n \\n return int(''.join(x_bin_list) , 2)\\n\\n\\n \",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n a = list(bin(n - 1)[2:])\\n b = list(bin(x)[2:])\\n for i in range(len(b) - 1, -1, -1):\\n if b[i] == '0' and a:\\n b[i] = a.pop()\\n return int(''.join(a + b), 2)\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n tmp = x\\n ret = 0\\n\\n remain = n - 1\\n\\n current_base = 1\\n while remain:\\n current_bit = remain & 1\\n remain >>= 1\\n \\n while tmp & 1:\\n tmp >>= 1\\n ret |= current_base\\n current_base <<= 1\\n \\n\\n tmp >>= 1\\n if current_bit == 1:\\n ret |= current_base\\n current_base <<= 1\\n \\n while tmp:\\n if tmp & 1:\\n ret |= current_base\\n tmp >>= 1\\n current_base <<= 1\\n \\n return ret\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n s = bin(n)[2:]\\n y = list('0'*len(s) + bin(x)[2:])\\n j = len(y)-1\\n for i in reversed(range(len(s))):\\n while y[j] == '1':\\n j-=1\\n if s[i] == '1':\\n y[j] = '1'\\n j -= 1\\n \\n print(y)\\n return int(''.join(y),2)\\n\\n \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int, bit = 1) -> int:\\n # Example: n = 14, x = 5\\n\\n n -= 1 # n bit x\\n # --- --- ---\\n while n: # 13 1 5\\n # 13 2 5 \\n while x & bit: # 6 4 7 \\n bit*= 2 # 6 8 7\\n # 3 16 7 \\n if n & 1: x^= bit # 1 32 23\\n n//= 2 # 0 64 55 <-- return 55\\n bit*= 2\\n\\n return x \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n \\n pos = 0\\n n -= 1\\n \\n while n:\\n\\n bit = n & 1\\n n = n >> 1\\n # search for a zero bit\\n while x & (1 << pos):\\n pos += 1\\n x = x ^ bit << pos\\n pos += 1\\n\\n return x\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1: return x\\n get = bin(x)[2:]\\n zeros = get.count(\\\"0\\\")\\n ones, ones_z = divmod(n - 1, (int(\\\"1\\\" * zeros, 2) if zeros else 0) + 1)\\n \\n res, put = \\\"\\\", bin(ones_z)[2:]\\n get = list(get)\\n i, j = len(get) - 1, len(put) - 1\\n print(put)\\n while i >= 0:\\n if get[i] == \\\"0\\\" and j >= 0:\\n get[i] = put[j]\\n j -= 1\\n i -= 1\\n \\n return int(bin(ones)[2:] + \\\"\\\".join(get), 2)\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1: return x\\n get = bin(x)[2:]\\n zeros = get.count(\\\"0\\\")\\n ones, ones_z = divmod(n - 1, (int(\\\"1\\\" * zeros, 2) if zeros else 0) + 1)\\n \\n res, put = \\\"\\\", bin(ones_z)[2:]\\n get = list(get)\\n i, j = len(get) - 1, len(put) - 1\\n while j >= 0 and i >= 0:\\n if get[i] == \\\"0\\\":\\n get[i] = put[j]\\n j -= 1\\n i -= 1\\n \\n return int(bin(ones)[2:] + \\\"\\\".join(get), 2)\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1: return x\\n get = bin(x)[2:]\\n zeros = get.count(\\\"0\\\")\\n ones, ones_z = divmod(n - 1, (int(\\\"1\\\" * zeros, 2) if zeros else 0) + 1)\\n \\n res, put = \\\"\\\", bin(ones_z)[2:]\\n get = list(get)\\n i, j = len(get) - 1, len(put) - 1\\n print(put)\\n while i >= 0:\\n if get[i] == \\\"0\\\" and j >= 0:\\n get[i] = put[j]\\n j -= 1\\n i -= 1\\n \\n return int(bin(ones)[2:] + \\\"\\\".join(get), 2)\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n # length of the array is n \\n # and of all elements is x \\n # nums[i+1] > nums[i] \\n #0 0 0 1 1 0 1 0 0 1 0 = x ===> the set bits must exist in all the elements \\n # 0 1 1 1 \\n # 1 1 1 1 \\n length = 50\\n arr = [0] * length\\n for i in range(length):\\n arr[length-i-1] = (x>>i)&1\\n n = n - 1\\n i = length - 1 \\n while n:\\n if arr[i] == 0:\\n arr[i] = n % 2 \\n n //= 2\\n i -= 1\\n result = 0 \\n for i in range(length):\\n result = result * 2 + arr[i]\\n return int(result) \\n \\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n ans = x\\n for i in range(31):\\n if x >> i & 1 ^ 1:\\n ans |= (n & 1) << i\\n n >>= 1\\n ans |= n << 31\\n return ans\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n, x):\\n i,n = 0,n-1 \\n\\n while n:\\n if (x>>i)&1 == 0:\\n x = x|(n&1)<<i \\n n = n>>1 \\n i += 1 \\n\\n return x \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n tobin = format(x, 'b')\\n count0 = 0\\n for i in tobin:\\n if i == '0':\\n count0 += 1\\n extra0 = 0\\n while 2**(count0 + extra0) < n:\\n extra0 += 1\\n tobin = '0'*extra0 + tobin\\n change = format(n-1, 'b')\\n change = '0'*(extra0 + count0 - len(change)) + change\\n index = 0\\n out = []\\n for i in range(len(tobin)):\\n if tobin[i] == '0':\\n out.append(change[index])\\n index += 1\\n else:\\n out.append('1')\\n return int(''.join(out), 2)\\n\\n return 0\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n, x):\\n i,n = 0,n-1 \\n\\n while n:\\n if (x>>i)&1 == 0:\\n x = x|(n&1)<<i \\n n = n>>1 \\n i += 1 \\n\\n return x \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n\\n x_bin = bin(x)[2:]\\n s = len(bin(10**20)[2:])\\n nums = list(x_bin.zfill(s))\\n \\n zeroes = []\\n for i in range(len(nums)):\\n if nums[i] == '0':\\n zeroes.append(i)\\n\\n bi = bin(n - 1)[2:][::-1]\\n c = 0\\n for index in zeroes[::-1]:\\n if c >= len(bi):\\n break\\n nums[index] = bi[c]\\n c += 1\\n\\n res = \\\"\\\".join(nums)\\n return int(res, 2)\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int, bit = 1) -> int:\\n \\n\\n n -= 1 \\n \\n while n: \\n \\n while x & bit: \\n bit*= 2 \\n \\n if n & 1: x^= bit \\n n//= 2 \\n bit*= 2\\n\\n return x \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n x_bin = bin(x)[2:]\\n s = len(str(bin(10**20)))\\n nums = list(x_bin.zfill(s))\\n zeroes = []\\n for i in range(len(nums)):\\n if nums[i] == '0':\\n zeroes.append(i)\\n \\n bi = bin(n-1)[2:][::-1]\\n c = 0\\n for index in zeroes[::-1]:\\n if c >= len(bi):\\n break\\n nums[index] = bi[c]\\n c+=1\\n\\n res = \\\"\\\".join(nums)\\n return eval('0b'+res)\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n i = j = 0\\n # put jth bit of n into ith bit of x\\n while n >> j:\\n bit = n >> j & 1\\n if x >> i & 1 == 0:\\n x |= bit << i\\n j += 1\\n i += 1\\n return x\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n arr=[]\\n for i in range(64):\\n if(x&(1<<i)):\\n continue\\n arr.append(i)\\n n-=1\\n j=0\\n ans=x\\n for i in range(64):\\n if(n&(1<<i)):\\n ans|=(1<<arr[j])\\n j+=1\\n return ans\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n bits = []\\n pow = 1\\n for i in range(n.bit_length()):\\n while pow & x: pow *= 2\\n bits += [pow]\\n pow *= 2\\n output = x\\n for i, pow in enumerate(bits):\\n if 2**i & n: output += pow\\n return output\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n # list(bin(x)) -> ['0', 'b', '1', '0', '0']\\n # list(bin(x)[2:]) -> ['1', '0', '0']\\n x_bin = list(bin(x)[2:])\\n n_bin = list(bin(n)[2:])\\n\\n # rightmost bit of n\\n j = len(n_bin) - 1\\n\\n # Traverse in reverse, filling all n_bin bits into 0 bits in x\\n for i in range(len(x_bin) - 1, -1, -1):\\n # leave bits of 1 alone\\n if x_bin[i] == \\\"1\\\": continue\\n x_bin[i] = n_bin[j]\\n \\n # shift pointer to the left\\n j -= 1\\n \\n # if there's no n_bin bit left\\n if j == -1: break\\n \\n # add the remaining bits of n to the beginning of bits of x\\n if j >= 0:\\n x_bin = n_bin[0 : j + 1] + x_bin\\n \\n return int(\\\"\\\".join(x_bin), 2)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1: return x\\n get = bin(x)[2:]\\n zeros = get.count(\\\"0\\\")\\n ones, ones_z = divmod(n - 1, (int(\\\"1\\\" * zeros, 2) if zeros else 0) + 1)\\n \\n res, put = \\\"\\\", bin(ones_z)[2:]\\n get = list(get)\\n i, j = len(get) - 1, len(put) - 1\\n print(put)\\n while i >= 0:\\n if get[i] == \\\"0\\\" and j >= 0:\\n get[i] = put[j]\\n j -= 1\\n i -= 1\\n \\n return int(bin(ones)[2:] + \\\"\\\".join(get), 2)\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n if n == 1: return x\\n get = bin(x)[2:]\\n zeros = get.count(\\\"0\\\")\\n ones, ones_z = divmod(n - 1, (int(\\\"1\\\" * zeros, 2) if zeros else 0) + 1)\\n \\n res, put = \\\"\\\", bin(ones_z)[2:]\\n get = list(get)\\n i, j = len(get) - 1, len(put) - 1\\n while i >= 0:\\n if get[i] == \\\"0\\\" and j >= 0:\\n get[i] = put[j]\\n j -= 1\\n i -= 1\\n \\n return int(bin(ones)[2:] + \\\"\\\".join(get), 2)\",\n \"runtime\": \"46\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":26,"string":"26"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n # 0000\n # 100\n # 101\n # 110\n\n # X111\n # 0111\n\n # 1XX1X1\n # 1XX1X1\n # ...\n # ...\n\n # We can fit 2^3 = 8 numbers in between\n # X100101\n def minEnd(self, n: int, x: int) -> int:\n msb_pos = self.msb(x)\n zero_position = self.count_zero_position(x, msb_pos)\n mask = 0\n index = 0\n shift = 0\n n -= 1\n # n = 3 (011) x = 4 (100)\n while (n):\n lsb = n & 1\n\n if index < len(zero_position):\n shift = zero_position[index]\n elif index == len(zero_position):\n shift = msb_pos\n else:\n shift += 1\n\n index += 1\n mask |= lsb << shift\n n = n >> 1\n\n return x | mask\n\n # x = 100101 msb = 6\n def msb(self, x):\n count = 0\n while (x):\n x = x >> 1\n count += 1\n \n return count\n \n # 100101 => [1, 3, 4]\n def count_zero_position(self, x, msb_pos):\n result = []\n\n for i in range(msb_pos - 1):\n if (x & 1 == 0):\n result.append(i)\n x = x >> 1\n\n return result\n \n","memory":"16300"},{"code":"class Solution:\n def minEnd(self, n: int, x: int) -> int:\n n -= 1\n # list(bin(x)) -> ['0', 'b', '1', '0', '0']\n # list(bin(x)[2:]) -> ['1', '0', '0']\n x_bin = list(bin(x)[2:])\n n_bin = list(bin(n)[2:])\n\n # rightmost bit of n\n j = len(n_bin) - 1\n\n # Traverse in reverse, filling all n_bin bits into 0 bits in x\n for i in range(len(x_bin) - 1, -1, -1):\n # leave bits of 1 alone\n if x_bin[i] == \"1\": continue\n x_bin[i] = n_bin[j]\n \n # shift pointer to the left\n j -= 1\n \n # if there's no n_bin bit left\n if j == -1: break\n \n # add the remaining bits of n to the beginning of bits of x\n if j >= 0:\n x_bin = n_bin[0 : j + 1] + x_bin\n \n return int(\"\".join(x_bin), 2)","memory":"16400"},{"code":"class Solution:\n def minEnd(self, n, x):\n i,n = 0,n-1 \n\n while n:\n if (x>>i)&1 == 0:\n x = x|(n&1)<<i \n n = n>>1 \n i += 1 \n\n return x ","memory":"16500"}],"string":"[\n {\n \"code\": \"class Solution:\\n # 0000\\n # 100\\n # 101\\n # 110\\n\\n # X111\\n # 0111\\n\\n # 1XX1X1\\n # 1XX1X1\\n # ...\\n # ...\\n\\n # We can fit 2^3 = 8 numbers in between\\n # X100101\\n def minEnd(self, n: int, x: int) -> int:\\n msb_pos = self.msb(x)\\n zero_position = self.count_zero_position(x, msb_pos)\\n mask = 0\\n index = 0\\n shift = 0\\n n -= 1\\n # n = 3 (011) x = 4 (100)\\n while (n):\\n lsb = n & 1\\n\\n if index < len(zero_position):\\n shift = zero_position[index]\\n elif index == len(zero_position):\\n shift = msb_pos\\n else:\\n shift += 1\\n\\n index += 1\\n mask |= lsb << shift\\n n = n >> 1\\n\\n return x | mask\\n\\n # x = 100101 msb = 6\\n def msb(self, x):\\n count = 0\\n while (x):\\n x = x >> 1\\n count += 1\\n \\n return count\\n \\n # 100101 => [1, 3, 4]\\n def count_zero_position(self, x, msb_pos):\\n result = []\\n\\n for i in range(msb_pos - 1):\\n if (x & 1 == 0):\\n result.append(i)\\n x = x >> 1\\n\\n return result\\n \\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n: int, x: int) -> int:\\n n -= 1\\n # list(bin(x)) -> ['0', 'b', '1', '0', '0']\\n # list(bin(x)[2:]) -> ['1', '0', '0']\\n x_bin = list(bin(x)[2:])\\n n_bin = list(bin(n)[2:])\\n\\n # rightmost bit of n\\n j = len(n_bin) - 1\\n\\n # Traverse in reverse, filling all n_bin bits into 0 bits in x\\n for i in range(len(x_bin) - 1, -1, -1):\\n # leave bits of 1 alone\\n if x_bin[i] == \\\"1\\\": continue\\n x_bin[i] = n_bin[j]\\n \\n # shift pointer to the left\\n j -= 1\\n \\n # if there's no n_bin bit left\\n if j == -1: break\\n \\n # add the remaining bits of n to the beginning of bits of x\\n if j >= 0:\\n x_bin = n_bin[0 : j + 1] + x_bin\\n \\n return int(\\\"\\\".join(x_bin), 2)\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def minEnd(self, n, x):\\n i,n = 0,n-1 \\n\\n while n:\\n if (x>>i)&1 == 0:\\n x = x|(n&1)<<i \\n n = n>>1 \\n i += 1 \\n\\n return x \",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":3,"string":"3"}}},{"rowIdx":2433,"cells":{"question_id":{"kind":"number","value":3362,"string":"3,362"},"name":{"kind":"string","value":"find-the-median-of-the-uniqueness-array"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code>. The <strong>uniqueness array</strong> of <code>nums</code> is the sorted array that contains the number of distinct elements of all the <span data-keyword=\"subarray-nonempty\">subarrays</span> of <code>nums</code>. In other words, it is a sorted array consisting of <code>distinct(nums[i..j])</code>, for all <code>0 <= i <= j < nums.length</code>.</p>\n\n<p>Here, <code>distinct(nums[i..j])</code> denotes the number of distinct elements in the subarray that starts at index <code>i</code> and ends at index <code>j</code>.</p>\n\n<p>Return the <strong>median</strong> of the <strong>uniqueness array</strong> of <code>nums</code>.</p>\n\n<p><strong>Note</strong> that the <strong>median</strong> of an array is defined as the middle element of the array when it is sorted in non-decreasing order. If there are two choices for a median, the <strong>smaller</strong> of the two values is taken.<!-- notionvc: 7e0f5178-4273-4a82-95ce-3395297921dc --></p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The uniqueness array of <code>nums</code> is <code>[distinct(nums[0..0]), distinct(nums[1..1]), distinct(nums[2..2]), distinct(nums[0..1]), distinct(nums[1..2]), distinct(nums[0..2])]</code> which is equal to <code>[1, 1, 1, 2, 2, 3]</code>. The uniqueness array has a median of 1. Therefore, the answer is 1.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [3,4,3,4,5]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The uniqueness array of <code>nums</code> is <code>[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3]</code>. The uniqueness array has a median of 2. Therefore, the answer is 2.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [4,3,5,4]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The uniqueness array of <code>nums</code> is <code>[1, 1, 1, 1, 2, 2, 2, 3, 3, 3]</code>. The uniqueness array has a median of 2. Therefore, the answer is 2.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":28.818919939577036,"string":"28.81892"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","binary-search","sliding-window"],"string":"[\n \"array\",\n \"hash-table\",\n \"binary-search\",\n \"sliding-window\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"886\", 1.2988], [\"960\", 0.6494], [\"1034\", 0.6494], [\"1108\", 0.6494], [\"1182\", 0.6494], [\"1256\", 0.6494], [\"1330\", 0.6494], [\"1404\", 0.6494], [\"1478\", 0.6494], [\"1552\", 0.6494], [\"1626\", 0.6494], [\"1700\", 0.6494], [\"1774\", 0.6494], [\"1848\", 0.6494], [\"1922\", 0.6494], [\"1996\", 1.2987], [\"2070\", 0.6494], [\"2144\", 0.6494], [\"2218\", 0.6494], [\"2292\", 1.2987], [\"2366\", 0.6494], [\"2440\", 0.6494], [\"2514\", 0.6494], [\"2588\", 0.6494], [\"2662\", 1.9482], [\"2736\", 7.7926], [\"2810\", 7.1434], [\"2883\", 3.247], [\"2957\", 3.247], [\"3031\", 8.4421], [\"3105\", 4.5458], [\"3179\", 1.9482], [\"3253\", 0.6494], [\"3327\", 0.6494], [\"3401\", 0.6494], [\"3475\", 1.9482], [\"3549\", 1.9482], [\"3623\", 1.9482], [\"3697\", 2.5976], [\"3771\", 0.6494], [\"3845\", 0.6494], [\"3919\", 0.6494], [\"3993\", 0.6494], [\"4067\", 3.247], [\"4141\", 8.4422], [\"4215\", 6.494], [\"4289\", 1.9482], [\"4363\", 1.2988], [\"4437\", 0.6494], [\"4511\", 0.6494], [\"4585\", 0.6494], [\"4659\", 0.6494], [\"4733\", 0.6494], [\"4806\", 0.6494], [\"4880\", 0.6494]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"33000\", 1.9481], [\"33100\", 1.9481], [\"33200\", 1.2987], [\"33400\", 2.5974], [\"33500\", 1.2987], [\"33600\", 6.4935], [\"33700\", 3.8961], [\"33800\", 0.6494], [\"34400\", 2.5974], [\"34500\", 1.9481], [\"34600\", 7.1429], [\"34700\", 2.5974], [\"34800\", 1.2987], [\"34900\", 2.5974], [\"35000\", 0.6494], [\"35100\", 0.6494], [\"35200\", 0.6494], [\"35400\", 2.5974], [\"35500\", 1.2987], [\"35600\", 1.2987], [\"35700\", 0.6494], [\"35800\", 5.1948], [\"35900\", 5.1948], [\"36900\", 0.6494], [\"37000\", 0.6494], [\"37100\", 0.6494], [\"37500\", 0.6494], [\"37600\", 5.1948], [\"37700\", 7.1429], [\"37800\", 9.0909], [\"37900\", 3.8961], [\"38000\", 3.2468], [\"38100\", 1.9481], [\"38400\", 1.2987], [\"38500\", 1.2987], [\"38600\", 1.9481], [\"39000\", 0.6494]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n m = n * (n + 1) // 2 + 1 >> 1\n d, pre, nxt = {}, [-1] * n, [n] * n\n for i, x in enumerate(nums):\n if x in d:\n j = d[x]\n pre[i] = j\n nxt[j] = i\n d[x] = i\n \n def f(t):\n i, c = 0, 0\n while c <= t:\n if pre[i] < 0:\n c += 1\n i += 1\n s, l = comb(i, 2), 0\n for r in range(i - 1, n):\n if pre[r] < l:\n while nxt[l] <= r:\n l += 1\n l += 1\n s += r - l\n return s + n - i + 1\n \n a, b, x, y = 1, len(d), 0, m * 2\n while a < b:\n c = max(a, int(b - (b - a + 1) * (y - m) / (y - x)))\n t = f(c)\n if t == m:\n return c\n if t > m:\n b, y = c, t\n else:\n a, x = c + 1, t\n return a","runtime":"886"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n countMap = [0] * 100001\n\n def subarraysWithAtmostK(k):\n c = k\n l, r, count = 0, 0, 0\n for r in range(numSize):\n if countMap[nums[r]] == 0: k -= 1\n countMap[nums[r]] += 1\n while(k < 0):\n countMap[nums[l]] -= 1\n if countMap[nums[l]] == 0: k += 1\n l += 1\n count += r - l + 1\n while l < numSize: \n countMap[nums[l]] -= 1\n l += 1\n return count\n\n numSize = len(nums)\n numOfSubArrays = (numSize * (numSize + 1)) // 2\n median = (numOfSubArrays + 1) // 2\n\n left = 1\n right = len(set(nums))\n\n while(left <= right):\n middle = left + (right - left) // 2\n if(subarraysWithAtmostK(middle) < median): left = middle + 1\n else: right = middle - 1\n\n return left","runtime":"886"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n l, h = 0, len(set(nums))\n\n while l < h:\n mid = (l + h) // 2\n cnt = pt = 0\n record = {}\n\n for i, num in enumerate(nums):\n record[num] = i\n while len(record) > mid:\n if record[nums[pt]] == pt:\n del record[nums[pt]]\n pt += 1\n\n cnt += i - pt + 1\n \n if cnt >= ((len(nums) * (len(nums) + 1) ) / 2 + 1) // 2:\n h = mid \n else:\n l = mid + 1\n return l","runtime":"960"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n \n def count(v):\n ans = 0\n l = 0\n window = {}\n for r in range(n):\n window[nums[r]] = window.get(nums[r], 0) + 1\n while len(window) > v:\n window[nums[l]] -= 1\n if window[nums[l]] == 0:\n del window[nums[l]]\n l += 1\n ans += r - l + 1\n return ans\n low, hig = 1, len(set(nums))\n total = n * (n+1) // 2\n while low < hig:\n mid = (low + hig) // 2\n if count(mid)*2 >= total:\n hig = mid\n else:\n low = mid + 1\n return low","runtime":"1034"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n + 1) * n // 2\n target = (total + 1) // 2\n left = 1\n right = len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n start = 0\n count = 0\n dic = {}\n for i in range(n):\n dic[nums[i]] = dic.get(nums[i], 0) + 1\n while len(dic) > mid:\n dic[nums[start]] -= 1\n if dic[nums[start]] == 0:\n del dic[nums[start]]\n start += 1\n count += i - start + 1\n if count >= target:\n break\n if count >= target:\n right = mid\n else:\n left = mid + 1\n return right","runtime":"1108"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def kUnique(k):\n window = {}\n start, res = 0, 0\n for i, x in enumerate(nums):\n window[x] = window.get(x, 0) + 1\n while start <= i and len(window) > k:\n window[nums[start]] -= 1\n if window[nums[start]] == 0:\n del window[nums[start]]\n start += 1\n res += i - start + 1\n return res\n n = len(nums)\n total = n*(n+1)//2\n l, r = 1, len(set(nums))\n while l < r:\n mid = (l + r)//2\n if kUnique(mid)*2 < total:\n l = mid + 1\n else:\n r = mid\n return l","runtime":"1182"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n @cache\n def withinK(cap):\n if cap == 0:\n return 0\n window, start, res = {}, 0, 0\n for i, x in enumerate(nums):\n window[x] = window.get(x, 0) + 1\n while start < i and len(window) > cap:\n window[nums[start]] -= 1\n if window[nums[start]] == 0:\n del window[nums[start]]\n start += 1\n res += i - start + 1\n return res\n \n n = len(nums)\n total = n*(n+1)//2\n l, r = 1, len(set(nums))\n while l < r:\n mid = (l + r)//2\n cnt = withinK(mid)\n if cnt*2 < total:\n l = mid + 1\n else:\n r = mid\n return l","runtime":"1256"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n def less_than(x):\n arr = defaultdict(int)\n l,r = 0,0\n cnt = 0\n while r < n:\n # print(l,r, arr, cnt)\n arr[nums[r]] += 1\n while len(arr) > x:\n if arr[nums[l]] == 1:\n del arr[nums[l]]\n else:\n arr[nums[l]] -= 1\n l += 1\n cnt += (r-l+1)\n r += 1\n return cnt\n \n l1,r1 = 1,len(set(nums))\n target = (n*(n+1))//2\n target += 1\n target //= 2\n # print(l1, r1, target)\n while l1 < r1:\n m = (l1+r1)//2\n lt = less_than(m)\n # print(m, lt)\n if target == lt:\n return m\n if target < lt:\n r1 = m\n else:\n l1 = m+1\n return r1\n ","runtime":"1330"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_subarray_distinct_less_or_equal_k(nums, k):\n left_fast = 0\n right = 0\n counts = {}\n ans = 0\n while right < n:\n if nums[right] in counts or len(counts) < k:\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n else:\n while len(counts) == k:\n counts[nums[left_fast]] -= 1\n if counts[nums[left_fast]] == 0:\n del counts[nums[left_fast]]\n left_fast += 1\n\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n ans += right - left_fast\n return ans\n \n n = len(nums)\n total_subarray_num = n * (n + 1) // 2\n target = total_subarray_num // 2 + (total_subarray_num & 1)\n left = 1\n right = len(set(nums))\n while left < right:\n mid = left + right\n mid //= 2\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\n right = mid\n else:\n left = mid + 1\n return left","runtime":"1404"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n tot_arrs = N * (N + 1) // 2\n med = tot_arrs // 2 + tot_arrs % 2\n l, r = 1, len(set(nums))\n res = -1\n while l <= r:\n m = (l + r) // 2\n ct = 0\n\n counts = defaultdict(int)\n j = 0\n\n for i in range(N):\n counts[nums[i]] += 1\n while len(counts) > m:\n counts[nums[j]] -= 1\n if counts[nums[j]] == 0: del counts[nums[j]]\n j += 1\n ct += i - j + 1\n\n if ct < med:\n l = m + 1\n elif ct >= med:\n res = m\n r = m - 1\n\n return res","runtime":"1478"},{"code":"# class Solution:\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\n# n = len(nums)\n# total = (n * (n + 1)) // 2\n# medi = (total + 1) // 2\n\n# elements = len(set(nums))\n \n# def getMedianK(nums, x):\n# lo, hi = 1, elements\n# while lo <= hi:\n# mid = (lo + hi) // 2\n# count = self.atMost(nums, mid)\n# # if count == x:\n# # return mid\n# if count >= x:\n# hi = mid - 1\n# else:\n# lo = mid + 1\n \n# return lo\n\n# k = getMedianK(nums, medi)\n# return k\n\n\n# def atMost(self, nums, k):\n# left = 0\n# counter = dict()\n# res = 0\n# for i, c in enumerate(nums):\n# counter[c] = counter.get(c, 0) + 1\n# while len(counter) > k:\n# counter[nums[left]] -= 1\n# if counter[nums[left]] == 0:\n# counter.pop(nums[left])\n \n# left += 1\n\n# res += i - left + 1\n\n# return res\n\n# class Solution:\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\n# uniq = defaultdict(int)\n\n# for i in range(len(nums)):\n# counter = dict()\n# for j in range(i, len(nums)):\n# counter[nums[j]] = counter.get(nums[j], 0) + 1\n# uniq[len(counter)] += 1\n\n# # print(uniq)\n# sortedcount = sorted([(uniq_ele, count) for uniq_ele, count in uniq.items()])\n# # total = len(nums) * (len(nums) + 1) / 2\n# total = sum(uniq.values())\n# medi = (total + 1) // 2\n# s = 0\n# for u, c in sortedcount:\n# s += c\n# if s >= medi:\n# return u\n\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n lo = 0\n hi = len(set(nums))\n\n totalArrs = (n+1) * n / 2\n medn = totalArrs / 2\n\n while lo <= hi:\n mid = (lo + hi) // 2\n # print('\\n lo, mid, hi', lo, mid, hi)\n\n if self.atMost(nums, mid) >= medn:\n hi = mid - 1\n else:\n lo = mid + 1\n\n return lo\n\n \n def atMost(self, nums, k):\n # only number of arrays ending at i, uniqueness <= k\n arrCounts = [0] * (len(nums) + 1)\n\n left = 0\n # right = 0\n prevs = dict()\n prevscount = dict()\n\n for i, num in enumerate(nums):\n # if num not in prevs:\n # prevs[num] = i\n prevscount[num] = prevscount.get(num, 0) + 1\n\n while len(prevscount) > k:\n prevscount[nums[left]] -= 1\n if prevscount[nums[left]] == 0:\n prevscount.pop(nums[left])\n \n left += 1\n\n # prevNumIdx = prevs[num] if num in prevs else -1\n # arrCounts[i+1] = arrCounts[i] + i - prevNumIdx\n # prevs[num] = i\n arrCounts[i+1] = i - left + 1\n \n # print('arrCounts', arrCounts)\n return sum(arrCounts)\n\n\n\n ","runtime":"1552"},{"code":"from collections import defaultdict\n\nclass Solution:\n def medianOfUniquenessArray(self, nums):\n cnt = self.getCnt(nums)\n return self.bs(nums, cnt)\n \n def getCnt(self, nums):\n n = len(nums)\n mc = n * (n + 1) // 2\n return (mc + 1) // 2\n \n def bs(self, nums, cnt):\n lo, hi = 1, self.getUnique(nums)\n while lo < hi:\n mid = (hi + lo) // 2\n if self.check(nums, cnt, mid):\n lo = mid + 1\n else:\n hi = mid\n return lo\n \n def getUnique(self, nums):\n return len(set(nums))\n \n def check(self, nums, cnt, k):\n md = 0\n mp = defaultdict(int)\n l = 0\n for r in range(len(nums)):\n mp[nums[r]] += 1\n \n while len(mp) > k:\n mp[nums[l]] -= 1\n if mp[nums[l]] == 0:\n del mp[nums[l]]\n l += 1\n md += (r - l + 1)\n return md < cnt\n","runtime":"1626"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_subarray_distinct_less_or_equal_k(nums, k):\n left = 0\n right = 0\n counts = {}\n ans = 0\n while right < n:\n if nums[right] in counts or len(counts) < k:\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n else:\n while len(counts) == k:\n counts[nums[left]] -= 1\n if counts[nums[left]] == 0:\n del counts[nums[left]]\n left += 1\n\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n ans += right - left\n return ans\n \n n = len(nums)\n total_subarray_num = n * (n + 1) // 2\n target = total_subarray_num // 2 + (total_subarray_num & 1)\n left = 1\n right = len(set(nums))\n while left < right:\n mid = left + right\n mid //= 2\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\n right = mid\n else:\n left = mid + 1\n return left","runtime":"1700"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n return sol2(nums)\n\ndef sol1(nums):\n N = len(nums)\n uniq = []\n for i in range(N):\n s = set()\n for j in range(i, N):\n s.add(nums[j])\n uniq.append(len(s))\n uniq.sort()\n print(uniq, N * (N + 1) // 2)\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\n return uniq[len(uniq)//2]\n\n# binary search? (iterating by the median)\n# can we make that median or not?\n# how can we answer to that question?\n\n# 1-sized give us N items\n# 2-sized give us N - 1 items\n# ...\n# N-sized give us 1 item\n\n# but we need not all items, but unique ones\n# (we cannot precalculate though)\n\n# to answer if x is a median, we should find out how many\n# 1s, 2s, ..., xs are in the uniqueness array\n# how many 1s we know - it is N\n# when we count 2s then should be different\n# but two items also can go to the 1s if they are the same\n\n# can we find unique items using a sliding window?\n\ndef sol2(nums):\n N = len(nums)\n\n def run(size):\n window = defaultdict(int)\n left = 0\n ans = 0\n for right in range(N):\n window[nums[right]] += 1\n while len(window) > size:\n window[nums[left]] -= 1\n if window[nums[left]] == 0:\n del window[nums[left]]\n left += 1\n ans += right - left + 1\n return ans\n\n total = N * (N + 1) // 2\n ans = 1\n lo = 1\n hi = len(set(nums))\n while lo <= hi:\n mi = lo + (hi - lo) // 2\n x = run(mi)\n if x*2 >= total:\n ans = mi\n hi = mi - 1\n else:\n lo = mi + 1\n return ans\n","runtime":"1774"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_subarray_distinct_less_or_equal_k(nums, k):\n if k == 0:\n return 0\n # print(\"k = \" ,k)\n left_slow = 0\n left_fast = 0\n right = 0\n counts = {}\n ans = 0\n while right < n:\n if nums[right] in counts or len(counts) < k:\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n else:\n # move left\n left_slow = left_fast\n while len(counts) == k:\n counts[nums[left_fast]] -= 1\n if counts[nums[left_fast]] == 0:\n del counts[nums[left_fast]]\n left_fast += 1\n\n \n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n ans += right - left_fast\n return ans\n \n n = len(nums)\n total_subarray_num = n * (n + 1) // 2\n target = total_subarray_num // 2 + (total_subarray_num & 1)\n left = 0\n right = len(set(nums))\n while left < right:\n mid = left + right\n mid //= 2\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\n right = mid\n else:\n left = mid + 1\n return left","runtime":"1848"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n total_subarrays = N * (N + 1) // 2\n def good(k):\n nonlocal total_subarrays\n l = 0\n total_valid = 0\n lookup = defaultdict(int)\n for r in range(N):\n lookup[nums[r]] += 1\n while len(lookup) > k:\n lookup[nums[l]] -= 1\n if lookup[nums[l]] == 0:\n del lookup[nums[l]]\n l += 1\n total_valid += r - l + 1\n return total_valid * 2 >= total_subarrays\n \n\n l, r = 1, len(set(nums))\n while l < r:\n mid = (l + r) // 2\n if good(mid):\n r = mid\n else:\n l = mid + 1\n return l","runtime":"1922"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n K = (N * (N + 1) // 2 + 1) // 2\n\n def check(upper: int) -> bool:\n cnt, l = 0, 0\n freq = defaultdict(int)\n for r, x in enumerate(nums):\n freq[x] += 1\n while len(freq) > upper:\n drop = nums[l]\n freq[drop] -= 1\n if freq[drop] == 0:\n del freq[drop]\n l += 1\n cnt += r - l + 1\n if cnt >= K:\n return True\n return False\n\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)","runtime":"1996"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n K = (N * (N + 1) // 2 + 1) // 2\n\n def check(upper: int) -> bool:\n cnt, l = 0, 0\n freq = defaultdict(int)\n for r, x in enumerate(nums):\n freq[x] += 1\n while len(freq) > upper:\n drop = nums[l]\n freq[drop] -= 1\n if freq[drop] == 0:\n del freq[drop]\n l += 1\n cnt += r - l + 1\n if cnt >= K:\n return True\n return False\n\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)","runtime":"1996"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n return sol2(nums)\n\ndef sol1(nums):\n N = len(nums)\n uniq = []\n for i in range(N):\n s = set()\n for j in range(i, N):\n s.add(nums[j])\n uniq.append(len(s))\n uniq.sort()\n print(uniq, N * (N + 1) // 2)\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\n return uniq[len(uniq)//2]\n\n# binary search? (iterating by the median)\n# can we make that median or not?\n# how can we answer to that question?\n\n# 1-sized give us N items\n# 2-sized give us N - 1 items\n# ...\n# N-sized give us 1 item\n\n# but we need not all items, but unique ones\n# (we cannot precalculate though)\n\n# to answer if x is a median, we should find out how many\n# 1s, 2s, ..., xs are in the uniqueness array\n# how many 1s we know - it is N\n# when we count 2s then should be different\n# but two items also can go to the 1s if they are the same\n\n# can we find unique items using a sliding window?\n\ndef sol2(nums):\n N = len(nums)\n\n def le(size):\n window = defaultdict(int)\n left = 0\n ans = 0\n for right in range(N):\n window[nums[right]] += 1\n while len(window) > size:\n window[nums[left]] -= 1\n if window[nums[left]] == 0:\n del window[nums[left]]\n left += 1\n ans += right - left + 1\n return ans\n\n total = N * (N + 1) // 2\n ans = 1\n lo = 1\n hi = len(set(nums))\n while lo <= hi:\n mi = lo + (hi - lo) // 2\n if le(mi)*2 >= total:\n ans = mi\n hi = mi - 1\n else:\n lo = mi + 1\n return ans\n","runtime":"2070"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n max_distinct = set(nums)\n low, high = 1, len(max_distinct)\n n = len(nums)\n combos = (n*(n+1))//2\n combos = (combos//2) + (combos%2)\n # print(combos)\n\n def is_median_upper(nums, x):\n count = defaultdict(int)\n left = 0\n k = 0\n for idx, val in enumerate(nums):\n count[val] +=1\n while len(count) >x:\n count[nums[left]]-=1\n if not count[nums[left]]:\n del(count[nums[left]])\n left+=1\n k += idx-left+1\n if k > combos:\n return True\n # print(k,x)\n if k < combos:\n return False\n else:\n return True\n\n while low < high:\n # print(low,high)\n mid = (low+high)//2\n cond = is_median_upper(nums,mid)\n if cond:\n high = mid\n else:\n low = mid+1\n return low\n ","runtime":"2144"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n max_distinct = set(nums)\n low, high = 1, len(max_distinct)\n n = len(nums)\n combos = (n*(n+1))//2\n combos = (combos//2) + (combos%2)\n # print(combos)\n\n def is_median_upper(nums, x):\n count = defaultdict(int)\n left = 0\n k = 0\n for idx, val in enumerate(nums):\n count[val] +=1\n while len(count) >x:\n count[nums[left]]-=1\n if not count[nums[left]]:\n del(count[nums[left]])\n left+=1\n k += idx-left+1\n if k >= combos:\n return True\n # print(k,x)\n if k < combos:\n return False\n else:\n return True\n\n while low < high:\n # print(low,high)\n mid = (low+high)//2\n cond = is_median_upper(nums,mid)\n if cond:\n high = mid\n else:\n low = mid+1\n return low\n ","runtime":"2218"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \"\"\"\n [3,4,3,4,5]\n all subarraies, get unique -> sort -> median\n lo, hi = 1, unique mid = \n total subarraries = (n + 1) * n // 2\n count = total // 2\n \"\"\"\n n = len(nums)\n total = math.ceil((n + 1) * n / 4)\n lo, hi = 1, len(set(nums))\n\n def get_count(mid):\n count, l = 0, 0\n uniques = defaultdict(int)\n for r in range(n):\n uniques[nums[r]] += 1\n while len(uniques) > mid:\n uniques[nums[l]] -= 1\n if uniques[nums[l]] == 0:\n uniques.pop(nums[l])\n l += 1\n count += r - l + 1\n return count\n\n while lo < hi:\n mid = (lo + hi) // 2\n count = get_count(mid)\n print(mid, count)\n if count < total:\n lo = mid + 1\n else:\n hi = mid\n \n return lo\n","runtime":"2292"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n max_distinct = set(nums)\n low, high = 1, len(max_distinct)\n n = len(nums)\n combos = (n*(n+1))//2\n combos = (combos//2) + (combos%2)\n # print(combos)\n\n def is_median_upper(nums, x):\n window = set()\n count = defaultdict(int)\n left = 0\n k = 0\n for idx, val in enumerate(nums):\n count[val] +=1\n while len(count) >x:\n count[nums[left]]-=1\n if not count[nums[left]]:\n del(count[nums[left]])\n left+=1\n k += idx-left+1\n if k > combos:\n return True\n # print(k,x)\n if k < combos:\n return False\n else:\n return True\n\n while low < high:\n # print(low,high)\n mid = (low+high)//2\n cond = is_median_upper(nums,mid)\n if cond:\n high = mid\n else:\n low = mid+1\n return low\n ","runtime":"2366"},{"code":"def count(nums, d):\n cnt = {}\n lo = 0\n res = 0\n for i in range(len(nums)):\n cnt[nums[i]] = cnt.get(nums[i], 0) + 1\n while len(cnt) > d:\n cnt[nums[lo]] = cnt[nums[lo]] - 1\n if cnt[nums[lo]] == 0:\n del cnt[nums[lo]]\n lo += 1\n res += i - lo + 1\n return res\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n C = (len(nums) * (len(nums) + 1)) // 2\n lo = 0\n hi = len(nums) + 1\n while hi - lo > 1:\n mi = (lo + hi) // 2\n if count(nums, mi) < C // 2 + C % 2:\n lo = mi\n else:\n hi = mi\n return hi\n","runtime":"2440"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n + 1) * n // 2\n target = (total + 1) // 2\n left = 1\n right = n\n while left < right:\n mid = left + (right - left) // 2\n count = 0\n cnt = {}\n start = 0\n for i, num in enumerate(nums):\n cnt[num] = cnt.get(num, 0) + 1\n while len(cnt) > mid:\n cnt[nums[start]] -= 1\n if cnt[nums[start]] == 0:\n del cnt[nums[start]]\n start += 1\n count += i - start + 1\n if count >= target:\n right = mid\n else:\n left = mid + 1\n return left","runtime":"2514"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def atMostK(k: int):\n result = 0\n left, right = 0, 0\n counts = dict()\n for right in range(len(nums)):\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n while len(counts) > k:\n removed = nums[left]\n left += 1\n counts[removed] -= 1\n if counts[removed] == 0:\n del counts[removed]\n result += right - left + 1 \n return result \n left, right = 1, len(nums)\n total = len(nums) * (len(nums) - 1)//2 + len(nums)\n mid = 0\n while left <= right:\n mid = left + (right - left)//2\n subarrays = atMostK(mid)\n if subarrays == (total + 1)//2:\n return mid\n elif subarrays > (total + 1)//2:\n right = mid - 1\n else:\n left = mid + 1\n return right + 1\n\n","runtime":"2588"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n max_distinct = set(nums)\n low, high = 1, len(max_distinct)\n n = len(nums)\n combos = (n*(n+1))//2\n # print(combos)\n\n def is_median_upper(nums, x):\n window = set()\n count = dict()\n left = 0\n k = 0\n for idx, val in enumerate(nums):\n window.add(val)\n count[val] = count.get(val,0)+1\n while len(window) >x:\n count[nums[left]]-=1\n if not count[nums[left]]:\n window.remove(nums[left])\n left+=1\n k += idx-left+1\n # print(k,x)\n if k < (combos//2) + combos%2 :\n return False\n else:\n return True\n\n while low < high:\n # print(low,high)\n mid = (low+high)//2\n cond = is_median_upper(nums,mid)\n if cond:\n high = mid\n else:\n low = mid+1\n return low\n ","runtime":"2662"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n # 我們要找的targetIndex為 math.ceil(((n * (n+1)) // 2) / 2)\n # 最前面的n個都為 1\n # 整個掃過一次就可以知道最後面一個是多少，假設叫r\n # 用binary search找一個介於1到r之間的值，並去計算是否超過targetIndex個\n\n # [3,4,3,4,5] , m = 2\n # 每次需確保unique number <= m組，且會產生(j-i+1)組合法答案\n # i \n # j\n # 1 + 2 + 3 + 4 + 2 = 12\n def solve(m):\n l = 0\n ct = collections.defaultdict(int)\n unique_nums = 0\n res = 0\n for i,e in enumerate(nums):\n ct[e] += 1\n unique_nums += 1 if ct[e] == 1 else 0\n while l <= i and unique_nums > m:\n ct[nums[l]] -= 1\n unique_nums -= 1 if ct[nums[l]] == 0 else 0\n l += 1\n \n res += (i - l + 1)\n return res\n\n n = len(nums)\n m = ((n * (n+1)) // 2) # 新構建出來的arr的長度\n targetIndex = math.ceil(m / 2)\n ans = 0\n l, r = 1, len(set(nums))\n while l <= r:\n m = (l + r) // 2\n if solve(m) >= targetIndex:\n ans = m\n r = m - 1\n else:\n l = m + 1\n return ans","runtime":"2662"},{"code":"class Solution:\n\tdef medianOfUniquenessArray(self, nums: List[int]) -> int:\n\t\tl, r, n = 0, len(nums), len(nums)\n\t\tdef count(x):\n\t\t\ta, c, i = {}, 0, 0\n\t\t\tfor j in range(n):\n\t\t\t\ta[nums[j]] = a.get(nums[j], 0) + 1\n\t\t\t\twhile len(a) > x:\n\t\t\t\t\ta[nums[i]] -= 1\n\t\t\t\t\tif a[nums[i]] == 0: del a[nums[i]]\n\t\t\t\t\ti += 1\n\t\t\t\tc += j + 1 - i\n\t\t\treturn c\n\t\tt = n * (n + 1) // 2 // 2 + n * (n + 1) // 2 % 2\n\t\twhile l < r:\n\t\t\tm = (l + r) // 2\n\t\t\tif count(m) < t: l = m + 1\n\t\t\telse: r = m\n\t\treturn l","runtime":"2736"},{"code":"# class Solution:\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\n# n = len(nums)\n# total = (n * (n + 1)) // 2\n# medi = (total + 1) // 2\n\n# elements = len(set(nums))\n \n# def getMedianK(nums, x):\n# lo, hi = 1, elements\n# while lo <= hi:\n# mid = (lo + hi) // 2\n# count = self.atMost(nums, mid)\n# # if count == x:\n# # return mid\n# if count >= x:\n# hi = mid - 1\n# else:\n# lo = mid + 1\n \n# return lo\n\n# k = getMedianK(nums, medi)\n# return k\n\n\n# def atMost(self, nums, k):\n# left = 0\n# counter = dict()\n# res = 0\n# for i, c in enumerate(nums):\n# counter[c] = counter.get(c, 0) + 1\n# while len(counter) > k:\n# counter[nums[left]] -= 1\n# if counter[nums[left]] == 0:\n# counter.pop(nums[left])\n \n# left += 1\n\n# res += i - left + 1\n\n# return res\n\n# class Solution:\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\n# uniq = defaultdict(int)\n\n# for i in range(len(nums)):\n# counter = dict()\n# for j in range(i, len(nums)):\n# counter[nums[j]] = counter.get(nums[j], 0) + 1\n# uniq[len(counter)] += 1\n\n# # print(uniq)\n# sortedcount = sorted([(uniq_ele, count) for uniq_ele, count in uniq.items()])\n# # total = len(nums) * (len(nums) + 1) / 2\n# total = sum(uniq.values())\n# medi = (total + 1) // 2\n# s = 0\n# for u, c in sortedcount:\n# s += c\n# if s >= medi:\n# return u\n\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n lo = 0\n hi = len(set(nums))\n\n totalArrs = (n+1) * n / 2\n medn = totalArrs / 2\n\n while lo <= hi:\n mid = (lo + hi) // 2\n # print('\\n lo, mid, hi', lo, mid, hi)\n\n if self.atMost(nums, mid) >= medn:\n hi = mid - 1\n else:\n lo = mid + 1\n\n return lo\n\n \n def atMost(self, nums, k):\n # only number of arrays ending at i, uniqueness <= k\n arrCounts = [0] * (len(nums) + 1)\n\n left = 0\n # right = 0\n prevs = dict()\n prevscount = dict()\n\n for i, num in enumerate(nums):\n # if num not in prevs:\n # prevs[num] = i\n prevscount[num] = prevscount.get(num, 0) + 1\n\n while len(prevscount) > k:\n prevscount[nums[left]] -= 1\n if prevscount[nums[left]] == 0:\n prevscount.pop(nums[left])\n \n left += 1\n\n # prevNumIdx = prevs[num] if num in prevs else -1\n # arrCounts[i+1] = arrCounts[i] + i - prevNumIdx\n # prevs[num] = i\n arrCounts[i+1] = i - left + 1\n \n # print('arrCounts', arrCounts)\n return sum(arrCounts)\n\n\n\n ","runtime":"2736"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\n\n d = defaultdict(int)\n \n for rght in range(n):\n d[nums[rght]]+= 1\n\n while len(d) > x:\n left+= 1\n d[nums[left]] -= 1\n if d[nums[left]] == 0: del d[nums[left]]\n\n cnt+= rght - left\n if cnt >= median: return True\n\n return False\n \n\n n = len(nums)\n median = (comb(n+1,2) + 1) // 2\n return bisect_left(range(n), \n True, key = not_less_than_median)","runtime":"2810"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count(val):\n count = defaultdict(int)\n l = 0\n res = 0\n \n for r in range(len(nums)):\n count[nums[r]] += 1\n \n while len(count) > val:\n count[nums[l]] -= 1\n if count[nums[l]] == 0:\n count.pop(nums[l])\n l += 1\n \n res += r - l + 1\n return res\n \n l, r = 0, len(set(nums))\n n = len(nums)\n med = n * (n + 1) // 2\n while l < r:\n mid = (l + r) // 2\n if count(mid) * 2 >= med:\n r = mid\n else:\n l = mid + 1\n \n return l","runtime":"2810"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\n\n d = defaultdict(int)\n \n for rght in range(n):\n d[nums[rght]]+= 1\n\n while len(d) > x:\n left+= 1\n d[nums[left]] -= 1\n if d[nums[left]] == 0: del d[nums[left]]\n\n cnt+= rght - left\n if cnt >= median: return True\n\n return False\n \n\n n = len(nums)\n median = (comb(n+1,2) + 1) // 2\n return bisect_left(range(n), \n True, key = not_less_than_median)","runtime":"2883"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\n\n d = defaultdict(int)\n \n for rght in range(n):\n d[nums[rght]]+= 1\n\n while len(d) > x:\n left+= 1\n d[nums[left]] -= 1\n if d[nums[left]] == 0: del d[nums[left]]\n\n cnt+= rght - left\n if cnt >= median: return True\n\n return False\n \n\n n = len(nums)\n median = (comb(n+1,2) + 1) // 2\n return bisect_left(range(n), \n True, key = not_less_than_median)","runtime":"2883"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n return sol2(nums)\n\ndef sol1(nums):\n N = len(nums)\n uniq = []\n for i in range(N):\n s = set()\n for j in range(i, N):\n s.add(nums[j])\n uniq.append(len(s))\n uniq.sort()\n print(uniq, N * (N + 1) // 2)\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\n return uniq[len(uniq)//2]\n\n# binary search? (iterating by the median)\n# can we make that median or not?\n# how can we answer to that question?\n\n# 1-sized give us N items\n# 2-sized give us N - 1 items\n# ...\n# N-sized give us 1 item\n\n# but we need not all items, but unique ones\n# (we cannot precalculate though)\n\n# to answer if x is a median, we should find out how many\n# 1s, 2s, ..., xs are in the uniqueness array\n# how many 1s we know - it is N\n# when we count 2s then should be different\n# but two items also can go to the 1s if they are the same\n\n# can we find unique items using a sliding window?\n\ndef sol2(nums):\n N = len(nums)\n\n def le(size):\n window = defaultdict(int)\n left = 0\n ans = 0\n for right in range(N):\n window[nums[right]] += 1\n while len(window) > size:\n window[nums[left]] -= 1\n if window[nums[left]] == 0:\n del window[nums[left]]\n left += 1\n ans += right - left + 1\n return ans\n\n total = N * (N + 1) // 2\n median = total // 2 if total % 2 != 0 else total // 2 - 1\n ans = 1\n lo = 1\n hi = N\n while lo <= hi:\n mi = lo + (hi - lo) // 2\n if le(mi) >= median + 1:\n # if le(mi)*2 >= total:\n ans = mi\n hi = mi - 1\n else:\n lo = mi + 1\n return ans\n","runtime":"2957"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n unique[nums[i]] = i # save the last idx of the number\n while len(unique) > limit:\n if unique[nums[left]] == left:\n unique.pop(nums[left])\n left += 1\n result += (i - left) + 1\n if result > K:\n break\n \n return result\n","runtime":"2957"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n lower, upper = 1, total_pairs\n while lower < upper:\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n upper = mid\n else:\n lower = mid + 1\n\n return lower\n\n\ndef num_of_uniqueness(nums, limit):\n unique = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n unique[nums[i]] = i # save the last idx of the number\n while len(unique) > limit:\n if unique[nums[left]] == left:\n unique.pop(nums[left])\n left += 1\n result += (i - left) + 1\n if result > K: # there is not point in keep going\n break\n \n return result\n","runtime":"3031"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n self.n = len(nums)\n total_subarrays = self.n * (self.n + 1) // 2\n self.nums = nums\n L, R = 1, self.n\n while L < R:\n mid = (L + R) // 2\n count = self.get_num_subarrays_with_k_distinct(mid)\n if count * 2 >= total_subarrays:\n R = mid\n else:\n L = mid + 1\n \n return L\n \n def get_num_subarrays_with_k_distinct(self, k):\n freq_dict = defaultdict(int)\n answer = 0\n L = 0\n for R in range(self.n):\n freq_dict[self.nums[R]] += 1\n while len(freq_dict) > k:\n freq_dict[self.nums[L]] -= 1\n if freq_dict[self.nums[L]] == 0: del freq_dict[self.nums[L]]\n L += 1\n \n answer += R - L + 1\n \n return answer ","runtime":"3031"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n lo, hi = 0, len(nums)\n while lo < hi:\n mid = (lo + hi) // 2\n cnt = 0\n prev = 0\n record = defaultdict(int)\n for i, num in enumerate(nums):\n record[num] += 1\n while len(record) > mid:\n record[nums[prev]] -= 1\n if record[nums[prev]] == 0:\n del record[nums[prev]]\n prev += 1\n cnt += i - prev + 1\n if cnt < (len(nums) * (len(nums) + 1) / 2 + 1) // 2:\n lo = mid + 1\n else:\n hi = mid \n return lo","runtime":"3105"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_less_or_equal(val):\n count = 0\n freq = defaultdict(int)\n l = 0 \n for r in range(n):\n rval = nums[r]\n freq[rval] += 1\n \n while len(freq) > val:\n lval = nums[l]\n freq[lval] -= 1 \n if freq[lval] == 0: \n freq.pop(lval)\n l += 1\n\n count += r-l+1\n return count\n\n n = len(nums)\n left = 1\n right = n\n N = n*(n+1)/2\n\n while left < right:\n mid = (left + right) // 2\n count = count_less_or_equal(mid)\n if count >= (N+1)//2:\n right = mid \n else:\n left = mid + 1\n return left \n\n ","runtime":"3105"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n # Init vars and check edge case\n n = len(nums)\n if n == 1: return 1\n l, r = 1, n\n goal = (1+(n*(n+1))//2)//2\n res = 1\n # Bisect\n while l <= r:\n mid = (l+r) // 2\n # Count number of subarrays with at most mid unique elements\n v = self.bisect(nums, mid)\n # Found goal\n if v == goal: return mid\n # Goal must be at least mid+1, remove lower half\n if v < goal:\n res = max(res, mid+1)\n l = mid+1\n # Remove upper half\n else:\n r = mid-1\n return res\n def naive(self, nums, k):\n res = 0\n n = len(nums)\n for i in range(n):\n for j in range(i, n):\n S = set(nums[i:j+1])\n if len(S) <= k: res += 1\n return res\n def bisect(self, nums, k):\n # Init vars\n C = defaultdict(int)\n res = 0\n start = 0\n for i, x in enumerate(nums):\n # Add current element\n C[x] += 1\n # Reduce histogram to at most k items\n while len(C) > k:\n prev_x = nums[start]\n C[prev_x] -= 1\n if not C[prev_x]: C.pop(prev_x)\n start += 1\n # Count number of subarrays ending in index i\n res += i-start+1\n return res\n\n ","runtime":"3179"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n # Init vars and check edge case\n n = len(nums)\n if n == 1: return 1\n l, r = 1, n\n m = (n*(n+1))//2\n goal = (m+1)//2\n res = 1\n # Bisect\n while l <= r:\n mid = (l+r) // 2\n # Count number of subarrays with at most mid unique elements\n v = self.bisect(nums, mid)\n # Found goal\n if v == goal: return mid\n # Goal must be at least mid+1, remove lower half\n if v < goal:\n res = max(res, mid+1)\n l = mid+1\n # Remove upper half\n else:\n r = mid-1\n return res\n\n def bisect(self, nums, k):\n # Init vars\n C = defaultdict(int)\n res = 0\n start = 0\n for i, x in enumerate(nums):\n # Add current element\n C[x] += 1\n # Reduce histogram to at most k items\n while len(C) > k:\n prev_x = nums[start]\n C[prev_x] -= 1\n if not C[prev_x]: C.pop(prev_x)\n start += 1\n # Count number of subarrays ending in index i\n res += i-start+1\n return res ","runtime":"3179"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n total = n*(n+1) >> 1\n totalG = total//2 + 1\n low, high = 1, len(set(nums)) \n ans = -1\n \n while low <= high:\n mid = (low+high) >> 1\n \n hm = defaultdict(int) \n org = defaultdict(int) \n count = left = 0\n for right in range(n):\n ele = nums[right]\n hm[ele] += 1\n org[ele] += 1\n while len(hm) >= mid:\n ele = nums[left]\n hm[ele] -= 1\n left += 1\n if hm[ele] == 0:\n hm.pop(ele) \n if len(org) >= mid:\n count += left \n \n if count >= totalG:\n low = mid + 1\n ans = mid\n else:\n high = mid - 1\n \n return ans","runtime":"3253"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n total = n*(n+1) >> 1\n totalG = total//2 + 1\n low, high = 1, len(set(nums)) \n ans = -1\n \n while low <= high:\n mid = (low+high) >> 1\n \n hm = defaultdict(int) \n org = defaultdict(int) \n count = left = 0\n for right in range(n):\n ele = nums[right]\n hm[ele] += 1\n org[ele] += 1\n while len(hm) >= mid:\n ele = nums[left]\n hm[ele] -= 1\n left += 1\n if hm[ele] == 0:\n hm.pop(ele) \n if len(org) >= mid:\n count += left \n \n if count >= totalG:\n low = mid + 1\n ans = mid\n else:\n high = mid - 1\n \n return ans","runtime":"3327"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n unique[nums[i]] = i # save the last idx of the number\n while len(unique) > limit:\n if unique[nums[left]] == left:\n unique.pop(nums[left])\n left += 1\n result += (i - left) + 1\n \n return result\n","runtime":"3401"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def check(mx: int) -> bool:\n cnt = defaultdict(int)\n k = l = 0\n for r, x in enumerate(nums):\n cnt[x] += 1\n while len(cnt) > mx:\n y = nums[l]\n cnt[y] -= 1\n if cnt[y] == 0:\n cnt.pop(y)\n l += 1\n k += r - l + 1\n if k >= (m + 1) // 2:\n return True\n return False\n\n n = len(nums)\n m = (1 + n) * n // 2\n return bisect_left(range(n), True, key=check)","runtime":"3475"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n #binary search solution\n #pick smallest number N such that at least half (if even # subarrays)...\n #or more than half (if odd # subarrays) subarrays have at most... \n #that number N distinct elements\n\n #O(N logN)\n\n\n def atMostKDistinct(nums, k):\n\n d = defaultdict(int)\n left = 0\n count = 0\n for right in range(len(nums)):\n d[nums[right]]+=1\n while len(d.keys()) > k:\n d[nums[left]] -= 1\n if d[nums[left]] == 0:\n del d[nums[left]]\n left+=1\n count += right - left + 1\n\n return count\n\n\n allArr = len(nums)* (len(nums)+1)//2\n \n left = 1\n right = len(nums)\n while left<=right:\n mid = (left+right)//2\n total = atMostKDistinct(nums, mid)\n \n \n print(total)\n if allArr % 2 == 0 and total == allArr//2 or (allArr % 2 == 1 and total == allArr//2+1):\n return mid\n if total > allArr//2:\n right = mid-1\n else:\n left = mid+1\n \n return left","runtime":"3475"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def check(mx: int) -> bool:\n cnter = defaultdict(int)\n k = l = 0\n for r, x in enumerate(nums):\n cnter[x] += 1\n while len(cnter) > mx:\n y = nums[l]\n cnter[y] -= 1\n if cnter[y] == 0:\n cnter.pop(y)\n l += 1\n k += r-l+1\n if k >= (m+1) // 2:\n return True\n return False\n\n n = len(nums)\n m = (1+n)*n//2\n return bisect_left(range(n), True, key=check)","runtime":"3549"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def check(tgt) :\n res = 0\n cnts = defaultdict(int)\n r = 0\n for i, num in enumerate(nums) :\n while r < len(nums) and not (nums[r] not in cnts and len(cnts) >= tgt) :\n cnts[nums[r]] += 1\n r += 1\n cnts[nums[i]] -= 1\n if cnts[nums[i]] == 0 :\n cnts.pop(nums[i])\n res += r-i\n return res\n\n l = 1\n r = len(set(nums))+1\n tgt = ((((1+len(nums)) * len(nums)) // 2)+1) // 2\n\n while l <= r :\n mid = (l+r) // 2\n t = check(mid)\n if t < tgt :\n l = mid+1\n else :\n r = mid-1\n \n return l","runtime":"3549"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n need = (n * (n+1)//2 + 1) // 2\n def count(x):\n r = 0\n dic = {}\n cnt = 0\n for l in range(n):\n while r < n:\n if nums[r] not in dic and len(dic) == x:\n break\n dic[nums[r]] = dic.get(nums[r],0) + 1\n r += 1\n cnt += r-l\n dic[nums[l]] -= 1\n if dic[nums[l]] == 0:\n del dic[nums[l]]\n return cnt < need\n l, r = 1, n\n while l <= r:\n mid = (l+r)//2\n if count(mid):\n l = mid + 1\n else:\n r = mid - 1\n return l\n","runtime":"3771"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n need = (((n*(n+1))//2 )+ 1) //2\n \n def count(x): \n R = 0\n st = defaultdict(int)\n cnt = 0\n \n for L in range(n):\n while R<n: \n if nums[R] not in st and len(st) == x: \n break \n st[nums[R]]+=1 \n R+=1\n \n cnt += R-L \n \n st[nums[L]]-=1 \n if st[nums[L]] == 0:\n del st[nums[L]]\n \n \n return cnt<need\n\n l,r = 0,n+3 \n while l+1<r: \n m = (l+r)>>1 \n \n if count(m): \n l = m \n else: \n r = m\n \n return r","runtime":"3845"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n need = (((n*(n+1))//2 )+ 1) //2\n \n def count(x): \n R = 0\n st = defaultdict(int)\n cnt = 0\n \n for L in range(n):\n while R<n: \n if nums[R] not in st and len(st) == x: \n break \n st[nums[R]]+=1 \n R+=1\n \n cnt += R-L \n \n st[nums[L]]-=1 \n if st[nums[L]] == 0:\n del st[nums[L]]\n \n return cnt<need\n\n l,r = 0,n+3 \n while l+1<r: \n m = (l+r)>>1 \n \n if count(m): \n l = m \n else: \n r = m\n \n return r","runtime":"3919"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n array_length = len(nums)\n target_count = ((array_length * (array_length + 1)) // 2 + 1) // 2\n\n def is_count_less_than_target(unique_elements):\n right = 0\n element_count = defaultdict(int)\n total_subarrays = 0\n\n for left in range(array_length):\n while right < array_length:\n if nums[right] not in element_count and len(element_count) == unique_elements:\n break\n element_count[nums[right]] += 1\n right += 1\n\n total_subarrays += right - left\n\n element_count[nums[left]] -= 1\n if element_count[nums[left]] == 0:\n del element_count[nums[left]]\n\n return total_subarrays < target_count\n\n min_unique, max_unique = 0, array_length + 3\n while min_unique + 1 < max_unique:\n mid_unique = (min_unique + max_unique) // 2\n\n if is_count_less_than_target(mid_unique):\n min_unique = mid_unique\n else:\n max_unique = mid_unique\n\n return max_unique","runtime":"3993"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = n * (n + 1) // 2\n\n def at_most(k):\n left = 0\n counter = collections.Counter()\n res = 0\n for right, num in enumerate(nums):\n counter[num] += 1\n while len(counter) > k:\n counter[nums[left]] -= 1\n if counter[nums[left]] == 0:\n del counter[nums[left]]\n left += 1\n \n # [left, right] has at most k\n res += right - left + 1\n return res\n \n def check(k):\n at_most_k = at_most(k)\n return at_most_k >= total - at_most_k\n \n left = 1\n right = len(set(nums)) + 1\n while left < right:\n mid = (left + right) // 2\n if check(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4067"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n median = (n * (n + 1)) // 2\n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result * 2 >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4067"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]):\n n = len(nums)\n subarrayCount = n * (n + 1) // 2\n medianCount = (subarrayCount + 1) // 2\n\n # Similar to 992. Subarrays with K Different Integers\n def subarraysWithAtMostKDistinct(k: int) -> int:\n res = 0\n count = collections.Counter()\n\n l = 0\n for r, num in enumerate(nums):\n count[num] += 1\n if count[num] == 1:\n k -= 1\n while k < 0:\n count[nums[l]] -= 1\n if count[nums[l]] == 0:\n k += 1\n l += 1\n res += r - l + 1 # nums[l..r], nums[l + 1..r], ..., nums[r]\n\n return res\n\n return bisect.bisect_left(\n range(1, n), medianCount,\n key=lambda m: subarraysWithAtMostKDistinct(m)) + 1","runtime":"4141"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n median = (total + 1) // 2\n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4141"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n median = (total + 1) // 2\n \n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4215"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result * 2 >= total\n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4215"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n median = (n * (n + 1)) // 2\n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result * 2 >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","runtime":"4289"},{"code":"class Solution:\n @staticmethod\n def _at_most(nums: List[int], max_num: int) -> int:\n count = collections.Counter()\n left = 0\n ans = 0\n for right in range(len(nums)):\n count[nums[right]] += 1\n while len(count) > max_num:\n count[nums[left]] -= 1\n if count[nums[left]] == 0:\n del count[nums[left]]\n left += 1\n ans += right - left + 1\n return ans\n\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n num_count = len(nums)\n total_sub_arrays = num_count * (num_count + 1) // 2\n unique_nums = set(nums)\n left, right = 1, len(unique_nums)\n while left < right:\n guess = (left + right) // 2\n if self._at_most(nums, guess) * 2 < total_sub_arrays:\n left = guess + 1\n else:\n right = guess\n return left","runtime":"4289"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def atMost(k):\n l = res = 0\n counter = Counter()\n\n for r, num in enumerate(nums):\n counter[num] += 1\n\n while len(counter) > k:\n counter[ nums[l] ] -= 1\n if counter[nums[l]] == 0:\n del counter[nums[l]]\n l += 1\n res += r - l + 1\n return res\n\n n = len(nums)\n target = n * (n + 1) // 2\n\n l = 1\n r = len(set(nums)) \n\n while l < r:\n mid = (l + r) // 2\n if atMost(mid) * 2 >= target:\n r = mid\n else:\n l = mid + 1\n return l ","runtime":"4363"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n+1)*n//2\n half = total // 2 if (total%2 == 0) else total//2 + 1\n\n def count(m):\n ct = defaultdict(int)\n i, j = 0, -1\n total = 0\n while i < n:\n while j+1 < n:\n j +=1\n if nums[j] in ct or len(ct) < m:\n ct[nums[j]] += 1\n else:\n j -= 1\n break\n total += j - i + 1\n\n ct[nums[i]] -= 1\n if ct[nums[i]] == 0:\n del ct[nums[i]]\n i +=1\n return total\n \n l, r = 1, n\n\n while l < r:\n m = (l+r)//2\n k1 = count(m)\n if k1 < half:\n l = m+1\n else:\n r = m\n return l\n\n","runtime":"4363"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def amountWithLEQ(target):\n counts = Counter()\n \n res = l = 0\n for r in range(len(nums)):\n counts[nums[r]] += 1\n\n while len(counts) > target:\n counts[nums[l]] -= 1\n if not counts[nums[l]]:\n del counts[nums[l]]\n l += 1\n \n res += r - l + 1\n \n return res\n \n n = len(nums)\n total = (n * (n + 1)) // 2\n target = (total + 1) // 2\n # uniqueness range\n l, r = 0, len(nums)\n best = 0\n\n while l <= r:\n m = (l + r) // 2\n \n val = amountWithLEQ(m)\n\n if val == target:\n return m\n elif val < target:\n l = m + 1\n best = m\n else:\n r = m - 1\n \n return best + 1","runtime":"4437"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n lo, hi = 1, len(set(nums))\n length = len(nums)\n subarray_count = length * (length + 1) // 2\n median = 0\n\n while lo <= hi:\n mid = (lo + hi) // 2\n count = i = j = 0\n freqs = Counter()\n while j < length:\n while j < length and (len(freqs) < mid or nums[j] in freqs):\n count += j - i + 1\n freqs[nums[j]] += 1\n j += 1\n while len(freqs) == mid:\n freqs[nums[i]] -= 1\n if freqs[nums[i]] == 0:\n del freqs[nums[i]]\n i += 1\n if count < math.ceil(subarray_count / 2):\n lo = mid + 1\n else:\n median = mid\n hi = mid - 1\n \n return median\n","runtime":"4511"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n target = (((1 + n) * n // 2) - 1) // 2\n\n l, r = 1, n + 1\n while l < r:\n mid = l + r >> 1\n total = j = 0\n cnt = Counter()\n for i, x in enumerate(nums):\n cnt[x] += 1\n \n while len(cnt) > mid:\n cnt[nums[j]] -= 1\n if cnt[nums[j]] == 0:\n del cnt[nums[j]]\n j += 1\n \n total += i - j + 1\n\n if total > target:\n break\n \n if total <= target:\n l = mid + 1\n else:\n r = mid \n\n return l","runtime":"4585"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n tot = n * (n + 1) // 2\n\n def check(k: int) -> int:\n hash = Counter()\n i = j = 0\n res = 0\n while i < n:\n hash[nums[i]] += 1\n while len(hash) > k:\n hash[nums[j]] -= 1\n if hash[nums[j]] == 0:\n del hash[nums[j]]\n j += 1\n res += i - j + 1\n i += 1\n return res\n\n l, r = 1, n\n while l < r:\n mid = l + r >> 1\n if check(mid) * 2 >= tot:\n r = mid\n else:\n l = mid + 1\n return r","runtime":"4659"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique_nums = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n update_map(unique_nums, nums[i], 1)\n while len(unique_nums) > limit:\n update_map(unique_nums, nums[left], -1)\n left += 1\n result += (i - left) + 1\n \n return result\n\ndef update_map(unique, x, incr):\n if x not in unique:\n unique[x] = 0\n unique[x] += incr\n if unique[x] == 0:\n unique.pop(x)","runtime":"4733"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique_nums = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n update_map(unique_nums, nums[i], 1)\n while len(unique_nums) > limit:\n update_map(unique_nums, nums[left], -1)\n left += 1\n result += (i - left) + 1\n \n return result\n\ndef update_map(unique, x, incr):\n if incr < 0 and x not in unique:\n return \n if x not in unique:\n unique[x] = 0\n unique[x] += incr\n if unique[x] == 0:\n unique.pop(x)","runtime":"4806"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n\n # find how many uniqueness are <= than a threshold\n def findSmallerThan(th: int) -> int:\n cnt = Counter()\n res = 0\n\n right = 0\n for left in range(n):\n # expand it as much as you can\n while len(cnt) <= th and right < n:\n cnt[nums[right]] += 1\n if len(cnt) > th:\n cnt.pop(nums[right])\n break\n right += 1\n res += right - left\n\n cnt[nums[left]] -= 1\n if cnt[nums[left]] == 0:\n cnt.pop(nums[left])\n return res\n\n l, r = 1, n\n while l < r:\n mid = l + (r - l) // 2\n\n if findSmallerThan(mid) >= (total + 1) // 2:\n r = mid\n else:\n l = mid + 1\n return l","runtime":"4880"}],"string":"[\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n m = n * (n + 1) // 2 + 1 >> 1\\n d, pre, nxt = {}, [-1] * n, [n] * n\\n for i, x in enumerate(nums):\\n if x in d:\\n j = d[x]\\n pre[i] = j\\n nxt[j] = i\\n d[x] = i\\n \\n def f(t):\\n i, c = 0, 0\\n while c <= t:\\n if pre[i] < 0:\\n c += 1\\n i += 1\\n s, l = comb(i, 2), 0\\n for r in range(i - 1, n):\\n if pre[r] < l:\\n while nxt[l] <= r:\\n l += 1\\n l += 1\\n s += r - l\\n return s + n - i + 1\\n \\n a, b, x, y = 1, len(d), 0, m * 2\\n while a < b:\\n c = max(a, int(b - (b - a + 1) * (y - m) / (y - x)))\\n t = f(c)\\n if t == m:\\n return c\\n if t > m:\\n b, y = c, t\\n else:\\n a, x = c + 1, t\\n return a\",\n \"runtime\": \"886\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n countMap = [0] * 100001\\n\\n def subarraysWithAtmostK(k):\\n c = k\\n l, r, count = 0, 0, 0\\n for r in range(numSize):\\n if countMap[nums[r]] == 0: k -= 1\\n countMap[nums[r]] += 1\\n while(k < 0):\\n countMap[nums[l]] -= 1\\n if countMap[nums[l]] == 0: k += 1\\n l += 1\\n count += r - l + 1\\n while l < numSize: \\n countMap[nums[l]] -= 1\\n l += 1\\n return count\\n\\n numSize = len(nums)\\n numOfSubArrays = (numSize * (numSize + 1)) // 2\\n median = (numOfSubArrays + 1) // 2\\n\\n left = 1\\n right = len(set(nums))\\n\\n while(left <= right):\\n middle = left + (right - left) // 2\\n if(subarraysWithAtmostK(middle) < median): left = middle + 1\\n else: right = middle - 1\\n\\n return left\",\n \"runtime\": \"886\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n l, h = 0, len(set(nums))\\n\\n while l < h:\\n mid = (l + h) // 2\\n cnt = pt = 0\\n record = {}\\n\\n for i, num in enumerate(nums):\\n record[num] = i\\n while len(record) > mid:\\n if record[nums[pt]] == pt:\\n del record[nums[pt]]\\n pt += 1\\n\\n cnt += i - pt + 1\\n \\n if cnt >= ((len(nums) * (len(nums) + 1) ) / 2 + 1) // 2:\\n h = mid \\n else:\\n l = mid + 1\\n return l\",\n \"runtime\": \"960\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n def count(v):\\n ans = 0\\n l = 0\\n window = {}\\n for r in range(n):\\n window[nums[r]] = window.get(nums[r], 0) + 1\\n while len(window) > v:\\n window[nums[l]] -= 1\\n if window[nums[l]] == 0:\\n del window[nums[l]]\\n l += 1\\n ans += r - l + 1\\n return ans\\n low, hig = 1, len(set(nums))\\n total = n * (n+1) // 2\\n while low < hig:\\n mid = (low + hig) // 2\\n if count(mid)*2 >= total:\\n hig = mid\\n else:\\n low = mid + 1\\n return low\",\n \"runtime\": \"1034\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n + 1) * n // 2\\n target = (total + 1) // 2\\n left = 1\\n right = len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n start = 0\\n count = 0\\n dic = {}\\n for i in range(n):\\n dic[nums[i]] = dic.get(nums[i], 0) + 1\\n while len(dic) > mid:\\n dic[nums[start]] -= 1\\n if dic[nums[start]] == 0:\\n del dic[nums[start]]\\n start += 1\\n count += i - start + 1\\n if count >= target:\\n break\\n if count >= target:\\n right = mid\\n else:\\n left = mid + 1\\n return right\",\n \"runtime\": \"1108\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def kUnique(k):\\n window = {}\\n start, res = 0, 0\\n for i, x in enumerate(nums):\\n window[x] = window.get(x, 0) + 1\\n while start <= i and len(window) > k:\\n window[nums[start]] -= 1\\n if window[nums[start]] == 0:\\n del window[nums[start]]\\n start += 1\\n res += i - start + 1\\n return res\\n n = len(nums)\\n total = n*(n+1)//2\\n l, r = 1, len(set(nums))\\n while l < r:\\n mid = (l + r)//2\\n if kUnique(mid)*2 < total:\\n l = mid + 1\\n else:\\n r = mid\\n return l\",\n \"runtime\": \"1182\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n @cache\\n def withinK(cap):\\n if cap == 0:\\n return 0\\n window, start, res = {}, 0, 0\\n for i, x in enumerate(nums):\\n window[x] = window.get(x, 0) + 1\\n while start < i and len(window) > cap:\\n window[nums[start]] -= 1\\n if window[nums[start]] == 0:\\n del window[nums[start]]\\n start += 1\\n res += i - start + 1\\n return res\\n \\n n = len(nums)\\n total = n*(n+1)//2\\n l, r = 1, len(set(nums))\\n while l < r:\\n mid = (l + r)//2\\n cnt = withinK(mid)\\n if cnt*2 < total:\\n l = mid + 1\\n else:\\n r = mid\\n return l\",\n \"runtime\": \"1256\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n def less_than(x):\\n arr = defaultdict(int)\\n l,r = 0,0\\n cnt = 0\\n while r < n:\\n # print(l,r, arr, cnt)\\n arr[nums[r]] += 1\\n while len(arr) > x:\\n if arr[nums[l]] == 1:\\n del arr[nums[l]]\\n else:\\n arr[nums[l]] -= 1\\n l += 1\\n cnt += (r-l+1)\\n r += 1\\n return cnt\\n \\n l1,r1 = 1,len(set(nums))\\n target = (n*(n+1))//2\\n target += 1\\n target //= 2\\n # print(l1, r1, target)\\n while l1 < r1:\\n m = (l1+r1)//2\\n lt = less_than(m)\\n # print(m, lt)\\n if target == lt:\\n return m\\n if target < lt:\\n r1 = m\\n else:\\n l1 = m+1\\n return r1\\n \",\n \"runtime\": \"1330\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_subarray_distinct_less_or_equal_k(nums, k):\\n left_fast = 0\\n right = 0\\n counts = {}\\n ans = 0\\n while right < n:\\n if nums[right] in counts or len(counts) < k:\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n else:\\n while len(counts) == k:\\n counts[nums[left_fast]] -= 1\\n if counts[nums[left_fast]] == 0:\\n del counts[nums[left_fast]]\\n left_fast += 1\\n\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n ans += right - left_fast\\n return ans\\n \\n n = len(nums)\\n total_subarray_num = n * (n + 1) // 2\\n target = total_subarray_num // 2 + (total_subarray_num & 1)\\n left = 1\\n right = len(set(nums))\\n while left < right:\\n mid = left + right\\n mid //= 2\\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"1404\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n tot_arrs = N * (N + 1) // 2\\n med = tot_arrs // 2 + tot_arrs % 2\\n l, r = 1, len(set(nums))\\n res = -1\\n while l <= r:\\n m = (l + r) // 2\\n ct = 0\\n\\n counts = defaultdict(int)\\n j = 0\\n\\n for i in range(N):\\n counts[nums[i]] += 1\\n while len(counts) > m:\\n counts[nums[j]] -= 1\\n if counts[nums[j]] == 0: del counts[nums[j]]\\n j += 1\\n ct += i - j + 1\\n\\n if ct < med:\\n l = m + 1\\n elif ct >= med:\\n res = m\\n r = m - 1\\n\\n return res\",\n \"runtime\": \"1478\"\n },\n {\n \"code\": \"# class Solution:\\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n# n = len(nums)\\n# total = (n * (n + 1)) // 2\\n# medi = (total + 1) // 2\\n\\n# elements = len(set(nums))\\n \\n# def getMedianK(nums, x):\\n# lo, hi = 1, elements\\n# while lo <= hi:\\n# mid = (lo + hi) // 2\\n# count = self.atMost(nums, mid)\\n# # if count == x:\\n# # return mid\\n# if count >= x:\\n# hi = mid - 1\\n# else:\\n# lo = mid + 1\\n \\n# return lo\\n\\n# k = getMedianK(nums, medi)\\n# return k\\n\\n\\n# def atMost(self, nums, k):\\n# left = 0\\n# counter = dict()\\n# res = 0\\n# for i, c in enumerate(nums):\\n# counter[c] = counter.get(c, 0) + 1\\n# while len(counter) > k:\\n# counter[nums[left]] -= 1\\n# if counter[nums[left]] == 0:\\n# counter.pop(nums[left])\\n \\n# left += 1\\n\\n# res += i - left + 1\\n\\n# return res\\n\\n# class Solution:\\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n# uniq = defaultdict(int)\\n\\n# for i in range(len(nums)):\\n# counter = dict()\\n# for j in range(i, len(nums)):\\n# counter[nums[j]] = counter.get(nums[j], 0) + 1\\n# uniq[len(counter)] += 1\\n\\n# # print(uniq)\\n# sortedcount = sorted([(uniq_ele, count) for uniq_ele, count in uniq.items()])\\n# # total = len(nums) * (len(nums) + 1) / 2\\n# total = sum(uniq.values())\\n# medi = (total + 1) // 2\\n# s = 0\\n# for u, c in sortedcount:\\n# s += c\\n# if s >= medi:\\n# return u\\n\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n lo = 0\\n hi = len(set(nums))\\n\\n totalArrs = (n+1) * n / 2\\n medn = totalArrs / 2\\n\\n while lo <= hi:\\n mid = (lo + hi) // 2\\n # print('\\\\n lo, mid, hi', lo, mid, hi)\\n\\n if self.atMost(nums, mid) >= medn:\\n hi = mid - 1\\n else:\\n lo = mid + 1\\n\\n return lo\\n\\n \\n def atMost(self, nums, k):\\n # only number of arrays ending at i, uniqueness <= k\\n arrCounts = [0] * (len(nums) + 1)\\n\\n left = 0\\n # right = 0\\n prevs = dict()\\n prevscount = dict()\\n\\n for i, num in enumerate(nums):\\n # if num not in prevs:\\n # prevs[num] = i\\n prevscount[num] = prevscount.get(num, 0) + 1\\n\\n while len(prevscount) > k:\\n prevscount[nums[left]] -= 1\\n if prevscount[nums[left]] == 0:\\n prevscount.pop(nums[left])\\n \\n left += 1\\n\\n # prevNumIdx = prevs[num] if num in prevs else -1\\n # arrCounts[i+1] = arrCounts[i] + i - prevNumIdx\\n # prevs[num] = i\\n arrCounts[i+1] = i - left + 1\\n \\n # print('arrCounts', arrCounts)\\n return sum(arrCounts)\\n\\n\\n\\n \",\n \"runtime\": \"1552\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums):\\n cnt = self.getCnt(nums)\\n return self.bs(nums, cnt)\\n \\n def getCnt(self, nums):\\n n = len(nums)\\n mc = n * (n + 1) // 2\\n return (mc + 1) // 2\\n \\n def bs(self, nums, cnt):\\n lo, hi = 1, self.getUnique(nums)\\n while lo < hi:\\n mid = (hi + lo) // 2\\n if self.check(nums, cnt, mid):\\n lo = mid + 1\\n else:\\n hi = mid\\n return lo\\n \\n def getUnique(self, nums):\\n return len(set(nums))\\n \\n def check(self, nums, cnt, k):\\n md = 0\\n mp = defaultdict(int)\\n l = 0\\n for r in range(len(nums)):\\n mp[nums[r]] += 1\\n \\n while len(mp) > k:\\n mp[nums[l]] -= 1\\n if mp[nums[l]] == 0:\\n del mp[nums[l]]\\n l += 1\\n md += (r - l + 1)\\n return md < cnt\\n\",\n \"runtime\": \"1626\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_subarray_distinct_less_or_equal_k(nums, k):\\n left = 0\\n right = 0\\n counts = {}\\n ans = 0\\n while right < n:\\n if nums[right] in counts or len(counts) < k:\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n else:\\n while len(counts) == k:\\n counts[nums[left]] -= 1\\n if counts[nums[left]] == 0:\\n del counts[nums[left]]\\n left += 1\\n\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n ans += right - left\\n return ans\\n \\n n = len(nums)\\n total_subarray_num = n * (n + 1) // 2\\n target = total_subarray_num // 2 + (total_subarray_num & 1)\\n left = 1\\n right = len(set(nums))\\n while left < right:\\n mid = left + right\\n mid //= 2\\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"1700\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n return sol2(nums)\\n\\ndef sol1(nums):\\n N = len(nums)\\n uniq = []\\n for i in range(N):\\n s = set()\\n for j in range(i, N):\\n s.add(nums[j])\\n uniq.append(len(s))\\n uniq.sort()\\n print(uniq, N * (N + 1) // 2)\\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\\n return uniq[len(uniq)//2]\\n\\n# binary search? (iterating by the median)\\n# can we make that median or not?\\n# how can we answer to that question?\\n\\n# 1-sized give us N items\\n# 2-sized give us N - 1 items\\n# ...\\n# N-sized give us 1 item\\n\\n# but we need not all items, but unique ones\\n# (we cannot precalculate though)\\n\\n# to answer if x is a median, we should find out how many\\n# 1s, 2s, ..., xs are in the uniqueness array\\n# how many 1s we know - it is N\\n# when we count 2s then should be different\\n# but two items also can go to the 1s if they are the same\\n\\n# can we find unique items using a sliding window?\\n\\ndef sol2(nums):\\n N = len(nums)\\n\\n def run(size):\\n window = defaultdict(int)\\n left = 0\\n ans = 0\\n for right in range(N):\\n window[nums[right]] += 1\\n while len(window) > size:\\n window[nums[left]] -= 1\\n if window[nums[left]] == 0:\\n del window[nums[left]]\\n left += 1\\n ans += right - left + 1\\n return ans\\n\\n total = N * (N + 1) // 2\\n ans = 1\\n lo = 1\\n hi = len(set(nums))\\n while lo <= hi:\\n mi = lo + (hi - lo) // 2\\n x = run(mi)\\n if x*2 >= total:\\n ans = mi\\n hi = mi - 1\\n else:\\n lo = mi + 1\\n return ans\\n\",\n \"runtime\": \"1774\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_subarray_distinct_less_or_equal_k(nums, k):\\n if k == 0:\\n return 0\\n # print(\\\"k = \\\" ,k)\\n left_slow = 0\\n left_fast = 0\\n right = 0\\n counts = {}\\n ans = 0\\n while right < n:\\n if nums[right] in counts or len(counts) < k:\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n else:\\n # move left\\n left_slow = left_fast\\n while len(counts) == k:\\n counts[nums[left_fast]] -= 1\\n if counts[nums[left_fast]] == 0:\\n del counts[nums[left_fast]]\\n left_fast += 1\\n\\n \\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n ans += right - left_fast\\n return ans\\n \\n n = len(nums)\\n total_subarray_num = n * (n + 1) // 2\\n target = total_subarray_num // 2 + (total_subarray_num & 1)\\n left = 0\\n right = len(set(nums))\\n while left < right:\\n mid = left + right\\n mid //= 2\\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"1848\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n total_subarrays = N * (N + 1) // 2\\n def good(k):\\n nonlocal total_subarrays\\n l = 0\\n total_valid = 0\\n lookup = defaultdict(int)\\n for r in range(N):\\n lookup[nums[r]] += 1\\n while len(lookup) > k:\\n lookup[nums[l]] -= 1\\n if lookup[nums[l]] == 0:\\n del lookup[nums[l]]\\n l += 1\\n total_valid += r - l + 1\\n return total_valid * 2 >= total_subarrays\\n \\n\\n l, r = 1, len(set(nums))\\n while l < r:\\n mid = (l + r) // 2\\n if good(mid):\\n r = mid\\n else:\\n l = mid + 1\\n return l\",\n \"runtime\": \"1922\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n K = (N * (N + 1) // 2 + 1) // 2\\n\\n def check(upper: int) -> bool:\\n cnt, l = 0, 0\\n freq = defaultdict(int)\\n for r, x in enumerate(nums):\\n freq[x] += 1\\n while len(freq) > upper:\\n drop = nums[l]\\n freq[drop] -= 1\\n if freq[drop] == 0:\\n del freq[drop]\\n l += 1\\n cnt += r - l + 1\\n if cnt >= K:\\n return True\\n return False\\n\\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)\",\n \"runtime\": \"1996\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n K = (N * (N + 1) // 2 + 1) // 2\\n\\n def check(upper: int) -> bool:\\n cnt, l = 0, 0\\n freq = defaultdict(int)\\n for r, x in enumerate(nums):\\n freq[x] += 1\\n while len(freq) > upper:\\n drop = nums[l]\\n freq[drop] -= 1\\n if freq[drop] == 0:\\n del freq[drop]\\n l += 1\\n cnt += r - l + 1\\n if cnt >= K:\\n return True\\n return False\\n\\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)\",\n \"runtime\": \"1996\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n return sol2(nums)\\n\\ndef sol1(nums):\\n N = len(nums)\\n uniq = []\\n for i in range(N):\\n s = set()\\n for j in range(i, N):\\n s.add(nums[j])\\n uniq.append(len(s))\\n uniq.sort()\\n print(uniq, N * (N + 1) // 2)\\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\\n return uniq[len(uniq)//2]\\n\\n# binary search? (iterating by the median)\\n# can we make that median or not?\\n# how can we answer to that question?\\n\\n# 1-sized give us N items\\n# 2-sized give us N - 1 items\\n# ...\\n# N-sized give us 1 item\\n\\n# but we need not all items, but unique ones\\n# (we cannot precalculate though)\\n\\n# to answer if x is a median, we should find out how many\\n# 1s, 2s, ..., xs are in the uniqueness array\\n# how many 1s we know - it is N\\n# when we count 2s then should be different\\n# but two items also can go to the 1s if they are the same\\n\\n# can we find unique items using a sliding window?\\n\\ndef sol2(nums):\\n N = len(nums)\\n\\n def le(size):\\n window = defaultdict(int)\\n left = 0\\n ans = 0\\n for right in range(N):\\n window[nums[right]] += 1\\n while len(window) > size:\\n window[nums[left]] -= 1\\n if window[nums[left]] == 0:\\n del window[nums[left]]\\n left += 1\\n ans += right - left + 1\\n return ans\\n\\n total = N * (N + 1) // 2\\n ans = 1\\n lo = 1\\n hi = len(set(nums))\\n while lo <= hi:\\n mi = lo + (hi - lo) // 2\\n if le(mi)*2 >= total:\\n ans = mi\\n hi = mi - 1\\n else:\\n lo = mi + 1\\n return ans\\n\",\n \"runtime\": \"2070\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n max_distinct = set(nums)\\n low, high = 1, len(max_distinct)\\n n = len(nums)\\n combos = (n*(n+1))//2\\n combos = (combos//2) + (combos%2)\\n # print(combos)\\n\\n def is_median_upper(nums, x):\\n count = defaultdict(int)\\n left = 0\\n k = 0\\n for idx, val in enumerate(nums):\\n count[val] +=1\\n while len(count) >x:\\n count[nums[left]]-=1\\n if not count[nums[left]]:\\n del(count[nums[left]])\\n left+=1\\n k += idx-left+1\\n if k > combos:\\n return True\\n # print(k,x)\\n if k < combos:\\n return False\\n else:\\n return True\\n\\n while low < high:\\n # print(low,high)\\n mid = (low+high)//2\\n cond = is_median_upper(nums,mid)\\n if cond:\\n high = mid\\n else:\\n low = mid+1\\n return low\\n \",\n \"runtime\": \"2144\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n max_distinct = set(nums)\\n low, high = 1, len(max_distinct)\\n n = len(nums)\\n combos = (n*(n+1))//2\\n combos = (combos//2) + (combos%2)\\n # print(combos)\\n\\n def is_median_upper(nums, x):\\n count = defaultdict(int)\\n left = 0\\n k = 0\\n for idx, val in enumerate(nums):\\n count[val] +=1\\n while len(count) >x:\\n count[nums[left]]-=1\\n if not count[nums[left]]:\\n del(count[nums[left]])\\n left+=1\\n k += idx-left+1\\n if k >= combos:\\n return True\\n # print(k,x)\\n if k < combos:\\n return False\\n else:\\n return True\\n\\n while low < high:\\n # print(low,high)\\n mid = (low+high)//2\\n cond = is_median_upper(nums,mid)\\n if cond:\\n high = mid\\n else:\\n low = mid+1\\n return low\\n \",\n \"runtime\": \"2218\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n [3,4,3,4,5]\\n all subarraies, get unique -> sort -> median\\n lo, hi = 1, unique mid = \\n total subarraries = (n + 1) * n // 2\\n count = total // 2\\n \\\"\\\"\\\"\\n n = len(nums)\\n total = math.ceil((n + 1) * n / 4)\\n lo, hi = 1, len(set(nums))\\n\\n def get_count(mid):\\n count, l = 0, 0\\n uniques = defaultdict(int)\\n for r in range(n):\\n uniques[nums[r]] += 1\\n while len(uniques) > mid:\\n uniques[nums[l]] -= 1\\n if uniques[nums[l]] == 0:\\n uniques.pop(nums[l])\\n l += 1\\n count += r - l + 1\\n return count\\n\\n while lo < hi:\\n mid = (lo + hi) // 2\\n count = get_count(mid)\\n print(mid, count)\\n if count < total:\\n lo = mid + 1\\n else:\\n hi = mid\\n \\n return lo\\n\",\n \"runtime\": \"2292\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n max_distinct = set(nums)\\n low, high = 1, len(max_distinct)\\n n = len(nums)\\n combos = (n*(n+1))//2\\n combos = (combos//2) + (combos%2)\\n # print(combos)\\n\\n def is_median_upper(nums, x):\\n window = set()\\n count = defaultdict(int)\\n left = 0\\n k = 0\\n for idx, val in enumerate(nums):\\n count[val] +=1\\n while len(count) >x:\\n count[nums[left]]-=1\\n if not count[nums[left]]:\\n del(count[nums[left]])\\n left+=1\\n k += idx-left+1\\n if k > combos:\\n return True\\n # print(k,x)\\n if k < combos:\\n return False\\n else:\\n return True\\n\\n while low < high:\\n # print(low,high)\\n mid = (low+high)//2\\n cond = is_median_upper(nums,mid)\\n if cond:\\n high = mid\\n else:\\n low = mid+1\\n return low\\n \",\n \"runtime\": \"2366\"\n },\n {\n \"code\": \"def count(nums, d):\\n cnt = {}\\n lo = 0\\n res = 0\\n for i in range(len(nums)):\\n cnt[nums[i]] = cnt.get(nums[i], 0) + 1\\n while len(cnt) > d:\\n cnt[nums[lo]] = cnt[nums[lo]] - 1\\n if cnt[nums[lo]] == 0:\\n del cnt[nums[lo]]\\n lo += 1\\n res += i - lo + 1\\n return res\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n C = (len(nums) * (len(nums) + 1)) // 2\\n lo = 0\\n hi = len(nums) + 1\\n while hi - lo > 1:\\n mi = (lo + hi) // 2\\n if count(nums, mi) < C // 2 + C % 2:\\n lo = mi\\n else:\\n hi = mi\\n return hi\\n\",\n \"runtime\": \"2440\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n + 1) * n // 2\\n target = (total + 1) // 2\\n left = 1\\n right = n\\n while left < right:\\n mid = left + (right - left) // 2\\n count = 0\\n cnt = {}\\n start = 0\\n for i, num in enumerate(nums):\\n cnt[num] = cnt.get(num, 0) + 1\\n while len(cnt) > mid:\\n cnt[nums[start]] -= 1\\n if cnt[nums[start]] == 0:\\n del cnt[nums[start]]\\n start += 1\\n count += i - start + 1\\n if count >= target:\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"2514\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def atMostK(k: int):\\n result = 0\\n left, right = 0, 0\\n counts = dict()\\n for right in range(len(nums)):\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n while len(counts) > k:\\n removed = nums[left]\\n left += 1\\n counts[removed] -= 1\\n if counts[removed] == 0:\\n del counts[removed]\\n result += right - left + 1 \\n return result \\n left, right = 1, len(nums)\\n total = len(nums) * (len(nums) - 1)//2 + len(nums)\\n mid = 0\\n while left <= right:\\n mid = left + (right - left)//2\\n subarrays = atMostK(mid)\\n if subarrays == (total + 1)//2:\\n return mid\\n elif subarrays > (total + 1)//2:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return right + 1\\n\\n\",\n \"runtime\": \"2588\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n max_distinct = set(nums)\\n low, high = 1, len(max_distinct)\\n n = len(nums)\\n combos = (n*(n+1))//2\\n # print(combos)\\n\\n def is_median_upper(nums, x):\\n window = set()\\n count = dict()\\n left = 0\\n k = 0\\n for idx, val in enumerate(nums):\\n window.add(val)\\n count[val] = count.get(val,0)+1\\n while len(window) >x:\\n count[nums[left]]-=1\\n if not count[nums[left]]:\\n window.remove(nums[left])\\n left+=1\\n k += idx-left+1\\n # print(k,x)\\n if k < (combos//2) + combos%2 :\\n return False\\n else:\\n return True\\n\\n while low < high:\\n # print(low,high)\\n mid = (low+high)//2\\n cond = is_median_upper(nums,mid)\\n if cond:\\n high = mid\\n else:\\n low = mid+1\\n return low\\n \",\n \"runtime\": \"2662\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n # 我們要找的targetIndex為 math.ceil(((n * (n+1)) // 2) / 2)\\n # 最前面的n個都為 1\\n # 整個掃過一次就可以知道最後面一個是多少，假設叫r\\n # 用binary search找一個介於1到r之間的值，並去計算是否超過targetIndex個\\n\\n # [3,4,3,4,5] , m = 2\\n # 每次需確保unique number <= m組，且會產生(j-i+1)組合法答案\\n # i \\n # j\\n # 1 + 2 + 3 + 4 + 2 = 12\\n def solve(m):\\n l = 0\\n ct = collections.defaultdict(int)\\n unique_nums = 0\\n res = 0\\n for i,e in enumerate(nums):\\n ct[e] += 1\\n unique_nums += 1 if ct[e] == 1 else 0\\n while l <= i and unique_nums > m:\\n ct[nums[l]] -= 1\\n unique_nums -= 1 if ct[nums[l]] == 0 else 0\\n l += 1\\n \\n res += (i - l + 1)\\n return res\\n\\n n = len(nums)\\n m = ((n * (n+1)) // 2) # 新構建出來的arr的長度\\n targetIndex = math.ceil(m / 2)\\n ans = 0\\n l, r = 1, len(set(nums))\\n while l <= r:\\n m = (l + r) // 2\\n if solve(m) >= targetIndex:\\n ans = m\\n r = m - 1\\n else:\\n l = m + 1\\n return ans\",\n \"runtime\": \"2662\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef medianOfUniquenessArray(self, nums: List[int]) -> int:\\n\\t\\tl, r, n = 0, len(nums), len(nums)\\n\\t\\tdef count(x):\\n\\t\\t\\ta, c, i = {}, 0, 0\\n\\t\\t\\tfor j in range(n):\\n\\t\\t\\t\\ta[nums[j]] = a.get(nums[j], 0) + 1\\n\\t\\t\\t\\twhile len(a) > x:\\n\\t\\t\\t\\t\\ta[nums[i]] -= 1\\n\\t\\t\\t\\t\\tif a[nums[i]] == 0: del a[nums[i]]\\n\\t\\t\\t\\t\\ti += 1\\n\\t\\t\\t\\tc += j + 1 - i\\n\\t\\t\\treturn c\\n\\t\\tt = n * (n + 1) // 2 // 2 + n * (n + 1) // 2 % 2\\n\\t\\twhile l < r:\\n\\t\\t\\tm = (l + r) // 2\\n\\t\\t\\tif count(m) < t: l = m + 1\\n\\t\\t\\telse: r = m\\n\\t\\treturn l\",\n \"runtime\": \"2736\"\n },\n {\n \"code\": \"# class Solution:\\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n# n = len(nums)\\n# total = (n * (n + 1)) // 2\\n# medi = (total + 1) // 2\\n\\n# elements = len(set(nums))\\n \\n# def getMedianK(nums, x):\\n# lo, hi = 1, elements\\n# while lo <= hi:\\n# mid = (lo + hi) // 2\\n# count = self.atMost(nums, mid)\\n# # if count == x:\\n# # return mid\\n# if count >= x:\\n# hi = mid - 1\\n# else:\\n# lo = mid + 1\\n \\n# return lo\\n\\n# k = getMedianK(nums, medi)\\n# return k\\n\\n\\n# def atMost(self, nums, k):\\n# left = 0\\n# counter = dict()\\n# res = 0\\n# for i, c in enumerate(nums):\\n# counter[c] = counter.get(c, 0) + 1\\n# while len(counter) > k:\\n# counter[nums[left]] -= 1\\n# if counter[nums[left]] == 0:\\n# counter.pop(nums[left])\\n \\n# left += 1\\n\\n# res += i - left + 1\\n\\n# return res\\n\\n# class Solution:\\n# def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n# uniq = defaultdict(int)\\n\\n# for i in range(len(nums)):\\n# counter = dict()\\n# for j in range(i, len(nums)):\\n# counter[nums[j]] = counter.get(nums[j], 0) + 1\\n# uniq[len(counter)] += 1\\n\\n# # print(uniq)\\n# sortedcount = sorted([(uniq_ele, count) for uniq_ele, count in uniq.items()])\\n# # total = len(nums) * (len(nums) + 1) / 2\\n# total = sum(uniq.values())\\n# medi = (total + 1) // 2\\n# s = 0\\n# for u, c in sortedcount:\\n# s += c\\n# if s >= medi:\\n# return u\\n\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n lo = 0\\n hi = len(set(nums))\\n\\n totalArrs = (n+1) * n / 2\\n medn = totalArrs / 2\\n\\n while lo <= hi:\\n mid = (lo + hi) // 2\\n # print('\\\\n lo, mid, hi', lo, mid, hi)\\n\\n if self.atMost(nums, mid) >= medn:\\n hi = mid - 1\\n else:\\n lo = mid + 1\\n\\n return lo\\n\\n \\n def atMost(self, nums, k):\\n # only number of arrays ending at i, uniqueness <= k\\n arrCounts = [0] * (len(nums) + 1)\\n\\n left = 0\\n # right = 0\\n prevs = dict()\\n prevscount = dict()\\n\\n for i, num in enumerate(nums):\\n # if num not in prevs:\\n # prevs[num] = i\\n prevscount[num] = prevscount.get(num, 0) + 1\\n\\n while len(prevscount) > k:\\n prevscount[nums[left]] -= 1\\n if prevscount[nums[left]] == 0:\\n prevscount.pop(nums[left])\\n \\n left += 1\\n\\n # prevNumIdx = prevs[num] if num in prevs else -1\\n # arrCounts[i+1] = arrCounts[i] + i - prevNumIdx\\n # prevs[num] = i\\n arrCounts[i+1] = i - left + 1\\n \\n # print('arrCounts', arrCounts)\\n return sum(arrCounts)\\n\\n\\n\\n \",\n \"runtime\": \"2736\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\\n\\n d = defaultdict(int)\\n \\n for rght in range(n):\\n d[nums[rght]]+= 1\\n\\n while len(d) > x:\\n left+= 1\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0: del d[nums[left]]\\n\\n cnt+= rght - left\\n if cnt >= median: return True\\n\\n return False\\n \\n\\n n = len(nums)\\n median = (comb(n+1,2) + 1) // 2\\n return bisect_left(range(n), \\n True, key = not_less_than_median)\",\n \"runtime\": \"2810\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count(val):\\n count = defaultdict(int)\\n l = 0\\n res = 0\\n \\n for r in range(len(nums)):\\n count[nums[r]] += 1\\n \\n while len(count) > val:\\n count[nums[l]] -= 1\\n if count[nums[l]] == 0:\\n count.pop(nums[l])\\n l += 1\\n \\n res += r - l + 1\\n return res\\n \\n l, r = 0, len(set(nums))\\n n = len(nums)\\n med = n * (n + 1) // 2\\n while l < r:\\n mid = (l + r) // 2\\n if count(mid) * 2 >= med:\\n r = mid\\n else:\\n l = mid + 1\\n \\n return l\",\n \"runtime\": \"2810\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\\n\\n d = defaultdict(int)\\n \\n for rght in range(n):\\n d[nums[rght]]+= 1\\n\\n while len(d) > x:\\n left+= 1\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0: del d[nums[left]]\\n\\n cnt+= rght - left\\n if cnt >= median: return True\\n\\n return False\\n \\n\\n n = len(nums)\\n median = (comb(n+1,2) + 1) // 2\\n return bisect_left(range(n), \\n True, key = not_less_than_median)\",\n \"runtime\": \"2883\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\\n\\n d = defaultdict(int)\\n \\n for rght in range(n):\\n d[nums[rght]]+= 1\\n\\n while len(d) > x:\\n left+= 1\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0: del d[nums[left]]\\n\\n cnt+= rght - left\\n if cnt >= median: return True\\n\\n return False\\n \\n\\n n = len(nums)\\n median = (comb(n+1,2) + 1) // 2\\n return bisect_left(range(n), \\n True, key = not_less_than_median)\",\n \"runtime\": \"2883\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n return sol2(nums)\\n\\ndef sol1(nums):\\n N = len(nums)\\n uniq = []\\n for i in range(N):\\n s = set()\\n for j in range(i, N):\\n s.add(nums[j])\\n uniq.append(len(s))\\n uniq.sort()\\n print(uniq, N * (N + 1) // 2)\\n if len(uniq) % 2 == 0: return uniq[len(uniq)//2 - 1]\\n return uniq[len(uniq)//2]\\n\\n# binary search? (iterating by the median)\\n# can we make that median or not?\\n# how can we answer to that question?\\n\\n# 1-sized give us N items\\n# 2-sized give us N - 1 items\\n# ...\\n# N-sized give us 1 item\\n\\n# but we need not all items, but unique ones\\n# (we cannot precalculate though)\\n\\n# to answer if x is a median, we should find out how many\\n# 1s, 2s, ..., xs are in the uniqueness array\\n# how many 1s we know - it is N\\n# when we count 2s then should be different\\n# but two items also can go to the 1s if they are the same\\n\\n# can we find unique items using a sliding window?\\n\\ndef sol2(nums):\\n N = len(nums)\\n\\n def le(size):\\n window = defaultdict(int)\\n left = 0\\n ans = 0\\n for right in range(N):\\n window[nums[right]] += 1\\n while len(window) > size:\\n window[nums[left]] -= 1\\n if window[nums[left]] == 0:\\n del window[nums[left]]\\n left += 1\\n ans += right - left + 1\\n return ans\\n\\n total = N * (N + 1) // 2\\n median = total // 2 if total % 2 != 0 else total // 2 - 1\\n ans = 1\\n lo = 1\\n hi = N\\n while lo <= hi:\\n mi = lo + (hi - lo) // 2\\n if le(mi) >= median + 1:\\n # if le(mi)*2 >= total:\\n ans = mi\\n hi = mi - 1\\n else:\\n lo = mi + 1\\n return ans\\n\",\n \"runtime\": \"2957\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n unique[nums[i]] = i # save the last idx of the number\\n while len(unique) > limit:\\n if unique[nums[left]] == left:\\n unique.pop(nums[left])\\n left += 1\\n result += (i - left) + 1\\n if result > K:\\n break\\n \\n return result\\n\",\n \"runtime\": \"2957\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n lower, upper = 1, total_pairs\\n while lower < upper:\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n upper = mid\\n else:\\n lower = mid + 1\\n\\n return lower\\n\\n\\ndef num_of_uniqueness(nums, limit):\\n unique = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n unique[nums[i]] = i # save the last idx of the number\\n while len(unique) > limit:\\n if unique[nums[left]] == left:\\n unique.pop(nums[left])\\n left += 1\\n result += (i - left) + 1\\n if result > K: # there is not point in keep going\\n break\\n \\n return result\\n\",\n \"runtime\": \"3031\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n self.n = len(nums)\\n total_subarrays = self.n * (self.n + 1) // 2\\n self.nums = nums\\n L, R = 1, self.n\\n while L < R:\\n mid = (L + R) // 2\\n count = self.get_num_subarrays_with_k_distinct(mid)\\n if count * 2 >= total_subarrays:\\n R = mid\\n else:\\n L = mid + 1\\n \\n return L\\n \\n def get_num_subarrays_with_k_distinct(self, k):\\n freq_dict = defaultdict(int)\\n answer = 0\\n L = 0\\n for R in range(self.n):\\n freq_dict[self.nums[R]] += 1\\n while len(freq_dict) > k:\\n freq_dict[self.nums[L]] -= 1\\n if freq_dict[self.nums[L]] == 0: del freq_dict[self.nums[L]]\\n L += 1\\n \\n answer += R - L + 1\\n \\n return answer \",\n \"runtime\": \"3031\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n lo, hi = 0, len(nums)\\n while lo < hi:\\n mid = (lo + hi) // 2\\n cnt = 0\\n prev = 0\\n record = defaultdict(int)\\n for i, num in enumerate(nums):\\n record[num] += 1\\n while len(record) > mid:\\n record[nums[prev]] -= 1\\n if record[nums[prev]] == 0:\\n del record[nums[prev]]\\n prev += 1\\n cnt += i - prev + 1\\n if cnt < (len(nums) * (len(nums) + 1) / 2 + 1) // 2:\\n lo = mid + 1\\n else:\\n hi = mid \\n return lo\",\n \"runtime\": \"3105\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_less_or_equal(val):\\n count = 0\\n freq = defaultdict(int)\\n l = 0 \\n for r in range(n):\\n rval = nums[r]\\n freq[rval] += 1\\n \\n while len(freq) > val:\\n lval = nums[l]\\n freq[lval] -= 1 \\n if freq[lval] == 0: \\n freq.pop(lval)\\n l += 1\\n\\n count += r-l+1\\n return count\\n\\n n = len(nums)\\n left = 1\\n right = n\\n N = n*(n+1)/2\\n\\n while left < right:\\n mid = (left + right) // 2\\n count = count_less_or_equal(mid)\\n if count >= (N+1)//2:\\n right = mid \\n else:\\n left = mid + 1\\n return left \\n\\n \",\n \"runtime\": \"3105\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n # Init vars and check edge case\\n n = len(nums)\\n if n == 1: return 1\\n l, r = 1, n\\n goal = (1+(n*(n+1))//2)//2\\n res = 1\\n # Bisect\\n while l <= r:\\n mid = (l+r) // 2\\n # Count number of subarrays with at most mid unique elements\\n v = self.bisect(nums, mid)\\n # Found goal\\n if v == goal: return mid\\n # Goal must be at least mid+1, remove lower half\\n if v < goal:\\n res = max(res, mid+1)\\n l = mid+1\\n # Remove upper half\\n else:\\n r = mid-1\\n return res\\n def naive(self, nums, k):\\n res = 0\\n n = len(nums)\\n for i in range(n):\\n for j in range(i, n):\\n S = set(nums[i:j+1])\\n if len(S) <= k: res += 1\\n return res\\n def bisect(self, nums, k):\\n # Init vars\\n C = defaultdict(int)\\n res = 0\\n start = 0\\n for i, x in enumerate(nums):\\n # Add current element\\n C[x] += 1\\n # Reduce histogram to at most k items\\n while len(C) > k:\\n prev_x = nums[start]\\n C[prev_x] -= 1\\n if not C[prev_x]: C.pop(prev_x)\\n start += 1\\n # Count number of subarrays ending in index i\\n res += i-start+1\\n return res\\n\\n \",\n \"runtime\": \"3179\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n # Init vars and check edge case\\n n = len(nums)\\n if n == 1: return 1\\n l, r = 1, n\\n m = (n*(n+1))//2\\n goal = (m+1)//2\\n res = 1\\n # Bisect\\n while l <= r:\\n mid = (l+r) // 2\\n # Count number of subarrays with at most mid unique elements\\n v = self.bisect(nums, mid)\\n # Found goal\\n if v == goal: return mid\\n # Goal must be at least mid+1, remove lower half\\n if v < goal:\\n res = max(res, mid+1)\\n l = mid+1\\n # Remove upper half\\n else:\\n r = mid-1\\n return res\\n\\n def bisect(self, nums, k):\\n # Init vars\\n C = defaultdict(int)\\n res = 0\\n start = 0\\n for i, x in enumerate(nums):\\n # Add current element\\n C[x] += 1\\n # Reduce histogram to at most k items\\n while len(C) > k:\\n prev_x = nums[start]\\n C[prev_x] -= 1\\n if not C[prev_x]: C.pop(prev_x)\\n start += 1\\n # Count number of subarrays ending in index i\\n res += i-start+1\\n return res \",\n \"runtime\": \"3179\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n total = n*(n+1) >> 1\\n totalG = total//2 + 1\\n low, high = 1, len(set(nums)) \\n ans = -1\\n \\n while low <= high:\\n mid = (low+high) >> 1\\n \\n hm = defaultdict(int) \\n org = defaultdict(int) \\n count = left = 0\\n for right in range(n):\\n ele = nums[right]\\n hm[ele] += 1\\n org[ele] += 1\\n while len(hm) >= mid:\\n ele = nums[left]\\n hm[ele] -= 1\\n left += 1\\n if hm[ele] == 0:\\n hm.pop(ele) \\n if len(org) >= mid:\\n count += left \\n \\n if count >= totalG:\\n low = mid + 1\\n ans = mid\\n else:\\n high = mid - 1\\n \\n return ans\",\n \"runtime\": \"3253\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n total = n*(n+1) >> 1\\n totalG = total//2 + 1\\n low, high = 1, len(set(nums)) \\n ans = -1\\n \\n while low <= high:\\n mid = (low+high) >> 1\\n \\n hm = defaultdict(int) \\n org = defaultdict(int) \\n count = left = 0\\n for right in range(n):\\n ele = nums[right]\\n hm[ele] += 1\\n org[ele] += 1\\n while len(hm) >= mid:\\n ele = nums[left]\\n hm[ele] -= 1\\n left += 1\\n if hm[ele] == 0:\\n hm.pop(ele) \\n if len(org) >= mid:\\n count += left \\n \\n if count >= totalG:\\n low = mid + 1\\n ans = mid\\n else:\\n high = mid - 1\\n \\n return ans\",\n \"runtime\": \"3327\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n unique[nums[i]] = i # save the last idx of the number\\n while len(unique) > limit:\\n if unique[nums[left]] == left:\\n unique.pop(nums[left])\\n left += 1\\n result += (i - left) + 1\\n \\n return result\\n\",\n \"runtime\": \"3401\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def check(mx: int) -> bool:\\n cnt = defaultdict(int)\\n k = l = 0\\n for r, x in enumerate(nums):\\n cnt[x] += 1\\n while len(cnt) > mx:\\n y = nums[l]\\n cnt[y] -= 1\\n if cnt[y] == 0:\\n cnt.pop(y)\\n l += 1\\n k += r - l + 1\\n if k >= (m + 1) // 2:\\n return True\\n return False\\n\\n n = len(nums)\\n m = (1 + n) * n // 2\\n return bisect_left(range(n), True, key=check)\",\n \"runtime\": \"3475\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n #binary search solution\\n #pick smallest number N such that at least half (if even # subarrays)...\\n #or more than half (if odd # subarrays) subarrays have at most... \\n #that number N distinct elements\\n\\n #O(N logN)\\n\\n\\n def atMostKDistinct(nums, k):\\n\\n d = defaultdict(int)\\n left = 0\\n count = 0\\n for right in range(len(nums)):\\n d[nums[right]]+=1\\n while len(d.keys()) > k:\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0:\\n del d[nums[left]]\\n left+=1\\n count += right - left + 1\\n\\n return count\\n\\n\\n allArr = len(nums)* (len(nums)+1)//2\\n \\n left = 1\\n right = len(nums)\\n while left<=right:\\n mid = (left+right)//2\\n total = atMostKDistinct(nums, mid)\\n \\n \\n print(total)\\n if allArr % 2 == 0 and total == allArr//2 or (allArr % 2 == 1 and total == allArr//2+1):\\n return mid\\n if total > allArr//2:\\n right = mid-1\\n else:\\n left = mid+1\\n \\n return left\",\n \"runtime\": \"3475\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def check(mx: int) -> bool:\\n cnter = defaultdict(int)\\n k = l = 0\\n for r, x in enumerate(nums):\\n cnter[x] += 1\\n while len(cnter) > mx:\\n y = nums[l]\\n cnter[y] -= 1\\n if cnter[y] == 0:\\n cnter.pop(y)\\n l += 1\\n k += r-l+1\\n if k >= (m+1) // 2:\\n return True\\n return False\\n\\n n = len(nums)\\n m = (1+n)*n//2\\n return bisect_left(range(n), True, key=check)\",\n \"runtime\": \"3549\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def check(tgt) :\\n res = 0\\n cnts = defaultdict(int)\\n r = 0\\n for i, num in enumerate(nums) :\\n while r < len(nums) and not (nums[r] not in cnts and len(cnts) >= tgt) :\\n cnts[nums[r]] += 1\\n r += 1\\n cnts[nums[i]] -= 1\\n if cnts[nums[i]] == 0 :\\n cnts.pop(nums[i])\\n res += r-i\\n return res\\n\\n l = 1\\n r = len(set(nums))+1\\n tgt = ((((1+len(nums)) * len(nums)) // 2)+1) // 2\\n\\n while l <= r :\\n mid = (l+r) // 2\\n t = check(mid)\\n if t < tgt :\\n l = mid+1\\n else :\\n r = mid-1\\n \\n return l\",\n \"runtime\": \"3549\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n need = (n * (n+1)//2 + 1) // 2\\n def count(x):\\n r = 0\\n dic = {}\\n cnt = 0\\n for l in range(n):\\n while r < n:\\n if nums[r] not in dic and len(dic) == x:\\n break\\n dic[nums[r]] = dic.get(nums[r],0) + 1\\n r += 1\\n cnt += r-l\\n dic[nums[l]] -= 1\\n if dic[nums[l]] == 0:\\n del dic[nums[l]]\\n return cnt < need\\n l, r = 1, n\\n while l <= r:\\n mid = (l+r)//2\\n if count(mid):\\n l = mid + 1\\n else:\\n r = mid - 1\\n return l\\n\",\n \"runtime\": \"3771\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n need = (((n*(n+1))//2 )+ 1) //2\\n \\n def count(x): \\n R = 0\\n st = defaultdict(int)\\n cnt = 0\\n \\n for L in range(n):\\n while R<n: \\n if nums[R] not in st and len(st) == x: \\n break \\n st[nums[R]]+=1 \\n R+=1\\n \\n cnt += R-L \\n \\n st[nums[L]]-=1 \\n if st[nums[L]] == 0:\\n del st[nums[L]]\\n \\n \\n return cnt<need\\n\\n l,r = 0,n+3 \\n while l+1<r: \\n m = (l+r)>>1 \\n \\n if count(m): \\n l = m \\n else: \\n r = m\\n \\n return r\",\n \"runtime\": \"3845\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n need = (((n*(n+1))//2 )+ 1) //2\\n \\n def count(x): \\n R = 0\\n st = defaultdict(int)\\n cnt = 0\\n \\n for L in range(n):\\n while R<n: \\n if nums[R] not in st and len(st) == x: \\n break \\n st[nums[R]]+=1 \\n R+=1\\n \\n cnt += R-L \\n \\n st[nums[L]]-=1 \\n if st[nums[L]] == 0:\\n del st[nums[L]]\\n \\n return cnt<need\\n\\n l,r = 0,n+3 \\n while l+1<r: \\n m = (l+r)>>1 \\n \\n if count(m): \\n l = m \\n else: \\n r = m\\n \\n return r\",\n \"runtime\": \"3919\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n array_length = len(nums)\\n target_count = ((array_length * (array_length + 1)) // 2 + 1) // 2\\n\\n def is_count_less_than_target(unique_elements):\\n right = 0\\n element_count = defaultdict(int)\\n total_subarrays = 0\\n\\n for left in range(array_length):\\n while right < array_length:\\n if nums[right] not in element_count and len(element_count) == unique_elements:\\n break\\n element_count[nums[right]] += 1\\n right += 1\\n\\n total_subarrays += right - left\\n\\n element_count[nums[left]] -= 1\\n if element_count[nums[left]] == 0:\\n del element_count[nums[left]]\\n\\n return total_subarrays < target_count\\n\\n min_unique, max_unique = 0, array_length + 3\\n while min_unique + 1 < max_unique:\\n mid_unique = (min_unique + max_unique) // 2\\n\\n if is_count_less_than_target(mid_unique):\\n min_unique = mid_unique\\n else:\\n max_unique = mid_unique\\n\\n return max_unique\",\n \"runtime\": \"3993\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = n * (n + 1) // 2\\n\\n def at_most(k):\\n left = 0\\n counter = collections.Counter()\\n res = 0\\n for right, num in enumerate(nums):\\n counter[num] += 1\\n while len(counter) > k:\\n counter[nums[left]] -= 1\\n if counter[nums[left]] == 0:\\n del counter[nums[left]]\\n left += 1\\n \\n # [left, right] has at most k\\n res += right - left + 1\\n return res\\n \\n def check(k):\\n at_most_k = at_most(k)\\n return at_most_k >= total - at_most_k\\n \\n left = 1\\n right = len(set(nums)) + 1\\n while left < right:\\n mid = (left + right) // 2\\n if check(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4067\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n median = (n * (n + 1)) // 2\\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result * 2 >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4067\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]):\\n n = len(nums)\\n subarrayCount = n * (n + 1) // 2\\n medianCount = (subarrayCount + 1) // 2\\n\\n # Similar to 992. Subarrays with K Different Integers\\n def subarraysWithAtMostKDistinct(k: int) -> int:\\n res = 0\\n count = collections.Counter()\\n\\n l = 0\\n for r, num in enumerate(nums):\\n count[num] += 1\\n if count[num] == 1:\\n k -= 1\\n while k < 0:\\n count[nums[l]] -= 1\\n if count[nums[l]] == 0:\\n k += 1\\n l += 1\\n res += r - l + 1 # nums[l..r], nums[l + 1..r], ..., nums[r]\\n\\n return res\\n\\n return bisect.bisect_left(\\n range(1, n), medianCount,\\n key=lambda m: subarraysWithAtMostKDistinct(m)) + 1\",\n \"runtime\": \"4141\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n median = (total + 1) // 2\\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4141\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n median = (total + 1) // 2\\n \\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4215\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result * 2 >= total\\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4215\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n median = (n * (n + 1)) // 2\\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result * 2 >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"runtime\": \"4289\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def _at_most(nums: List[int], max_num: int) -> int:\\n count = collections.Counter()\\n left = 0\\n ans = 0\\n for right in range(len(nums)):\\n count[nums[right]] += 1\\n while len(count) > max_num:\\n count[nums[left]] -= 1\\n if count[nums[left]] == 0:\\n del count[nums[left]]\\n left += 1\\n ans += right - left + 1\\n return ans\\n\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n num_count = len(nums)\\n total_sub_arrays = num_count * (num_count + 1) // 2\\n unique_nums = set(nums)\\n left, right = 1, len(unique_nums)\\n while left < right:\\n guess = (left + right) // 2\\n if self._at_most(nums, guess) * 2 < total_sub_arrays:\\n left = guess + 1\\n else:\\n right = guess\\n return left\",\n \"runtime\": \"4289\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def atMost(k):\\n l = res = 0\\n counter = Counter()\\n\\n for r, num in enumerate(nums):\\n counter[num] += 1\\n\\n while len(counter) > k:\\n counter[ nums[l] ] -= 1\\n if counter[nums[l]] == 0:\\n del counter[nums[l]]\\n l += 1\\n res += r - l + 1\\n return res\\n\\n n = len(nums)\\n target = n * (n + 1) // 2\\n\\n l = 1\\n r = len(set(nums)) \\n\\n while l < r:\\n mid = (l + r) // 2\\n if atMost(mid) * 2 >= target:\\n r = mid\\n else:\\n l = mid + 1\\n return l \",\n \"runtime\": \"4363\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n+1)*n//2\\n half = total // 2 if (total%2 == 0) else total//2 + 1\\n\\n def count(m):\\n ct = defaultdict(int)\\n i, j = 0, -1\\n total = 0\\n while i < n:\\n while j+1 < n:\\n j +=1\\n if nums[j] in ct or len(ct) < m:\\n ct[nums[j]] += 1\\n else:\\n j -= 1\\n break\\n total += j - i + 1\\n\\n ct[nums[i]] -= 1\\n if ct[nums[i]] == 0:\\n del ct[nums[i]]\\n i +=1\\n return total\\n \\n l, r = 1, n\\n\\n while l < r:\\n m = (l+r)//2\\n k1 = count(m)\\n if k1 < half:\\n l = m+1\\n else:\\n r = m\\n return l\\n\\n\",\n \"runtime\": \"4363\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def amountWithLEQ(target):\\n counts = Counter()\\n \\n res = l = 0\\n for r in range(len(nums)):\\n counts[nums[r]] += 1\\n\\n while len(counts) > target:\\n counts[nums[l]] -= 1\\n if not counts[nums[l]]:\\n del counts[nums[l]]\\n l += 1\\n \\n res += r - l + 1\\n \\n return res\\n \\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n target = (total + 1) // 2\\n # uniqueness range\\n l, r = 0, len(nums)\\n best = 0\\n\\n while l <= r:\\n m = (l + r) // 2\\n \\n val = amountWithLEQ(m)\\n\\n if val == target:\\n return m\\n elif val < target:\\n l = m + 1\\n best = m\\n else:\\n r = m - 1\\n \\n return best + 1\",\n \"runtime\": \"4437\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n lo, hi = 1, len(set(nums))\\n length = len(nums)\\n subarray_count = length * (length + 1) // 2\\n median = 0\\n\\n while lo <= hi:\\n mid = (lo + hi) // 2\\n count = i = j = 0\\n freqs = Counter()\\n while j < length:\\n while j < length and (len(freqs) < mid or nums[j] in freqs):\\n count += j - i + 1\\n freqs[nums[j]] += 1\\n j += 1\\n while len(freqs) == mid:\\n freqs[nums[i]] -= 1\\n if freqs[nums[i]] == 0:\\n del freqs[nums[i]]\\n i += 1\\n if count < math.ceil(subarray_count / 2):\\n lo = mid + 1\\n else:\\n median = mid\\n hi = mid - 1\\n \\n return median\\n\",\n \"runtime\": \"4511\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n target = (((1 + n) * n // 2) - 1) // 2\\n\\n l, r = 1, n + 1\\n while l < r:\\n mid = l + r >> 1\\n total = j = 0\\n cnt = Counter()\\n for i, x in enumerate(nums):\\n cnt[x] += 1\\n \\n while len(cnt) > mid:\\n cnt[nums[j]] -= 1\\n if cnt[nums[j]] == 0:\\n del cnt[nums[j]]\\n j += 1\\n \\n total += i - j + 1\\n\\n if total > target:\\n break\\n \\n if total <= target:\\n l = mid + 1\\n else:\\n r = mid \\n\\n return l\",\n \"runtime\": \"4585\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n tot = n * (n + 1) // 2\\n\\n def check(k: int) -> int:\\n hash = Counter()\\n i = j = 0\\n res = 0\\n while i < n:\\n hash[nums[i]] += 1\\n while len(hash) > k:\\n hash[nums[j]] -= 1\\n if hash[nums[j]] == 0:\\n del hash[nums[j]]\\n j += 1\\n res += i - j + 1\\n i += 1\\n return res\\n\\n l, r = 1, n\\n while l < r:\\n mid = l + r >> 1\\n if check(mid) * 2 >= tot:\\n r = mid\\n else:\\n l = mid + 1\\n return r\",\n \"runtime\": \"4659\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique_nums = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n update_map(unique_nums, nums[i], 1)\\n while len(unique_nums) > limit:\\n update_map(unique_nums, nums[left], -1)\\n left += 1\\n result += (i - left) + 1\\n \\n return result\\n\\ndef update_map(unique, x, incr):\\n if x not in unique:\\n unique[x] = 0\\n unique[x] += incr\\n if unique[x] == 0:\\n unique.pop(x)\",\n \"runtime\": \"4733\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique_nums = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n update_map(unique_nums, nums[i], 1)\\n while len(unique_nums) > limit:\\n update_map(unique_nums, nums[left], -1)\\n left += 1\\n result += (i - left) + 1\\n \\n return result\\n\\ndef update_map(unique, x, incr):\\n if incr < 0 and x not in unique:\\n return \\n if x not in unique:\\n unique[x] = 0\\n unique[x] += incr\\n if unique[x] == 0:\\n unique.pop(x)\",\n \"runtime\": \"4806\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n\\n # find how many uniqueness are <= than a threshold\\n def findSmallerThan(th: int) -> int:\\n cnt = Counter()\\n res = 0\\n\\n right = 0\\n for left in range(n):\\n # expand it as much as you can\\n while len(cnt) <= th and right < n:\\n cnt[nums[right]] += 1\\n if len(cnt) > th:\\n cnt.pop(nums[right])\\n break\\n right += 1\\n res += right - left\\n\\n cnt[nums[left]] -= 1\\n if cnt[nums[left]] == 0:\\n cnt.pop(nums[left])\\n return res\\n\\n l, r = 1, n\\n while l < r:\\n mid = l + (r - l) // 2\\n\\n if findSmallerThan(mid) >= (total + 1) // 2:\\n r = mid\\n else:\\n l = mid + 1\\n return l\",\n \"runtime\": \"4880\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":70,"string":"70"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n target = (((1 + n) * n // 2) - 1) // 2\n\n l, r = 1, n + 1\n while l < r:\n mid = l + r >> 1\n total = j = 0\n cnt = Counter()\n for i, x in enumerate(nums):\n cnt[x] += 1\n \n while len(cnt) > mid:\n cnt[nums[j]] -= 1\n if cnt[nums[j]] == 0:\n del cnt[nums[j]]\n j += 1\n \n total += i - j + 1\n\n if total > target:\n break\n \n if total <= target:\n l = mid + 1\n else:\n r = mid \n\n return l","memory":"33000"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n + 1) * n // 2\n target = (total + 1) // 2\n left = 1\n right = len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n start = 0\n count = 0\n dic = {}\n for i in range(n):\n dic[nums[i]] = dic.get(nums[i], 0) + 1\n while len(dic) > mid:\n dic[nums[start]] -= 1\n if dic[nums[start]] == 0:\n del dic[nums[start]]\n start += 1\n count += i - start + 1\n if count >= target:\n break\n if count >= target:\n right = mid\n else:\n left = mid + 1\n return right","memory":"33000"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n K = (N * (N + 1) // 2 + 1) // 2\n\n def check(upper: int) -> bool:\n cnt, l = 0, 0\n freq = defaultdict(int)\n for r, x in enumerate(nums):\n freq[x] += 1\n while len(freq) > upper:\n drop = nums[l]\n freq[drop] -= 1\n if freq[drop] == 0:\n del freq[drop]\n l += 1\n cnt += r - l + 1\n if cnt >= K:\n return True\n return False\n\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)","memory":"33100"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n K = (N * (N + 1) // 2 + 1) // 2\n\n def check(upper: int) -> bool:\n cnt, l = 0, 0\n freq = defaultdict(int)\n for r, x in enumerate(nums):\n freq[x] += 1\n while len(freq) > upper:\n drop = nums[l]\n freq[drop] -= 1\n if freq[drop] == 0:\n del freq[drop]\n l += 1\n cnt += r - l + 1\n if cnt >= K:\n return True\n return False\n\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)","memory":"33100"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n K = (N * (N + 1) // 2 + 1) // 2\n\n def check(upper: int) -> bool:\n cnt, l = 0, 0\n freq = defaultdict(int)\n for r, x in enumerate(nums):\n freq[x] += 1\n while len(freq) > upper:\n drop = nums[l]\n freq[drop] -= 1\n if freq[drop] == 0:\n del freq[drop]\n l += 1\n cnt += r - l + 1\n if cnt >= K:\n return True\n return False\n\n return bisect.bisect_left(range(1, len(set(nums))), True, key=check) + 1","memory":"33200"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n lower, upper = 1, total_pairs\n while lower < upper:\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n upper = mid\n else:\n lower = mid + 1\n\n return lower\n\n\ndef num_of_uniqueness(nums, limit):\n unique = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n unique[nums[i]] = i # save the last idx of the number\n while len(unique) > limit:\n if unique[nums[left]] == left:\n unique.pop(nums[left])\n left += 1\n result += (i - left) + 1\n if result > K: # there is not point in keep going\n break\n \n return result\n","memory":"33400"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n # 1 4 4 3 7 5 5\n\n # 5 -> [**X**]\n\n n = len(nums)\n elements = (n+1)*n//2\n el = (elements + 1) // 2\n print(\"el\", el)\n\n\n def check(k):\n total = 0\n counter = defaultdict(int)\n left = -1\n for right in range(n):\n counter[nums[right]] += 1\n\n while len(counter) > k:\n left += 1\n counter[nums[left]] -= 1\n if counter[nums[left]] == 0:\n del counter[nums[left]]\n \n l = right - left\n total += l\n if total >= el:\n return True\n\n return False\n\n low = 1\n high = n\n r = None\n while low <= high:\n m = (low+high)//2\n # print(\"low, high\", low, high)\n # print(\"m\", m)\n\n if check(m):\n # print(\"true\")\n high = m - 1\n r = m\n else:\n low = m + 1\n\n\n\n return r","memory":"33500"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\n\n d = defaultdict(int)\n \n for rght in range(n):\n d[nums[rght]]+= 1\n\n while len(d) > x:\n left+= 1\n d[nums[left]] -= 1\n if d[nums[left]] == 0: del d[nums[left]]\n\n cnt+= rght - left\n if cnt >= median: return True\n\n return False\n \n\n n = len(nums)\n median = (comb(n+1,2) + 1) // 2\n return bisect_left(range(n), \n True, key = not_less_than_median)","memory":"33600"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\n\n d = defaultdict(int)\n \n for rght in range(n):\n d[nums[rght]]+= 1\n\n while len(d) > x:\n left+= 1\n d[nums[left]] -= 1\n if d[nums[left]] == 0: del d[nums[left]]\n\n cnt+= rght - left\n if cnt >= median: return True\n\n return False\n \n\n n = len(nums)\n median = (comb(n+1,2) + 1) // 2\n return bisect_left(range(n), \n True, key = not_less_than_median)","memory":"33700"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique_nums = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n update_map(unique_nums, nums[i], 1)\n while len(unique_nums) > limit:\n update_map(unique_nums, nums[left], -1)\n left += 1\n result += (i - left) + 1\n \n return result\n\ndef update_map(unique, x, incr):\n if x not in unique:\n unique[x] = 0\n unique[x] += incr\n if unique[x] == 0:\n unique.pop(x)","memory":"33800"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n # Init vars and check edge case\n n = len(nums)\n if n == 1: return 1\n l, r = 1, n\n m = (n*(n+1))//2\n goal = (m+1)//2\n res = 1\n # Bisect\n while l <= r:\n mid = (l+r) // 2\n # Count number of subarrays with at most mid unique elements\n v = self.bisect(nums, mid)\n # Found goal\n if v == goal: return mid\n # Goal must be at least mid+1, remove lower half\n if v < goal:\n res = max(res, mid+1)\n l = mid+1\n # Remove upper half\n else:\n r = mid-1\n return res\n\n def bisect(self, nums, k):\n # Init vars\n C = defaultdict(int)\n res = 0\n start = 0\n for i, x in enumerate(nums):\n # Add current element\n C[x] += 1\n # Reduce histogram to at most k items\n while len(C) > k:\n prev_x = nums[start]\n C[prev_x] -= 1\n if not C[prev_x]: C.pop(prev_x)\n start += 1\n # Count number of subarrays ending in index i\n res += i-start+1\n return res ","memory":"34400"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int: \n n = len(nums)\n lo, hi = 0, n\n while lo < hi: \n mid = lo + hi >> 1\n val = ii = 0 \n freq = defaultdict(int)\n for i, x in enumerate(nums): \n freq[x] += 1\n while len(freq) > mid: \n freq[nums[ii]] -= 1\n if freq[nums[ii]] == 0: freq.pop(nums[ii])\n ii += 1\n val += i-ii+1\n if val < (n*(n+1)//2+1)//2: lo = mid + 1\n else: hi = mid \n return lo","memory":"34500"},{"code":"from collections import defaultdict\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_less_or_equal(val):\n count = 0\n freq = defaultdict(int)\n l = 0 \n for r in range(n):\n rval = nums[r]\n freq[rval] += 1\n \n while len(freq) > val:\n lval = nums[l]\n freq[lval] -= 1 \n if freq[lval] == 0: \n freq.pop(lval)\n l += 1\n\n count += r-l+1\n return count\n\n n = len(nums)\n left = 1\n right = n\n N = n*(n+1)/2\n\n while left < right:\n mid = (left + right) // 2\n count = count_less_or_equal(mid)\n if count >= (N+1)//2:\n right = mid \n else:\n left = mid + 1\n return left \n\n\n","memory":"34600"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_less_or_equal(val):\n count = 0\n freq = defaultdict(int)\n l = 0 \n for r in range(n):\n rval = nums[r]\n freq[rval] += 1\n \n while len(freq) > val:\n lval = nums[l]\n freq[lval] -= 1 \n if freq[lval] == 0: \n freq.pop(lval)\n l += 1\n\n count += r-l+1\n return count\n\n n = len(nums)\n left = 1\n right = n\n N = n*(n+1)/2\n\n while left < right:\n mid = (left + right) // 2\n count = count_less_or_equal(mid)\n if count >= (N+1)//2:\n right = mid \n else:\n left = mid + 1\n return left \n\n ","memory":"34600"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def atMostK(k: int):\n result = 0\n left, right = 0, 0\n counts = dict()\n for right in range(len(nums)):\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n while len(counts) > k:\n removed = nums[left]\n left += 1\n counts[removed] -= 1\n if counts[removed] == 0:\n del counts[removed]\n result += right - left + 1 \n return result \n left, right = 1, len(nums)\n total = len(nums) * (len(nums) - 1)//2 + len(nums)\n mid = 0\n while left <= right:\n mid = left + (right - left)//2\n subarrays = atMostK(mid)\n if subarrays == (total + 1)//2:\n return mid\n elif subarrays > (total + 1)//2:\n right = mid - 1\n else:\n left = mid + 1\n return right + 1\n\n","memory":"34700"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n total = (n+1)*n // 2\n half = total // 2 if (total % 2 == 0) else total // 2 + 1\n \n def count_le(m):\n ct = defaultdict(int)\n i, j = 0, -1\n total = 0\n while i < n:\n while j+1 < n:\n j += 1\n if nums[j] in ct or len(ct) < m:\n ct[nums[j]] += 1\n else:\n j -= 1\n break\n total += j-i+1\n \n ct[nums[i]] -= 1\n if ct[nums[i]] == 0:\n del ct[nums[i]]\n i += 1\n return total\n \n l, r = 1, n\n \n while l < r:\n m = (l+r) // 2\n k1 = count_le(m)\n k2 = count_le(m-1)\n if k1 < half:\n l = m+1\n elif k2 >= half:\n r = m\n else:\n return m\n return l","memory":"34800"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: list[int]):\n n = len(nums)\n subarrayCount = n * (n + 1) // 2\n medianCount = (subarrayCount + 1) // 2\n\n \n def subarraysWithAtMostKDistinct(k: int) -> int:\n res = 0\n count = collections.Counter()\n\n l = 0\n for r, num in enumerate(nums):\n count[num] += 1\n if count[num] == 1:\n k -= 1\n while k < 0:\n count[nums[l]] -= 1\n if count[nums[l]] == 0:\n k += 1\n l += 1\n res += r - l + 1 \n\n return res\n\n return bisect.bisect_left(\n range(1, n), medianCount,\n key=lambda m: subarraysWithAtMostKDistinct(m)) + 1","memory":"34900"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n def atMost(k):\n l = res = 0\n counter = Counter()\n\n for r, num in enumerate(nums):\n counter[num] += 1\n\n while len(counter) > k:\n counter[ nums[l] ] -= 1\n if counter[nums[l]] == 0:\n del counter[nums[l]]\n l += 1\n res += r - l + 1\n return res\n\n n = len(nums)\n target = n * (n + 1) // 2\n\n l = 1\n r = 10**10\n\n while l < r:\n mid = (l + r) // 2\n if atMost(mid) * 2 >= target:\n r = mid\n else:\n l = mid + 1\n return l ","memory":"35000"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def helper(target):\n counts = {}\n start = 0\n total_count = 0\n for ind, num in enumerate(nums):\n if num not in counts:\n counts[num] = 0\n counts[num] += 1\n\n while len(counts) > target:\n counts[nums[start]] -= 1\n if counts[nums[start]] == 0:\n del counts[nums[start]]\n start += 1\n #if len(counts) == target:\n total_count += ind - start + 1\n #print(f\"start = {start} ind = {ind} total_count = {total_count} target = {target}\")\n return total_count\n l = 0\n r = len(nums) + 1\n subarray_count = len(nums) * (len(nums) + 1) // 2\n median_index = (subarray_count // 2 - 1) if subarray_count % 2 == 0 else (subarray_count // 2)\n while l < r:\n\n mid = (l + r) // 2\n #print(f\"mid = {mid} median_index = {median_index} helper = {helper(mid)}\")\n if helper(mid) > median_index:\n r = mid\n else:\n l = mid + 1\n \n return l\n","memory":"35100"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n self.n = len(nums)\n total_subarrays = self.n * (self.n + 1) // 2\n self.nums = nums\n L, R = 1, self.n\n while L < R:\n mid = (L + R) // 2\n count = self.get_num_subarrays_with_k_distinct(mid)\n if count * 2 >= total_subarrays:\n R = mid\n else:\n L = mid + 1\n \n return L\n \n def get_num_subarrays_with_k_distinct(self, k):\n freq_dict = defaultdict(int)\n answer = 0\n L = 0\n for R in range(self.n):\n freq_dict[self.nums[R]] += 1\n while len(freq_dict) > k:\n freq_dict[self.nums[L]] -= 1\n if freq_dict[self.nums[L]] == 0: del freq_dict[self.nums[L]]\n L += 1\n \n answer += R - L + 1\n \n return answer ","memory":"35200"},{"code":"def count(nums, d):\n cnt = {}\n lo = 0\n res = 0\n for i in range(len(nums)):\n cnt[nums[i]] = cnt.get(nums[i], 0) + 1\n while len(cnt) > d:\n cnt[nums[lo]] = cnt[nums[lo]] - 1\n if cnt[nums[lo]] == 0:\n del cnt[nums[lo]]\n lo += 1\n res += i - lo + 1\n return res\n\nclass Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n C = (len(nums) * (len(nums) + 1)) // 2\n lo = 0\n hi = len(nums) + 1\n while hi - lo > 1:\n mi = (lo + hi) // 2\n if count(nums, mi) < C // 2 + C % 2:\n lo = mi\n else:\n hi = mi\n return hi\n","memory":"35400"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n need = (n * (n+1)//2 + 1) // 2\n def count(x):\n r = 0\n dic = {}\n cnt = 0\n for l in range(n):\n while r < n:\n if nums[r] not in dic and len(dic) == x:\n break\n dic[nums[r]] = dic.get(nums[r],0) + 1\n r += 1\n cnt += r-l\n dic[nums[l]] -= 1\n if dic[nums[l]] == 0:\n del dic[nums[l]]\n return cnt < need\n l, r = 1, n\n while l <= r:\n mid = (l+r)//2\n if count(mid):\n l = mid + 1\n else:\n r = mid - 1\n return l\n","memory":"35500"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n need = (n * (n+1)//2 + 1) // 2\n def count(x):\n r = 0\n dic = {}\n cnt = 0\n for l in range(n):\n while r < n:\n if nums[r] not in dic and len(dic) == x:\n break\n dic[nums[r]] = dic.get(nums[r],0) + 1\n r += 1\n cnt += r-l\n dic[nums[l]] -= 1\n if dic[nums[l]] == 0:\n del dic[nums[l]]\n return cnt < need\n l, r = 1, n\n while l <= r:\n mid = (l+r)//2\n if count(mid):\n l = mid + 1\n else:\n r = mid - 1\n return l\n","memory":"35500"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n\n # find how many uniqueness are <= than a threshold\n def findSmallerThan(th: int) -> int:\n cnt = Counter()\n res = 0\n\n right = 0\n for left in range(n):\n # expand it as much as you can\n while len(cnt) <= th and right < n:\n cnt[nums[right]] += 1\n if len(cnt) > th:\n cnt.pop(nums[right])\n break\n right += 1\n res += right - left\n\n cnt[nums[left]] -= 1\n if cnt[nums[left]] == 0:\n cnt.pop(nums[left])\n return res\n\n l, r = 1, n\n while l < r:\n mid = l + (r - l) // 2\n\n if findSmallerThan(mid) >= (total + 1) // 2:\n r = mid\n else:\n l = mid + 1\n return l","memory":"35600"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n global K\n n = len(nums)\n total_pairs = (n*(n-1))//2 + n\n K = (total_pairs + 1)//2\n return visit(nums, 1, total_pairs)\n\ndef visit(nums, lower, upper):\n if lower == upper:\n return lower\n\n mid = (lower + upper)//2\n x = num_of_uniqueness(nums, mid)\n if x >= K:\n return visit(nums, lower, mid)\n \n return visit(nums, mid+1, upper)\n\ndef num_of_uniqueness(nums, limit):\n unique = {}\n left = 0\n result = 0\n for i in range(len(nums)):\n unique[nums[i]] = i # save the last idx of the number\n while len(unique) > limit:\n if unique[nums[left]] == left:\n unique.pop(nums[left])\n left += 1\n result += (i - left) + 1\n \n return result\n","memory":"35700"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n # using atMost function, we can determine if a certain number will be median by seeing if the number of arrays\n # at least k is equal to half the total number of possible subarrays (len(nums) * (len(nums) - 1) // 2)\n if len(nums) <= 1:\n return 1\n\n def atMost(K):\n counts = defaultdict(int)\n res = i = 0\n\n for j in range(len(nums)):\n counts[nums[j]] += 1\n\n while len(counts) > K:\n counts[nums[i]] -= 1\n if counts[nums[i]] == 0:\n del counts[nums[i]]\n i += 1\n \n res += j - i + 1\n \n return res\n \n low, high = 0, len(nums)\n med = (len(nums) * (len(nums) + 1) // 2)\n\n while low <= high:\n mid = (low + high) // 2\n\n if atMost(mid) * 2 >= med:\n high = mid - 1\n else:\n low = mid + 1\n \n return low","memory":"35800"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \n n = len(nums)\n need = (((n*(n+1))//2 )+ 1) //2\n \n def count(x): \n R = 0\n st = defaultdict(int)\n cnt = 0\n \n for L in range(n):\n while R<n: \n if nums[R] not in st and len(st) == x: \n break \n st[nums[R]]+=1 \n R+=1\n \n cnt += R-L \n \n st[nums[L]]-=1 \n if st[nums[L]] == 0:\n del st[nums[L]]\n \n \n return cnt<need\n\n l,r = 0,n+3 \n while l+1<r: \n m = (l+r)>>1 \n \n if count(m): \n l = m \n else: \n r = m\n \n return r","memory":"35900"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n median = (n * (n + 1)) // 2\n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result * 2 >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","memory":"36900"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n m = n * (n + 1) // 2 + 1 >> 1\n d, pre, nxt = {}, [-1] * n, [n] * n\n for i, x in enumerate(nums):\n if x in d:\n j = d[x]\n pre[i] = j\n nxt[j] = i\n d[x] = i\n \n def f(t):\n i, c = 0, 0\n while c <= t:\n if pre[i] < 0:\n c += 1\n i += 1\n s, l = comb(i, 2), 0\n for r in range(i - 1, n):\n if pre[r] < l:\n while nxt[l] <= r:\n l += 1\n l += 1\n s += r - l\n return s + n - i + 1\n \n a, b, x, y = 1, len(d), 0, m * 2\n while a < b:\n c = max(a, int(b - (b - a + 1) * (y - m) / (y - x)))\n t = f(c)\n if t == m:\n return c\n if t > m:\n b, y = c, t\n else:\n a, x = c + 1, t\n return a","memory":"37000"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = (n * (n + 1)) // 2\n median = (total + 1) // 2\n \n def count(target):\n count = collections.Counter()\n result = 0\n i = 0\n for j in range(n):\n count[nums[j]] += 1\n while len(count) > target:\n count[nums[i]] -= 1\n if count[nums[i]] == 0:\n del count[nums[i]]\n i += 1\n result += (j - i + 1)\n return result >= median\n \n left, right = 1, len(set(nums))\n while left < right:\n mid = left + (right - left) // 2\n if count(mid):\n right = mid\n else:\n left = mid + 1\n return left","memory":"37100"},{"code":"class Solution:\n def count(self, nums, size):\n l, r, = 0, 0\n cnt = collections.Counter()\n nbr = collections.defaultdict(int)\n while l < len(nums) and r < len(nums):\n while r < len(nums) and len(cnt) <= size:\n cnt[nums[r]] += 1\n if len(cnt) == size:\n nbr[l] = max(nbr[l], r)\n \n r += 1\n while l < len(nums) and len(cnt) > size:\n cnt[nums[l]] -= 1\n if cnt[nums[l]] == 0:\n del cnt[nums[l]]\n l += 1\n nbr[l] = max(nbr[l], r-1)\n res = 0\n starts = list(sorted(nbr.keys()))\n for i in range(len(starts)):\n s = starts[i]\n e = nbr[s] - s + 1\n res += e * (e+1) // 2\n if i > 0:\n pe = nbr[starts[i-1]]\n if pe >= s:\n dup = pe - s + 1\n res -= dup * (dup + 1) // 2\n # print (nbr, size, res)\n return res\n\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n l, r = 1, len(nums)\n base = len(nums) * (len(nums) + 1) // 4\n # print (base)\n # if len(nums) == 10 and len(set(nums)) == 10:\n # return 4\n # print (base)\n combi = len(nums) * (len(nums) + 1) // 2\n while l < r:\n m = (l + r) // 2\n cnt = self.count(nums, m)\n if combi % 2 == 1 and cnt == base + 1:\n return m\n if combi % 2 == 0 and cnt == base:\n return m\n if cnt < base + 1:\n l = m + 1\n else:\n r = m\n return l \n \n'''\n1. Problem\n - given an integer array nums\n - sorted array that contains the number of distinct \n\n [1, 1, 1, 2, 2, 3]\n'''","memory":"37500"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n total = n*(n + 1)//2\n def atMostK(k):\n count = defaultdict(int)\n left = 0\n n = len(nums)\n ans = 0\n for right in range(n):\n count[nums[right]] += 1\n while(len(count) > k):\n count[nums[left]] -=1\n if count[nums[left]] == 0:\n count.pop(nums[left])\n\n left += 1\n\n ans += right - left + 1\n\n return ans\n\n left, right = 1, len(set(nums))\n ans = -1\n while left <= right:\n mid = left + (right - left)//2\n if atMostK(mid) * 2 >= total:\n right = mid - 1\n ans = mid\n else:\n left = mid + 1\n \n return ans","memory":"37600"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def at_most_k(k: int) -> int:\n j = cnt = 0\n char_freq = collections.Counter()\n for i, num in enumerate(nums):\n char_freq[num] += 1\n while j < i and len(char_freq) > k:\n char_freq[nums[j]] -= 1\n if char_freq[nums[j]] == 0: char_freq.pop(nums[j])\n j += 1\n cnt += i - j + 1\n return cnt\n \n total = len(nums) * (len(nums) + 1) // 2\n l, r = 1, len(set(nums))\n while l <= r:\n m = (l + r) // 2\n if at_most_k(m) * 2 >= total: r = m - 1\n else: l = m + 1\n return l","memory":"37700"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n lo, hi = 1, len(set(nums))\n length = len(nums)\n subarray_count = length * (length + 1) // 2\n median = 0\n\n while lo <= hi:\n mid = (lo + hi) // 2\n count = i = j = 0\n freqs = Counter()\n while j < length:\n while j < length and (len(freqs) < mid or nums[j] in freqs):\n count += j - i + 1\n freqs[nums[j]] += 1\n j += 1\n while len(freqs) == mid:\n freqs[nums[i]] -= 1\n if freqs[nums[i]] == 0:\n del freqs[nums[i]]\n i += 1\n if count < math.ceil(subarray_count / 2):\n lo = mid + 1\n else:\n median = mid\n hi = mid - 1\n \n return median\n","memory":"37800"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n \"\"\"\n [3,4,3,4,5]\n all subarraies, get unique -> sort -> median\n lo, hi = 1, unique mid = \n total subarraries = (n + 1) * n // 2\n count = total // 2\n \"\"\"\n n = len(nums)\n total = math.ceil((n + 1) * n / 4)\n lo, hi = 1, len(set(nums))\n\n def get_count(mid):\n count, l = 0, 0\n uniques = defaultdict(int)\n for r in range(n):\n uniques[nums[r]] += 1\n while len(uniques) > mid:\n uniques[nums[l]] -= 1\n if uniques[nums[l]] == 0:\n uniques.pop(nums[l])\n l += 1\n count += r - l + 1\n return count\n\n while lo < hi:\n mid = (lo + hi) // 2\n count = get_count(mid)\n print(mid, count)\n if count < total:\n lo = mid + 1\n else:\n hi = mid\n \n return lo\n","memory":"37900"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n n = len(nums)\n def less_than(x):\n arr = defaultdict(int)\n l,r = 0,0\n cnt = 0\n while r < n:\n # print(l,r, arr, cnt)\n arr[nums[r]] += 1\n while len(arr) > x:\n if arr[nums[l]] == 1:\n del arr[nums[l]]\n else:\n arr[nums[l]] -= 1\n l += 1\n cnt += (r-l+1)\n r += 1\n return cnt\n \n l1,r1 = 1,len(set(nums))\n target = (n*(n+1))//2\n target += 1\n target //= 2\n # print(l1, r1, target)\n while l1 < r1:\n m = (l1+r1)//2\n lt = less_than(m)\n # print(m, lt)\n if target == lt:\n return m\n if target < lt:\n r1 = m\n else:\n l1 = m+1\n return r1\n ","memory":"38000"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n def count_subarray_distinct_less_or_equal_k(nums, k):\n left_fast = 0\n right = 0\n counts = {}\n ans = 0\n while right < n:\n if nums[right] in counts or len(counts) < k:\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n else:\n while len(counts) == k:\n counts[nums[left_fast]] -= 1\n if counts[nums[left_fast]] == 0:\n del counts[nums[left_fast]]\n left_fast += 1\n\n counts[nums[right]] = counts.get(nums[right], 0) + 1\n right += 1\n ans += right - left_fast\n return ans\n \n n = len(nums)\n total_subarray_num = n * (n + 1) // 2\n target = total_subarray_num // 2 + (total_subarray_num & 1)\n left = 1\n right = len(set(nums))\n while left < right:\n mid = left + right\n mid //= 2\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\n right = mid\n else:\n left = mid + 1\n return left","memory":"38100"},{"code":"class Solution:\n @staticmethod\n def _at_most(nums: List[int], max_num: int) -> int:\n count = collections.Counter()\n left = 0\n ans = 0\n for right in range(len(nums)):\n count[nums[right]] += 1\n while len(count) > max_num:\n count[nums[left]] -= 1\n if count[nums[left]] == 0:\n del count[nums[left]]\n left += 1\n ans += right - left + 1\n return ans\n\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n num_count = len(nums)\n total_sub_arrays = num_count * (num_count + 1) // 2\n unique_nums = set(nums)\n left, right = 1, len(unique_nums)\n while left < right:\n guess = (left + right) // 2\n if self._at_most(nums, guess) * 2 < total_sub_arrays:\n left = guess + 1\n else:\n right = guess\n return left","memory":"38400"},{"code":"class Solution:\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\n N = len(nums)\n totalSubArrays = (1+N)*N // 2\n halfSize = (totalSubArrays+1) // 2\n\n def numberOfSubArrays(k):\n cnt = collections.Counter()\n left, right = 0, 0\n res = 0\n while right < len(nums):\n cnt[nums[right]] += 1\n if len(cnt) <= k:\n right += 1\n continue\n\n while left < right:\n cnt[nums[left]] -= 1\n if cnt[nums[left]] == 0:\n del cnt[nums[left]]\n left += 1\n res += right - left\n if len(cnt) <= k:\n right += 1\n break\n dist = right - left\n res += dist * (dist - 1) // 2\n res += len(nums)\n return res\n\n uniqueNums = len(set(nums))\n left, right = 1, uniqueNums\n while left < right:\n mid = left + (right - left) // 2\n if numberOfSubArrays(mid) < halfSize:\n left = mid + 1\n else:\n right = mid\n return left\n","memory":"38500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n target = (((1 + n) * n // 2) - 1) // 2\\n\\n l, r = 1, n + 1\\n while l < r:\\n mid = l + r >> 1\\n total = j = 0\\n cnt = Counter()\\n for i, x in enumerate(nums):\\n cnt[x] += 1\\n \\n while len(cnt) > mid:\\n cnt[nums[j]] -= 1\\n if cnt[nums[j]] == 0:\\n del cnt[nums[j]]\\n j += 1\\n \\n total += i - j + 1\\n\\n if total > target:\\n break\\n \\n if total <= target:\\n l = mid + 1\\n else:\\n r = mid \\n\\n return l\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n + 1) * n // 2\\n target = (total + 1) // 2\\n left = 1\\n right = len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n start = 0\\n count = 0\\n dic = {}\\n for i in range(n):\\n dic[nums[i]] = dic.get(nums[i], 0) + 1\\n while len(dic) > mid:\\n dic[nums[start]] -= 1\\n if dic[nums[start]] == 0:\\n del dic[nums[start]]\\n start += 1\\n count += i - start + 1\\n if count >= target:\\n break\\n if count >= target:\\n right = mid\\n else:\\n left = mid + 1\\n return right\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n K = (N * (N + 1) // 2 + 1) // 2\\n\\n def check(upper: int) -> bool:\\n cnt, l = 0, 0\\n freq = defaultdict(int)\\n for r, x in enumerate(nums):\\n freq[x] += 1\\n while len(freq) > upper:\\n drop = nums[l]\\n freq[drop] -= 1\\n if freq[drop] == 0:\\n del freq[drop]\\n l += 1\\n cnt += r - l + 1\\n if cnt >= K:\\n return True\\n return False\\n\\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)\",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n K = (N * (N + 1) // 2 + 1) // 2\\n\\n def check(upper: int) -> bool:\\n cnt, l = 0, 0\\n freq = defaultdict(int)\\n for r, x in enumerate(nums):\\n freq[x] += 1\\n while len(freq) > upper:\\n drop = nums[l]\\n freq[drop] -= 1\\n if freq[drop] == 0:\\n del freq[drop]\\n l += 1\\n cnt += r - l + 1\\n if cnt >= K:\\n return True\\n return False\\n\\n return bisect.bisect_left(range(len(set(nums))), True, 1, key=check)\",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n K = (N * (N + 1) // 2 + 1) // 2\\n\\n def check(upper: int) -> bool:\\n cnt, l = 0, 0\\n freq = defaultdict(int)\\n for r, x in enumerate(nums):\\n freq[x] += 1\\n while len(freq) > upper:\\n drop = nums[l]\\n freq[drop] -= 1\\n if freq[drop] == 0:\\n del freq[drop]\\n l += 1\\n cnt += r - l + 1\\n if cnt >= K:\\n return True\\n return False\\n\\n return bisect.bisect_left(range(1, len(set(nums))), True, key=check) + 1\",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n lower, upper = 1, total_pairs\\n while lower < upper:\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n upper = mid\\n else:\\n lower = mid + 1\\n\\n return lower\\n\\n\\ndef num_of_uniqueness(nums, limit):\\n unique = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n unique[nums[i]] = i # save the last idx of the number\\n while len(unique) > limit:\\n if unique[nums[left]] == left:\\n unique.pop(nums[left])\\n left += 1\\n result += (i - left) + 1\\n if result > K: # there is not point in keep going\\n break\\n \\n return result\\n\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n # 1 4 4 3 7 5 5\\n\\n # 5 -> [**X**]\\n\\n n = len(nums)\\n elements = (n+1)*n//2\\n el = (elements + 1) // 2\\n print(\\\"el\\\", el)\\n\\n\\n def check(k):\\n total = 0\\n counter = defaultdict(int)\\n left = -1\\n for right in range(n):\\n counter[nums[right]] += 1\\n\\n while len(counter) > k:\\n left += 1\\n counter[nums[left]] -= 1\\n if counter[nums[left]] == 0:\\n del counter[nums[left]]\\n \\n l = right - left\\n total += l\\n if total >= el:\\n return True\\n\\n return False\\n\\n low = 1\\n high = n\\n r = None\\n while low <= high:\\n m = (low+high)//2\\n # print(\\\"low, high\\\", low, high)\\n # print(\\\"m\\\", m)\\n\\n if check(m):\\n # print(\\\"true\\\")\\n high = m - 1\\n r = m\\n else:\\n low = m + 1\\n\\n\\n\\n return r\",\n \"memory\": \"33500\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\\n\\n d = defaultdict(int)\\n \\n for rght in range(n):\\n d[nums[rght]]+= 1\\n\\n while len(d) > x:\\n left+= 1\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0: del d[nums[left]]\\n\\n cnt+= rght - left\\n if cnt >= median: return True\\n\\n return False\\n \\n\\n n = len(nums)\\n median = (comb(n+1,2) + 1) // 2\\n return bisect_left(range(n), \\n True, key = not_less_than_median)\",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def not_less_than_median(x: int, cnt = 0, left = -1)-> bool:\\n\\n d = defaultdict(int)\\n \\n for rght in range(n):\\n d[nums[rght]]+= 1\\n\\n while len(d) > x:\\n left+= 1\\n d[nums[left]] -= 1\\n if d[nums[left]] == 0: del d[nums[left]]\\n\\n cnt+= rght - left\\n if cnt >= median: return True\\n\\n return False\\n \\n\\n n = len(nums)\\n median = (comb(n+1,2) + 1) // 2\\n return bisect_left(range(n), \\n True, key = not_less_than_median)\",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique_nums = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n update_map(unique_nums, nums[i], 1)\\n while len(unique_nums) > limit:\\n update_map(unique_nums, nums[left], -1)\\n left += 1\\n result += (i - left) + 1\\n \\n return result\\n\\ndef update_map(unique, x, incr):\\n if x not in unique:\\n unique[x] = 0\\n unique[x] += incr\\n if unique[x] == 0:\\n unique.pop(x)\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n # Init vars and check edge case\\n n = len(nums)\\n if n == 1: return 1\\n l, r = 1, n\\n m = (n*(n+1))//2\\n goal = (m+1)//2\\n res = 1\\n # Bisect\\n while l <= r:\\n mid = (l+r) // 2\\n # Count number of subarrays with at most mid unique elements\\n v = self.bisect(nums, mid)\\n # Found goal\\n if v == goal: return mid\\n # Goal must be at least mid+1, remove lower half\\n if v < goal:\\n res = max(res, mid+1)\\n l = mid+1\\n # Remove upper half\\n else:\\n r = mid-1\\n return res\\n\\n def bisect(self, nums, k):\\n # Init vars\\n C = defaultdict(int)\\n res = 0\\n start = 0\\n for i, x in enumerate(nums):\\n # Add current element\\n C[x] += 1\\n # Reduce histogram to at most k items\\n while len(C) > k:\\n prev_x = nums[start]\\n C[prev_x] -= 1\\n if not C[prev_x]: C.pop(prev_x)\\n start += 1\\n # Count number of subarrays ending in index i\\n res += i-start+1\\n return res \",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int: \\n n = len(nums)\\n lo, hi = 0, n\\n while lo < hi: \\n mid = lo + hi >> 1\\n val = ii = 0 \\n freq = defaultdict(int)\\n for i, x in enumerate(nums): \\n freq[x] += 1\\n while len(freq) > mid: \\n freq[nums[ii]] -= 1\\n if freq[nums[ii]] == 0: freq.pop(nums[ii])\\n ii += 1\\n val += i-ii+1\\n if val < (n*(n+1)//2+1)//2: lo = mid + 1\\n else: hi = mid \\n return lo\",\n \"memory\": \"34500\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_less_or_equal(val):\\n count = 0\\n freq = defaultdict(int)\\n l = 0 \\n for r in range(n):\\n rval = nums[r]\\n freq[rval] += 1\\n \\n while len(freq) > val:\\n lval = nums[l]\\n freq[lval] -= 1 \\n if freq[lval] == 0: \\n freq.pop(lval)\\n l += 1\\n\\n count += r-l+1\\n return count\\n\\n n = len(nums)\\n left = 1\\n right = n\\n N = n*(n+1)/2\\n\\n while left < right:\\n mid = (left + right) // 2\\n count = count_less_or_equal(mid)\\n if count >= (N+1)//2:\\n right = mid \\n else:\\n left = mid + 1\\n return left \\n\\n\\n\",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_less_or_equal(val):\\n count = 0\\n freq = defaultdict(int)\\n l = 0 \\n for r in range(n):\\n rval = nums[r]\\n freq[rval] += 1\\n \\n while len(freq) > val:\\n lval = nums[l]\\n freq[lval] -= 1 \\n if freq[lval] == 0: \\n freq.pop(lval)\\n l += 1\\n\\n count += r-l+1\\n return count\\n\\n n = len(nums)\\n left = 1\\n right = n\\n N = n*(n+1)/2\\n\\n while left < right:\\n mid = (left + right) // 2\\n count = count_less_or_equal(mid)\\n if count >= (N+1)//2:\\n right = mid \\n else:\\n left = mid + 1\\n return left \\n\\n \",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def atMostK(k: int):\\n result = 0\\n left, right = 0, 0\\n counts = dict()\\n for right in range(len(nums)):\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n while len(counts) > k:\\n removed = nums[left]\\n left += 1\\n counts[removed] -= 1\\n if counts[removed] == 0:\\n del counts[removed]\\n result += right - left + 1 \\n return result \\n left, right = 1, len(nums)\\n total = len(nums) * (len(nums) - 1)//2 + len(nums)\\n mid = 0\\n while left <= right:\\n mid = left + (right - left)//2\\n subarrays = atMostK(mid)\\n if subarrays == (total + 1)//2:\\n return mid\\n elif subarrays > (total + 1)//2:\\n right = mid - 1\\n else:\\n left = mid + 1\\n return right + 1\\n\\n\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n total = (n+1)*n // 2\\n half = total // 2 if (total % 2 == 0) else total // 2 + 1\\n \\n def count_le(m):\\n ct = defaultdict(int)\\n i, j = 0, -1\\n total = 0\\n while i < n:\\n while j+1 < n:\\n j += 1\\n if nums[j] in ct or len(ct) < m:\\n ct[nums[j]] += 1\\n else:\\n j -= 1\\n break\\n total += j-i+1\\n \\n ct[nums[i]] -= 1\\n if ct[nums[i]] == 0:\\n del ct[nums[i]]\\n i += 1\\n return total\\n \\n l, r = 1, n\\n \\n while l < r:\\n m = (l+r) // 2\\n k1 = count_le(m)\\n k2 = count_le(m-1)\\n if k1 < half:\\n l = m+1\\n elif k2 >= half:\\n r = m\\n else:\\n return m\\n return l\",\n \"memory\": \"34800\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: list[int]):\\n n = len(nums)\\n subarrayCount = n * (n + 1) // 2\\n medianCount = (subarrayCount + 1) // 2\\n\\n \\n def subarraysWithAtMostKDistinct(k: int) -> int:\\n res = 0\\n count = collections.Counter()\\n\\n l = 0\\n for r, num in enumerate(nums):\\n count[num] += 1\\n if count[num] == 1:\\n k -= 1\\n while k < 0:\\n count[nums[l]] -= 1\\n if count[nums[l]] == 0:\\n k += 1\\n l += 1\\n res += r - l + 1 \\n\\n return res\\n\\n return bisect.bisect_left(\\n range(1, n), medianCount,\\n key=lambda m: subarraysWithAtMostKDistinct(m)) + 1\",\n \"memory\": \"34900\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n def atMost(k):\\n l = res = 0\\n counter = Counter()\\n\\n for r, num in enumerate(nums):\\n counter[num] += 1\\n\\n while len(counter) > k:\\n counter[ nums[l] ] -= 1\\n if counter[nums[l]] == 0:\\n del counter[nums[l]]\\n l += 1\\n res += r - l + 1\\n return res\\n\\n n = len(nums)\\n target = n * (n + 1) // 2\\n\\n l = 1\\n r = 10**10\\n\\n while l < r:\\n mid = (l + r) // 2\\n if atMost(mid) * 2 >= target:\\n r = mid\\n else:\\n l = mid + 1\\n return l \",\n \"memory\": \"35000\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def helper(target):\\n counts = {}\\n start = 0\\n total_count = 0\\n for ind, num in enumerate(nums):\\n if num not in counts:\\n counts[num] = 0\\n counts[num] += 1\\n\\n while len(counts) > target:\\n counts[nums[start]] -= 1\\n if counts[nums[start]] == 0:\\n del counts[nums[start]]\\n start += 1\\n #if len(counts) == target:\\n total_count += ind - start + 1\\n #print(f\\\"start = {start} ind = {ind} total_count = {total_count} target = {target}\\\")\\n return total_count\\n l = 0\\n r = len(nums) + 1\\n subarray_count = len(nums) * (len(nums) + 1) // 2\\n median_index = (subarray_count // 2 - 1) if subarray_count % 2 == 0 else (subarray_count // 2)\\n while l < r:\\n\\n mid = (l + r) // 2\\n #print(f\\\"mid = {mid} median_index = {median_index} helper = {helper(mid)}\\\")\\n if helper(mid) > median_index:\\n r = mid\\n else:\\n l = mid + 1\\n \\n return l\\n\",\n \"memory\": \"35100\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n self.n = len(nums)\\n total_subarrays = self.n * (self.n + 1) // 2\\n self.nums = nums\\n L, R = 1, self.n\\n while L < R:\\n mid = (L + R) // 2\\n count = self.get_num_subarrays_with_k_distinct(mid)\\n if count * 2 >= total_subarrays:\\n R = mid\\n else:\\n L = mid + 1\\n \\n return L\\n \\n def get_num_subarrays_with_k_distinct(self, k):\\n freq_dict = defaultdict(int)\\n answer = 0\\n L = 0\\n for R in range(self.n):\\n freq_dict[self.nums[R]] += 1\\n while len(freq_dict) > k:\\n freq_dict[self.nums[L]] -= 1\\n if freq_dict[self.nums[L]] == 0: del freq_dict[self.nums[L]]\\n L += 1\\n \\n answer += R - L + 1\\n \\n return answer \",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"def count(nums, d):\\n cnt = {}\\n lo = 0\\n res = 0\\n for i in range(len(nums)):\\n cnt[nums[i]] = cnt.get(nums[i], 0) + 1\\n while len(cnt) > d:\\n cnt[nums[lo]] = cnt[nums[lo]] - 1\\n if cnt[nums[lo]] == 0:\\n del cnt[nums[lo]]\\n lo += 1\\n res += i - lo + 1\\n return res\\n\\nclass Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n C = (len(nums) * (len(nums) + 1)) // 2\\n lo = 0\\n hi = len(nums) + 1\\n while hi - lo > 1:\\n mi = (lo + hi) // 2\\n if count(nums, mi) < C // 2 + C % 2:\\n lo = mi\\n else:\\n hi = mi\\n return hi\\n\",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n need = (n * (n+1)//2 + 1) // 2\\n def count(x):\\n r = 0\\n dic = {}\\n cnt = 0\\n for l in range(n):\\n while r < n:\\n if nums[r] not in dic and len(dic) == x:\\n break\\n dic[nums[r]] = dic.get(nums[r],0) + 1\\n r += 1\\n cnt += r-l\\n dic[nums[l]] -= 1\\n if dic[nums[l]] == 0:\\n del dic[nums[l]]\\n return cnt < need\\n l, r = 1, n\\n while l <= r:\\n mid = (l+r)//2\\n if count(mid):\\n l = mid + 1\\n else:\\n r = mid - 1\\n return l\\n\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n need = (n * (n+1)//2 + 1) // 2\\n def count(x):\\n r = 0\\n dic = {}\\n cnt = 0\\n for l in range(n):\\n while r < n:\\n if nums[r] not in dic and len(dic) == x:\\n break\\n dic[nums[r]] = dic.get(nums[r],0) + 1\\n r += 1\\n cnt += r-l\\n dic[nums[l]] -= 1\\n if dic[nums[l]] == 0:\\n del dic[nums[l]]\\n return cnt < need\\n l, r = 1, n\\n while l <= r:\\n mid = (l+r)//2\\n if count(mid):\\n l = mid + 1\\n else:\\n r = mid - 1\\n return l\\n\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n\\n # find how many uniqueness are <= than a threshold\\n def findSmallerThan(th: int) -> int:\\n cnt = Counter()\\n res = 0\\n\\n right = 0\\n for left in range(n):\\n # expand it as much as you can\\n while len(cnt) <= th and right < n:\\n cnt[nums[right]] += 1\\n if len(cnt) > th:\\n cnt.pop(nums[right])\\n break\\n right += 1\\n res += right - left\\n\\n cnt[nums[left]] -= 1\\n if cnt[nums[left]] == 0:\\n cnt.pop(nums[left])\\n return res\\n\\n l, r = 1, n\\n while l < r:\\n mid = l + (r - l) // 2\\n\\n if findSmallerThan(mid) >= (total + 1) // 2:\\n r = mid\\n else:\\n l = mid + 1\\n return l\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n global K\\n n = len(nums)\\n total_pairs = (n*(n-1))//2 + n\\n K = (total_pairs + 1)//2\\n return visit(nums, 1, total_pairs)\\n\\ndef visit(nums, lower, upper):\\n if lower == upper:\\n return lower\\n\\n mid = (lower + upper)//2\\n x = num_of_uniqueness(nums, mid)\\n if x >= K:\\n return visit(nums, lower, mid)\\n \\n return visit(nums, mid+1, upper)\\n\\ndef num_of_uniqueness(nums, limit):\\n unique = {}\\n left = 0\\n result = 0\\n for i in range(len(nums)):\\n unique[nums[i]] = i # save the last idx of the number\\n while len(unique) > limit:\\n if unique[nums[left]] == left:\\n unique.pop(nums[left])\\n left += 1\\n result += (i - left) + 1\\n \\n return result\\n\",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n # using atMost function, we can determine if a certain number will be median by seeing if the number of arrays\\n # at least k is equal to half the total number of possible subarrays (len(nums) * (len(nums) - 1) // 2)\\n if len(nums) <= 1:\\n return 1\\n\\n def atMost(K):\\n counts = defaultdict(int)\\n res = i = 0\\n\\n for j in range(len(nums)):\\n counts[nums[j]] += 1\\n\\n while len(counts) > K:\\n counts[nums[i]] -= 1\\n if counts[nums[i]] == 0:\\n del counts[nums[i]]\\n i += 1\\n \\n res += j - i + 1\\n \\n return res\\n \\n low, high = 0, len(nums)\\n med = (len(nums) * (len(nums) + 1) // 2)\\n\\n while low <= high:\\n mid = (low + high) // 2\\n\\n if atMost(mid) * 2 >= med:\\n high = mid - 1\\n else:\\n low = mid + 1\\n \\n return low\",\n \"memory\": \"35800\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n need = (((n*(n+1))//2 )+ 1) //2\\n \\n def count(x): \\n R = 0\\n st = defaultdict(int)\\n cnt = 0\\n \\n for L in range(n):\\n while R<n: \\n if nums[R] not in st and len(st) == x: \\n break \\n st[nums[R]]+=1 \\n R+=1\\n \\n cnt += R-L \\n \\n st[nums[L]]-=1 \\n if st[nums[L]] == 0:\\n del st[nums[L]]\\n \\n \\n return cnt<need\\n\\n l,r = 0,n+3 \\n while l+1<r: \\n m = (l+r)>>1 \\n \\n if count(m): \\n l = m \\n else: \\n r = m\\n \\n return r\",\n \"memory\": \"35900\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n median = (n * (n + 1)) // 2\\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result * 2 >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"memory\": \"36900\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n m = n * (n + 1) // 2 + 1 >> 1\\n d, pre, nxt = {}, [-1] * n, [n] * n\\n for i, x in enumerate(nums):\\n if x in d:\\n j = d[x]\\n pre[i] = j\\n nxt[j] = i\\n d[x] = i\\n \\n def f(t):\\n i, c = 0, 0\\n while c <= t:\\n if pre[i] < 0:\\n c += 1\\n i += 1\\n s, l = comb(i, 2), 0\\n for r in range(i - 1, n):\\n if pre[r] < l:\\n while nxt[l] <= r:\\n l += 1\\n l += 1\\n s += r - l\\n return s + n - i + 1\\n \\n a, b, x, y = 1, len(d), 0, m * 2\\n while a < b:\\n c = max(a, int(b - (b - a + 1) * (y - m) / (y - x)))\\n t = f(c)\\n if t == m:\\n return c\\n if t > m:\\n b, y = c, t\\n else:\\n a, x = c + 1, t\\n return a\",\n \"memory\": \"37000\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = (n * (n + 1)) // 2\\n median = (total + 1) // 2\\n \\n def count(target):\\n count = collections.Counter()\\n result = 0\\n i = 0\\n for j in range(n):\\n count[nums[j]] += 1\\n while len(count) > target:\\n count[nums[i]] -= 1\\n if count[nums[i]] == 0:\\n del count[nums[i]]\\n i += 1\\n result += (j - i + 1)\\n return result >= median\\n \\n left, right = 1, len(set(nums))\\n while left < right:\\n mid = left + (right - left) // 2\\n if count(mid):\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"memory\": \"37100\"\n },\n {\n \"code\": \"class Solution:\\n def count(self, nums, size):\\n l, r, = 0, 0\\n cnt = collections.Counter()\\n nbr = collections.defaultdict(int)\\n while l < len(nums) and r < len(nums):\\n while r < len(nums) and len(cnt) <= size:\\n cnt[nums[r]] += 1\\n if len(cnt) == size:\\n nbr[l] = max(nbr[l], r)\\n \\n r += 1\\n while l < len(nums) and len(cnt) > size:\\n cnt[nums[l]] -= 1\\n if cnt[nums[l]] == 0:\\n del cnt[nums[l]]\\n l += 1\\n nbr[l] = max(nbr[l], r-1)\\n res = 0\\n starts = list(sorted(nbr.keys()))\\n for i in range(len(starts)):\\n s = starts[i]\\n e = nbr[s] - s + 1\\n res += e * (e+1) // 2\\n if i > 0:\\n pe = nbr[starts[i-1]]\\n if pe >= s:\\n dup = pe - s + 1\\n res -= dup * (dup + 1) // 2\\n # print (nbr, size, res)\\n return res\\n\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n l, r = 1, len(nums)\\n base = len(nums) * (len(nums) + 1) // 4\\n # print (base)\\n # if len(nums) == 10 and len(set(nums)) == 10:\\n # return 4\\n # print (base)\\n combi = len(nums) * (len(nums) + 1) // 2\\n while l < r:\\n m = (l + r) // 2\\n cnt = self.count(nums, m)\\n if combi % 2 == 1 and cnt == base + 1:\\n return m\\n if combi % 2 == 0 and cnt == base:\\n return m\\n if cnt < base + 1:\\n l = m + 1\\n else:\\n r = m\\n return l \\n \\n'''\\n1. Problem\\n - given an integer array nums\\n - sorted array that contains the number of distinct \\n\\n [1, 1, 1, 2, 2, 3]\\n'''\",\n \"memory\": \"37500\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n total = n*(n + 1)//2\\n def atMostK(k):\\n count = defaultdict(int)\\n left = 0\\n n = len(nums)\\n ans = 0\\n for right in range(n):\\n count[nums[right]] += 1\\n while(len(count) > k):\\n count[nums[left]] -=1\\n if count[nums[left]] == 0:\\n count.pop(nums[left])\\n\\n left += 1\\n\\n ans += right - left + 1\\n\\n return ans\\n\\n left, right = 1, len(set(nums))\\n ans = -1\\n while left <= right:\\n mid = left + (right - left)//2\\n if atMostK(mid) * 2 >= total:\\n right = mid - 1\\n ans = mid\\n else:\\n left = mid + 1\\n \\n return ans\",\n \"memory\": \"37600\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def at_most_k(k: int) -> int:\\n j = cnt = 0\\n char_freq = collections.Counter()\\n for i, num in enumerate(nums):\\n char_freq[num] += 1\\n while j < i and len(char_freq) > k:\\n char_freq[nums[j]] -= 1\\n if char_freq[nums[j]] == 0: char_freq.pop(nums[j])\\n j += 1\\n cnt += i - j + 1\\n return cnt\\n \\n total = len(nums) * (len(nums) + 1) // 2\\n l, r = 1, len(set(nums))\\n while l <= r:\\n m = (l + r) // 2\\n if at_most_k(m) * 2 >= total: r = m - 1\\n else: l = m + 1\\n return l\",\n \"memory\": \"37700\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n lo, hi = 1, len(set(nums))\\n length = len(nums)\\n subarray_count = length * (length + 1) // 2\\n median = 0\\n\\n while lo <= hi:\\n mid = (lo + hi) // 2\\n count = i = j = 0\\n freqs = Counter()\\n while j < length:\\n while j < length and (len(freqs) < mid or nums[j] in freqs):\\n count += j - i + 1\\n freqs[nums[j]] += 1\\n j += 1\\n while len(freqs) == mid:\\n freqs[nums[i]] -= 1\\n if freqs[nums[i]] == 0:\\n del freqs[nums[i]]\\n i += 1\\n if count < math.ceil(subarray_count / 2):\\n lo = mid + 1\\n else:\\n median = mid\\n hi = mid - 1\\n \\n return median\\n\",\n \"memory\": \"37800\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n [3,4,3,4,5]\\n all subarraies, get unique -> sort -> median\\n lo, hi = 1, unique mid = \\n total subarraries = (n + 1) * n // 2\\n count = total // 2\\n \\\"\\\"\\\"\\n n = len(nums)\\n total = math.ceil((n + 1) * n / 4)\\n lo, hi = 1, len(set(nums))\\n\\n def get_count(mid):\\n count, l = 0, 0\\n uniques = defaultdict(int)\\n for r in range(n):\\n uniques[nums[r]] += 1\\n while len(uniques) > mid:\\n uniques[nums[l]] -= 1\\n if uniques[nums[l]] == 0:\\n uniques.pop(nums[l])\\n l += 1\\n count += r - l + 1\\n return count\\n\\n while lo < hi:\\n mid = (lo + hi) // 2\\n count = get_count(mid)\\n print(mid, count)\\n if count < total:\\n lo = mid + 1\\n else:\\n hi = mid\\n \\n return lo\\n\",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n def less_than(x):\\n arr = defaultdict(int)\\n l,r = 0,0\\n cnt = 0\\n while r < n:\\n # print(l,r, arr, cnt)\\n arr[nums[r]] += 1\\n while len(arr) > x:\\n if arr[nums[l]] == 1:\\n del arr[nums[l]]\\n else:\\n arr[nums[l]] -= 1\\n l += 1\\n cnt += (r-l+1)\\n r += 1\\n return cnt\\n \\n l1,r1 = 1,len(set(nums))\\n target = (n*(n+1))//2\\n target += 1\\n target //= 2\\n # print(l1, r1, target)\\n while l1 < r1:\\n m = (l1+r1)//2\\n lt = less_than(m)\\n # print(m, lt)\\n if target == lt:\\n return m\\n if target < lt:\\n r1 = m\\n else:\\n l1 = m+1\\n return r1\\n \",\n \"memory\": \"38000\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n def count_subarray_distinct_less_or_equal_k(nums, k):\\n left_fast = 0\\n right = 0\\n counts = {}\\n ans = 0\\n while right < n:\\n if nums[right] in counts or len(counts) < k:\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n else:\\n while len(counts) == k:\\n counts[nums[left_fast]] -= 1\\n if counts[nums[left_fast]] == 0:\\n del counts[nums[left_fast]]\\n left_fast += 1\\n\\n counts[nums[right]] = counts.get(nums[right], 0) + 1\\n right += 1\\n ans += right - left_fast\\n return ans\\n \\n n = len(nums)\\n total_subarray_num = n * (n + 1) // 2\\n target = total_subarray_num // 2 + (total_subarray_num & 1)\\n left = 1\\n right = len(set(nums))\\n while left < right:\\n mid = left + right\\n mid //= 2\\n if count_subarray_distinct_less_or_equal_k(nums, mid) >= target:\\n # print(count_subarray_distinct_less_or_equal_k(nums, mid), target, mid)\\n right = mid\\n else:\\n left = mid + 1\\n return left\",\n \"memory\": \"38100\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def _at_most(nums: List[int], max_num: int) -> int:\\n count = collections.Counter()\\n left = 0\\n ans = 0\\n for right in range(len(nums)):\\n count[nums[right]] += 1\\n while len(count) > max_num:\\n count[nums[left]] -= 1\\n if count[nums[left]] == 0:\\n del count[nums[left]]\\n left += 1\\n ans += right - left + 1\\n return ans\\n\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n num_count = len(nums)\\n total_sub_arrays = num_count * (num_count + 1) // 2\\n unique_nums = set(nums)\\n left, right = 1, len(unique_nums)\\n while left < right:\\n guess = (left + right) // 2\\n if self._at_most(nums, guess) * 2 < total_sub_arrays:\\n left = guess + 1\\n else:\\n right = guess\\n return left\",\n \"memory\": \"38400\"\n },\n {\n \"code\": \"class Solution:\\n def medianOfUniquenessArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n totalSubArrays = (1+N)*N // 2\\n halfSize = (totalSubArrays+1) // 2\\n\\n def numberOfSubArrays(k):\\n cnt = collections.Counter()\\n left, right = 0, 0\\n res = 0\\n while right < len(nums):\\n cnt[nums[right]] += 1\\n if len(cnt) <= k:\\n right += 1\\n continue\\n\\n while left < right:\\n cnt[nums[left]] -= 1\\n if cnt[nums[left]] == 0:\\n del cnt[nums[left]]\\n left += 1\\n res += right - left\\n if len(cnt) <= k:\\n right += 1\\n break\\n dist = right - left\\n res += dist * (dist - 1) // 2\\n res += len(nums)\\n return res\\n\\n uniqueNums = len(set(nums))\\n left, right = 1, uniqueNums\\n while left < right:\\n mid = left + (right - left) // 2\\n if numberOfSubArrays(mid) < halfSize:\\n left = mid + 1\\n else:\\n right = mid\\n return left\\n\",\n \"memory\": \"38500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":39,"string":"39"}}},{"rowIdx":2434,"cells":{"question_id":{"kind":"number","value":3395,"string":"3,395"},"name":{"kind":"string","value":"minimum-length-of-anagram-concatenation"},"content":{"kind":"string","value":"<p>You are given a string <code>s</code>, which is known to be a concatenation of <strong>anagrams</strong> of some string <code>t</code>.</p>\n\n<p>Return the <strong>minimum</strong> possible length of the string <code>t</code>.</p>\n\n<p>An <strong>anagram</strong> is formed by rearranging the letters of a string. For example, "aab", "aba", and, "baa" are anagrams of "aab".</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "abba"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>One possible string <code>t</code> could be <code>"ba"</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "cdef"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>One possible string <code>t</code> could be <code>"cdef"</code>, notice that <code>t</code> can be equal to <code>s</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length <= 10<sup>5</sup></code></li>\n\t<li><code>s</code> consist only of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":41.865577422948384,"string":"41.865577"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["hash-table","string","counting"],"string":"[\n \"hash-table\",\n \"string\",\n \"counting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"87\", 1.6128], [\"113\", 0.5376], [\"139\", 0.5376], [\"165\", 0.5376], [\"191\", 0.5376], [\"217\", 5.3761], [\"244\", 1.0752], [\"270\", 0.5376], [\"296\", 1.6128], [\"322\", 2.1504], [\"348\", 5.913800000000001], [\"374\", 1.0752], [\"401\", 4.8385], [\"427\", 1.0752], [\"453\", 4.8385], [\"479\", 4.8385], [\"505\", 0.5376], [\"531\", 0.5376], [\"558\", 1.0752], [\"584\", 2.1504], [\"610\", 0.5376], [\"636\", 2.1504999999999996], [\"662\", 0.5376], [\"688\", 1.0752], [\"714\", 0.5376], [\"741\", 0.5376], [\"767\", 0.5376], [\"793\", 0.5376], [\"819\", 0.5376], [\"845\", 0.5376], [\"871\", 0.5376], [\"898\", 0.5376], [\"924\", 0.5376], [\"950\", 0.5376], [\"976\", 0.5376], [\"1002\", 0.5376], [\"1028\", 3.2258], [\"1055\", 2.6880999999999995], [\"1081\", 3.2255999999999996], [\"1107\", 0.5376], [\"1133\", 0.5376], [\"1159\", 1.6128], [\"1185\", 5.9138], [\"1212\", 4.8385], [\"1238\", 2.6879999999999997], [\"1264\", 2.6879999999999997], [\"1290\", 0.5376], [\"1316\", 0.5376], [\"1342\", 1.6128], [\"1369\", 0.5376], [\"1395\", 0.5376], [\"1421\", 0.5376], [\"1447\", 0.5376], [\"1473\", 0.5376], [\"1499\", 1.6128], [\"1526\", 0.5376], [\"1552\", 0.5376], [\"1578\", 0.5376], [\"1604\", 0.5376], [\"1630\", 0.5376], [\"1656\", 0.5376], [\"1682\", 0.5376], [\"1709\", 0.5376], [\"1735\", 0.5376], [\"1761\", 0.5376], [\"1787\", 0.5376], [\"1813\", 0.5376], [\"1839\", 0.5376], [\"1866\", 0.5376]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17200\", 0.5376], [\"17400\", 9.1398], [\"17500\", 34.4086], [\"17600\", 15.5914], [\"17700\", 5.3763], [\"17800\", 3.2258], [\"18000\", 1.0753], [\"18100\", 2.6882], [\"18200\", 0.5376], [\"18500\", 2.1505], [\"18600\", 1.6129], [\"18900\", 0.5376], [\"19200\", 1.0753], [\"19300\", 3.2258], [\"19400\", 3.2258], [\"21900\", 1.0753], [\"24500\", 0.5376], [\"25500\", 0.5376], [\"26100\", 0.5376], [\"26300\", 0.5376], [\"31300\", 0.5376], [\"31500\", 1.0753], [\"35200\", 0.5376], [\"58300\", 0.5376], [\"60100\", 0.5376], [\"72700\", 0.5376], [\"72800\", 2.6882]]}"},"rt_list":{"kind":"list like","value":[{"code":"from math import gcd\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n if s==\"ccccaaaa\":\n return 8\n a=Counter(s)\n x=list(set(a.values()))\n m=x[0]\n for i in range(1,len(x)):\n m=gcd(m,x[i])\n l=len(s)//m\n l1=l\n if m!=1:\n if sorted(s[:l])!=sorted(s[l:l+l]):\n l+=l1\n while(l<len(s) and sorted(s[:l])!=sorted(s[l:l+l])):\n l+=l1\n return l\n return len(s)//m\n\n","runtime":"87"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n C = collections.Counter(s)\n if len(C) == 1: # only one char\n return 1\n if min(C.values()) == 1:\n return len(s)\n curr = collections.Counter()\n for i in range(len(s)//2+1):\n curr[s[i]] += 1\n if len(s)%(i+1)==0 and len(curr)==len(C) and curr.keys()==C.keys() and len(set(C[ch]//curr[ch] for ch in C))==1:\n for j in range(i+1,len(s),i+1):\n tmp = collections.Counter(s[j:j+i+1])\n if tmp != curr:\n break\n else:\n return i+1\n return len(s)","runtime":"87"},{"code":"class Solution:\n def get_divs(self, n):\n res = set()\n div = 1\n while div * div <= n:\n if n % div == 0:\n res.add(div)\n res.add(n // div)\n div += 1\n return res\n\n def get_char_cnt(self, s):\n char_cnt = {}\n for c in s:\n char_cnt[c] = char_cnt.get(c, 0) + 1\n return char_cnt\n\n def minAnagramLength(self, s: str) -> int:\n char_cnt = self.get_char_cnt(s)\n\n divs = None\n for _, cnt in char_cnt.items():\n if not divs:\n divs = self.get_divs(cnt)\n else:\n divs = divs & self.get_divs(cnt)\n \n divs = sorted(list(divs), reverse=True)\n\n # div is the number of repeating times of a string\n for div in divs:\n n = len(s) // div\n char_cnt = None\n succ = True\n for i in range(0, len(s), n):\n sub_s = s[i:i + n]\n if not char_cnt:\n char_cnt = self.get_char_cnt(sub_s)\n else:\n if not char_cnt == self.get_char_cnt(sub_s):\n succ = False\n break\n if succ:\n return n\n\n ","runtime":"113"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = defaultdict(lambda: 0)\n n = len(s)\n for i in range(n):\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n divisors = []\n for i in range(n//distinct_letters, 1, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n divisors.append(i)\n\n res = n\n\n for divisor in divisors:\n bad_divisor = False\n candidate = n//divisor\n temp_count = defaultdict(lambda: 0)\n\n for i in range(candidate):\n temp_count[s[i]] += 1\n if len(temp_count) < distinct_letters:\n continue\n\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\n continue\n \n for letter, count in items:\n if counter[letter] // count != divisor:\n bad_divisor = True\n if bad_divisor:\n continue\n\n else:\n for j in range(1, divisor):\n new_count = defaultdict(lambda: 0)\n for i in range(candidate*j, candidate*(j+1)):\n cur_symb = s[i] \n new_count[cur_symb] += 1\n if new_count[cur_symb] > counter[cur_symb]:\n bad_divisor = True\n break\n if bad_divisor:\n break\n if new_count != temp_count:\n bad_divisor = True\n break\n if bad_divisor:\n continue\n else:\n res = candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"139"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = defaultdict(lambda: 0)\n n = len(s)\n for i in range(n):\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n divisors = []\n for i in range(n//distinct_letters, 1, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n divisors.append(i)\n\n res = n\n\n for divisor in divisors:\n bad_divisor = False\n candidate = n//divisor\n temp_count = defaultdict(lambda: 0)\n\n for i in range(candidate):\n temp_count[s[i]] += 1\n if len(temp_count) < distinct_letters:\n continue\n\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\n continue\n \n for letter, count in items:\n if counter[letter] // count != divisor:\n bad_divisor = True\n if bad_divisor:\n continue\n\n else:\n for j in range(1, divisor):\n new_count = defaultdict(lambda: 0)\n for i in range(candidate*j, candidate*(j+1)):\n cur_symb = s[i] \n new_count[cur_symb] += 1\n if new_count[cur_symb] > counter[cur_symb]:\n bad_divisor = True\n break\n if bad_divisor:\n break\n if new_count != temp_count:\n bad_divisor = True\n break\n if bad_divisor:\n continue\n else:\n res = candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"165"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n divisors = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n divisors.append(i)\n\n res = n\n\n for divisor in divisors:\n bad_divisor = False\n candidate = n//divisor\n temp_count = dict()\n\n for i in range(candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n if len(temp_count) < distinct_letters:\n continue\n\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\n continue\n \n for letter, count in items:\n if counter[letter] // count != divisor:\n bad_divisor = True\n if bad_divisor:\n continue\n\n else:\n for j in range(1, divisor):\n new_count = {}\n for k in range(candidate*j, candidate*(j+1)):\n cur_symb = s[k]\n if cur_symb not in new_count:\n new_count[cur_symb] = 1\n else:\n new_count[cur_symb] += 1\n if new_count[cur_symb] > counter[cur_symb]:\n bad_divisor = True\n break\n if bad_divisor:\n break\n if new_count != temp_count:\n bad_divisor = True\n break\n if bad_divisor:\n continue\n else:\n res = candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"191"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n cur_symb = s[i]\n if cur_symb not in counter:\n counter[cur_symb] = 1\n else:\n counter[cur_symb] += 1\n \n distinct_letters = len(counter)\n divisors = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n divisors.append(i)\n\n res = n\n\n for divisor in divisors:\n bad_divisor = False\n candidate = n//divisor\n temp_count = dict()\n\n for i in range(candidate):\n cur_symb = s[i]\n if cur_symb not in temp_count:\n temp_count[cur_symb] = 1\n else:\n temp_count[cur_symb] += 1\n if len(temp_count) < distinct_letters:\n continue\n\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\n continue\n \n for letter, count in items:\n if counter[letter] // count != divisor:\n bad_divisor = True\n if bad_divisor:\n continue\n\n else:\n for j in range(1, divisor):\n new_count = {}\n for i in range(candidate*j, candidate*(j+1)):\n cur_symb = s[i]\n if cur_symb not in new_count:\n new_count[cur_symb] = 1\n else:\n new_count[cur_symb] += 1\n if new_count[cur_symb] > counter[cur_symb]:\n bad_divisor = True\n break\n if bad_divisor:\n break\n if new_count != temp_count:\n bad_divisor = True\n break\n if bad_divisor:\n continue\n else:\n res = candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"217"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n\n res = n\n\n for candidate in candidates:\n bad_candidate = False\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n \n if len(temp_count) < len(counter):\n continue\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != candidate:\n continue\n \n for letter, count in items:\n if counter[letter] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"217"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = defaultdict(lambda: 0)\n n = len(s)\n for i in range(n):\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n divisors = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n divisors.append(i)\n\n res = n\n\n for divisor in divisors:\n bad_divisor = False\n candidate = n//divisor\n temp_count = defaultdict(lambda: 0)\n\n for i in range(candidate):\n temp_count[s[i]] += 1\n if len(temp_count) < distinct_letters:\n continue\n\n items = temp_count.items()\n letter, count = next(iter(items))\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\n continue\n \n for letter, count in items:\n if counter[letter] // count != divisor:\n bad_divisor = True\n if bad_divisor:\n continue\n\n else:\n for j in range(1, divisor):\n new_count = defaultdict(lambda: 0)\n for i in range(candidate*j, candidate*(j+1)):\n cur_symb = s[i] \n new_count[cur_symb] += 1\n if new_count[cur_symb] > counter[cur_symb]:\n bad_divisor = True\n break\n if bad_divisor:\n break\n if new_count != temp_count:\n bad_divisor = True\n break\n if bad_divisor:\n continue\n else:\n res = candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"244"},{"code":"from math import sqrt\nfrom collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n # factors = []\n # for i in range(1, int(sqrt(len(s))) + 1):\n # if len(s) % i == 0:\n # if len(s) // i == i:\n # factors.append(i)\n # else:\n # factors.append(i)\n # factors.append(len(s) // i)\n \n # factors.sort()\n\n # for i in factors:\n # # i is size of subaray\n # match = set()\n # for j in range(0, len(s), i):\n # chars = [0] * 26\n # for k in range(j, j + i):\n # chars[ord(s[k]) - ord('a')] += 1\n # match.add(tuple(chars))\n # if len(match) == 1:\n # return i\n\n # return len(s)\n\n def check(k: int) -> bool:\n for i in range(0, n, k):\n cnt1 = Counter(s[i : i + k])\n for c, v in cnt.items():\n if cnt1[c] * (n // k) != v:\n return False\n return True\n\n cnt = Counter(s)\n n = len(s)\n for i in range(1, n + 1):\n if n % i == 0 and check(i):\n return i\n \n\n\n\n\n\n \n\n ","runtime":"244"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n res = n\n print(candidates)\n print(counter)\n for candidate in candidates:\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n print(temp_count)\n \n if len(temp_count) < len(counter):\n continue\n k = 0\n for letter, count in temp_count.items():\n if k == 1:\n break\n count_to_check = count\n letter_to_check = letter\n k += 1\n #print(count_to_check)\n #print(letter_to_check)\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\n print(candidate)\n continue\n bad_candidate = False\n for letter, count in temp_count.items():\n count_to_check = count\n letter_to_check = letter\n if counter[letter_to_check] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n #print(s[k])\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n print(new_count)\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n\n\n\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"270"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n res = n\n print(candidates)\n print(counter)\n for candidate in candidates:\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n print(temp_count)\n \n if len(temp_count) < len(counter):\n continue\n k = 0\n for letter, count in temp_count.items():\n if k == 1:\n break\n count_to_check = count\n letter_to_check = letter\n k += 1\n #print(count_to_check)\n #print(letter_to_check)\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\n print(candidate)\n continue\n bad_candidate = False\n for letter, count in temp_count.items():\n count_to_check = count\n letter_to_check = letter\n if counter[letter_to_check] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n #print(s[k])\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n print(new_count)\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n\n\n\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"296"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n res = n\n print(candidates)\n print(counter)\n for candidate in candidates:\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n print(temp_count)\n \n if len(temp_count) < len(counter):\n continue\n k = 0\n for letter, count in temp_count.items():\n if k == 1:\n break\n count_to_check = count\n letter_to_check = letter\n k += 1\n #print(count_to_check)\n #print(letter_to_check)\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\n print(candidate)\n continue\n bad_candidate = False\n for letter, count in temp_count.items():\n count_to_check = count\n letter_to_check = letter\n if counter[letter_to_check] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n #print(s[k])\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n print(new_count)\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n\n\n\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"296"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n res = n\n print(candidates)\n print(counter)\n for candidate in candidates:\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n print(temp_count)\n \n if len(temp_count) < len(counter):\n continue\n k = 0\n for letter, count in temp_count.items():\n if k == 1:\n break\n count_to_check = count\n letter_to_check = letter\n k += 1\n #print(count_to_check)\n #print(letter_to_check)\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\n print(candidate)\n continue\n bad_candidate = False\n for letter, count in temp_count.items():\n count_to_check = count\n letter_to_check = letter\n if counter[letter_to_check] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n #print(s[k])\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n print(new_count)\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n\n\n\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","runtime":"322"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def check(k: int) -> bool:\n for i in range(0, n, k):\n cnt1 = Counter(s[i : i + k])\n for c, v in cnt.items():\n if cnt1[c] * (n // k) != v:\n return False\n return True\n\n cnt = Counter(s)\n n = len(s)\n for i in range(1, n + 1):\n if n % i == 0 and check(i):\n return i","runtime":"322"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n # Define a function to check if a given length k is valid\n def is_valid(k):\n # Initialize a counter for the first substring of length k\n prev = Counter(s[:k])\n # Iterate through the string with step k\n for i in range(k, len(s), k):\n # Create a counter for the current substring of length k\n cur = Counter(s[i:i+k])\n # Check if the current substring is an anagram of the previous one\n if prev != cur:\n return False\n # prev = cur\n return True\n \n # Count the frequency of each character in the string\n char_freq = Counter(s)\n # Get the minimum frequency of any character\n min_freq = min(char_freq.values())\n # Determine the minimum possible length of the anagram\n min_length = len(s) // min_freq\n \n # Check all possible lengths from min_length to len(s)\n for length in range(min_length, len(s)):\n # Check if the length is a divisor of len(s) and is valid\n if len(s) % length == 0 and is_valid(length):\n return length\n \n return len(s)","runtime":"348"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n # Define a function to check if a given length k is valid\n def is_valid(k):\n # Initialize a counter for the first substring of length k\n prev = Counter(s[:k])\n # Iterate through the string with step k\n for i in range(k, len(s), k):\n # Create a counter for the current substring of length k\n cur = Counter(s[i:i+k])\n # Check if the current substring is an anagram of the previous one\n if prev != cur:\n return False\n # prev = cur\n return True\n \n # Count the frequency of each character in the string\n char_freq = Counter(s)\n # Get the minimum frequency of any character\n min_freq = min(char_freq.values())\n # Determine the minimum possible length of the anagram\n min_length = len(s) // min_freq\n \n # Check all possible lengths from min_length to len(s)\n for length in range(min_length, len(s)):\n # Check if the length is a divisor of len(s) and is valid\n if len(s) % length == 0 and is_valid(length):\n return length\n \n return len(s)","runtime":"348"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def gcd_(a, b):\n if a < b:\n return gcd_(b, a)\n if b == 0:\n return a\n if a % b == 0:\n return b\n return gcd_(b, a%b)\n\n def isOK(k):\n count = Counter(s[:k])\n for i in range(k, len(s), k):\n if Counter(s[i:i+k]) != count:\n return False\n return True\n \n count = Counter(s)\n alpha = list(count.keys())\n gcd = count[alpha[0]]\n for a in alpha[1:]:\n gcd = gcd_(gcd, count[a])\n for i in reversed(range(2, gcd+1)):\n if len(s) % i != 0:\n continue\n k = len(s)//i\n if isOK(len(s)//i):\n return k\n return len(s)\n","runtime":"374"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n # Define a function to check if a given length k is valid\n def is_valid(k):\n # Initialize a counter for the first substring of length k\n prev = Counter(s[:k])\n # Iterate through the string with step k\n for i in range(k, len(s), k):\n # Create a counter for the current substring of length k\n cur = Counter(s[i:i+k])\n # Check if the current substring is an anagram of the previous one\n if prev != cur:\n return False\n prev = cur\n return True\n \n # Count the frequency of each character in the string\n char_freq = Counter(s)\n # Get the minimum frequency of any character\n min_freq = min(char_freq.values())\n # Determine the minimum possible length of the anagram\n min_length = len(s) // min_freq\n \n # Check all possible lengths from min_length to len(s)\n for length in range(min_length, len(s)):\n # Check if the length is a divisor of len(s) and is valid\n if len(s) % length == 0 and is_valid(length):\n return length\n \n return len(s)","runtime":"374"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 # increment chunk size multiplier","runtime":"401"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def is_anagram(s, t):\n d_s = collections.Counter(s)\n d_t = collections.Counter(t)\n if len(d_s) != len(d_t):\n return False\n for char, count in d_s.items():\n if d_t[char] != count:\n return False\n return True\n def factors(num):\n ans = [num]\n for n in range(2, math.floor(pow(num, .5))+ 1):\n if num % n == 0:\n ans.append(n)\n ans.append(num // n)\n return list(sorted(ans, reverse=True))\n def divides_all(num, vals):\n for val in vals:\n if val % num != 0:\n return False\n return True\n # I think if I find some num that all counts mod to, then I can hit that mod\n d = collections.Counter(s)\n vals = list(d.values())\n num = min(vals)\n for factor in factors(num):\n if divides_all(factor, vals):\n # How do I check, given it divides all, that the first \"anagram\" actually has all the intended characters?\n # Oh, I have to check literally it all.\n length = len(s) // factor\n for i in range(0, len(s) - length, length):\n if not is_anagram(s[i: i + length],s[i + length: i + length * 2]):\n break\n else: # if all is true\n return length\n return len(s)","runtime":"401"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 ","runtime":"427"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values())\n\n i, k = 1, S // x\n while True:\n t = i * k\n n, r = divmod(S, t)\n if r != 0:\n i += 1\n continue\n\n\n\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n\n\n i += 1","runtime":"427"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 ","runtime":"453"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 # increment chunk size multiplier","runtime":"453"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n stringList = list(s)\n n = len(s)\n for size in range(1, n):\n if n % size == 0: \n initialList = sorted(stringList[:size])\n for j in range(size, n, size):\n temp = stringList[j:j+size]\n temp.sort()\n\n if initialList != temp: \n break\n else:\n return size\n \n return n","runtime":"479"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n l = list(s)\n n = len(s)\n for i in range(1, n):\n if n % i == 0:\n il = sorted(s[:i])\n for j in range(i, n, i):\n temp = l[j:j + i]\n temp.sort()\n \n if il != temp:\n break\n else:\n return i\n\n return n\n \n\n","runtime":"479"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for j in range(1, len(s)+1):\n if len(s) % j != 0:\n continue\n first = sorted(s[:j])\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\n return j","runtime":"505"},{"code":"def check(s, i):\n repeat = s[:i]\n repeat = sorted(repeat)\n j = i\n while j < len(s):\n cur = s[j: j+i]\n cur = sorted(cur)\n if cur != repeat:\n return False\n j += i\n return True\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for i in range(1,n+1):\n if n % i == 0 and check(s, i):\n return i\n return n\n ","runtime":"531"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for j in range(1, len(s)+1):\n if len(s) % j != 0:\n continue\n first = sorted(s[:j])\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\n return j","runtime":"558"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for l in range(1, len(s)):\n if len(s) % l:\n continue\n anagram = sorted(s[:l])\n is_ans = True\n for i in range(0, len(s), l):\n if sorted(s[i : i + l]) != anagram:\n is_ans = False\n break\n if is_ans:\n return l\n return len(s)","runtime":"558"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for groupsize in range(1, len(s) + 1):\n if len(s) % groupsize == 0:\n size = True\n target = sorted(s[:groupsize])\n numgroups = len(s) // groupsize\n for n in range(numgroups - 1):\n if sorted(s[(n + 1) * groupsize:(n + 2) * groupsize]) != target:\n size = False\n break\n if size:\n return groupsize\n ","runtime":"584"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for j in range(1, len(s)+1):\n if len(s) % j != 0:\n continue\n first = sorted(s[:j])\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\n return j","runtime":"584"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def minAnangram(number):\n set1 = set()\n for i in range(0, len(s), number):\n if not set1:\n set1.add(\"\".join(sorted(s[i:i+number])))\n continue\n if \"\".join(sorted(s[i:i+number])) not in set1:\n return False\n return True\n n = len(s)\n for i in range(1, int(n*0.5) + 1):\n if n % i == 0:\n if minAnangram(i):\n return i\n if minAnangram(n):\n return n\n\n \n \n\n \n \n ","runtime":"610"},{"code":"class Solution:\n def finddiv(self, num):\n div = []\n for i in range(1, num):\n if num % i == 0:\n div.append(i)\n return div\n\n def minAnagramLength(self, s: str) -> int:\n divs = self.finddiv(len(s))\n\n for i in divs:\n ptr = 0\n prev = \"\"\n\n while ptr < len(s):\n temp = s[ptr:ptr+i]\n temp = ''.join(sorted(temp))\n\n if prev != temp and prev != \"\":\n break\n\n prev = temp\n ptr += i\n \n if ptr == len(s):\n return i\n \n return len(s)","runtime":"636"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n ## they all have to have the same factors\n\n def factors(n):\n factor = []\n for i in range(1, n+1):\n if n % i == 0:\n factor.append(i)\n return factor\n\n possible_lengths = factors(len(s))\n\n for length in possible_lengths:\n chunk1 = sorted(s[:length])\n valid = True\n for i in range(0, len(s), length):\n chunk2 = sorted(s[i:i+length])\n if chunk1 != chunk2:\n valid = False\n break\n \n if valid:\n return length\n ","runtime":"636"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(list(set(list(s))))==1:\n return 1\n d={}\n d2={}\n for i in s:\n d[i]=0\n d2[i]=0\n d1={}\n for i in s:\n if i not in d1:\n d1[i]=1\n else:\n d1[i]+=1\n c=0\n p=0\n for i in s:\n c3=0\n c1=0\n d[i]+=1\n c+=1\n for i in d:\n if d[i]:\n c1+=1\n if c1==len(d) and len(s)%c==0:\n s2=\"\"\n j=c\n m=0\n while(j<len(s)):\n m+=1\n c2=0\n s2+=s[j]\n if m%c==0:\n # print(s2)\n for t in s2:\n d2[t]+=1\n for t in d2:\n if d2[t]==d[t]:\n c2+=1\n if c2==len(d2):\n c3+=1\n \n s2=\"\"\n m=0\n for g in d2:\n d2[g]=0\n j+=1\n # print(d2)\n # print(c3)\n if c3+1==len(s)//c:\n return c\n p+=1\n return c","runtime":"662"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(s) == 1:\n return 1\n minimum = len(s)\n for i in reversed(range(1, len(s))):\n if len(s) % i == 0:\n splits = [s[j:j+i] for j in range(0, len(s), i)]\n first = sorted(splits[0])\n others = splits[1:]\n if all(sorted(k) == first for k in others):\n minimum = i\n return minimum\n","runtime":"688"},{"code":"from collections import defaultdict\nclass Solution:\n # Time: O(n*log(n))\n # Space: O(n), where n = len(s)\n def minAnagramLength(self, s: str) -> int:\n \n n = len(s)\n # Find divisors of length of s\n divisors = []\n for i in range(1, n+1):\n if n % i == 0:\n divisors.append(i)\n\n def count(string):\n count = defaultdict(int)\n for c in string:\n count[c] += 1\n return count\n\n def check(l):\n count_ref = count(s[:l])\n for i in range(l, n+1, l):\n if count(s[i-l: i]) != count_ref:\n return 0\n return 1\n\n for i in range(len(divisors)):\n if check(divisors[i]):\n return divisors[i]\n\n # Binary search on the length of t\n i, j = 0, len(divisors)-1\n while i <= j:\n m = (i+j)//2\n feasible = check(divisors[m])\n if feasible:\n j = m - 1\n else:\n i = m + 1\n return divisors[i]\n\n\n","runtime":"688"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n res = n\n\n c = [[]] * 2\n for i in range(1, n):\n if n % i != 0:\n continue\n\n steps = n // i\n found = True\n c[0] = [0] * 26\n\n for j in range(steps):\n idx = 1 if j != 0 else 0\n c[1] = [0] * 26\n for k in range(j * i, (j + 1) * i):\n c[idx][ord(s[k]) - 97] += 1\n\n if j != 0 and c[0] != c[1]:\n found = False\n break\n\n if found:\n return i\n\n return n\n","runtime":"714"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n\n d = {}\n\n for i in range(n):\n if s[i] not in d:\n d[s[i]] = 1\n else:\n d[s[i]] += 1\n \n no_of_distinct = len(d)\n\n # finding the factors of n\n factors = []\n for i in range(1, int(n**(0.5)) + 1):\n if n%i == 0:\n if i != n//i:\n factors.append(i)\n factors.append(n//i)\n else:\n factors.append(i) \n # print(factors)\n factors = sorted(factors)\n # print(factors)\n\n idx = -1\n for i in range(len(factors)):\n if factors[i] >= no_of_distinct:\n idx = i\n break\n # print(factors[idx:])\n\n mini = int(1e9)\n for each_factor in factors[idx:]:\n p = 0\n res = sorted(s[0:each_factor])\n count = 1\n p = p + each_factor \n while p < n:\n if sorted(s[p:p+each_factor]) == res:\n count += 1\n p += each_factor\n \n if count == (n//each_factor):\n return each_factor","runtime":"741"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n=len(s)\n for p in [i for i in range(1,n+1) if n%i==0]:\n ph=[]\n valid=True\n for i in range(0,n,p):\n ptrn=s[i:i+p]\n tph=[0]*26\n for alp in ptrn:\n tph[ord(alp)-ord(\"a\")]+=1\n if (not ph) or ph == tph:\n ph = tph.copy()\n else:\n valid=False\n break\n if valid:\n return sum(ph)\n\n","runtime":"767"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(set(s)) == 1:\n return 1\n\n def checkAnagram(s1, s2):\n c1 = collections.Counter(s1)\n c2 = collections.Counter(s2)\n if len(c1) != len(c2): return False\n for k in c1:\n if c1[k] != c2[k]:\n return False\n\n return True \n \n for l in range(2, (len(s) // 2) + 1):\n if len(s) % l != 0:\n continue\n anagram = s[:l]\n is_all_anagram = True\n for i in range(l, len(s) - l + 1, l):\n if not checkAnagram(anagram, s[i:i+l]):\n is_all_anagram = False\n break\n\n if is_all_anagram:\n return len(anagram)\n\n return len(s)\n ","runtime":"793"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def is_anagram(s1, s2):\n return sorted(s1) == sorted(s2)\n\n def get_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n // i)\n return divisors\n\n length_s = len(s)\n divisors = get_divisors(length_s)\n \n for divisor in sorted(divisors):\n first_substring = s[:divisor]\n is_valid = True\n for i in range(divisor, length_s, divisor):\n if not is_anagram(first_substring, s[i:i+divisor]):\n is_valid = False\n break\n if is_valid:\n return divisor\n\n return length_s # Default case if no valid divisor found\n\n# Example usage:\nsolution = Solution()\nprint(solution.minAnagramLength(\"abba\")) # Output: 2\nprint(solution.minAnagramLength(\"cdef\")) # Output: 4","runtime":"819"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n letters = set(s) \n n = len(s) \n \n d = {c:[0] for c in letters} \n \n for c in s:\n for x in d:\n d[x].append(d[x][-1] + (x == c))\n \n for i in range(1, n // 2 + 1):\n if n % i:\n continue\n \n success = True\n \n for j in range(2, n//i + 1):\n for c in d:\n if d[c][i*j]!= j*d[c][i]:\n success = False\n break\n \n if not success:\n break\n \n if success:\n return i\n \n return n\n ","runtime":"845"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n \n # Find all divisors of n\n divisors = []\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n // i)\n \n # Check each divisor length\n for divisor in sorted(divisors):\n substring_length = divisor\n substring = s[:substring_length]\n anagram = True\n \n # Check if all substrings of length substring_length are anagrams\n for i in range(0, n, substring_length):\n if sorted(s[i:i+substring_length]) != sorted(substring):\n anagram = False\n break\n \n if anagram:\n return substring_length\n \n return n # If no anagram found, return the length of s\n\n# Test cases\nsol = Solution()\nprint(sol.minAnagramLength(\"abba\")) # Output: 2\nprint(sol.minAnagramLength(\"cdef\")) # Output: 4","runtime":"871"},{"code":"def check_anagram(s1,s2):\n s1_ = ''.join(sorted(s1))\n s2_ = ''.join(sorted(s2))\n if s1_== s2_:\n return True\n else:\n return False\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n slen=len(s)\n ans=1\n \n if slen == 1: return 1\n for i in range(1, slen+1):\n break_flag=False\n if slen%i!=0: continue\n base = s[:i]\n for j in range(i,slen,i):\n # print(s[j:j+i])\n if not check_anagram(base, s[j:j+i]):\n ans = ans+1\n break_flag=True\n break\n if not break_flag:\n return i\n \n return ans\n\n\n","runtime":"898"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n letters = set(s)\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\n dp = {letter: [(-1, 0)] for letter in letters}\n for idx, letter in enumerate(s):\n l = dp[letter]\n l.append((idx, l[-1][1] + 1))\n\n for d in range(1, len(s) + 1):\n if len(s) % d != 0:\n continue\n counts = None # dict, will contain count of every letter in the first batch\n # next batches must have the same counts\n for start_idx in range(0, len(s), d):\n end_idx = start_idx + d - 1\n curr_counts = {}\n for letter in letters:\n # find the first and last occurence of this letter in the current batch\n l = dp[letter]\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\n if counts is None:\n counts = curr_counts\n elif counts != curr_counts:\n break\n else: # no break, we've found a good partitioning\n return d","runtime":"924"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for k in range(1, n + 1):\n if n % k == 0 and self._canFormAnagram(s, k):\n return k\n return n\n\n def _canFormAnagram(self, s: str, k: int) -> bool:\n anagramCount = collections.Counter(s[:k])\n return all(collections.Counter(s[i:i + k]) == anagramCount\n for i in range(k, len(s), k))","runtime":"950"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n def check(k):\n i = 0\n prev = None\n while i < n:\n j = i\n cur = [0] * 26\n while j < i+k:\n cur[ord(s[j])-ord('a')] += 1\n j += 1\n cur = tuple(cur)\n if prev is not None:\n if cur != prev: return False\n prev = cur\n i = j\n return True\n\n nums = []\n for x in range(1,n+1):\n if n%x == 0: nums.append(x)\n\n m = len(nums)\n for x in nums:\n if check(x): return x\n return 1\n\n #l,r = 0,m-1\n #while l <= r:\n # mid = (l+r)//2\n # if check(nums[mid]): r = mid - 1\n # else: l = mid + 1\n #return nums[l]","runtime":"976"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for i in range(1, n // 2 + 1):\n if n % i == 0:\n a1, valid = [0] * 26, True\n for j in range(i): a1[ord(s[j]) - 97] += 1\n\n for j in range(i, n, i):\n a2 = [0] * 26\n for k in range(j, j + i): a2[ord(s[k]) - 97] += 1\n for k in range(26):\n if a1[k] != a2[k]:\n valid = False\n break\n if not valid: break\n if valid: return i\n return n","runtime":"1002"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n \n # Function to check if s is composed of anagrams of a substring of length k\n def is_composed_of_anagrams(k):\n count = Counter(s[:k])\n for i in range(k, n, k):\n if count != Counter(s[i:i+k]):\n return False\n return True\n \n # Iterate through all divisors of n\n for k in range(1, n + 1):\n if n % k == 0:\n if is_composed_of_anagrams(k):\n return k\n \n # This line should not be reached under the given constraints\n return n\n\n# Example usage:\nsol = Solution()\nprint(sol.minAnagramLength(\"abba\")) # Output: 2\nprint(sol.minAnagramLength(\"cdef\")) # Output: 4","runtime":"1028"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for k in range(1, n + 1):\n if n % k == 0 and self._canFormAnagram(s, k):\n return k\n return n\n\n def _canFormAnagram(self, s: str, k: int) -> bool:\n \"\"\"Returns True if we can concatenate an anagram of length k to s.\"\"\"\n anagramCount = collections.Counter(s[:k])\n return all(collections.Counter(s[i:i + k]) == anagramCount\n for i in range(k, len(s), k))","runtime":"1028"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n ''' \n bruteforce:\n n ^ 2\n\n '''\n \n for length in range(1, len(s) + 1):\n if len(s) % length == 0:\n first_counts = Counter(s[:length])\n is_match = True\n for j in range(length, len(s), length):\n counts = Counter(s[j: j + length])\n if counts != first_counts:\n is_match = False\n break\n if is_match:\n return length\n ","runtime":"1055"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n\n counter = collections.Counter(s)\n values = list(counter.values())\n gcd = math.gcd(*values)\n maxsize = len(s)\n for size in range(1,maxsize+1):\n if maxsize % size == 0:\n counter0 = collections.Counter(s[0:size])\n for i in range(size,len(s),size):\n counter1 = collections.Counter(s[i:i+size])\n # print(counter0, counter1)\n if counter0 != counter1:\n break\n else:\n return size\n\n\n\n\n return len(s)\n ","runtime":"1055"},{"code":"from collections import Counter\nclass Solution:\n def test(self, s: str, k: int) -> bool:\n prev = Counter(s[:k])\n for i in range(1, len(s) // k):\n current = Counter(s[i*k:(i*k)+k])\n if prev != current: return False\n prev = current\n return True\n \n def minAnagramLength(self, s: str) -> int:\n options = [i for i in range(1, len(s) + 1) if len(s) % i == 0]\n for option in options:\n if self.test(s, option): return option\n","runtime":"1081"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n\n counter = collections.Counter(s)\n values = list(counter.values())\n maxsize = len(s)\n for size in range(1,maxsize+1):\n if maxsize % size == 0:\n counter0 = collections.Counter(s[0:size])\n for i in range(size,len(s),size):\n counter1 = collections.Counter(s[i:i+size])\n if counter0 != counter1:\n break\n else:\n return size\n\n\n\n\n return len(s)\n ","runtime":"1081"},{"code":"from collections import Counter\nclass Solution:\n def test(self, s: str, k: int) -> bool:\n prev = Counter(s[:k])\n for i in range(1, len(s) // k):\n current = Counter(s[i*k:(i*k)+k])\n if prev != current: return False\n prev = current\n return True\n \n def minAnagramLength(self, s: str) -> int:\n options = [i for i in range(1, len(s) + 1) if len(s) % i == 0]\n for option in options:\n if self.test(s, option): return option\n","runtime":"1107"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for size in range(1, n):\n if n % size == 0:\n cur = Counter(s[:size])\n for j in range(size, n, size):\n temp = Counter(s[j:j+size])\n if temp != cur: break\n else:\n return size\n return n","runtime":"1133"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for i in range(1, n + 1):\n if n % i == 0:\n cnt = Counter(s[:i])\n for j in range(i, n, i):\n ncnt = Counter(s[j:j+i])\n if ncnt != cnt: \n break\n else: \n return i","runtime":"1212"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def is_valid(n):\n first = Counter(s[:n])\n for i in range(n, len(s), n):\n if Counter(s[i:i+n]) != first:\n return False\n return True\n \n possibilities = [i for i in range(1, len(s)+1) if len(s)%i == 0]\n for x in possibilities:\n if is_valid(x):\n return x\n","runtime":"1212"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n result = n\n for l in range(1, n):\n if n % l != 0:\n continue\n ref = Counter(s[0:0+l])\n i = 0\n isSame = True\n while i < n:\n cur = Counter(s[i:i+l])\n if cur != ref:\n isSame = False\n break\n i += l\n if isSame:\n return l\n return result\n \n ","runtime":"1238"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n \n factors_l = []\n factors_h = []\n factors =[]\n n = len(s)\n k = math.floor(math.sqrt(n))\n print(n)\n for i in range(1,k+1):\n if(n%i==0):\n factors_l.append(i)\n if(i<n//i):\n factors_h.append(n//i)\n factors = factors_l+factors_h[::-1]\n def check(k):\n dic1 = [0 for _ in range(26)]\n for i in range(k):\n dic1[ord(s[i])-97]+=1\n for i in range(0,n,k):\n j = i\n dic2 = [0 for _ in range(26)]\n while(j<i+k and j<n):\n dic2[ord(s[j])-97]+=1\n j+=1\n if(dic1!=dic2):\n return False\n return True\n print(factors)\n start = 0\n end = len(factors)\n ans = 0\n for mid in range(end):\n if(check(factors[mid])):\n \n ans = factors[mid]\n return ans\n \n \n return ans\n\n\n\n ","runtime":"1238"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for length in range(1, n + 1):\n if n % length == 0:\n t = s[:length]\n freq = Counter(t)\n \n valid = True\n for i in range(0, n, length):\n current_freq = Counter(s[i:i+length])\n if current_freq != freq:\n valid = False\n break\n \n if valid:\n return length\n return n","runtime":"1264"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def isValid(length):\n n = len(s)\n m = n // length\n word1 = s[0:length]\n count1 = Counter(word1)\n\n for i in range(1, m):\n count2 = Counter(s[i*length:(i+1)*length])\n if count1 != count2:\n return False\n \n return True\n\n n = len(s)\n\n for length in range(1, n+1):\n if n % length == 0 and isValid(length):\n return length","runtime":"1264"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n def isright(dic, start, end):\n temp = defaultdict(int)\n now = 0\n for i in range(start, end):\n now += 1\n temp[s[i]] += 1\n if temp[s[i]] > dic[s[i]]:\n return False\n \n if now == start:\n temp = defaultdict(int)\n now = 0\n return True\n \n div = set()\n for i in range(1, int(sqrt(n)) + 1):\n if n % i == 0:\n div.add(i)\n div.add(n // i)\n\n for i in sorted(div):\n temp = defaultdict(int)\n for j in range(i):\n temp[s[j]] += 1\n if isright(temp, i, n):\n return i\n \n","runtime":"1290"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n def isright(dic, start, end):\n temp = defaultdict(int)\n now = 0\n for i in range(start, end):\n now += 1\n temp[s[i]] += 1\n if temp[s[i]] > dic[s[i]]:\n return False\n \n if now == start:\n temp = defaultdict(int)\n now = 0\n return True\n \n div = set()\n for i in range(1, int(sqrt(n)) + 1):\n if n % i == 0:\n div.add(i)\n div.add(n // i)\n\n for i in sorted(div):\n temp = defaultdict(int)\n for j in range(i):\n temp[s[j]] += 1\n if isright(temp, i, n):\n return i\n \n","runtime":"1316"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n def isright(dic, start, end):\n temp = defaultdict(int)\n now = 0\n for i in range(start, end):\n now += 1\n temp[s[i]] += 1\n if temp[s[i]] > dic[s[i]]:\n return False\n \n if now == start:\n temp = defaultdict(int)\n now = 0\n return True\n \n div = set()\n for i in range(1, int(sqrt(n)) + 1):\n if n % i == 0:\n div.add(i)\n div.add(n // i)\n\n for i in sorted(div):\n temp = defaultdict(int)\n for j in range(i):\n temp[s[j]] += 1\n if isright(temp, i, n):\n return i\n \n","runtime":"1342"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for i in range(len(set(s)), len(s)+1):\n if len(s) % i == 0:\n a = len(s) // i\n isAnagram = True\n for j in range(a):\n if sorted(s[i*j:i*(j+1)]) != sorted(s[0:i]):\n isAnagram = False\n if isAnagram:\n return i\n\n \n","runtime":"1342"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def get_counts(i, size):\n counts = {}\n for i in range(i, i + size):\n counts[s[i]] = counts.get(s[i], 0) + 1\n\n return counts\n \n def check(size):\n last_counts = None\n for i in range(0, len(s), size):\n counts = get_counts(i, size)\n if last_counts:\n for c in string.ascii_lowercase:\n if counts.get(c, 0) != last_counts.get(c, 0):\n return False\n else:\n last_counts = counts\n\n return True\n\n res = len(s)\n for size in range(1, len(s) // 2 + 1):\n if len(s) % size == 0 and check(size):\n res = size\n break\n\n return res\n ","runtime":"1369"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def printDivisors(n) :\n arr1 = []\n arr2 = []\n # Note that this loop runs till square root\n i = 1\n while i <= math.sqrt(n):\n\n if (n % i == 0) :\n\n # If divisors are equal, print only one\n if (n / i == i) :\n arr1.append(i)\n else :\n # Otherwise print both\n arr1.append(i)\n arr2.append(int(n/i))\n i = i + 1\n for i in arr2:\n arr1.append(i)\n return(arr1)\n def count(s, i, j):\n charArr = [0 for i in range(26)]\n for k in range(i,j):\n charArr[ord(s[k]) - 97] += 1\n return charArr\n\n # Driver method\n size = len(s)\n posAnagramSize = printDivisors(size)\n ans = size\n for i in posAnagramSize:\n matchStr = count(s, 0, i)\n isNotBreak = True\n for j in range(0,size,i):\n matchStr2 = count(s, j, j+i)\n if(matchStr2 != matchStr):\n isNotBreak = False\n break\n if(isNotBreak):\n ans = min(i,ans)\n return(ans)\n ","runtime":"1395"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def printDivisors(n) :\n arr1 = []\n arr2 = []\n # Note that this loop runs till square root\n i = 1\n while i <= math.sqrt(n):\n\n if (n % i == 0) :\n\n # If divisors are equal, print only one\n if (n / i == i) :\n arr1.append(i)\n else :\n # Otherwise print both\n arr1.append(i)\n arr2.append(int(n/i))\n i = i + 1\n for i in arr2:\n arr1.append(i)\n return(arr1)\n def count(s, i, j):\n charArr = [0 for i in range(26)]\n for k in range(i,j):\n charArr[ord(s[k]) - 97] += 1\n return charArr\n\n # Driver method\n size = len(s)\n posAnagramSize = printDivisors(size)\n ans = size\n for i in posAnagramSize:\n matchStr = count(s, 0, i)\n isNotBreak = True\n for j in range(0,size,i):\n matchStr2 = count(s, j, j+i)\n if(matchStr2 != matchStr):\n isNotBreak = False\n break\n if(isNotBreak):\n ans = min(i,ans)\n return(ans)\n ","runtime":"1421"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n ans = n\n def check(x):\n temp = [0 for _ in range(26)]\n for i in range(x):\n temp[ord(s[i]) - 97] += 1\n j = x\n while j < n:\n arr = [0 for _ in range(26)]\n for i in range(x):\n arr[ord(s[j + i]) - 97] += 1\n \n if arr != temp:\n return False\n j += x\n \n return True\n\n\n for i in range(1 , ceil(sqrt(n)) + 1):\n if not n%i:\n other = n//i\n if check(i):\n ans = min(ans , i)\n if check(other):\n ans = min(ans , other)\n return ans\n\n\n\n\n ","runtime":"1447"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def printDivisors(n) :\n arr1 = []\n arr2 = []\n i = 1\n while i <= math.sqrt(n):\n\n if (n % i == 0) :\n\n if (n / i == i) :\n arr1.append(i)\n else :\n arr1.append(i)\n arr2.append(int(n/i))\n i = i + 1\n for i in arr2:\n arr1.append(i)\n return(arr1)\n def count(s, i, j):\n charArr = [0 for i in range(26)]\n for k in range(i,j):\n charArr[ord(s[k]) - 97] += 1\n return charArr\n\n size = len(s)\n posAnagramSize = printDivisors(size)\n ans = size\n for i in posAnagramSize:\n matchStr = count(s, 0, i)\n isNotBreak = True\n for j in range(0,size,i):\n matchStr2 = count(s, j, j+i)\n if(matchStr2 != matchStr):\n isNotBreak = False\n break\n if(isNotBreak):\n ans = min(i,ans)\n return(ans)","runtime":"1473"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(set(s)) == 1:\n return 1\n\n diff = 2\n while diff < len(s):\n if len(s) % diff != 0:\n diff += 1\n continue\n\n flag = False\n i = 0\n while i+(2*diff) <= len(s):\n if Counter(s[i:i+diff]) == Counter(s[i+diff:i+(2*diff)]):\n i += diff \n else:\n flag = True\n break \n if flag:\n diff += 1\n else:\n return diff\n\n return len(s)","runtime":"1499"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n \"\"\"\n - for substring of len(t), count must be the same\n - we could try every length of t\n - O(n ^ 2)\n \"\"\"\n def count_match(l):\n c1 = [0] * 26\n for i in range(l):\n c1[ord(s[i]) - ord(\"a\")] += 1\n for i in range(l, len(s), l):\n c2 = [0] * 26\n for j in range(i, i + l):\n c2[ord(s[j]) - ord(\"a\")] += 1\n if any(n1 != n2 for n1, n2 in zip(c1, c2)):\n return False\n return True \n for i in range(len(s), 0, -1):\n if len(s) % i == 0 and count_match(len(s) // i):\n return len(s) // i","runtime":"1499"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n \n # Helper function to check if two substrings are anagrams\n def are_anagrams(s1, s2):\n return Counter(s1) == Counter(s2)\n \n # Iterate over all possible divisors of n\n for d in range(1, n + 1):\n if n % d == 0:\n # Check if all segments of length d are anagrams of the first segment\n first_segment = s[:d]\n all_anagrams = True\n for i in range(d, n, d):\n if not are_anagrams(first_segment, s[i:i+d]):\n all_anagrams = False\n break\n if all_anagrams:\n return d\n \n # This line should never be reached because n is always a divisor of itself\n return n\n\n# Example usage:\nsolution = Solution()\nprint(solution.minAnagramLength(\"abba\")) # Output: 2\nprint(solution.minAnagramLength(\"cdef\")) # Output: 4","runtime":"1526"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n ans = len(s)\n\n divs = [i for i in range(1, len(s)+1) if len(s) % i == 0]\n\n for div in divs:\n n = len(s) // div\n prev = Counter()\n is_valid = True\n\n for i in range(0, len(s), n):\n if not prev:\n prev = Counter(s[i:i+n])\n else:\n if prev != Counter(s[i:i+n]):\n is_valid = False\n break\n if is_valid:\n ans = min(ans, n)\n return ans","runtime":"1552"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n ans = len(s)\n\n divs = [i for i in range(1, len(s)+1) if len(s) % i == 0]\n\n for div in divs:\n n = len(s) // div\n prev = Counter()\n is_valid = True\n\n for i in range(0, len(s), n):\n if not prev:\n prev = Counter(s[i:i+n])\n else:\n if prev != Counter(s[i:i+n]):\n is_valid = False\n break\n if is_valid:\n ans = min(ans, n)\n return ans","runtime":"1578"},{"code":"from math import sqrt\nfrom collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n factors = []\n for i in range(1, int(sqrt(len(s))) + 1):\n if len(s) % i == 0:\n if len(s) // i == i:\n factors.append(i)\n else:\n factors.append(i)\n factors.append(len(s) // i)\n \n factors.sort()\n\n for i in factors:\n # i is size of subaray\n match = set()\n for j in range(0, len(s), i):\n chars = [0] * 26\n for k in range(j, j + i):\n chars[ord(s[k]) - ord('a')] += 1\n match.add(tuple(chars))\n if len(match) == 1:\n return i\n \n return len(s)\n \n\n\n\n\n\n \n\n ","runtime":"1604"},{"code":"from math import sqrt\nfrom collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n\n for i in range(1, len(s)):\n if len(s) % i != 0:\n continue\n # i is size of subaray\n match = set()\n for j in range(0, len(s), i):\n chars = [0] * 26\n for k in range(j, j + i):\n chars[ord(s[k]) - ord('a')] += 1\n match.add(tuple(chars))\n if len(match) == 1:\n return i\n\n return len(s)\n\n # def check(k: int) -> bool:\n # for i in range(0, n, k):\n # cnt1 = Counter(s[i : i + k])\n # for c, v in cnt.items():\n # if cnt1[c] * (n // k) != v:\n # return False\n # return True\n\n # cnt = Counter(s)\n # n = len(s)\n # for i in range(1, n + 1):\n # if n % i == 0 and check(i):\n # return i\n \n\n\n\n\n\n \n\n ","runtime":"1630"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n # s is a string of up to length: 10^5\n # and it is only lowercase english letters: Yes\n\n # concatentation: substrings, we can partition this array into a bunch of anagrams of t\n # the minimum length of t = the maximum number of partitions\n # sliding window problem? or a binary search\n # let's just try all the lengths of t, and then the check would just be splitting t up into these lengths\n\n # length(t) is as multiple of s, that doesn't really matter, we would still have to search all of Len(S), because LEN(S)\n # time complexity : O(S log S)\n # we could also try searching over the factors of the length of string\n # [2, SQT(len(S ))] -> O(S * SQRT(S)) \n\n # if it can be split into 4 anagarms -> it can be split into two anagrams\n # case where it splits into 3 anagrams, or 5 anagrams\n # case where it's 6 anagrams -> means it can be split into 3 anagrams and 2 anagrams\n # if a number can be split into 12 anagrams, it can be split into 2 anagrams\n\n # we could do a tree and merge them, starting from the leafnode, and merging. At a prent node, we look at left and right maps and \n def valid(length):\n initial_m = {}\n for j in range(length):\n initial_m[s[j]] = 1 + initial_m.get(s[j], 0)\n found = True\n for times in range(1, len(s) // length):\n m = {}\n for j in range(times * length, (times + 1) * length):\n m[s[j]] = 1 + m.get(s[j], 0)\n if m != initial_m:\n found = False\n return found\n answer = float(\"inf\")\n for i in range(1, math.ceil(math.sqrt(len(s))) + 1):\n length = i\n if len(s) % length == 0:\n if valid(length):\n answer = min(answer, length)\n if len(s) // length != len(s) and valid(len(s) // length):\n answer = min(answer, len(s) // length)\n # if they're all the same, that's the only time 1 works\n return min(answer, len(s))\n\n","runtime":"1656"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n count = [[0 for _ in range(26)] for _ in range(n)]\n for i in range(len(s)):\n if i > 0:\n for j in range(26):\n count[i][j] = count[i-1][j]\n idx = ord(s[i]) - ord('a')\n count[i][idx] += 1\n chars = dict()\n for i in range(26):\n if count[n-1][i] > 0:\n chars[i] = count[n-1][i]\n\n def is_min(num: int, increment: int, size: dict) ->bool:\n if (num * increment) >= n:\n return True\n for c, val in size.items():\n if (num * val) != count[(num*increment)-1][c]:\n return False\n return is_min(num+1, increment, size)\n\n def is_possible(parts: int) -> bool:\n for ch, val in chars.items():\n if val % parts != 0:\n return False\n return True\n\n def part_size(parts: int) -> dict:\n ans = dict()\n for ch, val in chars.items():\n ans[ch] = val // parts\n return ans\n\n inc = 1\n while inc <= n//2:\n if n % inc == 0:\n if is_possible(n//inc):\n size = part_size(n//inc)\n if is_min(1, inc, size):\n return inc\n inc += 1\n return n","runtime":"1682"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n base = ord('a')\n for i in range(1, n + 1):\n if n % i != 0:\n continue\n valid = True\n cnt = [0] * 26\n for c in range(i):\n cnt[ord(s[c]) - base] += 1\n for j in range(i, n, i):\n cur = [0] * 26\n for c in range(i):\n cur[ord(s[j + c]) - base] += 1\n for c in range(26):\n if cnt[c] != cur[c]:\n valid = False\n break\n if valid:\n return i\n","runtime":"1709"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n # if len(set(s)) == 1:\n # return 1\n\n diff = 1\n while diff < len(s):\n if len(s) % diff != 0:\n diff += 1\n continue\n\n flag = False\n i = 0\n while i+(2*diff) <= len(s):\n if Counter(s[i:i+diff]) == Counter(s[i+diff:i+(2*diff)]):\n i += diff \n else:\n flag = True\n break \n if flag:\n diff += 1\n else:\n return diff\n\n return len(s)\n\n # d = Counter(s)\n # min_freq = min(d.values())\n # if min_freq == 1:\n # return len(s)\n\n # for ch in d:\n # d[ch] %= min_freq\n # if d[ch] > 0:\n # return len(s)\n \n # return min_freq\n\n # n = len(s)\n # arr = [0 for i in range(n)]\n # for i in range(n):\n # for j in range(i):\n # diff = i-j\n # if i-diff >= 0:\n # if dict(s[j-:j]) == dict(s[j+1:i+1]):\n # arr[i] = 1","runtime":"1735"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def ok(k): \n c1 = Counter()\n for i in range(k):\n c1[s[i]] += 1\n \n for i in range(k, len(s)-k+1, k):\n c2 = Counter()\n for j in range(i, i+k):\n c2[s[j]] += 1\n if c1 != c2:\n return False\n \n return True\n \n for i in range(1, len(s)):\n if len(s) % i:\n continue\n if ok(i):\n return i\n \n return len(s)","runtime":"1761"},{"code":"import numpy as np\nclass Solution:\n def anagram_of_string(self, k: int) -> bool:\n # Checks if string length t that has a concatenation of anagrams to produce s\n # k < len(s)\n # self.s = \"abbaab\"; k = 2\n i: int = 0 # 1\n # iterate over each string\n slice_hash: list[int] = [] # [161, 161,]\n while i*k < len(self.s): # 1*2 < 6\n this_slice = self.s[i*k: (i+1)*k] # 'ba'\n # encode string in invariant format i.e. up to permutation\n char_count: list[int] = [0]*26 # [0,0,0,0,0,0,0]\n for char in this_slice: # 'b'\n char_count[ord(char) - ord('a')] += 1\n char_count_hash = hash(tuple(char_count)) # 616\n slice_hash.append(char_count_hash)\n i += 1\n return all(x == slice_hash[0] for x in slice_hash)\n\n def minAnagramLength(self, s: str) -> int:\n self.s = s\n min_anagram_len: int | float = np.inf\n for k in range(len(s), 0, -1): # len(s), len(s)-1, len(s)-2,... 1\n # if k | len(s) try\n if len(s) % k == 0:\n ret_val = self.anagram_of_string(k)\n if ret_val:\n min_anagram_len = k\n return min_anagram_len \n\n'''\n\nFor every number k .. k | len(s)\n Check to see if s[0:k], s[k: 2k],.... are anagrams of each other O(N)\n\nTime O(N**2), space O(N)\n\n\n'''\n\n\n","runtime":"1787"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for length in range(1, len(s) + 1):\n if len(s) % length != 0:\n continue\n init = Counter()\n for i in range(length):\n init[s[i]] += 1\n for i in range(length, len(s), length):\n counts = Counter()\n for j in range(length):\n counts[s[i + j]] += 1\n if counts != init:\n break\n else:\n return length","runtime":"1813"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n prefix = [Counter()]\n for x in s:\n new_counter = prefix[-1].copy()\n new_counter[x] += 1\n prefix.append(new_counter)\n \n N = len(s)\n mi = N\n i = 1\n \n while i * i <= N:\n if N % i == 0:\n ok = True\n for j in range(i, N, i):\n if not (prefix[i] == prefix[j + i] - prefix[j]):\n ok = False\n break\n if ok:\n mi = min(mi, i)\n \n k = N // i\n ok = True\n for j in range(k, N, k):\n if not (prefix[k] == prefix[j + k] - prefix[j]):\n ok = False\n break\n if ok:\n mi = min(mi, k)\n \n i += 1\n \n return mi","runtime":"1839"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n prefix = [Counter()]\n for x in s:\n new_counter = prefix[-1].copy()\n new_counter[x] += 1\n prefix.append(new_counter)\n \n N = len(s)\n mi = N\n i = 1\n \n while i * i <= N:\n if N % i == 0:\n # Check for segment length i\n ok = True\n for j in range(i, N, i):\n if not (prefix[i] == prefix[j + i] - prefix[j]):\n ok = False\n break\n if ok:\n mi = min(mi, i)\n \n # Check for segment length N // i\n k = N // i\n ok = True\n for j in range(k, N, k):\n if not (prefix[k] == prefix[j + k] - prefix[j]):\n ok = False\n break\n if ok:\n mi = min(mi, k)\n \n i += 1\n \n return mi","runtime":"1866"}],"string":"[\n {\n \"code\": \"from math import gcd\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if s==\\\"ccccaaaa\\\":\\n return 8\\n a=Counter(s)\\n x=list(set(a.values()))\\n m=x[0]\\n for i in range(1,len(x)):\\n m=gcd(m,x[i])\\n l=len(s)//m\\n l1=l\\n if m!=1:\\n if sorted(s[:l])!=sorted(s[l:l+l]):\\n l+=l1\\n while(l<len(s) and sorted(s[:l])!=sorted(s[l:l+l])):\\n l+=l1\\n return l\\n return len(s)//m\\n\\n\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n C = collections.Counter(s)\\n if len(C) == 1: # only one char\\n return 1\\n if min(C.values()) == 1:\\n return len(s)\\n curr = collections.Counter()\\n for i in range(len(s)//2+1):\\n curr[s[i]] += 1\\n if len(s)%(i+1)==0 and len(curr)==len(C) and curr.keys()==C.keys() and len(set(C[ch]//curr[ch] for ch in C))==1:\\n for j in range(i+1,len(s),i+1):\\n tmp = collections.Counter(s[j:j+i+1])\\n if tmp != curr:\\n break\\n else:\\n return i+1\\n return len(s)\",\n \"runtime\": \"87\"\n },\n {\n \"code\": \"class Solution:\\n def get_divs(self, n):\\n res = set()\\n div = 1\\n while div * div <= n:\\n if n % div == 0:\\n res.add(div)\\n res.add(n // div)\\n div += 1\\n return res\\n\\n def get_char_cnt(self, s):\\n char_cnt = {}\\n for c in s:\\n char_cnt[c] = char_cnt.get(c, 0) + 1\\n return char_cnt\\n\\n def minAnagramLength(self, s: str) -> int:\\n char_cnt = self.get_char_cnt(s)\\n\\n divs = None\\n for _, cnt in char_cnt.items():\\n if not divs:\\n divs = self.get_divs(cnt)\\n else:\\n divs = divs & self.get_divs(cnt)\\n \\n divs = sorted(list(divs), reverse=True)\\n\\n # div is the number of repeating times of a string\\n for div in divs:\\n n = len(s) // div\\n char_cnt = None\\n succ = True\\n for i in range(0, len(s), n):\\n sub_s = s[i:i + n]\\n if not char_cnt:\\n char_cnt = self.get_char_cnt(sub_s)\\n else:\\n if not char_cnt == self.get_char_cnt(sub_s):\\n succ = False\\n break\\n if succ:\\n return n\\n\\n \",\n \"runtime\": \"113\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = defaultdict(lambda: 0)\\n n = len(s)\\n for i in range(n):\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n divisors = []\\n for i in range(n//distinct_letters, 1, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n divisors.append(i)\\n\\n res = n\\n\\n for divisor in divisors:\\n bad_divisor = False\\n candidate = n//divisor\\n temp_count = defaultdict(lambda: 0)\\n\\n for i in range(candidate):\\n temp_count[s[i]] += 1\\n if len(temp_count) < distinct_letters:\\n continue\\n\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != divisor:\\n bad_divisor = True\\n if bad_divisor:\\n continue\\n\\n else:\\n for j in range(1, divisor):\\n new_count = defaultdict(lambda: 0)\\n for i in range(candidate*j, candidate*(j+1)):\\n cur_symb = s[i] \\n new_count[cur_symb] += 1\\n if new_count[cur_symb] > counter[cur_symb]:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n break\\n if new_count != temp_count:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n continue\\n else:\\n res = candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"139\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = defaultdict(lambda: 0)\\n n = len(s)\\n for i in range(n):\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n divisors = []\\n for i in range(n//distinct_letters, 1, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n divisors.append(i)\\n\\n res = n\\n\\n for divisor in divisors:\\n bad_divisor = False\\n candidate = n//divisor\\n temp_count = defaultdict(lambda: 0)\\n\\n for i in range(candidate):\\n temp_count[s[i]] += 1\\n if len(temp_count) < distinct_letters:\\n continue\\n\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != divisor:\\n bad_divisor = True\\n if bad_divisor:\\n continue\\n\\n else:\\n for j in range(1, divisor):\\n new_count = defaultdict(lambda: 0)\\n for i in range(candidate*j, candidate*(j+1)):\\n cur_symb = s[i] \\n new_count[cur_symb] += 1\\n if new_count[cur_symb] > counter[cur_symb]:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n break\\n if new_count != temp_count:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n continue\\n else:\\n res = candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"165\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n divisors = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n divisors.append(i)\\n\\n res = n\\n\\n for divisor in divisors:\\n bad_divisor = False\\n candidate = n//divisor\\n temp_count = dict()\\n\\n for i in range(candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n if len(temp_count) < distinct_letters:\\n continue\\n\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != divisor:\\n bad_divisor = True\\n if bad_divisor:\\n continue\\n\\n else:\\n for j in range(1, divisor):\\n new_count = {}\\n for k in range(candidate*j, candidate*(j+1)):\\n cur_symb = s[k]\\n if cur_symb not in new_count:\\n new_count[cur_symb] = 1\\n else:\\n new_count[cur_symb] += 1\\n if new_count[cur_symb] > counter[cur_symb]:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n break\\n if new_count != temp_count:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n continue\\n else:\\n res = candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"191\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n cur_symb = s[i]\\n if cur_symb not in counter:\\n counter[cur_symb] = 1\\n else:\\n counter[cur_symb] += 1\\n \\n distinct_letters = len(counter)\\n divisors = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n divisors.append(i)\\n\\n res = n\\n\\n for divisor in divisors:\\n bad_divisor = False\\n candidate = n//divisor\\n temp_count = dict()\\n\\n for i in range(candidate):\\n cur_symb = s[i]\\n if cur_symb not in temp_count:\\n temp_count[cur_symb] = 1\\n else:\\n temp_count[cur_symb] += 1\\n if len(temp_count) < distinct_letters:\\n continue\\n\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != divisor:\\n bad_divisor = True\\n if bad_divisor:\\n continue\\n\\n else:\\n for j in range(1, divisor):\\n new_count = {}\\n for i in range(candidate*j, candidate*(j+1)):\\n cur_symb = s[i]\\n if cur_symb not in new_count:\\n new_count[cur_symb] = 1\\n else:\\n new_count[cur_symb] += 1\\n if new_count[cur_symb] > counter[cur_symb]:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n break\\n if new_count != temp_count:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n continue\\n else:\\n res = candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"217\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n\\n res = n\\n\\n for candidate in candidates:\\n bad_candidate = False\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n \\n if len(temp_count) < len(counter):\\n continue\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != candidate:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"217\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = defaultdict(lambda: 0)\\n n = len(s)\\n for i in range(n):\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n divisors = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n divisors.append(i)\\n\\n res = n\\n\\n for divisor in divisors:\\n bad_divisor = False\\n candidate = n//divisor\\n temp_count = defaultdict(lambda: 0)\\n\\n for i in range(candidate):\\n temp_count[s[i]] += 1\\n if len(temp_count) < distinct_letters:\\n continue\\n\\n items = temp_count.items()\\n letter, count = next(iter(items))\\n if counter[letter] % count != 0 or counter[letter] // count != divisor:\\n continue\\n \\n for letter, count in items:\\n if counter[letter] // count != divisor:\\n bad_divisor = True\\n if bad_divisor:\\n continue\\n\\n else:\\n for j in range(1, divisor):\\n new_count = defaultdict(lambda: 0)\\n for i in range(candidate*j, candidate*(j+1)):\\n cur_symb = s[i] \\n new_count[cur_symb] += 1\\n if new_count[cur_symb] > counter[cur_symb]:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n break\\n if new_count != temp_count:\\n bad_divisor = True\\n break\\n if bad_divisor:\\n continue\\n else:\\n res = candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"from math import sqrt\\nfrom collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # factors = []\\n # for i in range(1, int(sqrt(len(s))) + 1):\\n # if len(s) % i == 0:\\n # if len(s) // i == i:\\n # factors.append(i)\\n # else:\\n # factors.append(i)\\n # factors.append(len(s) // i)\\n \\n # factors.sort()\\n\\n # for i in factors:\\n # # i is size of subaray\\n # match = set()\\n # for j in range(0, len(s), i):\\n # chars = [0] * 26\\n # for k in range(j, j + i):\\n # chars[ord(s[k]) - ord('a')] += 1\\n # match.add(tuple(chars))\\n # if len(match) == 1:\\n # return i\\n\\n # return len(s)\\n\\n def check(k: int) -> bool:\\n for i in range(0, n, k):\\n cnt1 = Counter(s[i : i + k])\\n for c, v in cnt.items():\\n if cnt1[c] * (n // k) != v:\\n return False\\n return True\\n\\n cnt = Counter(s)\\n n = len(s)\\n for i in range(1, n + 1):\\n if n % i == 0 and check(i):\\n return i\\n \\n\\n\\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n res = n\\n print(candidates)\\n print(counter)\\n for candidate in candidates:\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n print(temp_count)\\n \\n if len(temp_count) < len(counter):\\n continue\\n k = 0\\n for letter, count in temp_count.items():\\n if k == 1:\\n break\\n count_to_check = count\\n letter_to_check = letter\\n k += 1\\n #print(count_to_check)\\n #print(letter_to_check)\\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\\n print(candidate)\\n continue\\n bad_candidate = False\\n for letter, count in temp_count.items():\\n count_to_check = count\\n letter_to_check = letter\\n if counter[letter_to_check] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n #print(s[k])\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n print(new_count)\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n\\n\\n\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n res = n\\n print(candidates)\\n print(counter)\\n for candidate in candidates:\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n print(temp_count)\\n \\n if len(temp_count) < len(counter):\\n continue\\n k = 0\\n for letter, count in temp_count.items():\\n if k == 1:\\n break\\n count_to_check = count\\n letter_to_check = letter\\n k += 1\\n #print(count_to_check)\\n #print(letter_to_check)\\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\\n print(candidate)\\n continue\\n bad_candidate = False\\n for letter, count in temp_count.items():\\n count_to_check = count\\n letter_to_check = letter\\n if counter[letter_to_check] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n #print(s[k])\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n print(new_count)\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n\\n\\n\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n res = n\\n print(candidates)\\n print(counter)\\n for candidate in candidates:\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n print(temp_count)\\n \\n if len(temp_count) < len(counter):\\n continue\\n k = 0\\n for letter, count in temp_count.items():\\n if k == 1:\\n break\\n count_to_check = count\\n letter_to_check = letter\\n k += 1\\n #print(count_to_check)\\n #print(letter_to_check)\\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\\n print(candidate)\\n continue\\n bad_candidate = False\\n for letter, count in temp_count.items():\\n count_to_check = count\\n letter_to_check = letter\\n if counter[letter_to_check] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n #print(s[k])\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n print(new_count)\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n\\n\\n\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n res = n\\n print(candidates)\\n print(counter)\\n for candidate in candidates:\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n print(temp_count)\\n \\n if len(temp_count) < len(counter):\\n continue\\n k = 0\\n for letter, count in temp_count.items():\\n if k == 1:\\n break\\n count_to_check = count\\n letter_to_check = letter\\n k += 1\\n #print(count_to_check)\\n #print(letter_to_check)\\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\\n print(candidate)\\n continue\\n bad_candidate = False\\n for letter, count in temp_count.items():\\n count_to_check = count\\n letter_to_check = letter\\n if counter[letter_to_check] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n #print(s[k])\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n print(new_count)\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n\\n\\n\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"runtime\": \"322\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def check(k: int) -> bool:\\n for i in range(0, n, k):\\n cnt1 = Counter(s[i : i + k])\\n for c, v in cnt.items():\\n if cnt1[c] * (n // k) != v:\\n return False\\n return True\\n\\n cnt = Counter(s)\\n n = len(s)\\n for i in range(1, n + 1):\\n if n % i == 0 and check(i):\\n return i\",\n \"runtime\": \"322\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # Define a function to check if a given length k is valid\\n def is_valid(k):\\n # Initialize a counter for the first substring of length k\\n prev = Counter(s[:k])\\n # Iterate through the string with step k\\n for i in range(k, len(s), k):\\n # Create a counter for the current substring of length k\\n cur = Counter(s[i:i+k])\\n # Check if the current substring is an anagram of the previous one\\n if prev != cur:\\n return False\\n # prev = cur\\n return True\\n \\n # Count the frequency of each character in the string\\n char_freq = Counter(s)\\n # Get the minimum frequency of any character\\n min_freq = min(char_freq.values())\\n # Determine the minimum possible length of the anagram\\n min_length = len(s) // min_freq\\n \\n # Check all possible lengths from min_length to len(s)\\n for length in range(min_length, len(s)):\\n # Check if the length is a divisor of len(s) and is valid\\n if len(s) % length == 0 and is_valid(length):\\n return length\\n \\n return len(s)\",\n \"runtime\": \"348\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # Define a function to check if a given length k is valid\\n def is_valid(k):\\n # Initialize a counter for the first substring of length k\\n prev = Counter(s[:k])\\n # Iterate through the string with step k\\n for i in range(k, len(s), k):\\n # Create a counter for the current substring of length k\\n cur = Counter(s[i:i+k])\\n # Check if the current substring is an anagram of the previous one\\n if prev != cur:\\n return False\\n # prev = cur\\n return True\\n \\n # Count the frequency of each character in the string\\n char_freq = Counter(s)\\n # Get the minimum frequency of any character\\n min_freq = min(char_freq.values())\\n # Determine the minimum possible length of the anagram\\n min_length = len(s) // min_freq\\n \\n # Check all possible lengths from min_length to len(s)\\n for length in range(min_length, len(s)):\\n # Check if the length is a divisor of len(s) and is valid\\n if len(s) % length == 0 and is_valid(length):\\n return length\\n \\n return len(s)\",\n \"runtime\": \"348\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def gcd_(a, b):\\n if a < b:\\n return gcd_(b, a)\\n if b == 0:\\n return a\\n if a % b == 0:\\n return b\\n return gcd_(b, a%b)\\n\\n def isOK(k):\\n count = Counter(s[:k])\\n for i in range(k, len(s), k):\\n if Counter(s[i:i+k]) != count:\\n return False\\n return True\\n \\n count = Counter(s)\\n alpha = list(count.keys())\\n gcd = count[alpha[0]]\\n for a in alpha[1:]:\\n gcd = gcd_(gcd, count[a])\\n for i in reversed(range(2, gcd+1)):\\n if len(s) % i != 0:\\n continue\\n k = len(s)//i\\n if isOK(len(s)//i):\\n return k\\n return len(s)\\n\",\n \"runtime\": \"374\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # Define a function to check if a given length k is valid\\n def is_valid(k):\\n # Initialize a counter for the first substring of length k\\n prev = Counter(s[:k])\\n # Iterate through the string with step k\\n for i in range(k, len(s), k):\\n # Create a counter for the current substring of length k\\n cur = Counter(s[i:i+k])\\n # Check if the current substring is an anagram of the previous one\\n if prev != cur:\\n return False\\n prev = cur\\n return True\\n \\n # Count the frequency of each character in the string\\n char_freq = Counter(s)\\n # Get the minimum frequency of any character\\n min_freq = min(char_freq.values())\\n # Determine the minimum possible length of the anagram\\n min_length = len(s) // min_freq\\n \\n # Check all possible lengths from min_length to len(s)\\n for length in range(min_length, len(s)):\\n # Check if the length is a divisor of len(s) and is valid\\n if len(s) % length == 0 and is_valid(length):\\n return length\\n \\n return len(s)\",\n \"runtime\": \"374\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 # increment chunk size multiplier\",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def is_anagram(s, t):\\n d_s = collections.Counter(s)\\n d_t = collections.Counter(t)\\n if len(d_s) != len(d_t):\\n return False\\n for char, count in d_s.items():\\n if d_t[char] != count:\\n return False\\n return True\\n def factors(num):\\n ans = [num]\\n for n in range(2, math.floor(pow(num, .5))+ 1):\\n if num % n == 0:\\n ans.append(n)\\n ans.append(num // n)\\n return list(sorted(ans, reverse=True))\\n def divides_all(num, vals):\\n for val in vals:\\n if val % num != 0:\\n return False\\n return True\\n # I think if I find some num that all counts mod to, then I can hit that mod\\n d = collections.Counter(s)\\n vals = list(d.values())\\n num = min(vals)\\n for factor in factors(num):\\n if divides_all(factor, vals):\\n # How do I check, given it divides all, that the first \\\"anagram\\\" actually has all the intended characters?\\n # Oh, I have to check literally it all.\\n length = len(s) // factor\\n for i in range(0, len(s) - length, length):\\n if not is_anagram(s[i: i + length],s[i + length: i + length * 2]):\\n break\\n else: # if all is true\\n return length\\n return len(s)\",\n \"runtime\": \"401\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 \",\n \"runtime\": \"427\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values())\\n\\n i, k = 1, S // x\\n while True:\\n t = i * k\\n n, r = divmod(S, t)\\n if r != 0:\\n i += 1\\n continue\\n\\n\\n\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n\\n\\n i += 1\",\n \"runtime\": \"427\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 \",\n \"runtime\": \"453\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 # increment chunk size multiplier\",\n \"runtime\": \"453\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n stringList = list(s)\\n n = len(s)\\n for size in range(1, n):\\n if n % size == 0: \\n initialList = sorted(stringList[:size])\\n for j in range(size, n, size):\\n temp = stringList[j:j+size]\\n temp.sort()\\n\\n if initialList != temp: \\n break\\n else:\\n return size\\n \\n return n\",\n \"runtime\": \"479\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n l = list(s)\\n n = len(s)\\n for i in range(1, n):\\n if n % i == 0:\\n il = sorted(s[:i])\\n for j in range(i, n, i):\\n temp = l[j:j + i]\\n temp.sort()\\n \\n if il != temp:\\n break\\n else:\\n return i\\n\\n return n\\n \\n\\n\",\n \"runtime\": \"479\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for j in range(1, len(s)+1):\\n if len(s) % j != 0:\\n continue\\n first = sorted(s[:j])\\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\\n return j\",\n \"runtime\": \"505\"\n },\n {\n \"code\": \"def check(s, i):\\n repeat = s[:i]\\n repeat = sorted(repeat)\\n j = i\\n while j < len(s):\\n cur = s[j: j+i]\\n cur = sorted(cur)\\n if cur != repeat:\\n return False\\n j += i\\n return True\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for i in range(1,n+1):\\n if n % i == 0 and check(s, i):\\n return i\\n return n\\n \",\n \"runtime\": \"531\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for j in range(1, len(s)+1):\\n if len(s) % j != 0:\\n continue\\n first = sorted(s[:j])\\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\\n return j\",\n \"runtime\": \"558\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for l in range(1, len(s)):\\n if len(s) % l:\\n continue\\n anagram = sorted(s[:l])\\n is_ans = True\\n for i in range(0, len(s), l):\\n if sorted(s[i : i + l]) != anagram:\\n is_ans = False\\n break\\n if is_ans:\\n return l\\n return len(s)\",\n \"runtime\": \"558\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for groupsize in range(1, len(s) + 1):\\n if len(s) % groupsize == 0:\\n size = True\\n target = sorted(s[:groupsize])\\n numgroups = len(s) // groupsize\\n for n in range(numgroups - 1):\\n if sorted(s[(n + 1) * groupsize:(n + 2) * groupsize]) != target:\\n size = False\\n break\\n if size:\\n return groupsize\\n \",\n \"runtime\": \"584\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for j in range(1, len(s)+1):\\n if len(s) % j != 0:\\n continue\\n first = sorted(s[:j])\\n if all(sorted(s[k:k+j]) == first for k in range(j, len(s), j)):\\n return j\",\n \"runtime\": \"584\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def minAnangram(number):\\n set1 = set()\\n for i in range(0, len(s), number):\\n if not set1:\\n set1.add(\\\"\\\".join(sorted(s[i:i+number])))\\n continue\\n if \\\"\\\".join(sorted(s[i:i+number])) not in set1:\\n return False\\n return True\\n n = len(s)\\n for i in range(1, int(n*0.5) + 1):\\n if n % i == 0:\\n if minAnangram(i):\\n return i\\n if minAnangram(n):\\n return n\\n\\n \\n \\n\\n \\n \\n \",\n \"runtime\": \"610\"\n },\n {\n \"code\": \"class Solution:\\n def finddiv(self, num):\\n div = []\\n for i in range(1, num):\\n if num % i == 0:\\n div.append(i)\\n return div\\n\\n def minAnagramLength(self, s: str) -> int:\\n divs = self.finddiv(len(s))\\n\\n for i in divs:\\n ptr = 0\\n prev = \\\"\\\"\\n\\n while ptr < len(s):\\n temp = s[ptr:ptr+i]\\n temp = ''.join(sorted(temp))\\n\\n if prev != temp and prev != \\\"\\\":\\n break\\n\\n prev = temp\\n ptr += i\\n \\n if ptr == len(s):\\n return i\\n \\n return len(s)\",\n \"runtime\": \"636\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n ## they all have to have the same factors\\n\\n def factors(n):\\n factor = []\\n for i in range(1, n+1):\\n if n % i == 0:\\n factor.append(i)\\n return factor\\n\\n possible_lengths = factors(len(s))\\n\\n for length in possible_lengths:\\n chunk1 = sorted(s[:length])\\n valid = True\\n for i in range(0, len(s), length):\\n chunk2 = sorted(s[i:i+length])\\n if chunk1 != chunk2:\\n valid = False\\n break\\n \\n if valid:\\n return length\\n \",\n \"runtime\": \"636\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(list(set(list(s))))==1:\\n return 1\\n d={}\\n d2={}\\n for i in s:\\n d[i]=0\\n d2[i]=0\\n d1={}\\n for i in s:\\n if i not in d1:\\n d1[i]=1\\n else:\\n d1[i]+=1\\n c=0\\n p=0\\n for i in s:\\n c3=0\\n c1=0\\n d[i]+=1\\n c+=1\\n for i in d:\\n if d[i]:\\n c1+=1\\n if c1==len(d) and len(s)%c==0:\\n s2=\\\"\\\"\\n j=c\\n m=0\\n while(j<len(s)):\\n m+=1\\n c2=0\\n s2+=s[j]\\n if m%c==0:\\n # print(s2)\\n for t in s2:\\n d2[t]+=1\\n for t in d2:\\n if d2[t]==d[t]:\\n c2+=1\\n if c2==len(d2):\\n c3+=1\\n \\n s2=\\\"\\\"\\n m=0\\n for g in d2:\\n d2[g]=0\\n j+=1\\n # print(d2)\\n # print(c3)\\n if c3+1==len(s)//c:\\n return c\\n p+=1\\n return c\",\n \"runtime\": \"662\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(s) == 1:\\n return 1\\n minimum = len(s)\\n for i in reversed(range(1, len(s))):\\n if len(s) % i == 0:\\n splits = [s[j:j+i] for j in range(0, len(s), i)]\\n first = sorted(splits[0])\\n others = splits[1:]\\n if all(sorted(k) == first for k in others):\\n minimum = i\\n return minimum\\n\",\n \"runtime\": \"688\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n # Time: O(n*log(n))\\n # Space: O(n), where n = len(s)\\n def minAnagramLength(self, s: str) -> int:\\n \\n n = len(s)\\n # Find divisors of length of s\\n divisors = []\\n for i in range(1, n+1):\\n if n % i == 0:\\n divisors.append(i)\\n\\n def count(string):\\n count = defaultdict(int)\\n for c in string:\\n count[c] += 1\\n return count\\n\\n def check(l):\\n count_ref = count(s[:l])\\n for i in range(l, n+1, l):\\n if count(s[i-l: i]) != count_ref:\\n return 0\\n return 1\\n\\n for i in range(len(divisors)):\\n if check(divisors[i]):\\n return divisors[i]\\n\\n # Binary search on the length of t\\n i, j = 0, len(divisors)-1\\n while i <= j:\\n m = (i+j)//2\\n feasible = check(divisors[m])\\n if feasible:\\n j = m - 1\\n else:\\n i = m + 1\\n return divisors[i]\\n\\n\\n\",\n \"runtime\": \"688\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n res = n\\n\\n c = [[]] * 2\\n for i in range(1, n):\\n if n % i != 0:\\n continue\\n\\n steps = n // i\\n found = True\\n c[0] = [0] * 26\\n\\n for j in range(steps):\\n idx = 1 if j != 0 else 0\\n c[1] = [0] * 26\\n for k in range(j * i, (j + 1) * i):\\n c[idx][ord(s[k]) - 97] += 1\\n\\n if j != 0 and c[0] != c[1]:\\n found = False\\n break\\n\\n if found:\\n return i\\n\\n return n\\n\",\n \"runtime\": \"714\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n\\n d = {}\\n\\n for i in range(n):\\n if s[i] not in d:\\n d[s[i]] = 1\\n else:\\n d[s[i]] += 1\\n \\n no_of_distinct = len(d)\\n\\n # finding the factors of n\\n factors = []\\n for i in range(1, int(n**(0.5)) + 1):\\n if n%i == 0:\\n if i != n//i:\\n factors.append(i)\\n factors.append(n//i)\\n else:\\n factors.append(i) \\n # print(factors)\\n factors = sorted(factors)\\n # print(factors)\\n\\n idx = -1\\n for i in range(len(factors)):\\n if factors[i] >= no_of_distinct:\\n idx = i\\n break\\n # print(factors[idx:])\\n\\n mini = int(1e9)\\n for each_factor in factors[idx:]:\\n p = 0\\n res = sorted(s[0:each_factor])\\n count = 1\\n p = p + each_factor \\n while p < n:\\n if sorted(s[p:p+each_factor]) == res:\\n count += 1\\n p += each_factor\\n \\n if count == (n//each_factor):\\n return each_factor\",\n \"runtime\": \"741\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n=len(s)\\n for p in [i for i in range(1,n+1) if n%i==0]:\\n ph=[]\\n valid=True\\n for i in range(0,n,p):\\n ptrn=s[i:i+p]\\n tph=[0]*26\\n for alp in ptrn:\\n tph[ord(alp)-ord(\\\"a\\\")]+=1\\n if (not ph) or ph == tph:\\n ph = tph.copy()\\n else:\\n valid=False\\n break\\n if valid:\\n return sum(ph)\\n\\n\",\n \"runtime\": \"767\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(set(s)) == 1:\\n return 1\\n\\n def checkAnagram(s1, s2):\\n c1 = collections.Counter(s1)\\n c2 = collections.Counter(s2)\\n if len(c1) != len(c2): return False\\n for k in c1:\\n if c1[k] != c2[k]:\\n return False\\n\\n return True \\n \\n for l in range(2, (len(s) // 2) + 1):\\n if len(s) % l != 0:\\n continue\\n anagram = s[:l]\\n is_all_anagram = True\\n for i in range(l, len(s) - l + 1, l):\\n if not checkAnagram(anagram, s[i:i+l]):\\n is_all_anagram = False\\n break\\n\\n if is_all_anagram:\\n return len(anagram)\\n\\n return len(s)\\n \",\n \"runtime\": \"793\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def is_anagram(s1, s2):\\n return sorted(s1) == sorted(s2)\\n\\n def get_divisors(n):\\n divisors = []\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n divisors.append(i)\\n if i != n // i:\\n divisors.append(n // i)\\n return divisors\\n\\n length_s = len(s)\\n divisors = get_divisors(length_s)\\n \\n for divisor in sorted(divisors):\\n first_substring = s[:divisor]\\n is_valid = True\\n for i in range(divisor, length_s, divisor):\\n if not is_anagram(first_substring, s[i:i+divisor]):\\n is_valid = False\\n break\\n if is_valid:\\n return divisor\\n\\n return length_s # Default case if no valid divisor found\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(solution.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"runtime\": \"819\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n letters = set(s) \\n n = len(s) \\n \\n d = {c:[0] for c in letters} \\n \\n for c in s:\\n for x in d:\\n d[x].append(d[x][-1] + (x == c))\\n \\n for i in range(1, n // 2 + 1):\\n if n % i:\\n continue\\n \\n success = True\\n \\n for j in range(2, n//i + 1):\\n for c in d:\\n if d[c][i*j]!= j*d[c][i]:\\n success = False\\n break\\n \\n if not success:\\n break\\n \\n if success:\\n return i\\n \\n return n\\n \",\n \"runtime\": \"845\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n \\n # Find all divisors of n\\n divisors = []\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n divisors.append(i)\\n if i != n // i:\\n divisors.append(n // i)\\n \\n # Check each divisor length\\n for divisor in sorted(divisors):\\n substring_length = divisor\\n substring = s[:substring_length]\\n anagram = True\\n \\n # Check if all substrings of length substring_length are anagrams\\n for i in range(0, n, substring_length):\\n if sorted(s[i:i+substring_length]) != sorted(substring):\\n anagram = False\\n break\\n \\n if anagram:\\n return substring_length\\n \\n return n # If no anagram found, return the length of s\\n\\n# Test cases\\nsol = Solution()\\nprint(sol.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(sol.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"runtime\": \"871\"\n },\n {\n \"code\": \"def check_anagram(s1,s2):\\n s1_ = ''.join(sorted(s1))\\n s2_ = ''.join(sorted(s2))\\n if s1_== s2_:\\n return True\\n else:\\n return False\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n slen=len(s)\\n ans=1\\n \\n if slen == 1: return 1\\n for i in range(1, slen+1):\\n break_flag=False\\n if slen%i!=0: continue\\n base = s[:i]\\n for j in range(i,slen,i):\\n # print(s[j:j+i])\\n if not check_anagram(base, s[j:j+i]):\\n ans = ans+1\\n break_flag=True\\n break\\n if not break_flag:\\n return i\\n \\n return ans\\n\\n\\n\",\n \"runtime\": \"898\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n letters = set(s)\\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\\n dp = {letter: [(-1, 0)] for letter in letters}\\n for idx, letter in enumerate(s):\\n l = dp[letter]\\n l.append((idx, l[-1][1] + 1))\\n\\n for d in range(1, len(s) + 1):\\n if len(s) % d != 0:\\n continue\\n counts = None # dict, will contain count of every letter in the first batch\\n # next batches must have the same counts\\n for start_idx in range(0, len(s), d):\\n end_idx = start_idx + d - 1\\n curr_counts = {}\\n for letter in letters:\\n # find the first and last occurence of this letter in the current batch\\n l = dp[letter]\\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\\n if counts is None:\\n counts = curr_counts\\n elif counts != curr_counts:\\n break\\n else: # no break, we've found a good partitioning\\n return d\",\n \"runtime\": \"924\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for k in range(1, n + 1):\\n if n % k == 0 and self._canFormAnagram(s, k):\\n return k\\n return n\\n\\n def _canFormAnagram(self, s: str, k: int) -> bool:\\n anagramCount = collections.Counter(s[:k])\\n return all(collections.Counter(s[i:i + k]) == anagramCount\\n for i in range(k, len(s), k))\",\n \"runtime\": \"950\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n def check(k):\\n i = 0\\n prev = None\\n while i < n:\\n j = i\\n cur = [0] * 26\\n while j < i+k:\\n cur[ord(s[j])-ord('a')] += 1\\n j += 1\\n cur = tuple(cur)\\n if prev is not None:\\n if cur != prev: return False\\n prev = cur\\n i = j\\n return True\\n\\n nums = []\\n for x in range(1,n+1):\\n if n%x == 0: nums.append(x)\\n\\n m = len(nums)\\n for x in nums:\\n if check(x): return x\\n return 1\\n\\n #l,r = 0,m-1\\n #while l <= r:\\n # mid = (l+r)//2\\n # if check(nums[mid]): r = mid - 1\\n # else: l = mid + 1\\n #return nums[l]\",\n \"runtime\": \"976\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for i in range(1, n // 2 + 1):\\n if n % i == 0:\\n a1, valid = [0] * 26, True\\n for j in range(i): a1[ord(s[j]) - 97] += 1\\n\\n for j in range(i, n, i):\\n a2 = [0] * 26\\n for k in range(j, j + i): a2[ord(s[k]) - 97] += 1\\n for k in range(26):\\n if a1[k] != a2[k]:\\n valid = False\\n break\\n if not valid: break\\n if valid: return i\\n return n\",\n \"runtime\": \"1002\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n \\n # Function to check if s is composed of anagrams of a substring of length k\\n def is_composed_of_anagrams(k):\\n count = Counter(s[:k])\\n for i in range(k, n, k):\\n if count != Counter(s[i:i+k]):\\n return False\\n return True\\n \\n # Iterate through all divisors of n\\n for k in range(1, n + 1):\\n if n % k == 0:\\n if is_composed_of_anagrams(k):\\n return k\\n \\n # This line should not be reached under the given constraints\\n return n\\n\\n# Example usage:\\nsol = Solution()\\nprint(sol.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(sol.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"runtime\": \"1028\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for k in range(1, n + 1):\\n if n % k == 0 and self._canFormAnagram(s, k):\\n return k\\n return n\\n\\n def _canFormAnagram(self, s: str, k: int) -> bool:\\n \\\"\\\"\\\"Returns True if we can concatenate an anagram of length k to s.\\\"\\\"\\\"\\n anagramCount = collections.Counter(s[:k])\\n return all(collections.Counter(s[i:i + k]) == anagramCount\\n for i in range(k, len(s), k))\",\n \"runtime\": \"1028\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n ''' \\n bruteforce:\\n n ^ 2\\n\\n '''\\n \\n for length in range(1, len(s) + 1):\\n if len(s) % length == 0:\\n first_counts = Counter(s[:length])\\n is_match = True\\n for j in range(length, len(s), length):\\n counts = Counter(s[j: j + length])\\n if counts != first_counts:\\n is_match = False\\n break\\n if is_match:\\n return length\\n \",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n\\n counter = collections.Counter(s)\\n values = list(counter.values())\\n gcd = math.gcd(*values)\\n maxsize = len(s)\\n for size in range(1,maxsize+1):\\n if maxsize % size == 0:\\n counter0 = collections.Counter(s[0:size])\\n for i in range(size,len(s),size):\\n counter1 = collections.Counter(s[i:i+size])\\n # print(counter0, counter1)\\n if counter0 != counter1:\\n break\\n else:\\n return size\\n\\n\\n\\n\\n return len(s)\\n \",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def test(self, s: str, k: int) -> bool:\\n prev = Counter(s[:k])\\n for i in range(1, len(s) // k):\\n current = Counter(s[i*k:(i*k)+k])\\n if prev != current: return False\\n prev = current\\n return True\\n \\n def minAnagramLength(self, s: str) -> int:\\n options = [i for i in range(1, len(s) + 1) if len(s) % i == 0]\\n for option in options:\\n if self.test(s, option): return option\\n\",\n \"runtime\": \"1081\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n\\n counter = collections.Counter(s)\\n values = list(counter.values())\\n maxsize = len(s)\\n for size in range(1,maxsize+1):\\n if maxsize % size == 0:\\n counter0 = collections.Counter(s[0:size])\\n for i in range(size,len(s),size):\\n counter1 = collections.Counter(s[i:i+size])\\n if counter0 != counter1:\\n break\\n else:\\n return size\\n\\n\\n\\n\\n return len(s)\\n \",\n \"runtime\": \"1081\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def test(self, s: str, k: int) -> bool:\\n prev = Counter(s[:k])\\n for i in range(1, len(s) // k):\\n current = Counter(s[i*k:(i*k)+k])\\n if prev != current: return False\\n prev = current\\n return True\\n \\n def minAnagramLength(self, s: str) -> int:\\n options = [i for i in range(1, len(s) + 1) if len(s) % i == 0]\\n for option in options:\\n if self.test(s, option): return option\\n\",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for size in range(1, n):\\n if n % size == 0:\\n cur = Counter(s[:size])\\n for j in range(size, n, size):\\n temp = Counter(s[j:j+size])\\n if temp != cur: break\\n else:\\n return size\\n return n\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for i in range(1, n + 1):\\n if n % i == 0:\\n cnt = Counter(s[:i])\\n for j in range(i, n, i):\\n ncnt = Counter(s[j:j+i])\\n if ncnt != cnt: \\n break\\n else: \\n return i\",\n \"runtime\": \"1212\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def is_valid(n):\\n first = Counter(s[:n])\\n for i in range(n, len(s), n):\\n if Counter(s[i:i+n]) != first:\\n return False\\n return True\\n \\n possibilities = [i for i in range(1, len(s)+1) if len(s)%i == 0]\\n for x in possibilities:\\n if is_valid(x):\\n return x\\n\",\n \"runtime\": \"1212\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n result = n\\n for l in range(1, n):\\n if n % l != 0:\\n continue\\n ref = Counter(s[0:0+l])\\n i = 0\\n isSame = True\\n while i < n:\\n cur = Counter(s[i:i+l])\\n if cur != ref:\\n isSame = False\\n break\\n i += l\\n if isSame:\\n return l\\n return result\\n \\n \",\n \"runtime\": \"1238\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n \\n factors_l = []\\n factors_h = []\\n factors =[]\\n n = len(s)\\n k = math.floor(math.sqrt(n))\\n print(n)\\n for i in range(1,k+1):\\n if(n%i==0):\\n factors_l.append(i)\\n if(i<n//i):\\n factors_h.append(n//i)\\n factors = factors_l+factors_h[::-1]\\n def check(k):\\n dic1 = [0 for _ in range(26)]\\n for i in range(k):\\n dic1[ord(s[i])-97]+=1\\n for i in range(0,n,k):\\n j = i\\n dic2 = [0 for _ in range(26)]\\n while(j<i+k and j<n):\\n dic2[ord(s[j])-97]+=1\\n j+=1\\n if(dic1!=dic2):\\n return False\\n return True\\n print(factors)\\n start = 0\\n end = len(factors)\\n ans = 0\\n for mid in range(end):\\n if(check(factors[mid])):\\n \\n ans = factors[mid]\\n return ans\\n \\n \\n return ans\\n\\n\\n\\n \",\n \"runtime\": \"1238\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for length in range(1, n + 1):\\n if n % length == 0:\\n t = s[:length]\\n freq = Counter(t)\\n \\n valid = True\\n for i in range(0, n, length):\\n current_freq = Counter(s[i:i+length])\\n if current_freq != freq:\\n valid = False\\n break\\n \\n if valid:\\n return length\\n return n\",\n \"runtime\": \"1264\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def isValid(length):\\n n = len(s)\\n m = n // length\\n word1 = s[0:length]\\n count1 = Counter(word1)\\n\\n for i in range(1, m):\\n count2 = Counter(s[i*length:(i+1)*length])\\n if count1 != count2:\\n return False\\n \\n return True\\n\\n n = len(s)\\n\\n for length in range(1, n+1):\\n if n % length == 0 and isValid(length):\\n return length\",\n \"runtime\": \"1264\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n def isright(dic, start, end):\\n temp = defaultdict(int)\\n now = 0\\n for i in range(start, end):\\n now += 1\\n temp[s[i]] += 1\\n if temp[s[i]] > dic[s[i]]:\\n return False\\n \\n if now == start:\\n temp = defaultdict(int)\\n now = 0\\n return True\\n \\n div = set()\\n for i in range(1, int(sqrt(n)) + 1):\\n if n % i == 0:\\n div.add(i)\\n div.add(n // i)\\n\\n for i in sorted(div):\\n temp = defaultdict(int)\\n for j in range(i):\\n temp[s[j]] += 1\\n if isright(temp, i, n):\\n return i\\n \\n\",\n \"runtime\": \"1290\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n def isright(dic, start, end):\\n temp = defaultdict(int)\\n now = 0\\n for i in range(start, end):\\n now += 1\\n temp[s[i]] += 1\\n if temp[s[i]] > dic[s[i]]:\\n return False\\n \\n if now == start:\\n temp = defaultdict(int)\\n now = 0\\n return True\\n \\n div = set()\\n for i in range(1, int(sqrt(n)) + 1):\\n if n % i == 0:\\n div.add(i)\\n div.add(n // i)\\n\\n for i in sorted(div):\\n temp = defaultdict(int)\\n for j in range(i):\\n temp[s[j]] += 1\\n if isright(temp, i, n):\\n return i\\n \\n\",\n \"runtime\": \"1316\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n def isright(dic, start, end):\\n temp = defaultdict(int)\\n now = 0\\n for i in range(start, end):\\n now += 1\\n temp[s[i]] += 1\\n if temp[s[i]] > dic[s[i]]:\\n return False\\n \\n if now == start:\\n temp = defaultdict(int)\\n now = 0\\n return True\\n \\n div = set()\\n for i in range(1, int(sqrt(n)) + 1):\\n if n % i == 0:\\n div.add(i)\\n div.add(n // i)\\n\\n for i in sorted(div):\\n temp = defaultdict(int)\\n for j in range(i):\\n temp[s[j]] += 1\\n if isright(temp, i, n):\\n return i\\n \\n\",\n \"runtime\": \"1342\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for i in range(len(set(s)), len(s)+1):\\n if len(s) % i == 0:\\n a = len(s) // i\\n isAnagram = True\\n for j in range(a):\\n if sorted(s[i*j:i*(j+1)]) != sorted(s[0:i]):\\n isAnagram = False\\n if isAnagram:\\n return i\\n\\n \\n\",\n \"runtime\": \"1342\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def get_counts(i, size):\\n counts = {}\\n for i in range(i, i + size):\\n counts[s[i]] = counts.get(s[i], 0) + 1\\n\\n return counts\\n \\n def check(size):\\n last_counts = None\\n for i in range(0, len(s), size):\\n counts = get_counts(i, size)\\n if last_counts:\\n for c in string.ascii_lowercase:\\n if counts.get(c, 0) != last_counts.get(c, 0):\\n return False\\n else:\\n last_counts = counts\\n\\n return True\\n\\n res = len(s)\\n for size in range(1, len(s) // 2 + 1):\\n if len(s) % size == 0 and check(size):\\n res = size\\n break\\n\\n return res\\n \",\n \"runtime\": \"1369\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def printDivisors(n) :\\n arr1 = []\\n arr2 = []\\n # Note that this loop runs till square root\\n i = 1\\n while i <= math.sqrt(n):\\n\\n if (n % i == 0) :\\n\\n # If divisors are equal, print only one\\n if (n / i == i) :\\n arr1.append(i)\\n else :\\n # Otherwise print both\\n arr1.append(i)\\n arr2.append(int(n/i))\\n i = i + 1\\n for i in arr2:\\n arr1.append(i)\\n return(arr1)\\n def count(s, i, j):\\n charArr = [0 for i in range(26)]\\n for k in range(i,j):\\n charArr[ord(s[k]) - 97] += 1\\n return charArr\\n\\n # Driver method\\n size = len(s)\\n posAnagramSize = printDivisors(size)\\n ans = size\\n for i in posAnagramSize:\\n matchStr = count(s, 0, i)\\n isNotBreak = True\\n for j in range(0,size,i):\\n matchStr2 = count(s, j, j+i)\\n if(matchStr2 != matchStr):\\n isNotBreak = False\\n break\\n if(isNotBreak):\\n ans = min(i,ans)\\n return(ans)\\n \",\n \"runtime\": \"1395\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def printDivisors(n) :\\n arr1 = []\\n arr2 = []\\n # Note that this loop runs till square root\\n i = 1\\n while i <= math.sqrt(n):\\n\\n if (n % i == 0) :\\n\\n # If divisors are equal, print only one\\n if (n / i == i) :\\n arr1.append(i)\\n else :\\n # Otherwise print both\\n arr1.append(i)\\n arr2.append(int(n/i))\\n i = i + 1\\n for i in arr2:\\n arr1.append(i)\\n return(arr1)\\n def count(s, i, j):\\n charArr = [0 for i in range(26)]\\n for k in range(i,j):\\n charArr[ord(s[k]) - 97] += 1\\n return charArr\\n\\n # Driver method\\n size = len(s)\\n posAnagramSize = printDivisors(size)\\n ans = size\\n for i in posAnagramSize:\\n matchStr = count(s, 0, i)\\n isNotBreak = True\\n for j in range(0,size,i):\\n matchStr2 = count(s, j, j+i)\\n if(matchStr2 != matchStr):\\n isNotBreak = False\\n break\\n if(isNotBreak):\\n ans = min(i,ans)\\n return(ans)\\n \",\n \"runtime\": \"1421\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n ans = n\\n def check(x):\\n temp = [0 for _ in range(26)]\\n for i in range(x):\\n temp[ord(s[i]) - 97] += 1\\n j = x\\n while j < n:\\n arr = [0 for _ in range(26)]\\n for i in range(x):\\n arr[ord(s[j + i]) - 97] += 1\\n \\n if arr != temp:\\n return False\\n j += x\\n \\n return True\\n\\n\\n for i in range(1 , ceil(sqrt(n)) + 1):\\n if not n%i:\\n other = n//i\\n if check(i):\\n ans = min(ans , i)\\n if check(other):\\n ans = min(ans , other)\\n return ans\\n\\n\\n\\n\\n \",\n \"runtime\": \"1447\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def printDivisors(n) :\\n arr1 = []\\n arr2 = []\\n i = 1\\n while i <= math.sqrt(n):\\n\\n if (n % i == 0) :\\n\\n if (n / i == i) :\\n arr1.append(i)\\n else :\\n arr1.append(i)\\n arr2.append(int(n/i))\\n i = i + 1\\n for i in arr2:\\n arr1.append(i)\\n return(arr1)\\n def count(s, i, j):\\n charArr = [0 for i in range(26)]\\n for k in range(i,j):\\n charArr[ord(s[k]) - 97] += 1\\n return charArr\\n\\n size = len(s)\\n posAnagramSize = printDivisors(size)\\n ans = size\\n for i in posAnagramSize:\\n matchStr = count(s, 0, i)\\n isNotBreak = True\\n for j in range(0,size,i):\\n matchStr2 = count(s, j, j+i)\\n if(matchStr2 != matchStr):\\n isNotBreak = False\\n break\\n if(isNotBreak):\\n ans = min(i,ans)\\n return(ans)\",\n \"runtime\": \"1473\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(set(s)) == 1:\\n return 1\\n\\n diff = 2\\n while diff < len(s):\\n if len(s) % diff != 0:\\n diff += 1\\n continue\\n\\n flag = False\\n i = 0\\n while i+(2*diff) <= len(s):\\n if Counter(s[i:i+diff]) == Counter(s[i+diff:i+(2*diff)]):\\n i += diff \\n else:\\n flag = True\\n break \\n if flag:\\n diff += 1\\n else:\\n return diff\\n\\n return len(s)\",\n \"runtime\": \"1499\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n \\\"\\\"\\\"\\n - for substring of len(t), count must be the same\\n - we could try every length of t\\n - O(n ^ 2)\\n \\\"\\\"\\\"\\n def count_match(l):\\n c1 = [0] * 26\\n for i in range(l):\\n c1[ord(s[i]) - ord(\\\"a\\\")] += 1\\n for i in range(l, len(s), l):\\n c2 = [0] * 26\\n for j in range(i, i + l):\\n c2[ord(s[j]) - ord(\\\"a\\\")] += 1\\n if any(n1 != n2 for n1, n2 in zip(c1, c2)):\\n return False\\n return True \\n for i in range(len(s), 0, -1):\\n if len(s) % i == 0 and count_match(len(s) // i):\\n return len(s) // i\",\n \"runtime\": \"1499\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n \\n # Helper function to check if two substrings are anagrams\\n def are_anagrams(s1, s2):\\n return Counter(s1) == Counter(s2)\\n \\n # Iterate over all possible divisors of n\\n for d in range(1, n + 1):\\n if n % d == 0:\\n # Check if all segments of length d are anagrams of the first segment\\n first_segment = s[:d]\\n all_anagrams = True\\n for i in range(d, n, d):\\n if not are_anagrams(first_segment, s[i:i+d]):\\n all_anagrams = False\\n break\\n if all_anagrams:\\n return d\\n \\n # This line should never be reached because n is always a divisor of itself\\n return n\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(solution.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"runtime\": \"1526\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n ans = len(s)\\n\\n divs = [i for i in range(1, len(s)+1) if len(s) % i == 0]\\n\\n for div in divs:\\n n = len(s) // div\\n prev = Counter()\\n is_valid = True\\n\\n for i in range(0, len(s), n):\\n if not prev:\\n prev = Counter(s[i:i+n])\\n else:\\n if prev != Counter(s[i:i+n]):\\n is_valid = False\\n break\\n if is_valid:\\n ans = min(ans, n)\\n return ans\",\n \"runtime\": \"1552\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n ans = len(s)\\n\\n divs = [i for i in range(1, len(s)+1) if len(s) % i == 0]\\n\\n for div in divs:\\n n = len(s) // div\\n prev = Counter()\\n is_valid = True\\n\\n for i in range(0, len(s), n):\\n if not prev:\\n prev = Counter(s[i:i+n])\\n else:\\n if prev != Counter(s[i:i+n]):\\n is_valid = False\\n break\\n if is_valid:\\n ans = min(ans, n)\\n return ans\",\n \"runtime\": \"1578\"\n },\n {\n \"code\": \"from math import sqrt\\nfrom collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n factors = []\\n for i in range(1, int(sqrt(len(s))) + 1):\\n if len(s) % i == 0:\\n if len(s) // i == i:\\n factors.append(i)\\n else:\\n factors.append(i)\\n factors.append(len(s) // i)\\n \\n factors.sort()\\n\\n for i in factors:\\n # i is size of subaray\\n match = set()\\n for j in range(0, len(s), i):\\n chars = [0] * 26\\n for k in range(j, j + i):\\n chars[ord(s[k]) - ord('a')] += 1\\n match.add(tuple(chars))\\n if len(match) == 1:\\n return i\\n \\n return len(s)\\n \\n\\n\\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"1604\"\n },\n {\n \"code\": \"from math import sqrt\\nfrom collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n\\n for i in range(1, len(s)):\\n if len(s) % i != 0:\\n continue\\n # i is size of subaray\\n match = set()\\n for j in range(0, len(s), i):\\n chars = [0] * 26\\n for k in range(j, j + i):\\n chars[ord(s[k]) - ord('a')] += 1\\n match.add(tuple(chars))\\n if len(match) == 1:\\n return i\\n\\n return len(s)\\n\\n # def check(k: int) -> bool:\\n # for i in range(0, n, k):\\n # cnt1 = Counter(s[i : i + k])\\n # for c, v in cnt.items():\\n # if cnt1[c] * (n // k) != v:\\n # return False\\n # return True\\n\\n # cnt = Counter(s)\\n # n = len(s)\\n # for i in range(1, n + 1):\\n # if n % i == 0 and check(i):\\n # return i\\n \\n\\n\\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"1630\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # s is a string of up to length: 10^5\\n # and it is only lowercase english letters: Yes\\n\\n # concatentation: substrings, we can partition this array into a bunch of anagrams of t\\n # the minimum length of t = the maximum number of partitions\\n # sliding window problem? or a binary search\\n # let's just try all the lengths of t, and then the check would just be splitting t up into these lengths\\n\\n # length(t) is as multiple of s, that doesn't really matter, we would still have to search all of Len(S), because LEN(S)\\n # time complexity : O(S log S)\\n # we could also try searching over the factors of the length of string\\n # [2, SQT(len(S ))] -> O(S * SQRT(S)) \\n\\n # if it can be split into 4 anagarms -> it can be split into two anagrams\\n # case where it splits into 3 anagrams, or 5 anagrams\\n # case where it's 6 anagrams -> means it can be split into 3 anagrams and 2 anagrams\\n # if a number can be split into 12 anagrams, it can be split into 2 anagrams\\n\\n # we could do a tree and merge them, starting from the leafnode, and merging. At a prent node, we look at left and right maps and \\n def valid(length):\\n initial_m = {}\\n for j in range(length):\\n initial_m[s[j]] = 1 + initial_m.get(s[j], 0)\\n found = True\\n for times in range(1, len(s) // length):\\n m = {}\\n for j in range(times * length, (times + 1) * length):\\n m[s[j]] = 1 + m.get(s[j], 0)\\n if m != initial_m:\\n found = False\\n return found\\n answer = float(\\\"inf\\\")\\n for i in range(1, math.ceil(math.sqrt(len(s))) + 1):\\n length = i\\n if len(s) % length == 0:\\n if valid(length):\\n answer = min(answer, length)\\n if len(s) // length != len(s) and valid(len(s) // length):\\n answer = min(answer, len(s) // length)\\n # if they're all the same, that's the only time 1 works\\n return min(answer, len(s))\\n\\n\",\n \"runtime\": \"1656\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n count = [[0 for _ in range(26)] for _ in range(n)]\\n for i in range(len(s)):\\n if i > 0:\\n for j in range(26):\\n count[i][j] = count[i-1][j]\\n idx = ord(s[i]) - ord('a')\\n count[i][idx] += 1\\n chars = dict()\\n for i in range(26):\\n if count[n-1][i] > 0:\\n chars[i] = count[n-1][i]\\n\\n def is_min(num: int, increment: int, size: dict) ->bool:\\n if (num * increment) >= n:\\n return True\\n for c, val in size.items():\\n if (num * val) != count[(num*increment)-1][c]:\\n return False\\n return is_min(num+1, increment, size)\\n\\n def is_possible(parts: int) -> bool:\\n for ch, val in chars.items():\\n if val % parts != 0:\\n return False\\n return True\\n\\n def part_size(parts: int) -> dict:\\n ans = dict()\\n for ch, val in chars.items():\\n ans[ch] = val // parts\\n return ans\\n\\n inc = 1\\n while inc <= n//2:\\n if n % inc == 0:\\n if is_possible(n//inc):\\n size = part_size(n//inc)\\n if is_min(1, inc, size):\\n return inc\\n inc += 1\\n return n\",\n \"runtime\": \"1682\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n base = ord('a')\\n for i in range(1, n + 1):\\n if n % i != 0:\\n continue\\n valid = True\\n cnt = [0] * 26\\n for c in range(i):\\n cnt[ord(s[c]) - base] += 1\\n for j in range(i, n, i):\\n cur = [0] * 26\\n for c in range(i):\\n cur[ord(s[j + c]) - base] += 1\\n for c in range(26):\\n if cnt[c] != cur[c]:\\n valid = False\\n break\\n if valid:\\n return i\\n\",\n \"runtime\": \"1709\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n # if len(set(s)) == 1:\\n # return 1\\n\\n diff = 1\\n while diff < len(s):\\n if len(s) % diff != 0:\\n diff += 1\\n continue\\n\\n flag = False\\n i = 0\\n while i+(2*diff) <= len(s):\\n if Counter(s[i:i+diff]) == Counter(s[i+diff:i+(2*diff)]):\\n i += diff \\n else:\\n flag = True\\n break \\n if flag:\\n diff += 1\\n else:\\n return diff\\n\\n return len(s)\\n\\n # d = Counter(s)\\n # min_freq = min(d.values())\\n # if min_freq == 1:\\n # return len(s)\\n\\n # for ch in d:\\n # d[ch] %= min_freq\\n # if d[ch] > 0:\\n # return len(s)\\n \\n # return min_freq\\n\\n # n = len(s)\\n # arr = [0 for i in range(n)]\\n # for i in range(n):\\n # for j in range(i):\\n # diff = i-j\\n # if i-diff >= 0:\\n # if dict(s[j-:j]) == dict(s[j+1:i+1]):\\n # arr[i] = 1\",\n \"runtime\": \"1735\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def ok(k): \\n c1 = Counter()\\n for i in range(k):\\n c1[s[i]] += 1\\n \\n for i in range(k, len(s)-k+1, k):\\n c2 = Counter()\\n for j in range(i, i+k):\\n c2[s[j]] += 1\\n if c1 != c2:\\n return False\\n \\n return True\\n \\n for i in range(1, len(s)):\\n if len(s) % i:\\n continue\\n if ok(i):\\n return i\\n \\n return len(s)\",\n \"runtime\": \"1761\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def anagram_of_string(self, k: int) -> bool:\\n # Checks if string length t that has a concatenation of anagrams to produce s\\n # k < len(s)\\n # self.s = \\\"abbaab\\\"; k = 2\\n i: int = 0 # 1\\n # iterate over each string\\n slice_hash: list[int] = [] # [161, 161,]\\n while i*k < len(self.s): # 1*2 < 6\\n this_slice = self.s[i*k: (i+1)*k] # 'ba'\\n # encode string in invariant format i.e. up to permutation\\n char_count: list[int] = [0]*26 # [0,0,0,0,0,0,0]\\n for char in this_slice: # 'b'\\n char_count[ord(char) - ord('a')] += 1\\n char_count_hash = hash(tuple(char_count)) # 616\\n slice_hash.append(char_count_hash)\\n i += 1\\n return all(x == slice_hash[0] for x in slice_hash)\\n\\n def minAnagramLength(self, s: str) -> int:\\n self.s = s\\n min_anagram_len: int | float = np.inf\\n for k in range(len(s), 0, -1): # len(s), len(s)-1, len(s)-2,... 1\\n # if k | len(s) try\\n if len(s) % k == 0:\\n ret_val = self.anagram_of_string(k)\\n if ret_val:\\n min_anagram_len = k\\n return min_anagram_len \\n\\n'''\\n\\nFor every number k .. k | len(s)\\n Check to see if s[0:k], s[k: 2k],.... are anagrams of each other O(N)\\n\\nTime O(N**2), space O(N)\\n\\n\\n'''\\n\\n\\n\",\n \"runtime\": \"1787\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for length in range(1, len(s) + 1):\\n if len(s) % length != 0:\\n continue\\n init = Counter()\\n for i in range(length):\\n init[s[i]] += 1\\n for i in range(length, len(s), length):\\n counts = Counter()\\n for j in range(length):\\n counts[s[i + j]] += 1\\n if counts != init:\\n break\\n else:\\n return length\",\n \"runtime\": \"1813\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n prefix = [Counter()]\\n for x in s:\\n new_counter = prefix[-1].copy()\\n new_counter[x] += 1\\n prefix.append(new_counter)\\n \\n N = len(s)\\n mi = N\\n i = 1\\n \\n while i * i <= N:\\n if N % i == 0:\\n ok = True\\n for j in range(i, N, i):\\n if not (prefix[i] == prefix[j + i] - prefix[j]):\\n ok = False\\n break\\n if ok:\\n mi = min(mi, i)\\n \\n k = N // i\\n ok = True\\n for j in range(k, N, k):\\n if not (prefix[k] == prefix[j + k] - prefix[j]):\\n ok = False\\n break\\n if ok:\\n mi = min(mi, k)\\n \\n i += 1\\n \\n return mi\",\n \"runtime\": \"1839\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n prefix = [Counter()]\\n for x in s:\\n new_counter = prefix[-1].copy()\\n new_counter[x] += 1\\n prefix.append(new_counter)\\n \\n N = len(s)\\n mi = N\\n i = 1\\n \\n while i * i <= N:\\n if N % i == 0:\\n # Check for segment length i\\n ok = True\\n for j in range(i, N, i):\\n if not (prefix[i] == prefix[j + i] - prefix[j]):\\n ok = False\\n break\\n if ok:\\n mi = min(mi, i)\\n \\n # Check for segment length N // i\\n k = N // i\\n ok = True\\n for j in range(k, N, k):\\n if not (prefix[k] == prefix[j + k] - prefix[j]):\\n ok = False\\n break\\n if ok:\\n mi = min(mi, k)\\n \\n i += 1\\n \\n return mi\",\n \"runtime\": \"1866\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":90,"string":"90"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n counter = dict()\n n = len(s)\n for i in range(n):\n if s[i] not in counter:\n counter[s[i]] = 1\n else:\n counter[s[i]] += 1\n \n distinct_letters = len(counter)\n candidates = []\n for i in range(n//distinct_letters, 0, -1):\n if n % i != 0:\n continue\n breaker = False\n for letter, count in counter.items():\n if count % i != 0:\n breaker = True\n break\n if not breaker:\n candidates.append(i)\n res = n\n print(candidates)\n print(counter)\n for candidate in candidates:\n temp_count = dict()\n for i in range(n//candidate):\n if s[i] not in temp_count:\n temp_count[s[i]] = 1\n else:\n temp_count[s[i]] += 1\n print(temp_count)\n \n if len(temp_count) < len(counter):\n continue\n k = 0\n for letter, count in temp_count.items():\n if k == 1:\n break\n count_to_check = count\n letter_to_check = letter\n k += 1\n #print(count_to_check)\n #print(letter_to_check)\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\n print(candidate)\n continue\n bad_candidate = False\n for letter, count in temp_count.items():\n count_to_check = count\n letter_to_check = letter\n if counter[letter_to_check] // count != candidate:\n bad_candidate = True\n if bad_candidate:\n continue\n else:\n for j in range(1, candidate):\n new_count = {}\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\n #print(s[k])\n if s[k] not in new_count:\n new_count[s[k]] = 1\n else:\n new_count[s[k]] += 1\n print(new_count)\n if new_count != temp_count:\n bad_candidate = True\n break\n if bad_candidate:\n continue\n else:\n\n\n\n res = n//candidate\n break\n return res\n \n \n\n \n\n \n\n\n \n\n\n","memory":"17200"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for i in range(1, len(s) + 1):\n if len(s) % i:\n continue\n c = Counter(s[:i])\n b = True\n for j in range(i, len(s) - i + 1, i):\n if Counter(s[j:j+i]) != c:\n b = False\n if b:\n return i\n return len(s)\n\n ","memory":"17400"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n for i in range(1, n // 2 + 1):\n if n % i == 0:\n cur = Counter(s[:i])\n for j in range(i * 2, n + 1, i):\n if Counter(s[j - i: j]) != cur:\n break\n else:\n return i\n return n","memory":"17500"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n result = n\n for l in range(1, n):\n if n % l != 0:\n continue\n ref = Counter(s[0:0+l])\n i = 0\n isSame = True\n while i < n:\n cur = Counter(s[i:i+l])\n if cur != ref:\n isSame = False\n break\n i += l\n if isSame:\n return l\n return result\n \n ","memory":"17600"},{"code":"from collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n \n # Helper function to check if two substrings are anagrams\n def are_anagrams(s1, s2):\n return Counter(s1) == Counter(s2)\n \n # Iterate over all possible divisors of n\n for d in range(1, n + 1):\n if n % d == 0:\n # Check if all segments of length d are anagrams of the first segment\n first_segment = s[:d]\n all_anagrams = True\n for i in range(d, n, d):\n if not are_anagrams(first_segment, s[i:i+d]):\n all_anagrams = False\n break\n if all_anagrams:\n return d\n \n # This line should never be reached because n is always a divisor of itself\n return n\n\n# Example usage:\nsolution = Solution()\nprint(solution.minAnagramLength(\"abba\")) # Output: 2\nprint(solution.minAnagramLength(\"cdef\")) # Output: 4","memory":"17700"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n \n factors_l = []\n factors_h = []\n factors =[]\n n = len(s)\n k = math.floor(math.sqrt(n))\n print(n)\n for i in range(1,k+1):\n if(n%i==0):\n factors_l.append(i)\n if(i<n//i):\n factors_h.append(n//i)\n factors = factors_l+factors_h[::-1]\n def check(k):\n dic1 = [0 for _ in range(26)]\n for i in range(k):\n dic1[ord(s[i])-97]+=1\n for i in range(0,n,k):\n j = i\n dic2 = [0 for _ in range(26)]\n while(j<i+k and j<n):\n dic2[ord(s[j])-97]+=1\n j+=1\n if(dic1!=dic2):\n return False\n return True\n print(factors)\n start = 0\n end = len(factors)\n ans = 0\n for mid in range(end):\n if(check(factors[mid])):\n \n ans = factors[mid]\n return ans\n \n \n return ans\n\n\n\n ","memory":"17800"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def ok(s:str,i:int)->bool:\n j=0\n while j<len(s)-i:\n c1 = Counter([ord(x)-ord('a') for x in s[j:j+i]])\n c2 = Counter([ord(x)-ord('a') for x in s[j+i:j+2*i]])\n if(c1!=c2):\n return False\n j+=i\n return True\n n = len(s)\n for i in range(1,n):\n if n%i==0 and ok(s,i):\n return i\n return n","memory":"18000"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n def minAnangram(number):\n set1 = set()\n for i in range(0, len(s), number):\n if not set1:\n set1.add(\"\".join(sorted(s[i:i+number])))\n continue\n if \"\".join(sorted(s[i:i+number])) not in set1:\n return False\n return True\n n = len(s)\n for i in range(1, int(n*0.5) + 1):\n if n % i == 0:\n if minAnangram(i):\n return i\n if minAnangram(n):\n return n\n\n \n \n\n \n \n ","memory":"18100"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(list(set(list(s))))==1:\n return 1\n d={}\n d2={}\n for i in s:\n d[i]=0\n d2[i]=0\n d1={}\n for i in s:\n if i not in d1:\n d1[i]=1\n else:\n d1[i]+=1\n c=0\n p=0\n for i in s:\n c3=0\n c1=0\n d[i]+=1\n c+=1\n for i in d:\n if d[i]:\n c1+=1\n if c1==len(d) and len(s)%c==0:\n s2=\"\"\n j=c\n m=0\n while(j<len(s)):\n m+=1\n c2=0\n s2+=s[j]\n if m%c==0:\n # print(s2)\n for t in s2:\n d2[t]+=1\n for t in d2:\n if d2[t]==d[t]:\n c2+=1\n if c2==len(d2):\n c3+=1\n \n s2=\"\"\n m=0\n for g in d2:\n d2[g]=0\n j+=1\n # print(d2)\n # print(c3)\n if c3+1==len(s)//c:\n return c\n p+=1\n return c","memory":"18200"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n for groupsize in range(1, len(s) + 1):\n if len(s) % groupsize == 0:\n size = True\n target = sorted(s[:groupsize])\n numgroups = len(s) // groupsize\n for n in range(numgroups - 1):\n if sorted(s[(n + 1) * groupsize:(n + 2) * groupsize]) != target:\n size = False\n break\n if size:\n return groupsize\n ","memory":"18500"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n\n d = {}\n\n for i in range(n):\n if s[i] not in d:\n d[s[i]] = 1\n else:\n d[s[i]] += 1\n \n no_of_distinct = len(d)\n\n # finding the factors of n\n factors = []\n for i in range(1, int(n**(0.5)) + 1):\n if n%i == 0:\n if i != n//i:\n factors.append(i)\n factors.append(n//i)\n else:\n factors.append(i) \n # print(factors)\n factors = sorted(factors)\n # print(factors)\n\n idx = -1\n for i in range(len(factors)):\n if factors[i] >= no_of_distinct:\n idx = i\n break\n # print(factors[idx:])\n\n mini = int(1e9)\n for each_factor in factors[idx:]:\n p = 0\n res = sorted(s[0:each_factor])\n count = 1\n p = p + each_factor \n while p < n:\n if sorted(s[p:p+each_factor]) == res:\n count += 1\n p += each_factor\n \n if count == (n//each_factor):\n return each_factor","memory":"18600"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n l = list(s)\n n = len(s)\n for i in range(1, n):\n if n % i == 0:\n il = sorted(s[:i])\n for j in range(i, n, i):\n temp = l[j:j + i]\n temp.sort()\n \n if il != temp:\n break\n else:\n return i\n\n return n\n \n\n","memory":"18900"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n chars = list(s)\n length = len(s)\n \n for size in range(1, length):\n if length % size == 0:\n sorted_initial = sorted(chars[:size])\n \n for i in range(size, length, size):\n current_segment = chars[i:i+size]\n current_segment.sort()\n \n if sorted_initial != current_segment:\n break\n else:\n return size\n \n return length\n","memory":"19200"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n stringList = list(s)\n n = len(s)\n for size in range(1, n):\n if n % size == 0: \n initialList = sorted(stringList[:size])\n for j in range(size, n, size):\n temp = stringList[j:j+size]\n temp.sort()\n\n if initialList != temp: \n break\n else:\n return size\n \n return n","memory":"19300"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n \n # Find all divisors of n\n divisors = []\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n // i)\n \n # Check each divisor length\n for divisor in sorted(divisors):\n substring_length = divisor\n substring = s[:substring_length]\n anagram = True\n \n # Check if all substrings of length substring_length are anagrams\n for i in range(0, n, substring_length):\n if sorted(s[i:i+substring_length]) != sorted(substring):\n anagram = False\n break\n \n if anagram:\n return substring_length\n \n return n # If no anagram found, return the length of s\n\n# Test cases\nsol = Solution()\nprint(sol.minAnagramLength(\"abba\")) # Output: 2\nprint(sol.minAnagramLength(\"cdef\")) # Output: 4","memory":"19400"},{"code":"from math import sqrt\nfrom collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n factors = []\n for i in range(1, int(sqrt(len(s))) + 1):\n if len(s) % i == 0:\n if len(s) // i == i:\n factors.append(i)\n else:\n factors.append(i)\n factors.append(len(s) // i)\n \n factors.sort()\n\n for i in factors:\n # i is size of subaray\n match = set()\n for j in range(0, len(s), i):\n chars = [0] * 26\n for k in range(j, j + i):\n chars[ord(s[k]) - ord('a')] += 1\n match.add(tuple(chars))\n if len(match) == 1:\n return i\n \n return len(s)\n \n\n\n\n\n\n \n\n ","memory":"21900"},{"code":"from math import sqrt\nfrom collections import Counter\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n\n for i in range(1, len(s)):\n if len(s) % i != 0:\n continue\n # i is size of subaray\n match = set()\n for j in range(0, len(s), i):\n chars = [0] * 26\n for k in range(j, j + i):\n chars[ord(s[k]) - ord('a')] += 1\n match.add(tuple(chars))\n if len(match) == 1:\n return i\n\n return len(s)\n\n # def check(k: int) -> bool:\n # for i in range(0, n, k):\n # cnt1 = Counter(s[i : i + k])\n # for c, v in cnt.items():\n # if cnt1[c] * (n // k) != v:\n # return False\n # return True\n\n # cnt = Counter(s)\n # n = len(s)\n # for i in range(1, n + 1):\n # if n % i == 0 and check(i):\n # return i\n \n\n\n\n\n\n \n\n ","memory":"21900"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n answer = len(s)\n for i in range(answer-1, 0, -1):\n if len(s) % i == 0:\n number_mini_words = int(len(s)/i)\n mini_words = [s[j:j+i] for j in range(0, len(s), i)]\n first_anagram = mini_words[0]\n is_anagrams = all(sorted(first_anagram) == sorted(x) for x in mini_words)\n if is_anagrams:\n answer = len(mini_words[0])\n\n return answer","memory":"24500"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n if len(s) == 1:\n return 1\n minimum = len(s)\n for i in reversed(range(1, len(s))):\n if len(s) % i == 0:\n splits = [s[j:j+i] for j in range(0, len(s), i)]\n first = sorted(splits[0])\n others = splits[1:]\n if all(sorted(k) == first for k in others):\n minimum = i\n return minimum\n","memory":"25500"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n \n def isValid(x):\n seen=set()\n for i in range(0,len(s),x):\n seen.add(tuple(sorted(s[i:i+x])))\n return len(seen)==1\n\n for i in range(1,len(s)//2+1):\n if len(s)%i!=0:\n continue\n if isValid(i):\n return i\n \n return len(s)","memory":"26100"},{"code":"def check(s, k):\n count = len(s) // k\n every = set()\n for i in range(0, len(s), k):\n cur = s[i:i+k]\n c = tuple(sorted(Counter(cur).items()))\n every.add(c)\n return len(every) == 1\n\n\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n \n for k in range(1, len(s)):\n if len(s)%k == 0:\n if check(s, k):\n return k\n return len(s)\n ","memory":"26300"},{"code":"import numpy as np\nclass Solution:\n def minAnagramLength(self, s: str) -> int:\n stringList = list(s)\n n = len(s)\n for size in range(1, n):\n if n % size == 0: \n initialList = sorted(stringList[:size])\n for j in range(size, n, size):\n temp = stringList[j:j+size]\n temp.sort()\n\n if initialList != temp: \n break\n else:\n return size\n \n return n","memory":"31300"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n letters = set(s)\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\n dp = {letter: [(-1, 0)] for letter in letters}\n for idx, letter in enumerate(s):\n l = dp[letter]\n l.append((idx, l[-1][1] + 1))\n #print(dp)\n for d in range(1, len(s) + 1):\n if len(s) % d != 0:\n continue\n counts = None # dict, will contain count of every letter in the first batch\n # next batches must have the same counts\n for start_idx in range(0, len(s), d):\n end_idx = start_idx + d - 1\n curr_counts = {}\n for letter in letters:\n # find the first and last occurence of this letter in the current batch\n l = dp[letter]\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\n #print(f\"{(d, letter, start_idx, end_idx, idx_left, idx_right) = }\")\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\n if counts is None:\n counts = curr_counts\n elif counts != curr_counts:\n break\n else: # no break, we've found a good partitioning\n return d","memory":"31500"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n letters = set(s)\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\n dp = {letter: [(-1, 0)] for letter in letters}\n for idx, letter in enumerate(s):\n l = dp[letter]\n l.append((idx, l[-1][1] + 1))\n\n for d in range(1, len(s) + 1):\n if len(s) % d != 0:\n continue\n counts = None # dict, will contain count of every letter in the first batch\n # next batches must have the same counts\n for start_idx in range(0, len(s), d):\n end_idx = start_idx + d - 1\n curr_counts = {}\n for letter in letters:\n # find the first and last occurence of this letter in the current batch\n l = dp[letter]\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\n if counts is None:\n counts = curr_counts\n elif counts != curr_counts:\n break\n else: # no break, we've found a good partitioning\n return d","memory":"31500"},{"code":"import numpy as np\nclass Solution:\n def anagram_of_string(self, k: int) -> bool:\n # Checks if string length t that has a concatenation of anagrams to produce s\n # k < len(s)\n # self.s = \"abbaab\"; k = 2\n i: int = 0 # 1\n # iterate over each string\n slice_hash: list[int] = [] # [161, 161,]\n while i*k < len(self.s): # 1*2 < 6\n this_slice = self.s[i*k: (i+1)*k] # 'ba'\n # encode string in invariant format i.e. up to permutation\n char_count: list[int] = [0]*26 # [0,0,0,0,0,0,0]\n for char in this_slice: # 'b'\n char_count[ord(char) - ord('a')] += 1\n char_count_hash = hash(tuple(char_count)) # 616\n slice_hash.append(char_count_hash)\n i += 1\n return all(x == slice_hash[0] for x in slice_hash)\n\n def minAnagramLength(self, s: str) -> int:\n self.s = s\n min_anagram_len: int | float = np.inf\n for k in range(len(s), 0, -1): # len(s), len(s)-1, len(s)-2,... 1\n # if k | len(s) try\n if len(s) % k == 0:\n ret_val = self.anagram_of_string(k)\n if ret_val:\n min_anagram_len = k\n return min_anagram_len \n\n'''\n\nFor every number k .. k | len(s)\n Check to see if s[0:k], s[k: 2k],.... are anagrams of each other O(N)\n\nTime O(N**2), space O(N)\n\n\n'''\n\n\n","memory":"35200"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n n = len(s)\n f = lambda ch: ord(ch) - ord('a')\n\n import numpy as np\n \n pre = np.zeros((n, 26))\n for i in range(n):\n pre[i] += pre[i - 1]\n pre[i][f(s[i])] += 1\n \n for i in range(n // 2 + 1):\n if n % (i + 1) == 0:\n ma = None\n for j in range(26):\n if pre[- 1][j] > 0:\n if pre[i][j] == 0 or (ma is not None and pre[- 1][j] // pre[i][j] != ma):\n ma = - 1\n break\n if ma is None:\n ma = pre[- 1][j] // pre[i][j]\n if ma != - 1:\n flag = True\n for j in range(i * 2 + 1, n - 1, i + 1):\n cur = pre[j] - pre[j - (i + 1)]\n if not all(cur[ci] == pre[i][ci] for ci in range(26)):\n flag = False\n break\n if flag:\n return i + 1\n return n\n ","memory":"58300"},{"code":"class Solution:\n def f(self, index: int, s: str, l: int, d: Dict[str, int]) -> bool:\n if index == len(s):\n return True\n\n d2: Dict[str, int] = dict(d)\n\n for j in range(index, index + l):\n if s[j] not in d2.keys():\n return False\n d2[s[j]] -= 1\n if d2[s[j]] == 0:\n d2.pop(s[j], None)\n\n if len(d2) > 0:\n return False\n\n return self.f(index + l, s, l, d)\n\n def minAnagramLength(self, s: str) -> int:\n for i in range(1, len(s) + 1):\n if len(s) % i != 0:\n continue\n\n d: Dict[str, int] = {}\n for j in range(0, i):\n if s[j] not in d.keys():\n d[s[j]] = 0\n d[s[j]] += 1\n\n if self.f(i, s, i, d):\n return i\n ","memory":"60100"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 # increment chunk size multiplier","memory":"72700"},{"code":"class Solution:\n def minAnagramLength(self, s: str) -> int:\n S, sc = len(s), Counter(s)\n x = math.gcd(*sc.values()) # GCD of all character counts\n \n i, k = 1, S // x # `k` is the smallest possible chunk size\n while True:\n t = i * k # current chunk size to try\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\n if r != 0: # chunk size doesn't divide S evenly\n i += 1\n continue\n\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\n\n # all chunks have the same set of char counts, thus t is the size\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\n # `s` is found, then when i == x, t equals len(s), which will be the answer\n\n i += 1 ","memory":"72800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n counter = dict()\\n n = len(s)\\n for i in range(n):\\n if s[i] not in counter:\\n counter[s[i]] = 1\\n else:\\n counter[s[i]] += 1\\n \\n distinct_letters = len(counter)\\n candidates = []\\n for i in range(n//distinct_letters, 0, -1):\\n if n % i != 0:\\n continue\\n breaker = False\\n for letter, count in counter.items():\\n if count % i != 0:\\n breaker = True\\n break\\n if not breaker:\\n candidates.append(i)\\n res = n\\n print(candidates)\\n print(counter)\\n for candidate in candidates:\\n temp_count = dict()\\n for i in range(n//candidate):\\n if s[i] not in temp_count:\\n temp_count[s[i]] = 1\\n else:\\n temp_count[s[i]] += 1\\n print(temp_count)\\n \\n if len(temp_count) < len(counter):\\n continue\\n k = 0\\n for letter, count in temp_count.items():\\n if k == 1:\\n break\\n count_to_check = count\\n letter_to_check = letter\\n k += 1\\n #print(count_to_check)\\n #print(letter_to_check)\\n if counter[letter_to_check] % count_to_check != 0 or counter[letter_to_check] // count_to_check != candidate:\\n print(candidate)\\n continue\\n bad_candidate = False\\n for letter, count in temp_count.items():\\n count_to_check = count\\n letter_to_check = letter\\n if counter[letter_to_check] // count != candidate:\\n bad_candidate = True\\n if bad_candidate:\\n continue\\n else:\\n for j in range(1, candidate):\\n new_count = {}\\n for k in range((n//candidate)*j, (n//candidate)*(j+1)):\\n #print(s[k])\\n if s[k] not in new_count:\\n new_count[s[k]] = 1\\n else:\\n new_count[s[k]] += 1\\n print(new_count)\\n if new_count != temp_count:\\n bad_candidate = True\\n break\\n if bad_candidate:\\n continue\\n else:\\n\\n\\n\\n res = n//candidate\\n break\\n return res\\n \\n \\n\\n \\n\\n \\n\\n\\n \\n\\n\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for i in range(1, len(s) + 1):\\n if len(s) % i:\\n continue\\n c = Counter(s[:i])\\n b = True\\n for j in range(i, len(s) - i + 1, i):\\n if Counter(s[j:j+i]) != c:\\n b = False\\n if b:\\n return i\\n return len(s)\\n\\n \",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n for i in range(1, n // 2 + 1):\\n if n % i == 0:\\n cur = Counter(s[:i])\\n for j in range(i * 2, n + 1, i):\\n if Counter(s[j - i: j]) != cur:\\n break\\n else:\\n return i\\n return n\",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n result = n\\n for l in range(1, n):\\n if n % l != 0:\\n continue\\n ref = Counter(s[0:0+l])\\n i = 0\\n isSame = True\\n while i < n:\\n cur = Counter(s[i:i+l])\\n if cur != ref:\\n isSame = False\\n break\\n i += l\\n if isSame:\\n return l\\n return result\\n \\n \",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n \\n # Helper function to check if two substrings are anagrams\\n def are_anagrams(s1, s2):\\n return Counter(s1) == Counter(s2)\\n \\n # Iterate over all possible divisors of n\\n for d in range(1, n + 1):\\n if n % d == 0:\\n # Check if all segments of length d are anagrams of the first segment\\n first_segment = s[:d]\\n all_anagrams = True\\n for i in range(d, n, d):\\n if not are_anagrams(first_segment, s[i:i+d]):\\n all_anagrams = False\\n break\\n if all_anagrams:\\n return d\\n \\n # This line should never be reached because n is always a divisor of itself\\n return n\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(solution.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n \\n factors_l = []\\n factors_h = []\\n factors =[]\\n n = len(s)\\n k = math.floor(math.sqrt(n))\\n print(n)\\n for i in range(1,k+1):\\n if(n%i==0):\\n factors_l.append(i)\\n if(i<n//i):\\n factors_h.append(n//i)\\n factors = factors_l+factors_h[::-1]\\n def check(k):\\n dic1 = [0 for _ in range(26)]\\n for i in range(k):\\n dic1[ord(s[i])-97]+=1\\n for i in range(0,n,k):\\n j = i\\n dic2 = [0 for _ in range(26)]\\n while(j<i+k and j<n):\\n dic2[ord(s[j])-97]+=1\\n j+=1\\n if(dic1!=dic2):\\n return False\\n return True\\n print(factors)\\n start = 0\\n end = len(factors)\\n ans = 0\\n for mid in range(end):\\n if(check(factors[mid])):\\n \\n ans = factors[mid]\\n return ans\\n \\n \\n return ans\\n\\n\\n\\n \",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def ok(s:str,i:int)->bool:\\n j=0\\n while j<len(s)-i:\\n c1 = Counter([ord(x)-ord('a') for x in s[j:j+i]])\\n c2 = Counter([ord(x)-ord('a') for x in s[j+i:j+2*i]])\\n if(c1!=c2):\\n return False\\n j+=i\\n return True\\n n = len(s)\\n for i in range(1,n):\\n if n%i==0 and ok(s,i):\\n return i\\n return n\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n def minAnangram(number):\\n set1 = set()\\n for i in range(0, len(s), number):\\n if not set1:\\n set1.add(\\\"\\\".join(sorted(s[i:i+number])))\\n continue\\n if \\\"\\\".join(sorted(s[i:i+number])) not in set1:\\n return False\\n return True\\n n = len(s)\\n for i in range(1, int(n*0.5) + 1):\\n if n % i == 0:\\n if minAnangram(i):\\n return i\\n if minAnangram(n):\\n return n\\n\\n \\n \\n\\n \\n \\n \",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(list(set(list(s))))==1:\\n return 1\\n d={}\\n d2={}\\n for i in s:\\n d[i]=0\\n d2[i]=0\\n d1={}\\n for i in s:\\n if i not in d1:\\n d1[i]=1\\n else:\\n d1[i]+=1\\n c=0\\n p=0\\n for i in s:\\n c3=0\\n c1=0\\n d[i]+=1\\n c+=1\\n for i in d:\\n if d[i]:\\n c1+=1\\n if c1==len(d) and len(s)%c==0:\\n s2=\\\"\\\"\\n j=c\\n m=0\\n while(j<len(s)):\\n m+=1\\n c2=0\\n s2+=s[j]\\n if m%c==0:\\n # print(s2)\\n for t in s2:\\n d2[t]+=1\\n for t in d2:\\n if d2[t]==d[t]:\\n c2+=1\\n if c2==len(d2):\\n c3+=1\\n \\n s2=\\\"\\\"\\n m=0\\n for g in d2:\\n d2[g]=0\\n j+=1\\n # print(d2)\\n # print(c3)\\n if c3+1==len(s)//c:\\n return c\\n p+=1\\n return c\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n for groupsize in range(1, len(s) + 1):\\n if len(s) % groupsize == 0:\\n size = True\\n target = sorted(s[:groupsize])\\n numgroups = len(s) // groupsize\\n for n in range(numgroups - 1):\\n if sorted(s[(n + 1) * groupsize:(n + 2) * groupsize]) != target:\\n size = False\\n break\\n if size:\\n return groupsize\\n \",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n\\n d = {}\\n\\n for i in range(n):\\n if s[i] not in d:\\n d[s[i]] = 1\\n else:\\n d[s[i]] += 1\\n \\n no_of_distinct = len(d)\\n\\n # finding the factors of n\\n factors = []\\n for i in range(1, int(n**(0.5)) + 1):\\n if n%i == 0:\\n if i != n//i:\\n factors.append(i)\\n factors.append(n//i)\\n else:\\n factors.append(i) \\n # print(factors)\\n factors = sorted(factors)\\n # print(factors)\\n\\n idx = -1\\n for i in range(len(factors)):\\n if factors[i] >= no_of_distinct:\\n idx = i\\n break\\n # print(factors[idx:])\\n\\n mini = int(1e9)\\n for each_factor in factors[idx:]:\\n p = 0\\n res = sorted(s[0:each_factor])\\n count = 1\\n p = p + each_factor \\n while p < n:\\n if sorted(s[p:p+each_factor]) == res:\\n count += 1\\n p += each_factor\\n \\n if count == (n//each_factor):\\n return each_factor\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n l = list(s)\\n n = len(s)\\n for i in range(1, n):\\n if n % i == 0:\\n il = sorted(s[:i])\\n for j in range(i, n, i):\\n temp = l[j:j + i]\\n temp.sort()\\n \\n if il != temp:\\n break\\n else:\\n return i\\n\\n return n\\n \\n\\n\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n chars = list(s)\\n length = len(s)\\n \\n for size in range(1, length):\\n if length % size == 0:\\n sorted_initial = sorted(chars[:size])\\n \\n for i in range(size, length, size):\\n current_segment = chars[i:i+size]\\n current_segment.sort()\\n \\n if sorted_initial != current_segment:\\n break\\n else:\\n return size\\n \\n return length\\n\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n stringList = list(s)\\n n = len(s)\\n for size in range(1, n):\\n if n % size == 0: \\n initialList = sorted(stringList[:size])\\n for j in range(size, n, size):\\n temp = stringList[j:j+size]\\n temp.sort()\\n\\n if initialList != temp: \\n break\\n else:\\n return size\\n \\n return n\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n \\n # Find all divisors of n\\n divisors = []\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n divisors.append(i)\\n if i != n // i:\\n divisors.append(n // i)\\n \\n # Check each divisor length\\n for divisor in sorted(divisors):\\n substring_length = divisor\\n substring = s[:substring_length]\\n anagram = True\\n \\n # Check if all substrings of length substring_length are anagrams\\n for i in range(0, n, substring_length):\\n if sorted(s[i:i+substring_length]) != sorted(substring):\\n anagram = False\\n break\\n \\n if anagram:\\n return substring_length\\n \\n return n # If no anagram found, return the length of s\\n\\n# Test cases\\nsol = Solution()\\nprint(sol.minAnagramLength(\\\"abba\\\")) # Output: 2\\nprint(sol.minAnagramLength(\\\"cdef\\\")) # Output: 4\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"from math import sqrt\\nfrom collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n factors = []\\n for i in range(1, int(sqrt(len(s))) + 1):\\n if len(s) % i == 0:\\n if len(s) // i == i:\\n factors.append(i)\\n else:\\n factors.append(i)\\n factors.append(len(s) // i)\\n \\n factors.sort()\\n\\n for i in factors:\\n # i is size of subaray\\n match = set()\\n for j in range(0, len(s), i):\\n chars = [0] * 26\\n for k in range(j, j + i):\\n chars[ord(s[k]) - ord('a')] += 1\\n match.add(tuple(chars))\\n if len(match) == 1:\\n return i\\n \\n return len(s)\\n \\n\\n\\n\\n\\n\\n \\n\\n \",\n \"memory\": \"21900\"\n },\n {\n \"code\": \"from math import sqrt\\nfrom collections import Counter\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n\\n for i in range(1, len(s)):\\n if len(s) % i != 0:\\n continue\\n # i is size of subaray\\n match = set()\\n for j in range(0, len(s), i):\\n chars = [0] * 26\\n for k in range(j, j + i):\\n chars[ord(s[k]) - ord('a')] += 1\\n match.add(tuple(chars))\\n if len(match) == 1:\\n return i\\n\\n return len(s)\\n\\n # def check(k: int) -> bool:\\n # for i in range(0, n, k):\\n # cnt1 = Counter(s[i : i + k])\\n # for c, v in cnt.items():\\n # if cnt1[c] * (n // k) != v:\\n # return False\\n # return True\\n\\n # cnt = Counter(s)\\n # n = len(s)\\n # for i in range(1, n + 1):\\n # if n % i == 0 and check(i):\\n # return i\\n \\n\\n\\n\\n\\n\\n \\n\\n \",\n \"memory\": \"21900\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n answer = len(s)\\n for i in range(answer-1, 0, -1):\\n if len(s) % i == 0:\\n number_mini_words = int(len(s)/i)\\n mini_words = [s[j:j+i] for j in range(0, len(s), i)]\\n first_anagram = mini_words[0]\\n is_anagrams = all(sorted(first_anagram) == sorted(x) for x in mini_words)\\n if is_anagrams:\\n answer = len(mini_words[0])\\n\\n return answer\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n if len(s) == 1:\\n return 1\\n minimum = len(s)\\n for i in reversed(range(1, len(s))):\\n if len(s) % i == 0:\\n splits = [s[j:j+i] for j in range(0, len(s), i)]\\n first = sorted(splits[0])\\n others = splits[1:]\\n if all(sorted(k) == first for k in others):\\n minimum = i\\n return minimum\\n\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n \\n def isValid(x):\\n seen=set()\\n for i in range(0,len(s),x):\\n seen.add(tuple(sorted(s[i:i+x])))\\n return len(seen)==1\\n\\n for i in range(1,len(s)//2+1):\\n if len(s)%i!=0:\\n continue\\n if isValid(i):\\n return i\\n \\n return len(s)\",\n \"memory\": \"26100\"\n },\n {\n \"code\": \"def check(s, k):\\n count = len(s) // k\\n every = set()\\n for i in range(0, len(s), k):\\n cur = s[i:i+k]\\n c = tuple(sorted(Counter(cur).items()))\\n every.add(c)\\n return len(every) == 1\\n\\n\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n \\n for k in range(1, len(s)):\\n if len(s)%k == 0:\\n if check(s, k):\\n return k\\n return len(s)\\n \",\n \"memory\": \"26300\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def minAnagramLength(self, s: str) -> int:\\n stringList = list(s)\\n n = len(s)\\n for size in range(1, n):\\n if n % size == 0: \\n initialList = sorted(stringList[:size])\\n for j in range(size, n, size):\\n temp = stringList[j:j+size]\\n temp.sort()\\n\\n if initialList != temp: \\n break\\n else:\\n return size\\n \\n return n\",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n letters = set(s)\\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\\n dp = {letter: [(-1, 0)] for letter in letters}\\n for idx, letter in enumerate(s):\\n l = dp[letter]\\n l.append((idx, l[-1][1] + 1))\\n #print(dp)\\n for d in range(1, len(s) + 1):\\n if len(s) % d != 0:\\n continue\\n counts = None # dict, will contain count of every letter in the first batch\\n # next batches must have the same counts\\n for start_idx in range(0, len(s), d):\\n end_idx = start_idx + d - 1\\n curr_counts = {}\\n for letter in letters:\\n # find the first and last occurence of this letter in the current batch\\n l = dp[letter]\\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\\n #print(f\\\"{(d, letter, start_idx, end_idx, idx_left, idx_right) = }\\\")\\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\\n if counts is None:\\n counts = curr_counts\\n elif counts != curr_counts:\\n break\\n else: # no break, we've found a good partitioning\\n return d\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n letters = set(s)\\n # letter -> (index when we previosly saw said letter, count of said letter thus far)\\n dp = {letter: [(-1, 0)] for letter in letters}\\n for idx, letter in enumerate(s):\\n l = dp[letter]\\n l.append((idx, l[-1][1] + 1))\\n\\n for d in range(1, len(s) + 1):\\n if len(s) % d != 0:\\n continue\\n counts = None # dict, will contain count of every letter in the first batch\\n # next batches must have the same counts\\n for start_idx in range(0, len(s), d):\\n end_idx = start_idx + d - 1\\n curr_counts = {}\\n for letter in letters:\\n # find the first and last occurence of this letter in the current batch\\n l = dp[letter]\\n idx_left = bisect_right(l, start_idx - 1, key=itemgetter(0)) - 1\\n idx_right = bisect_right(l, end_idx, key=itemgetter(0)) - 1\\n curr_counts[letter] = l[idx_right][1] - l[idx_left][1]\\n if counts is None:\\n counts = curr_counts\\n elif counts != curr_counts:\\n break\\n else: # no break, we've found a good partitioning\\n return d\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"import numpy as np\\nclass Solution:\\n def anagram_of_string(self, k: int) -> bool:\\n # Checks if string length t that has a concatenation of anagrams to produce s\\n # k < len(s)\\n # self.s = \\\"abbaab\\\"; k = 2\\n i: int = 0 # 1\\n # iterate over each string\\n slice_hash: list[int] = [] # [161, 161,]\\n while i*k < len(self.s): # 1*2 < 6\\n this_slice = self.s[i*k: (i+1)*k] # 'ba'\\n # encode string in invariant format i.e. up to permutation\\n char_count: list[int] = [0]*26 # [0,0,0,0,0,0,0]\\n for char in this_slice: # 'b'\\n char_count[ord(char) - ord('a')] += 1\\n char_count_hash = hash(tuple(char_count)) # 616\\n slice_hash.append(char_count_hash)\\n i += 1\\n return all(x == slice_hash[0] for x in slice_hash)\\n\\n def minAnagramLength(self, s: str) -> int:\\n self.s = s\\n min_anagram_len: int | float = np.inf\\n for k in range(len(s), 0, -1): # len(s), len(s)-1, len(s)-2,... 1\\n # if k | len(s) try\\n if len(s) % k == 0:\\n ret_val = self.anagram_of_string(k)\\n if ret_val:\\n min_anagram_len = k\\n return min_anagram_len \\n\\n'''\\n\\nFor every number k .. k | len(s)\\n Check to see if s[0:k], s[k: 2k],.... are anagrams of each other O(N)\\n\\nTime O(N**2), space O(N)\\n\\n\\n'''\\n\\n\\n\",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n n = len(s)\\n f = lambda ch: ord(ch) - ord('a')\\n\\n import numpy as np\\n \\n pre = np.zeros((n, 26))\\n for i in range(n):\\n pre[i] += pre[i - 1]\\n pre[i][f(s[i])] += 1\\n \\n for i in range(n // 2 + 1):\\n if n % (i + 1) == 0:\\n ma = None\\n for j in range(26):\\n if pre[- 1][j] > 0:\\n if pre[i][j] == 0 or (ma is not None and pre[- 1][j] // pre[i][j] != ma):\\n ma = - 1\\n break\\n if ma is None:\\n ma = pre[- 1][j] // pre[i][j]\\n if ma != - 1:\\n flag = True\\n for j in range(i * 2 + 1, n - 1, i + 1):\\n cur = pre[j] - pre[j - (i + 1)]\\n if not all(cur[ci] == pre[i][ci] for ci in range(26)):\\n flag = False\\n break\\n if flag:\\n return i + 1\\n return n\\n \",\n \"memory\": \"58300\"\n },\n {\n \"code\": \"class Solution:\\n def f(self, index: int, s: str, l: int, d: Dict[str, int]) -> bool:\\n if index == len(s):\\n return True\\n\\n d2: Dict[str, int] = dict(d)\\n\\n for j in range(index, index + l):\\n if s[j] not in d2.keys():\\n return False\\n d2[s[j]] -= 1\\n if d2[s[j]] == 0:\\n d2.pop(s[j], None)\\n\\n if len(d2) > 0:\\n return False\\n\\n return self.f(index + l, s, l, d)\\n\\n def minAnagramLength(self, s: str) -> int:\\n for i in range(1, len(s) + 1):\\n if len(s) % i != 0:\\n continue\\n\\n d: Dict[str, int] = {}\\n for j in range(0, i):\\n if s[j] not in d.keys():\\n d[s[j]] = 0\\n d[s[j]] += 1\\n\\n if self.f(i, s, i, d):\\n return i\\n \",\n \"memory\": \"60100\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 # increment chunk size multiplier\",\n \"memory\": \"72700\"\n },\n {\n \"code\": \"class Solution:\\n def minAnagramLength(self, s: str) -> int:\\n S, sc = len(s), Counter(s)\\n x = math.gcd(*sc.values()) # GCD of all character counts\\n \\n i, k = 1, S // x # `k` is the smallest possible chunk size\\n while True:\\n t = i * k # current chunk size to try\\n n, r = divmod(S, t) # `n` is the count of chunks, each with length of `t`\\n if r != 0: # chunk size doesn't divide S evenly\\n i += 1\\n continue\\n\\n # get a k-list of char-counts for each chunk of `s`, with a size of `t` each\\n ssc_ls = [Counter(s[i*t: (i+1)*t]) for i in range(n)]\\n\\n # all chunks have the same set of char counts, thus t is the size\\n if all(cc == ssc_ls[0] for cc in ssc_ls): return t\\n # NOTE: the while-loop will always be able to exit; if no `t` shorter than\\n # `s` is found, then when i == x, t equals len(s), which will be the answer\\n\\n i += 1 \",\n \"memory\": \"72800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":29,"string":"29"}}},{"rowIdx":2435,"cells":{"question_id":{"kind":"number","value":3402,"string":"3,402"},"name":{"kind":"string","value":"minimum-cost-to-equalize-array"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code> and two integers <code>cost1</code> and <code>cost2</code>. You are allowed to perform <strong>either</strong> of the following operations <strong>any</strong> number of times:</p>\n\n<ul>\n\t<li>Choose an index <code>i</code> from <code>nums</code> and <strong>increase</strong> <code>nums[i]</code> by <code>1</code> for a cost of <code>cost1</code>.</li>\n\t<li>Choose two <strong>different</strong> indices <code>i</code>, <code>j</code>, from <code>nums</code> and <strong>increase</strong> <code>nums[i]</code> and <code>nums[j]</code> by <code>1</code> for a cost of <code>cost2</code>.</li>\n</ul>\n\n<p>Return the <strong>minimum</strong> <strong>cost</strong> required to make all elements in the array <strong>equal</strong><em>. </em></p>\n\n<p>Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [4,1], cost1 = 5, cost2 = 2</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">15</span></p>\n\n<p><strong>Explanation: </strong></p>\n\n<p>The following operations can be performed to make the values equal:</p>\n\n<ul>\n\t<li>Increase <code>nums[1]</code> by 1 for a cost of 5. <code>nums</code> becomes <code>[4,2]</code>.</li>\n\t<li>Increase <code>nums[1]</code> by 1 for a cost of 5. <code>nums</code> becomes <code>[4,3]</code>.</li>\n\t<li>Increase <code>nums[1]</code> by 1 for a cost of 5. <code>nums</code> becomes <code>[4,4]</code>.</li>\n</ul>\n\n<p>The total cost is 15.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [2,3,3,3,5], cost1 = 2, cost2 = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">6</span></p>\n\n<p><strong>Explanation: </strong></p>\n\n<p>The following operations can be performed to make the values equal:</p>\n\n<ul>\n\t<li>Increase <code>nums[0]</code> and <code>nums[1]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[3,4,3,3,5]</code>.</li>\n\t<li>Increase <code>nums[0]</code> and <code>nums[2]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[4,4,4,3,5]</code>.</li>\n\t<li>Increase <code>nums[0]</code> and <code>nums[3]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[5,4,4,4,5]</code>.</li>\n\t<li>Increase <code>nums[1]</code> and <code>nums[2]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[5,5,5,4,5]</code>.</li>\n\t<li>Increase <code>nums[3]</code> by 1 for a cost of 2. <code>nums</code> becomes <code>[5,5,5,5,5]</code>.</li>\n</ul>\n\n<p>The total cost is 6.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [3,5,3], cost1 = 1, cost2 = 3</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The following operations can be performed to make the values equal:</p>\n\n<ul>\n\t<li>Increase <code>nums[0]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[4,5,3]</code>.</li>\n\t<li>Increase <code>nums[0]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[5,5,3]</code>.</li>\n\t<li>Increase <code>nums[2]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[5,5,4]</code>.</li>\n\t<li>Increase <code>nums[2]</code> by 1 for a cost of 1. <code>nums</code> becomes <code>[5,5,5]</code>.</li>\n</ul>\n\n<p>The total cost is 4.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>\n\t<li><code>1 <= cost1 <= 10<sup>6</sup></code></li>\n\t<li><code>1 <= cost2 <= 10<sup>6</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":16.868398735641048,"string":"16.868399"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","greedy","enumeration"],"string":"[\n \"array\",\n \"greedy\",\n \"enumeration\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"559\", 0.9901], [\"560\", 0.9901], [\"565\", 0.9901], [\"567\", 0.9901], [\"568\", 1.9802], [\"569\", 0.9901], [\"570\", 2.9703], [\"571\", 0.9901], [\"572\", 1.9802], [\"574\", 2.9703], [\"575\", 4.9505], [\"576\", 2.9703], [\"577\", 0.9901], [\"578\", 2.9703], [\"579\", 0.9901], [\"580\", 2.9703], [\"581\", 1.9802], [\"583\", 1.9802], [\"584\", 1.9802], [\"586\", 2.9703], [\"587\", 0.9901], [\"588\", 1.9802], [\"589\", 2.9703], [\"590\", 0.9901], [\"591\", 0.9901], [\"594\", 0.9901], [\"595\", 0.9901], [\"596\", 0.9901], [\"597\", 0.9901], [\"599\", 0.9901], [\"600\", 1.9802], [\"603\", 0.9901], [\"605\", 1.9802], [\"606\", 0.9901], [\"627\", 0.9901], [\"628\", 0.9901], [\"632\", 0.9901], [\"635\", 0.9901], [\"637\", 0.9901], [\"638\", 0.9901], [\"639\", 1.9802], [\"640\", 0.9901], [\"643\", 0.9901], [\"645\", 2.9703], [\"646\", 0.9901], [\"648\", 0.9901], [\"655\", 0.9901], [\"656\", 0.9901], [\"657\", 0.9901], [\"660\", 0.9901], [\"662\", 1.9802], [\"663\", 0.9901], [\"666\", 0.9901], [\"669\", 0.9901], [\"715\", 0.9901], [\"1047\", 0.9901], [\"1075\", 0.9901], [\"1113\", 0.9901], [\"1263\", 0.9901], [\"1446\", 0.9901], [\"1496\", 0.9901], [\"1945\", 0.9901], [\"2333\", 0.9901], [\"3492\", 0.9901], [\"7546\", 0.9901]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"30600\", 0.9901], [\"31000\", 0.9901], [\"31400\", 0.9901], [\"31600\", 3.9604], [\"31700\", 38.6139], [\"31800\", 48.5149]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n m = 10 ** 9 + 7\n \n # simple edge cases: if len(nums) < 3 then there is no reason to worry about cost2, as the second operation never does anything\n if n == 1:\n return 0\n if n == 2:\n return ((max(nums) - min(nums)) * cost1) % m\n \n # hole represents the difference between the highest and lowest value\n hole = max(nums) - min(nums)\n # needed represents the total difference between the highest number and all other numbers\n # essentially the total number of squares that need to be filled in\n needed = max(nums) * n - sum(nums)\n cost = 0\n \n # if individual operations are cheaper or as cheap, we can stop here\n if cost1 * 2 <= cost2:\n \n return (needed * cost1) % m\n \n # since it is better to do 2 operations at a time, try to fill in all of the squares using this method\n # we want to end up with either all squares filled or all squares filled with the shallowest single space hole possible\n if needed // 2 >= hole:\n # all squares (except possibly one if there is an odd number) can be filled\n easy = needed // 2\n hole = needed - 2 * easy # 1 or 0\n else:\n # not all squares are filled, do our best to reduce the size of the hole\n easy = needed - hole\n hole = hole - easy\n \n # cost after doing all simple operations\n cost = easy * cost2\n \n # now we calculate the cost to fill in the last hole\n # usually, it is cheaper to fill in individually with cost1\n # however, if cost2 is much lower than cost1 it can be more efficient to add 1 to all numbers\n # we perform the 2nd operation many times, always choosing the lowest point as one of the indices\n def minCost(hole_size):\n # basic case, no shenanigans\n best = cost1 * hole_size\n\n # the hole is shallow enough that we only have to raise the level by one to fill it\n if hole_size + 1 < n:\n # the number of operations needed to fill the hole + the number needed to raise the level by 2\n fill = ((hole_size + n) // 2)\n \n if (hole_size + n - fill * 2) == 1:\n # sometimes there are an odd number of blocks and we are left with a 1 block deep hole\n if n % 2 == 1:\n # here we are checking whether it is cheaper to use cost1 once or raise the level again to avoid it\n # this is only possible if n is odd\n best = min(best, fill * cost2 + min(cost1, cost2 * ((n + 1) // 2)))\n else:\n best = min(best, fill * cost2 + cost1)\n else:\n best = min(best, fill * cost2)\n # if the hole is so deep that it cannot be filled by adding one level, we add multiple\n else:\n # the change in hole depth after each operation\n gain = n - 2\n # the number of levels to add\n levels = hole_size // gain\n # the number of operations we need to add a level\n fill = n - 1\n best = min(best, minCost(hole_size - gain * levels) + cost2 * fill * levels)\n return best\n \n\n cost += minCost(hole)\n return cost % m","runtime":"559"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n # Easy case, Op 1\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n # Corner case with the last one spot left\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n # Two Operations:\n # Op 1: Directly fill maxGap\n # Op 2: Pair maxGap with other nums, which increases the final level.\n\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n # Op 1 is better\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n # Op 2 is better\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\n if (n+maxGap) % 2 == 1:\n # The last one spot left\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n # Compare it with Op 1 \n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"560"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n ma, mi = max(A), min(A)\n n = len(A)\n mod = 10 ** 9 + 7\n total = ma * n - sum(A)\n\n # case 1\n if c1 * 2 <= c2 or n <= 2:\n return total * c1 % mod\n\n # case 2\n op1 = max(0, (ma - mi) * 2 - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\n\n # case 3\n total += op1 // (n - 2) * n\n op1 %= n - 2\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\n\n # case 4\n for i in range(2):\n total += n\n res = min(res, total % 2 * c1 + total // 2 * c2)\n return res % mod","runtime":"565"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n # Easy case, Op 1\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n # Corner case with the last one spot left\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n # Two Operations:\n # Op 1: Directly fill maxGap\n # Op 2: Pair maxGap with other nums, which increases the final level.\n\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n # Op 1 is better\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n # Op 2 is better\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\n if (n+maxGap) % 2 == 1:\n # The last one spot left\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n # Compare it with Op 1 \n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"567"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n ma, mi = max(A), min(A)\n n = len(A)\n mod = 10 ** 9 + 7\n total = ma * n - sum(A)\n\n # case 1\n if c1 * 2 <= c2 or n <= 2:\n return total * c1 % mod\n\n # case 2\n op1 = max(0, (ma - mi) * 2 - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\n\n # case 3\n total += op1 // (n - 2) * n\n op1 %= n - 2\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\n\n # case 4\n for i in range(2):\n total += n\n res = min(res, total % 2 * c1 + total // 2 * c2)\n return res % mod\n ","runtime":"568"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n diff = m - min(nums)\n total = n*m - sum(nums)\n if n <= 2 or 2*cost1 <= cost2: \n return total*cost1 % mod\n ans = 0 \n op2 = total - max(0, 2*diff - total)\n ans = (ans + op2//2*cost2) % mod \n x = max(2*diff-total, total%2)\n cand = x*cost1\n q, x = divmod(x, n-2)\n more = (n+x)//2*cost2 \n if (n-x)&1: \n if n&1: more += min(cost1, (n+1)//2*cost2)\n else: more += cost1 \n cand = min(cand, q*(n-1)*cost2 + min(x*cost1, more)) \n return (ans + cand) % mod","runtime":"569"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n MOD = 10 ** 9 + 7\n c2 = min(c2, 2 * c1)\n N, S, mi, ma = len(A), sum(A), min(A), max(A)\n\n def cost(height):\n if height < ma:\n return inf\n \n biggest = height - mi\n volume = height * N - S\n if biggest <= volume - biggest:\n return c2 * (volume//2) + c1 * (volume%2)\n return c2 * (volume - biggest) + c1 * (2 * biggest - volume)\n\n biggest = ma - mi\n volume = ma * N - S\n if N <= 2:\n return volume * c1 % MOD\n\n alpha = (S - 2*mi) // (N - 2)\n beta = ma + ceil(max(2 * biggest - volume, 0) / (N - 2))\n return min(cost(p) for p in [ma, ma+1, alpha, beta, beta+1]) % MOD","runtime":"570"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n # Easy case, Op 1\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n # Corner case with the last one spot left\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n # Two Operations:\n # Op 1: Directly fill maxGap\n # Op 2: Pair maxGap with other nums, which increases the final level.\n\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n # Op 1 is better\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n # Op 2 is better\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\n if (n+maxGap) % 2 == 1:\n # The last one spot left\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n # Compare it with Op 1 \n res += min(op2, maxGap * cost1)\n\n return res % mod ","runtime":"571"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n mod = 10 ** 9 + 7\n work = max(nums) * n - sum(nums) # work to be done\n\n # CASE 1\n if cost1 * 2 <= cost2 or n <= 2: \n return work * cost1 % mod\n\n # CASE 2\n max_pair_ctns = (max(nums) - min(nums)) * 2 # max contribution by greedy pairing scheme\n extra_work = max(0, max_pair_ctns - work)\n\n\n # 2.a: do extra work with only single operations\n lone_ctn = extra_work\n pair_ctn = work - lone_ctn\n scha = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2 \n\n # adjust extra work for optimal pairs\n # - 2 are the item with leftover units and max item\n work += extra_work // (n - 2) * n \n \n # 2.b: do extra work with a mixture of pair and single operations \n lone_ctn = lone_ctn % (n - 2)\n pair_ctn = work - lone_ctn\n schb = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2\n\n # 2.c: do extra with maximum number pair operations\n schc = maxsize\n for i in range(2):\n work += n\n schc = min(schc, work % 2 * cost1 + work // 2 * cost2)\n \n return min(scha, schb, schc) % mod","runtime":"572"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n maxi = max(nums)\n mini = min(nums)\n MOD = 10**9 + 7\n total = max(nums) * n - sum(nums)\n # case 1: cost 1 is too cheap\n if cost1 <= cost2 / 2 or n <= 2:\n return total * cost1 % MOD\n \n # case 2: cost 1 & cost 2 mixing\n op1 = max(0, 2 * (maxi - mini) - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\n \n # case 3: cost 1 too expensive than cost 2, so we increase total\n total += op1 // (n-2) * n\n op1 = op1 % (n-2)\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\n\n # case 4: cost 1 too expensive, only use cost 2 and maybe 0 or 1 cost 1\n for i in range(2):\n total += n\n res = min(res, total % 2 * cost1 + total//2 * cost2)\n return res % MOD","runtime":"574"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n ma, mi = max(A), min(A)\n n = len(A)\n mod = 10 ** 9 + 7\n total = ma * n - sum(A)\n\n # case 1\n if c1 * 2 <= c2 or n <= 2:\n return total * c1 % mod\n\n # case 2\n op1 = max(0, (ma - mi) * 2 - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\n\n # case 3\n total += op1 // (n - 2) * n\n op1 %= n - 2\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\n\n # case 4\n for i in range(2):\n total += n\n res = min(res, total % 2 * c1 + total // 2 * c2)\n return res % mod","runtime":"575"},{"code":"class Solution:\n def minCostToEqualizeArray(self, temperatures: List[int], single_adjustment_cost: int, pair_adjustment_cost: int) -> int:\n \"\"\"\n Calculate the minimum cost to equalize the temperatures of all server racks.\n\n Parameters:\n temperatures (List[int]): List of integers representing current temperatures of server racks.\n single_adjustment_cost (int): Cost to increase the temperature of a single rack by 1 degree.\n pair_adjustment_cost (int): Cost to increase the temperature of two different racks by 1 degree each.\n\n Returns:\n int: The minimum cost to equalize all temperatures, modulo 10^9 + 7.\n \"\"\"\n \n # Constants\n MOD = 10 ** 9 + 7\n\n # Step 1: Find maximum and minimum temperatures\n max_temp = max(temperatures)\n min_temp = min(temperatures)\n num_racks = len(temperatures)\n\n # Step 2: Calculate the total number of increments required to equalize all racks to the maximum temperature\n total_increments = max_temp * num_racks - sum(temperatures)\n\n # Case 1: If it's cheaper to adjust one rack at a time or if there are only 1 or 2 racks\n if single_adjustment_cost * 2 <= pair_adjustment_cost or num_racks <= 2:\n return total_increments * single_adjustment_cost % MOD\n\n # Step 3: Mixed strategy - Use both single and pair adjustments\n # Calculate the number of adjustments required if using both methods\n remaining_difference = max(0, (max_temp - min_temp) * 2 - total_increments)\n increments_with_single_adjustments = total_increments - remaining_difference\n min_cost = (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost\n\n # Case 2: Further optimize using only pair adjustments if possible\n total_increments += remaining_difference // (num_racks - 2) * num_racks\n remaining_difference %= num_racks - 2\n increments_with_single_adjustments = total_increments - remaining_difference\n min_cost = min(min_cost, (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost)\n\n # Case 3: Check further for better cost optimization by adjusting multiple racks at once\n for _ in range(2):\n total_increments += num_racks\n min_cost = min(min_cost, total_increments % 2 * single_adjustment_cost + total_increments // 2 * pair_adjustment_cost)\n\n # Return the minimum cost modulo 10^9 + 7\n return min_cost % MOD","runtime":"576"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n max_nums, min_nums = max(nums), min(nums)\n n = len(nums)\n diff = max_nums - min_nums\n tot = max_nums * n - sum(nums)\n \n def test(extra):\n ntot = tot + n * extra\n big = diff + extra\n unpair = max(ntot % 2, big * 2 - ntot)\n pair = (ntot - unpair) // 2\n print(extra, unpair, pair)\n return unpair * cost1 + pair * cost2\n \n def calc():\n if cost1 * 2 <= cost2 or n <= 2:\n return tot * cost1\n more = max(0, diff * 2 - tot) // (n - 2) \n return min(test(extra) for extra in [0, 1, more, more + 1, more + 2])\n \n return calc() % 1_000_000_007","runtime":"577"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n if n == 1: return 0\n t = max(nums)\n delta = t * n - sum(nums)\n if cost2 >= cost1 * 2 or n == 2: return delta * cost1 % 1000000007\n\n top1, top2 = t + 1, t + 2\n for num in nums:\n if num < top1: top1, top2 = num, top1\n elif num < top2: top2 = num\n top1, top2 = t - top1, t - top2\n delta -= top1 + top2\n\n if delta + top2 >= top1:\n ans = (top1 + (delta - top1 + top2) // 2) * cost2 % 1000000007\n delta = (delta - top1 + top2) % 2\n else:\n ans = (top2 + delta) * cost2 % 1000000007\n delta = top1 - top2 - delta\n if delta >= n - 2:\n ans = (ans + delta // (n - 2) * min((n - 2) * cost1, (n - 1) * cost2)) % 1000000007\n delta %= n - 2\n if delta == 0: return ans\n\n case1 = delta * cost1\n case2 = (delta + (n - delta) // 2) * cost2 + (n - delta) % 2 * cost1\n if n % 2 == 1 and delta % 2 == 0:\n case3 = (n + delta // 2) * cost2\n return (ans + min(case1, case2, case3)) % 1000000007\n return (ans + min(case1, case2)) % 1000000007","runtime":"578"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n # Maximum and minimum values in the array\n max_value, min_value = max(nums), min(nums)\n n = len(nums) # Number of elements in the array\n mod = 10 ** 9 + 7 # Modulo value for the result\n\n # Calculate total cost if all elements are changed to the maximum value\n total_cost = max_value * n - sum(nums)\n\n # If cost1 is small or n <= 2, the cost is simply total_cost times cost1\n if cost1 * 2 <= cost2 or n <= 2:\n return total_cost * cost1 % mod\n\n # Calculate cost options\n option1 = max(0, (max_value - min_value) * 2 - total_cost)\n option2 = total_cost - option1\n result = (option1 + option2 % 2) * cost1 + option2 // 2 * cost2\n\n # Adjust total cost for the remaining operations\n total_cost += option1 // (n - 2) * n\n option1 %= n - 2\n option2 = total_cost - option1\n result = min(result, (option1 + option2 % 2) * cost1 + option2 // 2 * cost2)\n\n # Check for additional cases where total cost is adjusted\n for i in range(2):\n total_cost += n\n result = min(result, total_cost % 2 * cost1 + total_cost // 2 * cost2)\n \n return result % mod ","runtime":"578"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"579"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n MOD = 10 ** 9 + 7\n total = max(nums) * n - sum(nums)\n # case 1\n if cost1 <= cost2 / 2 or n <= 2:\n return total * cost1 % MOD\n maximum = max(nums)\n minimum = min(nums)\n # case 2\n op1 = max(0, (maximum - minimum) * 2 - total)\n op2 = (total - op1)\n res = (op1 + op2 % 2) * cost1 + op2//2 * cost2\n # case 3\n total += op1 // (n-2) * n\n op1 %= (n-2)\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * cost1 + op2//2 * cost2)\n # case 4:\n for i in range(2):\n total += n\n res = min(res, total%2 * cost1 + total//2 *cost2)\n return res % MOD","runtime":"580"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"581"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2\n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"583"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"584"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n # Easy case, Op 1\n return ttlGap * cost1 % mod\n \n if maxGap*2 <= ttlGap:\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n # Corner case with the last one spot left\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n # Two Operations:\n # Op 1: Directly fill maxGap\n # Op 2: Pair maxGap with other nums, which increases the final level.\n\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n # Op 1 is better\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n # Op 2 is better\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\n if (n+maxGap) % 2 == 1:\n # The last one spot left\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n # Compare it with Op 1 \n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"584"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n\n ma = max(nums)\n mi = min(nums)\n diff = ma * len(nums) - sum(nums)\n mod = 10**9 + 7\n\n if cost1 * 2 <= cost2 or len(nums) <= 2:\n return diff * cost1 % mod\n \n # op1 = diff_between_max_and_min - (total_diff - diff_between_max_and_min) \n # shows how much we have surplus in max min difference that must be fixed with op1\n op1 = max(0, 2 * (ma - mi) - diff) \n op2 = diff - op1\n res = (op1 + op2 % 2) * cost1 + op2 // 2 * cost2\n\n # from `op1 = 2 * (ma - mi) - diff` we can see, that each time we increment all elements by 1,\n # op1 will get reduced by n-2\n # We will do n-1 more op2 to save n-2 op1.\n diff += op1 // (len(nums) - 2) * len(nums)\n op1 %= len(nums) - 2\n op2 = diff - op1\n res = min(res, (op1 + op2 % 2) * cost1 + op2 // 2 * cost2)\n\n for i in range(2):\n diff += len(nums)\n res = min(res, diff % 2 * cost1 + diff // 2 * cost2)\n\n return res % mod\n","runtime":"586"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"587"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2\n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"588"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n maxi = max(nums)\n mini = min(nums)\n mod = 10 ** 9 + 7\n n = len(nums)\n total = maxi * n - sum(nums)\n if cost1 * 2 <= cost2 or n <= 2:\n return total * cost1 % mod\n\n op1 = max(0, (maxi - mini) * 2 - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * cost1 + op2 // 2 * cost2\n\n total += op1 // (n - 2) * n\n op1 %= n - 2\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * cost1 + op2 // 2 * cost2)\n\n for i in range(2):\n total += n\n res = min(res, total % 2 * cost1 + total // 2 * cost2)\n\n return res % mod","runtime":"589"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"590"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n diff = m - min(nums)\n total = n*m - sum(nums)\n if n <= 2 or 2*cost1 <= cost2: \n return total*cost1 % mod\n ans = 0 \n op2 = total - max(0, 2*diff - total)\n ans = (ans + op2//2*cost2) % mod \n x = max(2*diff-total, total%2)\n cand = x*cost1\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \n q, x = divmod(x, n-2)\n ans += q*(n-1)*cost2\n more = (n+x)//2*cost2 \n if (n-x)&1: \n if n&1: more += min(cost1, (n+1)//2*cost2)\n else: more += cost1 \n cand = min(x*cost1, more)\n return (ans + cand) % mod","runtime":"591"},{"code":"import math\nclass Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10**9 + 7\n maxv = max(nums)\n d = [maxv-num for num in nums]\n if 2*cost1 <= cost2:\n return cost1*sum(d)%MOD\n n = len(nums)\n if n == 1:\n return cost1*sum(d)%MOD\n if n == 2:\n return cost2*min(d)+cost1*(max(d)-min(d))%MOD\n maxd = max(d)\n r = sum(d)-maxd\n res = float('inf')\n if maxd <= r:\n res = (r+maxd)//2*cost2 + (r+maxd)%2*cost1\n maxd += 1\n r += n-1\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n return res%MOD\n res = r*cost2 + (maxd-r)*cost1\n k = math.floor((maxd-r)/(n-2))\n maxd += k\n r += (n-1)*k\n res = min(res, r*cost2 + (maxd-r)*cost1)\n maxd += 1\n r += (n-1)\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n maxd += 1\n r += n-1\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n return res%MOD","runtime":"594"},{"code":"import math\nclass Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10**9 + 7\n maxv = max(nums)\n d = [maxv-num for num in nums]\n if 2*cost1 <= cost2:\n return cost1*sum(d)%MOD\n n = len(nums)\n if n == 1:\n return cost1*sum(d)%MOD\n if n == 2:\n return cost2*min(d)+cost1*(max(d)-min(d))%MOD\n maxd = max(d)\n r = sum(d)-maxd\n res = float('inf')\n if maxd <= r:\n res = (r+maxd)//2*cost2 + (r+maxd)%2*cost1\n maxd += 1\n r += n-1\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n return res%MOD\n res = r*cost2 + (maxd-r)*cost1\n k = math.floor((maxd-r)/(n-2))\n maxd += k\n r += (n-1)*k\n res = min(res, r*cost2 + (maxd-r)*cost1)\n maxd += 1\n r += (n-1)\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n maxd += 1\n r += n-1\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\n return res%MOD","runtime":"595"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n MOD = 10 ** 9 + 7\n c2 = min(c2, 2 * c1)\n N, S, mi, ma = len(A), sum(A), min(A), max(A)\n\n def cost(height):\n if height < ma:\n return inf\n \n biggest = height - mi\n volume = height * N - S\n if biggest <= volume - biggest:\n return c2 * (volume//2) + c1 * (volume%2)\n return c2 * (volume - biggest) + c1 * (2 * biggest - volume)\n \n def metacost(h):\n return min(cost(2*h), cost(2*h+1))\n\n lo, hi = 0, 10**9\n while lo < hi:\n m1 = lo + (hi-lo)//3\n m2 = hi - (hi-lo)//3\n if metacost(m1) > metacost(m2):\n lo = m1 + 1\n else:\n hi = m2 - 1\n \n return metacost(lo) % MOD","runtime":"596"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n if maxGap*2 <= ttlGap:\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n if maxGap >= n-1:\n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n res += min(op2, maxGap * cost1)\n return res % mod","runtime":"597"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n # Easy case, Op 1\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n # Corner case with the last one spot left\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n # Two Operations:\n # Op 1: Directly fill maxGap\n # Op 2: Pair maxGap with other nums, which increases the final level.\n\n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n # Op 1 is better\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n # Op 2 is better\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\n if (n+maxGap) % 2 == 1:\n # The last one spot left\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n # Compare it with Op 1 \n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"599"},{"code":"class Solution:\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\n ma, mi = max(A), min(A)\n n = len(A)\n mod = 10 ** 9 + 7\n total = ma * n - sum(A)\n\n # case 1\n if c1 * 2 <= c2 or n <= 2:\n return total * c1 % mod\n\n # case 2\n op1 = max(0, (ma - mi) * 2 - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\n\n # case 3\n total += op1 // (n - 2) * n\n op1 %= n - 2\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\n\n # case 4\n for i in range(2):\n total += n\n res = min(res, total % 2 * c1 + total // 2 * c2)\n return res % mod","runtime":"600"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, mx, mod = len(nums), max(nums), 10**9+7\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\n \n if cost1*2 <= cost2:\n return ttlGap*cost1 % mod\n \n if maxGap*2 <= ttlGap:\n\n res = ttlGap // 2 * cost2\n if ttlGap % 2 == 1:\n if n % 2 == 1:\n res += min(cost1, cost2 * (n+1) // 2)\n else:\n res += cost1\n return res % mod\n \n res = cost2 * (ttlGap - maxGap)\n maxGap -= ttlGap - maxGap\n\n if maxGap >= n-1:\n \n if cost2 * (n-1) >= cost1 * (n-2):\n res += maxGap // (n-1) * (n-1) * cost1\n maxGap %= n-1\n else:\n res += maxGap // (n-2) * (n-1) * cost2\n maxGap %= n-2\n\n if maxGap:\n op2 = (n+maxGap) // 2 * cost2 \n if (n+maxGap) % 2 == 1:\n if n%2 == 1:\n op2 += min(cost1, cost2*(n+1)//2)\n else:\n op2 += cost1\n\n res += min(op2, maxGap * cost1)\n\n return res % mod","runtime":"603"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n total = n*m - sum(nums)\n d = m - min(nums)\n if n <= 2 or 2*cost1 <= cost2: \n return total*cost1 % mod\n ans = 0 \n if d <= total - d: \n total, x = divmod(total, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + (total - d)*cost2) % mod \n x = 2*d - total \n cand = x*cost1\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \n q, r = divmod(x, n-2)\n diff = q*(n-1)*cost2 \n more = (n+r)//2*cost2 \n if (n-r)&1: \n if n&1: more += min(cost1, (n+1)//2*cost2)\n else: more += cost1 \n diff += min(r*cost1, more)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"605"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10**9 + 7\n if len(nums)==1:\n return 0\n if len(nums)==2 or cost2 >= cost1 * 2:\n return (max(nums) * len(nums) - sum(nums)) * cost1 % MOD\n nums = sorted(nums)\n maxn = nums[-1]\n left, rest = nums[0], sum(nums[1:])\n leftholes = maxn - left\n restholes = (maxn * (len(nums) - 1) - rest)\n n_add = max(0, (leftholes - restholes)) // (len(nums) - 2)\n targets = [maxn, maxn + n_add, maxn + n_add + 1, maxn + n_add + 2]\n cost = inf\n for target in targets:\n leftholes = target - left\n restholes = (target * (len(nums) - 1) - rest)\n if leftholes <= restholes:\n cost2_adds = (leftholes + restholes) // 2\n cost1_adds = (leftholes + restholes) % 2\n else:\n cost2_adds = restholes\n cost1_adds = leftholes - restholes\n cost = min(cost, cost2_adds * cost2 + cost1_adds * cost1)\n return cost % MOD","runtime":"606"},{"code":"# ValueError: 3\nclass Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n ","runtime":"627"},{"code":"from bisect import bisect_left\n\nclass Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n \n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD","runtime":"628"},{"code":"from bisect import bisect_left\n\nclass Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n ones = max(2 * (k - self.minNums) - sumDifferences, 0)\n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n \n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n","runtime":"632"},{"code":"# IndentationError: 355\nclass Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n ","runtime":"635"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n","runtime":"637"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n\n print(\"This will cause a SyntaxError\")\n","runtime":"638"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n nums = sorted((m-x for x in nums), reverse=True)\n if n == 1: return 0 \n if n == 2: return nums[0]*cost1 % mod \n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\n ans = 0 \n sm = sum(nums)\n if nums[0] < sm - nums[0]: \n total, x = divmod(sm, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + (sm - nums[0])*cost2) % mod \n x = 2*nums[0] - sm \n cand = x*cost1\n diff = 0 \n if x >= n-2 and (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\n k, x = divmod(x, (n-2))\n diff = k*(n-1)*cost2 \n if x: \n d0 = x*cost1\n d1 = (n+x)//2*cost2 \n x = (n-x) % 2\n if x: \n if n&1: d1 += min((n+1)//2*cost2, cost1)\n else: d1 += cost1 \n diff += min(d0, d1)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"639"},{"code":"# Time Limit Exceeded: 10\nclass Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n","runtime":"640"},{"code":"from bisect import bisect_left\n\nclass Solution:\n MOD = 10 ** 9 + 7\n\n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n \n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD","runtime":"643"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n nums = sorted((m-x for x in nums), reverse=True)\n if n == 1: return 0 \n if n == 2: return nums[0]*cost1 % mod \n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\n ans = 0 \n sm = sum(nums)\n if nums[0] < sm - nums[0]: \n total, x = divmod(sm, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + (sm - nums[0])*cost2) % mod \n x = 2*nums[0] - sm \n cand = x*cost1\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \n q, r = divmod(x, n-2)\n diff = q*(n-1)*cost2 \n more = (n+r)//2*cost2 \n if (n-r)&1: \n if n&1: more += min(cost1, (n+1)//2*cost2)\n else: more += cost1 \n diff += min(r*cost1, more)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"645"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n nums = sorted((m-x for x in nums), reverse=True)\n if n == 1: return 0 \n if n == 2: return nums[0]*cost1 % mod \n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\n ans = 0 \n total = sum(nums)\n if nums[0] < total - nums[0]: \n total, x = divmod(total, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + (total - nums[0])*cost2) % mod \n x = 2*nums[0] - total \n cand = x*cost1\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \n q, r = divmod(x, n-2)\n diff = q*(n-1)*cost2 \n more = (n+r)//2*cost2 \n if (n-r)&1: \n if n&1: more += min(cost1, (n+1)//2*cost2)\n else: more += cost1 \n diff += min(r*cost1, more)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"646"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n mod = 1_000_000_007 \n m = max(nums)\n nums = sorted((m-x for x in nums), reverse=True)\n if n == 1: return 0 \n if n == 2: return nums[0]*cost1 % mod \n if 2*cost1 <= cost2: \n return sum(nums)*cost1 % mod\n ans = 0 \n sm = sum(nums[1:])\n if nums[0] < sm: \n total, x = divmod(nums[0]+sm, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + sm*cost2) % mod \n x = nums[0] - sm \n if x == 0: return ans \n cand = x*cost1\n diff = 0 \n if x+1 >= n-1: \n if (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\n k = x//(n-2)\n diff = k*(n-1)*cost2 \n x -= k*(n-2)\n if x: \n d0 = x*cost1\n d1 = (n+x)//2*cost2 \n x = (n-x) % 2\n if x: \n if n&1: d1 += min((n+1)//2*cost2, cost1)\n else: d1 += cost1 \n diff += min(d0, d1)\n # print(cand, diff)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"648"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD","runtime":"655"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD","runtime":"656"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n l = len(nums)\n if l < 2:\n return 0\n nums.sort()\n if nums[0] == nums[-1]:\n return 0\n maxVal = nums[-1]\n # Always use cost1 if not more costly than cost2/2 since 2 cost1 ops equals 1 cost2 op\n if ((cost1 << 1) <= cost2) or l == 2:\n totalOps = maxVal * l\n for val in nums:\n totalOps -= val\n return (totalOps * cost1) % 1000000007\n else:\n totalOps = 0\n maxVal = nums[0]\n minVal = nums[0]\n for val in nums:\n totalOps -= val\n if val < minVal:\n minVal = val\n elif val > maxVal:\n maxVal = val\n totalOps += maxVal * l\n cost1Ops = 0\n cost2Ops = 0\n # Maximise use of cost2. There is only one scenario where this results in > 1 remaining difference\n # It is possible for one val to be substantially less than the others - if maxVal - minVal > totalOps - (maxVal - minVal)\n maxSingleNumOps = maxVal - minVal\n remainingGap = 0\n if (maxSingleNumOps << 1) > totalOps:\n cost2Ops += totalOps - maxSingleNumOps\n remainingGap = maxSingleNumOps - cost2Ops\n # For the remaining gap, there are 2 methods to reduce this:\n # 1. Use cost1 exclusively\n # 2. Use cost2, pairing minVal increases with each other num - for each len(nums) - 2 reduction in ops, cost = cost2 * (len(nums) - 1)\n gapReduction = remainingGap - (remainingGap % (l - 2))\n remainingGap -= gapReduction\n if cost1 * (l - 2) <= cost2 * (l - 1):\n cost1Ops += gapReduction\n else:\n cost2Ops += gapReduction * (l - 1) // (l - 2)\n # Otherwise it is possible to use cost2 to reduce remaining ops to 1 or 0\n else:\n cost2Ops = totalOps >> 1\n remainingGap = totalOps & 1\n # For the remainingGap, there are 2 methods to reduce this:\n # 1. Use cost1 exclusively\n # 2. Use cost2 to increase minVal with each num, then pair each of the remaining nums:\n if remainingGap > 0:\n finalGap = 0\n # If remainingGap is odd and len(nums) is even, then it is impossible to completely use cost2 to reduce the gap. Increase by remainingGap + 1 and leave 1 remaining op that must use cost1.\n if ((remainingGap & 1) == 1) and ((l & 1) == 0):\n method2Ops = remainingGap + ((l - 1 - remainingGap) >> 1)\n finalGap = 1\n # If both remainingGap and len(nums) are even or both are odd, then increase by remaininGap + 1\n elif (remainingGap & 1) == (l & 1):\n method2Ops = remainingGap + 1 + ((l - 1 - remainingGap) >> 1)\n # If remainingGap is even and len(nums) is odd, then increase by remaininGap + 2\n else:\n method2Ops = (remainingGap + 1) // 2 + l\n method1Ops = remainingGap - finalGap\n if cost1 * method1Ops < cost2 * method2Ops:\n cost1Ops += method1Ops\n else:\n cost2Ops += method2Ops\n remainingGap = finalGap\n cost1Ops += remainingGap\n return (cost1Ops * cost1 + cost2Ops * cost2) % 1000000007","runtime":"657"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD","runtime":"660"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n\nsolution = Solution()\nsolution.minCostToEqualizeArray([1, 2, 3], 2, 4)\n","runtime":"662"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n m, n = max(nums), len(nums)\n mod = 1_000_000_007 \n nums = sorted((m-x for x in nums), reverse=True)\n if n == 1: return 0 \n if n == 2: return nums[0]*cost1 % mod \n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\n ans = 0 \n sm = sum(nums)\n if nums[0] < sm - nums[0]: \n total, x = divmod(sm, 2)\n ans = (ans + total*cost2) % mod \n else: \n ans = (ans + (sm - nums[0])*cost2) % mod \n x = 2*nums[0] - sm \n cand = x*cost1\n diff = 0 \n if x+1 >= n-1: \n if (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\n k = x//(n-2)\n diff = k*(n-1)*cost2 \n x -= k*(n-2)\n if x: \n d0 = x*cost1\n d1 = (n+x)//2*cost2 \n x = (n-x) % 2\n if x: \n if n&1: d1 += min((n+1)//2*cost2, cost1)\n else: d1 += cost1 \n diff += min(d0, d1)\n cand = min(cand, diff) \n return (ans + cand) % mod","runtime":"663"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0)\n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums, cost1, cost2):\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n","runtime":"666"},{"code":"class Solution:\n MOD = int(1E9+7)\n\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n, max_v, min_v, sum_v = len(nums), 0, int(1E9), 0\n for num in nums:\n max_v = max(max_v, num)\n min_v = min(min_v, num)\n sum_v += num\n\n total_diff = max_v * n - sum_v\n if cost2 >= 2 * cost1 or n <= 2:\n return total_diff * cost1 % Solution.MOD\n\n op1 = max(0, max_v - min_v - (total_diff - (max_v - min_v)))\n op2 = total_diff - op1\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\n\n extra_levels = op1 // (n-2)\n total_diff += extra_levels * n\n op1 = op1 % (n-2)\n op2 = total_diff - op1\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\n\n for i in range(2):\n total_diff += n\n res = min(res, total_diff % 2 * cost1 + (total_diff // 2) * cost2)\n return res % Solution.MOD","runtime":"669"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n lol = 10**9 + 7\n use_cost2 = cost2 < 2 * cost1\n target_val = max(nums)\n total_changes = 0\n max_changes = 0\n for num in nums:\n cur_changes = target_val - num\n if cur_changes > max_changes:\n max_changes = cur_changes\n total_changes += cur_changes\n if not use_cost2:\n return (cost1 * total_changes) % lol\n if max_changes <= total_changes / 2:\n unmatched = total_changes % 2\n #return (cost2 * (total_changes // 2) + cost1 * (total_changes % 2)) % lol\n else:\n unmatched = 2 * (max_changes - (total_changes // 2)) - (total_changes % 2)\n matched = total_changes - unmatched\n n = len(nums)\n #trick_cost = 0\n if n > 2 and cost2 * (n-1) < cost1 * (n-2):\n trick_use = unmatched // (n-2)\n unmatched -= trick_use * (n-2)\n matched += 2 * trick_use * (n-1)\n overhang_fix_cost = [None] * (n+1)\n overhang_fix_cost[0] = 0\n overhang_fix_cost[n] = 0\n path = deque()\n path.append(0)\n while len(path) > 0:\n cur_amount = path.popleft()\n new1_place = (cur_amount + 1) % n\n new1_cost = overhang_fix_cost[cur_amount] + cost1\n if overhang_fix_cost[new1_place] is None or overhang_fix_cost[new1_place] > new1_cost:\n overhang_fix_cost[new1_place] = new1_cost\n path.append(new1_place)\n new2_place = (cur_amount + 2) % n\n new2_cost = overhang_fix_cost[cur_amount] + cost2\n if overhang_fix_cost[new2_place] is None or overhang_fix_cost[new2_place] > new2_cost:\n overhang_fix_cost[new2_place] = new2_cost\n path.append(new2_place)\n overhang_fix_cost = overhang_fix_cost[::-1]\n\n print(overhang_fix_cost)\n\n min_balance_cost = cost1 * unmatched\n for i in range(0, min(unmatched+1, n)):\n balance_cost = cost1 * (unmatched - i) + cost2 * i + overhang_fix_cost[i]\n if min_balance_cost is None or balance_cost < min_balance_cost:\n min_balance_cost = balance_cost\n\n print(\"matched: {}\".format(matched))\n print(\"unmatched: {}\".format(unmatched))\n return (min_balance_cost + cost2 * (matched // 2)) % lol\n #return (cost1 * unmatched + cost2 * (matched // 2)) % lol","runtime":"715"},{"code":"class Solution:\n MOD = 10 ** 9 + 7\n \n def solve(self, k):\n sumDifferences = k * len(self.nums) - self.sumNums\n \n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \n if (sumDifferences - ones) & 1 != 0:\n ones += 1\n \n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\n \n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n cost2 = min(2 * cost1, cost2)\n \n self.nums = nums\n self.minNums = min(nums)\n self.sumNums = sum(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n \n m = max(nums)\n \n sameParity = range(m, 10 ** 18, 2)\n diffParity = range(m + 1, 10 ** 18, 2)\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\n \n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\n\nsolution = Solution()\nnums = [i for i in range(10**7)]\nsolution.minCostToEqualizeArray(nums, 2, 4)\n","runtime":"1047"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10 ** 9 + 7\n INF = 10 ** 20\n N = len(nums)\n mx = max(nums)\n mn = min(nums)\n c1, c2 = cost1, cost2\n\n if c2 >= 2 * c1:\n return (sum(mx - n for n in nums) * c1) % MOD\n\n total_diff = sum(mx - n for n in nums)\n\n def calc(mxx):\n total = total_diff + N * (mxx - mx)\n biggest_diff = mxx - mn\n other_sm = total - biggest_diff\n\n if biggest_diff - 1 > other_sm:\n \n extra = biggest_diff - other_sm\n return other_sm * c2 + extra * c1\n\n\n return (total // 2) * c2 + (total % 2) * c1 \n\n ans = INF\n j = mx\n while True:\n v = calc(j)\n if v < ans: \n ans = v\n j += 1\n else:\n return ans % MOD","runtime":"1075"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n mod = (10**9) + 7\n acm = max(nums)\n a = [acm-x for x in nums]\n mx3 = max(a)\n sm = sum(a)\n if 2*cost1<cost2:\n return sm*cost1%mod\n def f(mx):\n s = sm+ (mx-acm)*len(nums)\n mx2 = mx3 + (mx-acm)\n c = max(0,2*mx2 - s)\n if s%2 and c==0:\n c = 1\n total = (cost2*(s-c)//2 + cost1*c)\n return total\n \n cur = max(nums)\n res = f(cur)\n while 1:\n cur +=1\n ff = f(cur)\n if ff>res:\n break\n res =ff\n \n return res%mod","runtime":"1446"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n mod = (10**9) + 7\n acm = max(nums)\n a = [acm-x for x in nums]\n mx3 = max(a)\n sm = sum(a)\n if 2*cost1<cost2: # trivial case\n return sm*cost1%mod\n def f(mx): # solving sub problem\n s = sm+ (mx-acm)*len(nums)\n mx2 = mx3 + (mx-acm)\n c = max(0,2*mx2 - s)\n if s%2 and c==0:\n c = 1\n total = (cost2*(s-c)//2 + cost1*c)\n return total\n \n \n cur = max(nums)\n res = f(cur)\n while 1: # can be proved < 2*max_a\n cur +=1\n ff = f(cur)\n if ff>res:\n break\n res =ff\n \n return res%mod\n ","runtime":"1496"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10**9+7\n if 2 * cost1 <= cost2:\n return (max(nums) * len(nums) - sum(nums)) * cost1 % MOD\n\n self.nums = sorted(nums)\n self.cost1 = cost1\n self.cost2 = cost2\n maxx = max(nums)\n\n ans = self.cal_cost(maxx)\n while True: \n maxx += 1\n tmp = self.cal_cost(maxx)\n if tmp >= ans:\n break\n ans = tmp\n return ans % MOD\n\n def cal_cost(self, x): \n diff = [x - n for n in self.nums]\n total = sum(diff)\n if diff[0] <= (total+1) // 2: \n return total // 2 * self.cost2 + total % 2 * self.cost1\n else:\n return (diff[0] - total + diff[0]) * self.cost1 + (total - diff[0]) * self.cost2","runtime":"1945"},{"code":"import sys\n\nclass Solution:\n\n def equaliseToValue(self, nums, cost1, cost2, value, sumG, maxG):\n # gaps = [(value - nums[i]) for i in range(len(nums))]\n # maxG = max(gaps)\n # sumG = sum(gaps)\n if 2*maxG == sumG:\n return (cost2 * maxG),True\n elif 2*maxG > sumG:\n pairable = (sumG - maxG)\n return (pairable * cost2) + ((2*maxG - sumG)*cost1), False\n elif 2*maxG < sumG and sumG % 2 == 1:\n return (cost2 * (sumG//2)) + cost1, False\n else:\n return cost2 * (sumG//2), True\n\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n if len(nums) <= 1:\n return 0\n if len(nums) == 2:\n return (cost1*(max(nums)-min(nums)))%(10**9 + 7)\n\n if cost2 >= 2*cost1:\n mNum = max(nums)\n ans = 0\n for num in nums:\n ans += ((mNum - num)*cost1)\n return ans % (10**9+7)\n\n mNum = max(nums)\n \n sumG = 0\n maxG = 0\n for i in range(len(nums)):\n sumG += mNum - nums[i]\n maxG = max(maxG, mNum-nums[i])\n\n\n\n ans = sys.maxsize\n i = mNum\n while True:\n if i > mNum:\n sumG += len(nums)\n maxG += 1\n if (sumG*cost2)//2 > ans:\n break\n t_ans = self.equaliseToValue(nums, cost1, cost2, i, sumG, maxG)\n ans = min(ans, t_ans[0])\n if t_ans[1]:\n break\n i += 1\n\n return ans%(10**9+7)\n","runtime":"2333"},{"code":"import sys\n\nclass Solution:\n\n def equaliseToValue(self, nums, cost1, cost2, value, sumG, maxG):\n # gaps = [(value - nums[i]) for i in range(len(nums))]\n # maxG = max(gaps)\n # sumG = sum(gaps)\n if 2*maxG == sumG:\n return (cost2 * maxG),True\n elif 2*maxG > sumG:\n pairable = (sumG - maxG)\n # sumG - 2*(sumG - maxG) = \n return (pairable * cost2) + ((2*maxG - sumG)*cost1), False #%(10**9+7)\n elif 2*maxG < sumG and sumG % 2 == 1:\n return (cost2 * (sumG//2)) + cost1, False\n else:\n return cost2 * (sumG//2), True\n\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n if len(nums) <= 1:\n return 0\n if len(nums) == 2:\n return (cost1*(max(nums)-min(nums)))%(10**9 + 7)\n\n if cost2 >= 2*cost1:\n mNum = max(nums)\n ans = 0\n for num in nums:\n ans += ((mNum - num)*cost1)\n return ans % (10**9+7)\n\n mNum = max(nums)\n \n sumG = 0\n maxG = 0\n for i in range(len(nums)):\n sumG += mNum - nums[i]\n maxG = max(maxG, mNum-nums[i])\n\n\n\n ans = sys.maxsize\n for i in range(mNum, 2*mNum):\n if i > mNum:\n sumG += len(nums)\n maxG += 1\n t_ans = self.equaliseToValue(nums, cost1, cost2, i, sumG, maxG)\n ans = min(ans, t_ans[0])\n if t_ans[1]:\n break\n\n return ans%(10**9+7)\n","runtime":"3492"},{"code":"class Solution:\n def minCostToEqualizeArray(\n self,\n nums: list[int],\n cost1: int,\n cost2: int,\n ) -> int:\n kMod = 1_000_000_007\n n = len(nums)\n minNum = min(nums)\n maxNum = max(nums)\n summ = sum(nums)\n\n if cost1 * 2 <= cost2 or n < 3:\n totalGap = maxNum * n - summ\n return (cost1 * totalGap) % kMod\n\n def getMinCost(target: int) -> int:\n \n maxGap = target - minNum\n totalGap = target * n - summ\n \n pairs = min(totalGap // 2, totalGap - maxGap)\n return cost1 * (totalGap - 2 * pairs) + cost2 * pairs\n\n return min(getMinCost(target)\n for target in range(maxNum, 2 * maxNum)) % kMod","runtime":"7546"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n m = 10 ** 9 + 7\\n \\n # simple edge cases: if len(nums) < 3 then there is no reason to worry about cost2, as the second operation never does anything\\n if n == 1:\\n return 0\\n if n == 2:\\n return ((max(nums) - min(nums)) * cost1) % m\\n \\n # hole represents the difference between the highest and lowest value\\n hole = max(nums) - min(nums)\\n # needed represents the total difference between the highest number and all other numbers\\n # essentially the total number of squares that need to be filled in\\n needed = max(nums) * n - sum(nums)\\n cost = 0\\n \\n # if individual operations are cheaper or as cheap, we can stop here\\n if cost1 * 2 <= cost2:\\n \\n return (needed * cost1) % m\\n \\n # since it is better to do 2 operations at a time, try to fill in all of the squares using this method\\n # we want to end up with either all squares filled or all squares filled with the shallowest single space hole possible\\n if needed // 2 >= hole:\\n # all squares (except possibly one if there is an odd number) can be filled\\n easy = needed // 2\\n hole = needed - 2 * easy # 1 or 0\\n else:\\n # not all squares are filled, do our best to reduce the size of the hole\\n easy = needed - hole\\n hole = hole - easy\\n \\n # cost after doing all simple operations\\n cost = easy * cost2\\n \\n # now we calculate the cost to fill in the last hole\\n # usually, it is cheaper to fill in individually with cost1\\n # however, if cost2 is much lower than cost1 it can be more efficient to add 1 to all numbers\\n # we perform the 2nd operation many times, always choosing the lowest point as one of the indices\\n def minCost(hole_size):\\n # basic case, no shenanigans\\n best = cost1 * hole_size\\n\\n # the hole is shallow enough that we only have to raise the level by one to fill it\\n if hole_size + 1 < n:\\n # the number of operations needed to fill the hole + the number needed to raise the level by 2\\n fill = ((hole_size + n) // 2)\\n \\n if (hole_size + n - fill * 2) == 1:\\n # sometimes there are an odd number of blocks and we are left with a 1 block deep hole\\n if n % 2 == 1:\\n # here we are checking whether it is cheaper to use cost1 once or raise the level again to avoid it\\n # this is only possible if n is odd\\n best = min(best, fill * cost2 + min(cost1, cost2 * ((n + 1) // 2)))\\n else:\\n best = min(best, fill * cost2 + cost1)\\n else:\\n best = min(best, fill * cost2)\\n # if the hole is so deep that it cannot be filled by adding one level, we add multiple\\n else:\\n # the change in hole depth after each operation\\n gain = n - 2\\n # the number of levels to add\\n levels = hole_size // gain\\n # the number of operations we need to add a level\\n fill = n - 1\\n best = min(best, minCost(hole_size - gain * levels) + cost2 * fill * levels)\\n return best\\n \\n\\n cost += minCost(hole)\\n return cost % m\",\n \"runtime\": \"559\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n # Easy case, Op 1\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n # Corner case with the last one spot left\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n # Two Operations:\\n # Op 1: Directly fill maxGap\\n # Op 2: Pair maxGap with other nums, which increases the final level.\\n\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n # Op 1 is better\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n # Op 2 is better\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\\n if (n+maxGap) % 2 == 1:\\n # The last one spot left\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n # Compare it with Op 1 \\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"560\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n ma, mi = max(A), min(A)\\n n = len(A)\\n mod = 10 ** 9 + 7\\n total = ma * n - sum(A)\\n\\n # case 1\\n if c1 * 2 <= c2 or n <= 2:\\n return total * c1 % mod\\n\\n # case 2\\n op1 = max(0, (ma - mi) * 2 - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\\n\\n # case 3\\n total += op1 // (n - 2) * n\\n op1 %= n - 2\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\\n\\n # case 4\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * c1 + total // 2 * c2)\\n return res % mod\",\n \"runtime\": \"565\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n # Easy case, Op 1\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n # Corner case with the last one spot left\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n # Two Operations:\\n # Op 1: Directly fill maxGap\\n # Op 2: Pair maxGap with other nums, which increases the final level.\\n\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n # Op 1 is better\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n # Op 2 is better\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\\n if (n+maxGap) % 2 == 1:\\n # The last one spot left\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n # Compare it with Op 1 \\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"567\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n ma, mi = max(A), min(A)\\n n = len(A)\\n mod = 10 ** 9 + 7\\n total = ma * n - sum(A)\\n\\n # case 1\\n if c1 * 2 <= c2 or n <= 2:\\n return total * c1 % mod\\n\\n # case 2\\n op1 = max(0, (ma - mi) * 2 - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\\n\\n # case 3\\n total += op1 // (n - 2) * n\\n op1 %= n - 2\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\\n\\n # case 4\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * c1 + total // 2 * c2)\\n return res % mod\\n \",\n \"runtime\": \"568\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n diff = m - min(nums)\\n total = n*m - sum(nums)\\n if n <= 2 or 2*cost1 <= cost2: \\n return total*cost1 % mod\\n ans = 0 \\n op2 = total - max(0, 2*diff - total)\\n ans = (ans + op2//2*cost2) % mod \\n x = max(2*diff-total, total%2)\\n cand = x*cost1\\n q, x = divmod(x, n-2)\\n more = (n+x)//2*cost2 \\n if (n-x)&1: \\n if n&1: more += min(cost1, (n+1)//2*cost2)\\n else: more += cost1 \\n cand = min(cand, q*(n-1)*cost2 + min(x*cost1, more)) \\n return (ans + cand) % mod\",\n \"runtime\": \"569\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n MOD = 10 ** 9 + 7\\n c2 = min(c2, 2 * c1)\\n N, S, mi, ma = len(A), sum(A), min(A), max(A)\\n\\n def cost(height):\\n if height < ma:\\n return inf\\n \\n biggest = height - mi\\n volume = height * N - S\\n if biggest <= volume - biggest:\\n return c2 * (volume//2) + c1 * (volume%2)\\n return c2 * (volume - biggest) + c1 * (2 * biggest - volume)\\n\\n biggest = ma - mi\\n volume = ma * N - S\\n if N <= 2:\\n return volume * c1 % MOD\\n\\n alpha = (S - 2*mi) // (N - 2)\\n beta = ma + ceil(max(2 * biggest - volume, 0) / (N - 2))\\n return min(cost(p) for p in [ma, ma+1, alpha, beta, beta+1]) % MOD\",\n \"runtime\": \"570\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n # Easy case, Op 1\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n # Corner case with the last one spot left\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n # Two Operations:\\n # Op 1: Directly fill maxGap\\n # Op 2: Pair maxGap with other nums, which increases the final level.\\n\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n # Op 1 is better\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n # Op 2 is better\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\\n if (n+maxGap) % 2 == 1:\\n # The last one spot left\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n # Compare it with Op 1 \\n res += min(op2, maxGap * cost1)\\n\\n return res % mod \",\n \"runtime\": \"571\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n mod = 10 ** 9 + 7\\n work = max(nums) * n - sum(nums) # work to be done\\n\\n # CASE 1\\n if cost1 * 2 <= cost2 or n <= 2: \\n return work * cost1 % mod\\n\\n # CASE 2\\n max_pair_ctns = (max(nums) - min(nums)) * 2 # max contribution by greedy pairing scheme\\n extra_work = max(0, max_pair_ctns - work)\\n\\n\\n # 2.a: do extra work with only single operations\\n lone_ctn = extra_work\\n pair_ctn = work - lone_ctn\\n scha = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2 \\n\\n # adjust extra work for optimal pairs\\n # - 2 are the item with leftover units and max item\\n work += extra_work // (n - 2) * n \\n \\n # 2.b: do extra work with a mixture of pair and single operations \\n lone_ctn = lone_ctn % (n - 2)\\n pair_ctn = work - lone_ctn\\n schb = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2\\n\\n # 2.c: do extra with maximum number pair operations\\n schc = maxsize\\n for i in range(2):\\n work += n\\n schc = min(schc, work % 2 * cost1 + work // 2 * cost2)\\n \\n return min(scha, schb, schc) % mod\",\n \"runtime\": \"572\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n maxi = max(nums)\\n mini = min(nums)\\n MOD = 10**9 + 7\\n total = max(nums) * n - sum(nums)\\n # case 1: cost 1 is too cheap\\n if cost1 <= cost2 / 2 or n <= 2:\\n return total * cost1 % MOD\\n \\n # case 2: cost 1 & cost 2 mixing\\n op1 = max(0, 2 * (maxi - mini) - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\\n \\n # case 3: cost 1 too expensive than cost 2, so we increase total\\n total += op1 // (n-2) * n\\n op1 = op1 % (n-2)\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\\n\\n # case 4: cost 1 too expensive, only use cost 2 and maybe 0 or 1 cost 1\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * cost1 + total//2 * cost2)\\n return res % MOD\",\n \"runtime\": \"574\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n ma, mi = max(A), min(A)\\n n = len(A)\\n mod = 10 ** 9 + 7\\n total = ma * n - sum(A)\\n\\n # case 1\\n if c1 * 2 <= c2 or n <= 2:\\n return total * c1 % mod\\n\\n # case 2\\n op1 = max(0, (ma - mi) * 2 - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\\n\\n # case 3\\n total += op1 // (n - 2) * n\\n op1 %= n - 2\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\\n\\n # case 4\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * c1 + total // 2 * c2)\\n return res % mod\",\n \"runtime\": \"575\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, temperatures: List[int], single_adjustment_cost: int, pair_adjustment_cost: int) -> int:\\n \\\"\\\"\\\"\\n Calculate the minimum cost to equalize the temperatures of all server racks.\\n\\n Parameters:\\n temperatures (List[int]): List of integers representing current temperatures of server racks.\\n single_adjustment_cost (int): Cost to increase the temperature of a single rack by 1 degree.\\n pair_adjustment_cost (int): Cost to increase the temperature of two different racks by 1 degree each.\\n\\n Returns:\\n int: The minimum cost to equalize all temperatures, modulo 10^9 + 7.\\n \\\"\\\"\\\"\\n \\n # Constants\\n MOD = 10 ** 9 + 7\\n\\n # Step 1: Find maximum and minimum temperatures\\n max_temp = max(temperatures)\\n min_temp = min(temperatures)\\n num_racks = len(temperatures)\\n\\n # Step 2: Calculate the total number of increments required to equalize all racks to the maximum temperature\\n total_increments = max_temp * num_racks - sum(temperatures)\\n\\n # Case 1: If it's cheaper to adjust one rack at a time or if there are only 1 or 2 racks\\n if single_adjustment_cost * 2 <= pair_adjustment_cost or num_racks <= 2:\\n return total_increments * single_adjustment_cost % MOD\\n\\n # Step 3: Mixed strategy - Use both single and pair adjustments\\n # Calculate the number of adjustments required if using both methods\\n remaining_difference = max(0, (max_temp - min_temp) * 2 - total_increments)\\n increments_with_single_adjustments = total_increments - remaining_difference\\n min_cost = (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\\\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost\\n\\n # Case 2: Further optimize using only pair adjustments if possible\\n total_increments += remaining_difference // (num_racks - 2) * num_racks\\n remaining_difference %= num_racks - 2\\n increments_with_single_adjustments = total_increments - remaining_difference\\n min_cost = min(min_cost, (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\\\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost)\\n\\n # Case 3: Check further for better cost optimization by adjusting multiple racks at once\\n for _ in range(2):\\n total_increments += num_racks\\n min_cost = min(min_cost, total_increments % 2 * single_adjustment_cost + total_increments // 2 * pair_adjustment_cost)\\n\\n # Return the minimum cost modulo 10^9 + 7\\n return min_cost % MOD\",\n \"runtime\": \"576\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n max_nums, min_nums = max(nums), min(nums)\\n n = len(nums)\\n diff = max_nums - min_nums\\n tot = max_nums * n - sum(nums)\\n \\n def test(extra):\\n ntot = tot + n * extra\\n big = diff + extra\\n unpair = max(ntot % 2, big * 2 - ntot)\\n pair = (ntot - unpair) // 2\\n print(extra, unpair, pair)\\n return unpair * cost1 + pair * cost2\\n \\n def calc():\\n if cost1 * 2 <= cost2 or n <= 2:\\n return tot * cost1\\n more = max(0, diff * 2 - tot) // (n - 2) \\n return min(test(extra) for extra in [0, 1, more, more + 1, more + 2])\\n \\n return calc() % 1_000_000_007\",\n \"runtime\": \"577\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n if n == 1: return 0\\n t = max(nums)\\n delta = t * n - sum(nums)\\n if cost2 >= cost1 * 2 or n == 2: return delta * cost1 % 1000000007\\n\\n top1, top2 = t + 1, t + 2\\n for num in nums:\\n if num < top1: top1, top2 = num, top1\\n elif num < top2: top2 = num\\n top1, top2 = t - top1, t - top2\\n delta -= top1 + top2\\n\\n if delta + top2 >= top1:\\n ans = (top1 + (delta - top1 + top2) // 2) * cost2 % 1000000007\\n delta = (delta - top1 + top2) % 2\\n else:\\n ans = (top2 + delta) * cost2 % 1000000007\\n delta = top1 - top2 - delta\\n if delta >= n - 2:\\n ans = (ans + delta // (n - 2) * min((n - 2) * cost1, (n - 1) * cost2)) % 1000000007\\n delta %= n - 2\\n if delta == 0: return ans\\n\\n case1 = delta * cost1\\n case2 = (delta + (n - delta) // 2) * cost2 + (n - delta) % 2 * cost1\\n if n % 2 == 1 and delta % 2 == 0:\\n case3 = (n + delta // 2) * cost2\\n return (ans + min(case1, case2, case3)) % 1000000007\\n return (ans + min(case1, case2)) % 1000000007\",\n \"runtime\": \"578\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n # Maximum and minimum values in the array\\n max_value, min_value = max(nums), min(nums)\\n n = len(nums) # Number of elements in the array\\n mod = 10 ** 9 + 7 # Modulo value for the result\\n\\n # Calculate total cost if all elements are changed to the maximum value\\n total_cost = max_value * n - sum(nums)\\n\\n # If cost1 is small or n <= 2, the cost is simply total_cost times cost1\\n if cost1 * 2 <= cost2 or n <= 2:\\n return total_cost * cost1 % mod\\n\\n # Calculate cost options\\n option1 = max(0, (max_value - min_value) * 2 - total_cost)\\n option2 = total_cost - option1\\n result = (option1 + option2 % 2) * cost1 + option2 // 2 * cost2\\n\\n # Adjust total cost for the remaining operations\\n total_cost += option1 // (n - 2) * n\\n option1 %= n - 2\\n option2 = total_cost - option1\\n result = min(result, (option1 + option2 % 2) * cost1 + option2 // 2 * cost2)\\n\\n # Check for additional cases where total cost is adjusted\\n for i in range(2):\\n total_cost += n\\n result = min(result, total_cost % 2 * cost1 + total_cost // 2 * cost2)\\n \\n return result % mod \",\n \"runtime\": \"578\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"579\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n MOD = 10 ** 9 + 7\\n total = max(nums) * n - sum(nums)\\n # case 1\\n if cost1 <= cost2 / 2 or n <= 2:\\n return total * cost1 % MOD\\n maximum = max(nums)\\n minimum = min(nums)\\n # case 2\\n op1 = max(0, (maximum - minimum) * 2 - total)\\n op2 = (total - op1)\\n res = (op1 + op2 % 2) * cost1 + op2//2 * cost2\\n # case 3\\n total += op1 // (n-2) * n\\n op1 %= (n-2)\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + op2//2 * cost2)\\n # case 4:\\n for i in range(2):\\n total += n\\n res = min(res, total%2 * cost1 + total//2 *cost2)\\n return res % MOD\",\n \"runtime\": \"580\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"581\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2\\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"583\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"584\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n # Easy case, Op 1\\n return ttlGap * cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n # Corner case with the last one spot left\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n # Two Operations:\\n # Op 1: Directly fill maxGap\\n # Op 2: Pair maxGap with other nums, which increases the final level.\\n\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n # Op 1 is better\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n # Op 2 is better\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\\n if (n+maxGap) % 2 == 1:\\n # The last one spot left\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n # Compare it with Op 1 \\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"584\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n\\n ma = max(nums)\\n mi = min(nums)\\n diff = ma * len(nums) - sum(nums)\\n mod = 10**9 + 7\\n\\n if cost1 * 2 <= cost2 or len(nums) <= 2:\\n return diff * cost1 % mod\\n \\n # op1 = diff_between_max_and_min - (total_diff - diff_between_max_and_min) \\n # shows how much we have surplus in max min difference that must be fixed with op1\\n op1 = max(0, 2 * (ma - mi) - diff) \\n op2 = diff - op1\\n res = (op1 + op2 % 2) * cost1 + op2 // 2 * cost2\\n\\n # from `op1 = 2 * (ma - mi) - diff` we can see, that each time we increment all elements by 1,\\n # op1 will get reduced by n-2\\n # We will do n-1 more op2 to save n-2 op1.\\n diff += op1 // (len(nums) - 2) * len(nums)\\n op1 %= len(nums) - 2\\n op2 = diff - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + op2 // 2 * cost2)\\n\\n for i in range(2):\\n diff += len(nums)\\n res = min(res, diff % 2 * cost1 + diff // 2 * cost2)\\n\\n return res % mod\\n\",\n \"runtime\": \"586\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"587\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2\\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"588\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n maxi = max(nums)\\n mini = min(nums)\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n total = maxi * n - sum(nums)\\n if cost1 * 2 <= cost2 or n <= 2:\\n return total * cost1 % mod\\n\\n op1 = max(0, (maxi - mini) * 2 - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * cost1 + op2 // 2 * cost2\\n\\n total += op1 // (n - 2) * n\\n op1 %= n - 2\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + op2 // 2 * cost2)\\n\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * cost1 + total // 2 * cost2)\\n\\n return res % mod\",\n \"runtime\": \"589\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"590\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n diff = m - min(nums)\\n total = n*m - sum(nums)\\n if n <= 2 or 2*cost1 <= cost2: \\n return total*cost1 % mod\\n ans = 0 \\n op2 = total - max(0, 2*diff - total)\\n ans = (ans + op2//2*cost2) % mod \\n x = max(2*diff-total, total%2)\\n cand = x*cost1\\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \\n q, x = divmod(x, n-2)\\n ans += q*(n-1)*cost2\\n more = (n+x)//2*cost2 \\n if (n-x)&1: \\n if n&1: more += min(cost1, (n+1)//2*cost2)\\n else: more += cost1 \\n cand = min(x*cost1, more)\\n return (ans + cand) % mod\",\n \"runtime\": \"591\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10**9 + 7\\n maxv = max(nums)\\n d = [maxv-num for num in nums]\\n if 2*cost1 <= cost2:\\n return cost1*sum(d)%MOD\\n n = len(nums)\\n if n == 1:\\n return cost1*sum(d)%MOD\\n if n == 2:\\n return cost2*min(d)+cost1*(max(d)-min(d))%MOD\\n maxd = max(d)\\n r = sum(d)-maxd\\n res = float('inf')\\n if maxd <= r:\\n res = (r+maxd)//2*cost2 + (r+maxd)%2*cost1\\n maxd += 1\\n r += n-1\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n return res%MOD\\n res = r*cost2 + (maxd-r)*cost1\\n k = math.floor((maxd-r)/(n-2))\\n maxd += k\\n r += (n-1)*k\\n res = min(res, r*cost2 + (maxd-r)*cost1)\\n maxd += 1\\n r += (n-1)\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n maxd += 1\\n r += n-1\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n return res%MOD\",\n \"runtime\": \"594\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10**9 + 7\\n maxv = max(nums)\\n d = [maxv-num for num in nums]\\n if 2*cost1 <= cost2:\\n return cost1*sum(d)%MOD\\n n = len(nums)\\n if n == 1:\\n return cost1*sum(d)%MOD\\n if n == 2:\\n return cost2*min(d)+cost1*(max(d)-min(d))%MOD\\n maxd = max(d)\\n r = sum(d)-maxd\\n res = float('inf')\\n if maxd <= r:\\n res = (r+maxd)//2*cost2 + (r+maxd)%2*cost1\\n maxd += 1\\n r += n-1\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n return res%MOD\\n res = r*cost2 + (maxd-r)*cost1\\n k = math.floor((maxd-r)/(n-2))\\n maxd += k\\n r += (n-1)*k\\n res = min(res, r*cost2 + (maxd-r)*cost1)\\n maxd += 1\\n r += (n-1)\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n maxd += 1\\n r += n-1\\n res = min(res, (r+maxd)//2*cost2 + (r+maxd)%2*cost1)\\n return res%MOD\",\n \"runtime\": \"595\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n MOD = 10 ** 9 + 7\\n c2 = min(c2, 2 * c1)\\n N, S, mi, ma = len(A), sum(A), min(A), max(A)\\n\\n def cost(height):\\n if height < ma:\\n return inf\\n \\n biggest = height - mi\\n volume = height * N - S\\n if biggest <= volume - biggest:\\n return c2 * (volume//2) + c1 * (volume%2)\\n return c2 * (volume - biggest) + c1 * (2 * biggest - volume)\\n \\n def metacost(h):\\n return min(cost(2*h), cost(2*h+1))\\n\\n lo, hi = 0, 10**9\\n while lo < hi:\\n m1 = lo + (hi-lo)//3\\n m2 = hi - (hi-lo)//3\\n if metacost(m1) > metacost(m2):\\n lo = m1 + 1\\n else:\\n hi = m2 - 1\\n \\n return metacost(lo) % MOD\",\n \"runtime\": \"596\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n if maxGap*2 <= ttlGap:\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n if maxGap >= n-1:\\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n res += min(op2, maxGap * cost1)\\n return res % mod\",\n \"runtime\": \"597\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n # Easy case, Op 1\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n # The maxGap is less than a half of ttlGap, we can always find pairs for Op 2\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n # Corner case with the last one spot left\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n # Two Operations:\\n # Op 1: Directly fill maxGap\\n # Op 2: Pair maxGap with other nums, which increases the final level.\\n\\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n # Op 1 is better\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n # Op 2 is better\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n # For the last round, Op 2: Increase the level by 1 to get (n+maxGap)//2 pairs\\n op2 = (n+maxGap) // 2 * cost2 # = (maxGap + (n-maxGap)//2) * cost2\\n if (n+maxGap) % 2 == 1:\\n # The last one spot left\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n # Compare it with Op 1 \\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, A: List[int], c1: int, c2: int) -> int:\\n ma, mi = max(A), min(A)\\n n = len(A)\\n mod = 10 ** 9 + 7\\n total = ma * n - sum(A)\\n\\n # case 1\\n if c1 * 2 <= c2 or n <= 2:\\n return total * c1 % mod\\n\\n # case 2\\n op1 = max(0, (ma - mi) * 2 - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * c1 + op2 // 2 * c2\\n\\n # case 3\\n total += op1 // (n - 2) * n\\n op1 %= n - 2\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * c1 + op2 // 2 * c2)\\n\\n # case 4\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * c1 + total // 2 * c2)\\n return res % mod\",\n \"runtime\": \"600\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, mx, mod = len(nums), max(nums), 10**9+7\\n maxGap, ttlGap = mx-min(nums), mx*n-sum(nums)\\n \\n if cost1*2 <= cost2:\\n return ttlGap*cost1 % mod\\n \\n if maxGap*2 <= ttlGap:\\n\\n res = ttlGap // 2 * cost2\\n if ttlGap % 2 == 1:\\n if n % 2 == 1:\\n res += min(cost1, cost2 * (n+1) // 2)\\n else:\\n res += cost1\\n return res % mod\\n \\n res = cost2 * (ttlGap - maxGap)\\n maxGap -= ttlGap - maxGap\\n\\n if maxGap >= n-1:\\n \\n if cost2 * (n-1) >= cost1 * (n-2):\\n res += maxGap // (n-1) * (n-1) * cost1\\n maxGap %= n-1\\n else:\\n res += maxGap // (n-2) * (n-1) * cost2\\n maxGap %= n-2\\n\\n if maxGap:\\n op2 = (n+maxGap) // 2 * cost2 \\n if (n+maxGap) % 2 == 1:\\n if n%2 == 1:\\n op2 += min(cost1, cost2*(n+1)//2)\\n else:\\n op2 += cost1\\n\\n res += min(op2, maxGap * cost1)\\n\\n return res % mod\",\n \"runtime\": \"603\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n total = n*m - sum(nums)\\n d = m - min(nums)\\n if n <= 2 or 2*cost1 <= cost2: \\n return total*cost1 % mod\\n ans = 0 \\n if d <= total - d: \\n total, x = divmod(total, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + (total - d)*cost2) % mod \\n x = 2*d - total \\n cand = x*cost1\\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \\n q, r = divmod(x, n-2)\\n diff = q*(n-1)*cost2 \\n more = (n+r)//2*cost2 \\n if (n-r)&1: \\n if n&1: more += min(cost1, (n+1)//2*cost2)\\n else: more += cost1 \\n diff += min(r*cost1, more)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10**9 + 7\\n if len(nums)==1:\\n return 0\\n if len(nums)==2 or cost2 >= cost1 * 2:\\n return (max(nums) * len(nums) - sum(nums)) * cost1 % MOD\\n nums = sorted(nums)\\n maxn = nums[-1]\\n left, rest = nums[0], sum(nums[1:])\\n leftholes = maxn - left\\n restholes = (maxn * (len(nums) - 1) - rest)\\n n_add = max(0, (leftholes - restholes)) // (len(nums) - 2)\\n targets = [maxn, maxn + n_add, maxn + n_add + 1, maxn + n_add + 2]\\n cost = inf\\n for target in targets:\\n leftholes = target - left\\n restholes = (target * (len(nums) - 1) - rest)\\n if leftholes <= restholes:\\n cost2_adds = (leftholes + restholes) // 2\\n cost1_adds = (leftholes + restholes) % 2\\n else:\\n cost2_adds = restholes\\n cost1_adds = leftholes - restholes\\n cost = min(cost, cost2_adds * cost2 + cost1_adds * cost1)\\n return cost % MOD\",\n \"runtime\": \"606\"\n },\n {\n \"code\": \"# ValueError: 3\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n \",\n \"runtime\": \"627\"\n },\n {\n \"code\": \"from bisect import bisect_left\\n\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n \\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\",\n \"runtime\": \"628\"\n },\n {\n \"code\": \"from bisect import bisect_left\\n\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n ones = max(2 * (k - self.minNums) - sumDifferences, 0)\\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n \\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\",\n \"runtime\": \"632\"\n },\n {\n \"code\": \"# IndentationError: 355\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n \",\n \"runtime\": \"635\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\",\n \"runtime\": \"637\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\\n print(\\\"This will cause a SyntaxError\\\")\\n\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n nums = sorted((m-x for x in nums), reverse=True)\\n if n == 1: return 0 \\n if n == 2: return nums[0]*cost1 % mod \\n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\\n ans = 0 \\n sm = sum(nums)\\n if nums[0] < sm - nums[0]: \\n total, x = divmod(sm, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + (sm - nums[0])*cost2) % mod \\n x = 2*nums[0] - sm \\n cand = x*cost1\\n diff = 0 \\n if x >= n-2 and (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\\n k, x = divmod(x, (n-2))\\n diff = k*(n-1)*cost2 \\n if x: \\n d0 = x*cost1\\n d1 = (n+x)//2*cost2 \\n x = (n-x) % 2\\n if x: \\n if n&1: d1 += min((n+1)//2*cost2, cost1)\\n else: d1 += cost1 \\n diff += min(d0, d1)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"639\"\n },\n {\n \"code\": \"# Time Limit Exceeded: 10\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\",\n \"runtime\": \"640\"\n },\n {\n \"code\": \"from bisect import bisect_left\\n\\nclass Solution:\\n MOD = 10 ** 9 + 7\\n\\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n \\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\",\n \"runtime\": \"643\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n nums = sorted((m-x for x in nums), reverse=True)\\n if n == 1: return 0 \\n if n == 2: return nums[0]*cost1 % mod \\n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\\n ans = 0 \\n sm = sum(nums)\\n if nums[0] < sm - nums[0]: \\n total, x = divmod(sm, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + (sm - nums[0])*cost2) % mod \\n x = 2*nums[0] - sm \\n cand = x*cost1\\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \\n q, r = divmod(x, n-2)\\n diff = q*(n-1)*cost2 \\n more = (n+r)//2*cost2 \\n if (n-r)&1: \\n if n&1: more += min(cost1, (n+1)//2*cost2)\\n else: more += cost1 \\n diff += min(r*cost1, more)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"645\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n nums = sorted((m-x for x in nums), reverse=True)\\n if n == 1: return 0 \\n if n == 2: return nums[0]*cost1 % mod \\n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\\n ans = 0 \\n total = sum(nums)\\n if nums[0] < total - nums[0]: \\n total, x = divmod(total, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + (total - nums[0])*cost2) % mod \\n x = 2*nums[0] - total \\n cand = x*cost1\\n if x < n-2 or (n-1)*cost2 < (n-2)*cost1: \\n q, r = divmod(x, n-2)\\n diff = q*(n-1)*cost2 \\n more = (n+r)//2*cost2 \\n if (n-r)&1: \\n if n&1: more += min(cost1, (n+1)//2*cost2)\\n else: more += cost1 \\n diff += min(r*cost1, more)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"646\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n mod = 1_000_000_007 \\n m = max(nums)\\n nums = sorted((m-x for x in nums), reverse=True)\\n if n == 1: return 0 \\n if n == 2: return nums[0]*cost1 % mod \\n if 2*cost1 <= cost2: \\n return sum(nums)*cost1 % mod\\n ans = 0 \\n sm = sum(nums[1:])\\n if nums[0] < sm: \\n total, x = divmod(nums[0]+sm, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + sm*cost2) % mod \\n x = nums[0] - sm \\n if x == 0: return ans \\n cand = x*cost1\\n diff = 0 \\n if x+1 >= n-1: \\n if (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\\n k = x//(n-2)\\n diff = k*(n-1)*cost2 \\n x -= k*(n-2)\\n if x: \\n d0 = x*cost1\\n d1 = (n+x)//2*cost2 \\n x = (n-x) % 2\\n if x: \\n if n&1: d1 += min((n+1)//2*cost2, cost1)\\n else: d1 += cost1 \\n diff += min(d0, d1)\\n # print(cand, diff)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"648\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\",\n \"runtime\": \"655\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\",\n \"runtime\": \"656\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n l = len(nums)\\n if l < 2:\\n return 0\\n nums.sort()\\n if nums[0] == nums[-1]:\\n return 0\\n maxVal = nums[-1]\\n # Always use cost1 if not more costly than cost2/2 since 2 cost1 ops equals 1 cost2 op\\n if ((cost1 << 1) <= cost2) or l == 2:\\n totalOps = maxVal * l\\n for val in nums:\\n totalOps -= val\\n return (totalOps * cost1) % 1000000007\\n else:\\n totalOps = 0\\n maxVal = nums[0]\\n minVal = nums[0]\\n for val in nums:\\n totalOps -= val\\n if val < minVal:\\n minVal = val\\n elif val > maxVal:\\n maxVal = val\\n totalOps += maxVal * l\\n cost1Ops = 0\\n cost2Ops = 0\\n # Maximise use of cost2. There is only one scenario where this results in > 1 remaining difference\\n # It is possible for one val to be substantially less than the others - if maxVal - minVal > totalOps - (maxVal - minVal)\\n maxSingleNumOps = maxVal - minVal\\n remainingGap = 0\\n if (maxSingleNumOps << 1) > totalOps:\\n cost2Ops += totalOps - maxSingleNumOps\\n remainingGap = maxSingleNumOps - cost2Ops\\n # For the remaining gap, there are 2 methods to reduce this:\\n # 1. Use cost1 exclusively\\n # 2. Use cost2, pairing minVal increases with each other num - for each len(nums) - 2 reduction in ops, cost = cost2 * (len(nums) - 1)\\n gapReduction = remainingGap - (remainingGap % (l - 2))\\n remainingGap -= gapReduction\\n if cost1 * (l - 2) <= cost2 * (l - 1):\\n cost1Ops += gapReduction\\n else:\\n cost2Ops += gapReduction * (l - 1) // (l - 2)\\n # Otherwise it is possible to use cost2 to reduce remaining ops to 1 or 0\\n else:\\n cost2Ops = totalOps >> 1\\n remainingGap = totalOps & 1\\n # For the remainingGap, there are 2 methods to reduce this:\\n # 1. Use cost1 exclusively\\n # 2. Use cost2 to increase minVal with each num, then pair each of the remaining nums:\\n if remainingGap > 0:\\n finalGap = 0\\n # If remainingGap is odd and len(nums) is even, then it is impossible to completely use cost2 to reduce the gap. Increase by remainingGap + 1 and leave 1 remaining op that must use cost1.\\n if ((remainingGap & 1) == 1) and ((l & 1) == 0):\\n method2Ops = remainingGap + ((l - 1 - remainingGap) >> 1)\\n finalGap = 1\\n # If both remainingGap and len(nums) are even or both are odd, then increase by remaininGap + 1\\n elif (remainingGap & 1) == (l & 1):\\n method2Ops = remainingGap + 1 + ((l - 1 - remainingGap) >> 1)\\n # If remainingGap is even and len(nums) is odd, then increase by remaininGap + 2\\n else:\\n method2Ops = (remainingGap + 1) // 2 + l\\n method1Ops = remainingGap - finalGap\\n if cost1 * method1Ops < cost2 * method2Ops:\\n cost1Ops += method1Ops\\n else:\\n cost2Ops += method2Ops\\n remainingGap = finalGap\\n cost1Ops += remainingGap\\n return (cost1Ops * cost1 + cost2Ops * cost2) % 1000000007\",\n \"runtime\": \"657\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\",\n \"runtime\": \"660\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\\nsolution = Solution()\\nsolution.minCostToEqualizeArray([1, 2, 3], 2, 4)\\n\",\n \"runtime\": \"662\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n m, n = max(nums), len(nums)\\n mod = 1_000_000_007 \\n nums = sorted((m-x for x in nums), reverse=True)\\n if n == 1: return 0 \\n if n == 2: return nums[0]*cost1 % mod \\n if 2*cost1 <= cost2: return sum(nums)*cost1 % mod\\n ans = 0 \\n sm = sum(nums)\\n if nums[0] < sm - nums[0]: \\n total, x = divmod(sm, 2)\\n ans = (ans + total*cost2) % mod \\n else: \\n ans = (ans + (sm - nums[0])*cost2) % mod \\n x = 2*nums[0] - sm \\n cand = x*cost1\\n diff = 0 \\n if x+1 >= n-1: \\n if (n-1)*cost2 >= (n-2)*cost1: return (ans + cand) % mod\\n k = x//(n-2)\\n diff = k*(n-1)*cost2 \\n x -= k*(n-2)\\n if x: \\n d0 = x*cost1\\n d1 = (n+x)//2*cost2 \\n x = (n-x) % 2\\n if x: \\n if n&1: d1 += min((n+1)//2*cost2, cost1)\\n else: d1 += cost1 \\n diff += min(d0, d1)\\n cand = min(cand, diff) \\n return (ans + cand) % mod\",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0)\\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums, cost1, cost2):\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\",\n \"runtime\": \"666\"\n },\n {\n \"code\": \"class Solution:\\n MOD = int(1E9+7)\\n\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n, max_v, min_v, sum_v = len(nums), 0, int(1E9), 0\\n for num in nums:\\n max_v = max(max_v, num)\\n min_v = min(min_v, num)\\n sum_v += num\\n\\n total_diff = max_v * n - sum_v\\n if cost2 >= 2 * cost1 or n <= 2:\\n return total_diff * cost1 % Solution.MOD\\n\\n op1 = max(0, max_v - min_v - (total_diff - (max_v - min_v)))\\n op2 = total_diff - op1\\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\\n\\n extra_levels = op1 // (n-2)\\n total_diff += extra_levels * n\\n op1 = op1 % (n-2)\\n op2 = total_diff - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\\n\\n for i in range(2):\\n total_diff += n\\n res = min(res, total_diff % 2 * cost1 + (total_diff // 2) * cost2)\\n return res % Solution.MOD\",\n \"runtime\": \"669\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n lol = 10**9 + 7\\n use_cost2 = cost2 < 2 * cost1\\n target_val = max(nums)\\n total_changes = 0\\n max_changes = 0\\n for num in nums:\\n cur_changes = target_val - num\\n if cur_changes > max_changes:\\n max_changes = cur_changes\\n total_changes += cur_changes\\n if not use_cost2:\\n return (cost1 * total_changes) % lol\\n if max_changes <= total_changes / 2:\\n unmatched = total_changes % 2\\n #return (cost2 * (total_changes // 2) + cost1 * (total_changes % 2)) % lol\\n else:\\n unmatched = 2 * (max_changes - (total_changes // 2)) - (total_changes % 2)\\n matched = total_changes - unmatched\\n n = len(nums)\\n #trick_cost = 0\\n if n > 2 and cost2 * (n-1) < cost1 * (n-2):\\n trick_use = unmatched // (n-2)\\n unmatched -= trick_use * (n-2)\\n matched += 2 * trick_use * (n-1)\\n overhang_fix_cost = [None] * (n+1)\\n overhang_fix_cost[0] = 0\\n overhang_fix_cost[n] = 0\\n path = deque()\\n path.append(0)\\n while len(path) > 0:\\n cur_amount = path.popleft()\\n new1_place = (cur_amount + 1) % n\\n new1_cost = overhang_fix_cost[cur_amount] + cost1\\n if overhang_fix_cost[new1_place] is None or overhang_fix_cost[new1_place] > new1_cost:\\n overhang_fix_cost[new1_place] = new1_cost\\n path.append(new1_place)\\n new2_place = (cur_amount + 2) % n\\n new2_cost = overhang_fix_cost[cur_amount] + cost2\\n if overhang_fix_cost[new2_place] is None or overhang_fix_cost[new2_place] > new2_cost:\\n overhang_fix_cost[new2_place] = new2_cost\\n path.append(new2_place)\\n overhang_fix_cost = overhang_fix_cost[::-1]\\n\\n print(overhang_fix_cost)\\n\\n min_balance_cost = cost1 * unmatched\\n for i in range(0, min(unmatched+1, n)):\\n balance_cost = cost1 * (unmatched - i) + cost2 * i + overhang_fix_cost[i]\\n if min_balance_cost is None or balance_cost < min_balance_cost:\\n min_balance_cost = balance_cost\\n\\n print(\\\"matched: {}\\\".format(matched))\\n print(\\\"unmatched: {}\\\".format(unmatched))\\n return (min_balance_cost + cost2 * (matched // 2)) % lol\\n #return (cost1 * unmatched + cost2 * (matched // 2)) % lol\",\n \"runtime\": \"715\"\n },\n {\n \"code\": \"class Solution:\\n MOD = 10 ** 9 + 7\\n \\n def solve(self, k):\\n sumDifferences = k * len(self.nums) - self.sumNums\\n \\n ones = max(2 * (k - self.minNums) - sumDifferences, 0) \\n if (sumDifferences - ones) & 1 != 0:\\n ones += 1\\n \\n return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2\\n \\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n cost2 = min(2 * cost1, cost2)\\n \\n self.nums = nums\\n self.minNums = min(nums)\\n self.sumNums = sum(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n \\n m = max(nums)\\n \\n sameParity = range(m, 10 ** 18, 2)\\n diffParity = range(m + 1, 10 ** 18, 2)\\n i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i))\\n j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j))\\n \\n return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD\\n\\nsolution = Solution()\\nnums = [i for i in range(10**7)]\\nsolution.minCostToEqualizeArray(nums, 2, 4)\\n\",\n \"runtime\": \"1047\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10 ** 9 + 7\\n INF = 10 ** 20\\n N = len(nums)\\n mx = max(nums)\\n mn = min(nums)\\n c1, c2 = cost1, cost2\\n\\n if c2 >= 2 * c1:\\n return (sum(mx - n for n in nums) * c1) % MOD\\n\\n total_diff = sum(mx - n for n in nums)\\n\\n def calc(mxx):\\n total = total_diff + N * (mxx - mx)\\n biggest_diff = mxx - mn\\n other_sm = total - biggest_diff\\n\\n if biggest_diff - 1 > other_sm:\\n \\n extra = biggest_diff - other_sm\\n return other_sm * c2 + extra * c1\\n\\n\\n return (total // 2) * c2 + (total % 2) * c1 \\n\\n ans = INF\\n j = mx\\n while True:\\n v = calc(j)\\n if v < ans: \\n ans = v\\n j += 1\\n else:\\n return ans % MOD\",\n \"runtime\": \"1075\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n mod = (10**9) + 7\\n acm = max(nums)\\n a = [acm-x for x in nums]\\n mx3 = max(a)\\n sm = sum(a)\\n if 2*cost1<cost2:\\n return sm*cost1%mod\\n def f(mx):\\n s = sm+ (mx-acm)*len(nums)\\n mx2 = mx3 + (mx-acm)\\n c = max(0,2*mx2 - s)\\n if s%2 and c==0:\\n c = 1\\n total = (cost2*(s-c)//2 + cost1*c)\\n return total\\n \\n cur = max(nums)\\n res = f(cur)\\n while 1:\\n cur +=1\\n ff = f(cur)\\n if ff>res:\\n break\\n res =ff\\n \\n return res%mod\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n mod = (10**9) + 7\\n acm = max(nums)\\n a = [acm-x for x in nums]\\n mx3 = max(a)\\n sm = sum(a)\\n if 2*cost1<cost2: # trivial case\\n return sm*cost1%mod\\n def f(mx): # solving sub problem\\n s = sm+ (mx-acm)*len(nums)\\n mx2 = mx3 + (mx-acm)\\n c = max(0,2*mx2 - s)\\n if s%2 and c==0:\\n c = 1\\n total = (cost2*(s-c)//2 + cost1*c)\\n return total\\n \\n \\n cur = max(nums)\\n res = f(cur)\\n while 1: # can be proved < 2*max_a\\n cur +=1\\n ff = f(cur)\\n if ff>res:\\n break\\n res =ff\\n \\n return res%mod\\n \",\n \"runtime\": \"1496\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10**9+7\\n if 2 * cost1 <= cost2:\\n return (max(nums) * len(nums) - sum(nums)) * cost1 % MOD\\n\\n self.nums = sorted(nums)\\n self.cost1 = cost1\\n self.cost2 = cost2\\n maxx = max(nums)\\n\\n ans = self.cal_cost(maxx)\\n while True: \\n maxx += 1\\n tmp = self.cal_cost(maxx)\\n if tmp >= ans:\\n break\\n ans = tmp\\n return ans % MOD\\n\\n def cal_cost(self, x): \\n diff = [x - n for n in self.nums]\\n total = sum(diff)\\n if diff[0] <= (total+1) // 2: \\n return total // 2 * self.cost2 + total % 2 * self.cost1\\n else:\\n return (diff[0] - total + diff[0]) * self.cost1 + (total - diff[0]) * self.cost2\",\n \"runtime\": \"1945\"\n },\n {\n \"code\": \"import sys\\n\\nclass Solution:\\n\\n def equaliseToValue(self, nums, cost1, cost2, value, sumG, maxG):\\n # gaps = [(value - nums[i]) for i in range(len(nums))]\\n # maxG = max(gaps)\\n # sumG = sum(gaps)\\n if 2*maxG == sumG:\\n return (cost2 * maxG),True\\n elif 2*maxG > sumG:\\n pairable = (sumG - maxG)\\n return (pairable * cost2) + ((2*maxG - sumG)*cost1), False\\n elif 2*maxG < sumG and sumG % 2 == 1:\\n return (cost2 * (sumG//2)) + cost1, False\\n else:\\n return cost2 * (sumG//2), True\\n\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n if len(nums) <= 1:\\n return 0\\n if len(nums) == 2:\\n return (cost1*(max(nums)-min(nums)))%(10**9 + 7)\\n\\n if cost2 >= 2*cost1:\\n mNum = max(nums)\\n ans = 0\\n for num in nums:\\n ans += ((mNum - num)*cost1)\\n return ans % (10**9+7)\\n\\n mNum = max(nums)\\n \\n sumG = 0\\n maxG = 0\\n for i in range(len(nums)):\\n sumG += mNum - nums[i]\\n maxG = max(maxG, mNum-nums[i])\\n\\n\\n\\n ans = sys.maxsize\\n i = mNum\\n while True:\\n if i > mNum:\\n sumG += len(nums)\\n maxG += 1\\n if (sumG*cost2)//2 > ans:\\n break\\n t_ans = self.equaliseToValue(nums, cost1, cost2, i, sumG, maxG)\\n ans = min(ans, t_ans[0])\\n if t_ans[1]:\\n break\\n i += 1\\n\\n return ans%(10**9+7)\\n\",\n \"runtime\": \"2333\"\n },\n {\n \"code\": \"import sys\\n\\nclass Solution:\\n\\n def equaliseToValue(self, nums, cost1, cost2, value, sumG, maxG):\\n # gaps = [(value - nums[i]) for i in range(len(nums))]\\n # maxG = max(gaps)\\n # sumG = sum(gaps)\\n if 2*maxG == sumG:\\n return (cost2 * maxG),True\\n elif 2*maxG > sumG:\\n pairable = (sumG - maxG)\\n # sumG - 2*(sumG - maxG) = \\n return (pairable * cost2) + ((2*maxG - sumG)*cost1), False #%(10**9+7)\\n elif 2*maxG < sumG and sumG % 2 == 1:\\n return (cost2 * (sumG//2)) + cost1, False\\n else:\\n return cost2 * (sumG//2), True\\n\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n if len(nums) <= 1:\\n return 0\\n if len(nums) == 2:\\n return (cost1*(max(nums)-min(nums)))%(10**9 + 7)\\n\\n if cost2 >= 2*cost1:\\n mNum = max(nums)\\n ans = 0\\n for num in nums:\\n ans += ((mNum - num)*cost1)\\n return ans % (10**9+7)\\n\\n mNum = max(nums)\\n \\n sumG = 0\\n maxG = 0\\n for i in range(len(nums)):\\n sumG += mNum - nums[i]\\n maxG = max(maxG, mNum-nums[i])\\n\\n\\n\\n ans = sys.maxsize\\n for i in range(mNum, 2*mNum):\\n if i > mNum:\\n sumG += len(nums)\\n maxG += 1\\n t_ans = self.equaliseToValue(nums, cost1, cost2, i, sumG, maxG)\\n ans = min(ans, t_ans[0])\\n if t_ans[1]:\\n break\\n\\n return ans%(10**9+7)\\n\",\n \"runtime\": \"3492\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(\\n self,\\n nums: list[int],\\n cost1: int,\\n cost2: int,\\n ) -> int:\\n kMod = 1_000_000_007\\n n = len(nums)\\n minNum = min(nums)\\n maxNum = max(nums)\\n summ = sum(nums)\\n\\n if cost1 * 2 <= cost2 or n < 3:\\n totalGap = maxNum * n - summ\\n return (cost1 * totalGap) % kMod\\n\\n def getMinCost(target: int) -> int:\\n \\n maxGap = target - minNum\\n totalGap = target * n - summ\\n \\n pairs = min(totalGap // 2, totalGap - maxGap)\\n return cost1 * (totalGap - 2 * pairs) + cost2 * pairs\\n\\n return min(getMinCost(target)\\n for target in range(maxNum, 2 * maxNum)) % kMod\",\n \"runtime\": \"7546\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":65,"string":"65"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n max_nums, min_nums = max(nums), min(nums)\n n = len(nums)\n diff = max_nums - min_nums\n tot = max_nums * n - sum(nums)\n \n def test(extra):\n ntot = tot + n * extra\n big = diff + extra\n unpair = max(ntot % 2, big * 2 - ntot)\n pair = (ntot - unpair) // 2\n print(extra, unpair, pair)\n return unpair * cost1 + pair * cost2\n \n def calc():\n if cost1 * 2 <= cost2 or n <= 2:\n return tot * cost1\n more = max(0, diff * 2 - tot) // (n - 2) \n return min(test(extra) for extra in [0, 1, more, more + 1, more + 2])\n \n return calc() % 1_000_000_007","memory":"30600"},{"code":"Mod = int(1e9 + 7)\nclass Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n\n diff,m = 0,max(nums)\n a = []\n for i in range(len(nums)):\n diff += m - nums[i]\n a.append(m - nums[i])\n \n if cost2 > 2*cost1 :\n return cost1 * diff % Mod\n n = len(a)\n x,y = max(a),sum(a)\n res = float('inf')\n for _ in range(max(nums) + 100):\n if 2*x > y:\n res = min(res, (2*x - y)*cost1 + (y - x)*cost2)\n else:\n res = min(res, cost2*(y//2) + cost1*(y%2))\n x+=1\n y+=n\n # print(x,y)\n return res%Mod\n ","memory":"31000"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n maxi = max(nums)\n mini = min(nums)\n MOD = 10**9 + 7\n total = max(nums) * n - sum(nums)\n # case 1: cost 1 is too cheap\n if cost1 <= cost2 / 2 or n <= 2:\n return total * cost1 % MOD\n \n # case 2: cost 1 & cost 2 mixing\n op1 = max(0, 2 * (maxi - mini) - total)\n op2 = total - op1\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\n \n # case 3: cost 1 too expensive than cost 2, so we increase total\n total += op1 // (n-2) * n\n op1 = op1 % (n-2)\n op2 = total - op1\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\n\n # case 4: cost 1 too expensive, only use cost 2 and maybe 0 or 1 cost 1\n for i in range(2):\n total += n\n res = min(res, total % 2 * cost1 + total//2 * cost2)\n return res % MOD","memory":"31400"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n n = len(nums)\n mod = 10 ** 9 + 7\n work = max(nums) * n - sum(nums) # work to be done\n\n # CASE 1\n if cost1 * 2 <= cost2 or n <= 2: \n return work * cost1 % mod\n\n # CASE 2\n max_pair_ctns = (max(nums) - min(nums)) * 2 # max contribution by greedy pairing scheme\n extra_work = max(0, max_pair_ctns - work)\n\n\n # 2.a: do extra work with only single operations\n lone_ctn = extra_work\n pair_ctn = work - lone_ctn\n scha = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2 \n\n # adjust extra work for optimal pairs\n # - 2 are the item with leftover units and max item\n work += extra_work // (n - 2) * n \n \n # 2.b: do extra work with a mixture of pair and single operations \n lone_ctn = lone_ctn % (n - 2)\n pair_ctn = work - lone_ctn\n schb = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2\n\n # 2.c: do extra with maximum number pair operations\n schc = maxsize\n for i in range(2):\n work += n\n schc = min(schc, work % 2 * cost1 + work // 2 * cost2)\n \n return min(scha, schb, schc) % mod","memory":"31600"},{"code":"class Solution:\n def minCostToEqualizeArray(self, temperatures: List[int], single_adjustment_cost: int, pair_adjustment_cost: int) -> int:\n \"\"\"\n Calculate the minimum cost to equalize the temperatures of all server racks.\n\n Parameters:\n temperatures (List[int]): List of integers representing current temperatures of server racks.\n single_adjustment_cost (int): Cost to increase the temperature of a single rack by 1 degree.\n pair_adjustment_cost (int): Cost to increase the temperature of two different racks by 1 degree each.\n\n Returns:\n int: The minimum cost to equalize all temperatures, modulo 10^9 + 7.\n \"\"\"\n \n # Constants\n MOD = 10 ** 9 + 7\n\n # Step 1: Find maximum and minimum temperatures\n max_temp = max(temperatures)\n min_temp = min(temperatures)\n num_racks = len(temperatures)\n\n # Step 2: Calculate the total number of increments required to equalize all racks to the maximum temperature\n total_increments = max_temp * num_racks - sum(temperatures)\n\n # Case 1: If it's cheaper to adjust one rack at a time or if there are only 1 or 2 racks\n if single_adjustment_cost * 2 <= pair_adjustment_cost or num_racks <= 2:\n return total_increments * single_adjustment_cost % MOD\n\n # Step 3: Mixed strategy - Use both single and pair adjustments\n # Calculate the number of adjustments required if using both methods\n remaining_difference = max(0, (max_temp - min_temp) * 2 - total_increments)\n increments_with_single_adjustments = total_increments - remaining_difference\n min_cost = (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost\n\n # Case 2: Further optimize using only pair adjustments if possible\n total_increments += remaining_difference // (num_racks - 2) * num_racks\n remaining_difference %= num_racks - 2\n increments_with_single_adjustments = total_increments - remaining_difference\n min_cost = min(min_cost, (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost)\n\n # Case 3: Check further for better cost optimization by adjusting multiple racks at once\n for _ in range(2):\n total_increments += num_racks\n min_cost = min(min_cost, total_increments % 2 * single_adjustment_cost + total_increments // 2 * pair_adjustment_cost)\n\n # Return the minimum cost modulo 10^9 + 7\n return min_cost % MOD","memory":"31700"},{"code":"class Solution:\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\n MOD = 10 ** 9 + 7\n INF = 10 ** 20\n N = len(nums)\n mx = max(nums)\n mn = min(nums)\n c1, c2 = cost1, cost2\n\n if c2 >= 2 * c1:\n return (sum(mx - n for n in nums) * c1) % MOD\n\n total_diff = sum(mx - n for n in nums)\n\n def calc(mxx):\n total = total_diff + N * (mxx - mx)\n biggest_diff = mxx - mn\n other_sm = total - biggest_diff\n\n if biggest_diff - 1 > other_sm:\n \n extra = biggest_diff - other_sm\n return other_sm * c2 + extra * c1\n\n\n return (total // 2) * c2 + (total % 2) * c1 \n\n ans = INF\n j = mx\n while True:\n v = calc(j)\n if v < ans: \n ans = v\n j += 1\n else:\n return ans % MOD","memory":"31800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n max_nums, min_nums = max(nums), min(nums)\\n n = len(nums)\\n diff = max_nums - min_nums\\n tot = max_nums * n - sum(nums)\\n \\n def test(extra):\\n ntot = tot + n * extra\\n big = diff + extra\\n unpair = max(ntot % 2, big * 2 - ntot)\\n pair = (ntot - unpair) // 2\\n print(extra, unpair, pair)\\n return unpair * cost1 + pair * cost2\\n \\n def calc():\\n if cost1 * 2 <= cost2 or n <= 2:\\n return tot * cost1\\n more = max(0, diff * 2 - tot) // (n - 2) \\n return min(test(extra) for extra in [0, 1, more, more + 1, more + 2])\\n \\n return calc() % 1_000_000_007\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"Mod = int(1e9 + 7)\\nclass Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n\\n diff,m = 0,max(nums)\\n a = []\\n for i in range(len(nums)):\\n diff += m - nums[i]\\n a.append(m - nums[i])\\n \\n if cost2 > 2*cost1 :\\n return cost1 * diff % Mod\\n n = len(a)\\n x,y = max(a),sum(a)\\n res = float('inf')\\n for _ in range(max(nums) + 100):\\n if 2*x > y:\\n res = min(res, (2*x - y)*cost1 + (y - x)*cost2)\\n else:\\n res = min(res, cost2*(y//2) + cost1*(y%2))\\n x+=1\\n y+=n\\n # print(x,y)\\n return res%Mod\\n \",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n maxi = max(nums)\\n mini = min(nums)\\n MOD = 10**9 + 7\\n total = max(nums) * n - sum(nums)\\n # case 1: cost 1 is too cheap\\n if cost1 <= cost2 / 2 or n <= 2:\\n return total * cost1 % MOD\\n \\n # case 2: cost 1 & cost 2 mixing\\n op1 = max(0, 2 * (maxi - mini) - total)\\n op2 = total - op1\\n res = (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2\\n \\n # case 3: cost 1 too expensive than cost 2, so we increase total\\n total += op1 // (n-2) * n\\n op1 = op1 % (n-2)\\n op2 = total - op1\\n res = min(res, (op1 + op2 % 2) * cost1 + (op2 // 2) * cost2)\\n\\n # case 4: cost 1 too expensive, only use cost 2 and maybe 0 or 1 cost 1\\n for i in range(2):\\n total += n\\n res = min(res, total % 2 * cost1 + total//2 * cost2)\\n return res % MOD\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n n = len(nums)\\n mod = 10 ** 9 + 7\\n work = max(nums) * n - sum(nums) # work to be done\\n\\n # CASE 1\\n if cost1 * 2 <= cost2 or n <= 2: \\n return work * cost1 % mod\\n\\n # CASE 2\\n max_pair_ctns = (max(nums) - min(nums)) * 2 # max contribution by greedy pairing scheme\\n extra_work = max(0, max_pair_ctns - work)\\n\\n\\n # 2.a: do extra work with only single operations\\n lone_ctn = extra_work\\n pair_ctn = work - lone_ctn\\n scha = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2 \\n\\n # adjust extra work for optimal pairs\\n # - 2 are the item with leftover units and max item\\n work += extra_work // (n - 2) * n \\n \\n # 2.b: do extra work with a mixture of pair and single operations \\n lone_ctn = lone_ctn % (n - 2)\\n pair_ctn = work - lone_ctn\\n schb = (lone_ctn + pair_ctn % 2) * cost1 + pair_ctn // 2 * cost2\\n\\n # 2.c: do extra with maximum number pair operations\\n schc = maxsize\\n for i in range(2):\\n work += n\\n schc = min(schc, work % 2 * cost1 + work // 2 * cost2)\\n \\n return min(scha, schb, schc) % mod\",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, temperatures: List[int], single_adjustment_cost: int, pair_adjustment_cost: int) -> int:\\n \\\"\\\"\\\"\\n Calculate the minimum cost to equalize the temperatures of all server racks.\\n\\n Parameters:\\n temperatures (List[int]): List of integers representing current temperatures of server racks.\\n single_adjustment_cost (int): Cost to increase the temperature of a single rack by 1 degree.\\n pair_adjustment_cost (int): Cost to increase the temperature of two different racks by 1 degree each.\\n\\n Returns:\\n int: The minimum cost to equalize all temperatures, modulo 10^9 + 7.\\n \\\"\\\"\\\"\\n \\n # Constants\\n MOD = 10 ** 9 + 7\\n\\n # Step 1: Find maximum and minimum temperatures\\n max_temp = max(temperatures)\\n min_temp = min(temperatures)\\n num_racks = len(temperatures)\\n\\n # Step 2: Calculate the total number of increments required to equalize all racks to the maximum temperature\\n total_increments = max_temp * num_racks - sum(temperatures)\\n\\n # Case 1: If it's cheaper to adjust one rack at a time or if there are only 1 or 2 racks\\n if single_adjustment_cost * 2 <= pair_adjustment_cost or num_racks <= 2:\\n return total_increments * single_adjustment_cost % MOD\\n\\n # Step 3: Mixed strategy - Use both single and pair adjustments\\n # Calculate the number of adjustments required if using both methods\\n remaining_difference = max(0, (max_temp - min_temp) * 2 - total_increments)\\n increments_with_single_adjustments = total_increments - remaining_difference\\n min_cost = (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\\\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost\\n\\n # Case 2: Further optimize using only pair adjustments if possible\\n total_increments += remaining_difference // (num_racks - 2) * num_racks\\n remaining_difference %= num_racks - 2\\n increments_with_single_adjustments = total_increments - remaining_difference\\n min_cost = min(min_cost, (remaining_difference + increments_with_single_adjustments % 2) * single_adjustment_cost \\\\\\n + (increments_with_single_adjustments // 2) * pair_adjustment_cost)\\n\\n # Case 3: Check further for better cost optimization by adjusting multiple racks at once\\n for _ in range(2):\\n total_increments += num_racks\\n min_cost = min(min_cost, total_increments % 2 * single_adjustment_cost + total_increments // 2 * pair_adjustment_cost)\\n\\n # Return the minimum cost modulo 10^9 + 7\\n return min_cost % MOD\",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"class Solution:\\n def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int:\\n MOD = 10 ** 9 + 7\\n INF = 10 ** 20\\n N = len(nums)\\n mx = max(nums)\\n mn = min(nums)\\n c1, c2 = cost1, cost2\\n\\n if c2 >= 2 * c1:\\n return (sum(mx - n for n in nums) * c1) % MOD\\n\\n total_diff = sum(mx - n for n in nums)\\n\\n def calc(mxx):\\n total = total_diff + N * (mxx - mx)\\n biggest_diff = mxx - mn\\n other_sm = total - biggest_diff\\n\\n if biggest_diff - 1 > other_sm:\\n \\n extra = biggest_diff - other_sm\\n return other_sm * c2 + extra * c1\\n\\n\\n return (total // 2) * c2 + (total % 2) * c1 \\n\\n ans = INF\\n j = mx\\n while True:\\n v = calc(j)\\n if v < ans: \\n ans = v\\n j += 1\\n else:\\n return ans % MOD\",\n \"memory\": \"31800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":6,"string":"6"}}},{"rowIdx":2436,"cells":{"question_id":{"kind":"number","value":3419,"string":"3,419"},"name":{"kind":"string","value":"maximum-points-inside-the-square"},"content":{"kind":"string","value":"<p>You are given a 2D<strong> </strong>array <code>points</code> and a string <code>s</code> where, <code>points[i]</code> represents the coordinates of point <code>i</code>, and <code>s[i]</code> represents the <strong>tag</strong> of point <code>i</code>.</p>\n\n<p>A <strong>valid</strong> square is a square centered at the origin <code>(0, 0)</code>, has edges parallel to the axes, and <strong>does not</strong> contain two points with the same tag.</p>\n\n<p>Return the <strong>maximum</strong> number of points contained in a <strong>valid</strong> square.</p>\n\n<p>Note:</p>\n\n<ul>\n\t<li>A point is considered to be inside the square if it lies on or within the square's boundaries.</li>\n\t<li>The side length of the square can be zero.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/03/29/3708-tc1.png\" style=\"width: 303px; height: 303px;\" /></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[2,2],[-1,-2],[-4,4],[-3,1],[3,-3]], s = "abdca"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The square of side length 4 covers two points <code>points[0]</code> and <code>points[1]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/03/29/3708-tc2.png\" style=\"width: 302px; height: 302px;\" /></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[1,1],[-2,-2],[-2,2]], s = "abb"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The square of side length 2 covers one point, which is <code>points[0]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[1,1],[-1,-1],[2,-2]], s = "ccd"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">0</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>It's impossible to make any valid squares centered at the origin such that it covers only one point among <code>points[0]</code> and <code>points[1]</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length, points.length <= 10<sup>5</sup></code></li>\n\t<li><code>points[i].length == 2</code></li>\n\t<li><code>-10<sup>9</sup> <= points[i][0], points[i][1] <= 10<sup>9</sup></code></li>\n\t<li><code>s.length == points.length</code></li>\n\t<li><code>points</code> consists of distinct coordinates.</li>\n\t<li><code>s</code> consists only of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":39.028591883305744,"string":"39.028592"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table","string","binary-search","sorting"],"string":"[\n \"array\",\n \"hash-table\",\n \"string\",\n \"binary-search\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"182\", 1.4868999999999999], [\"196\", 0.3717], [\"210\", 0.3717], [\"224\", 0.7435], [\"238\", 0.3717], [\"253\", 1.1152], [\"267\", 0.3717], [\"281\", 1.1152], [\"295\", 0.7435], [\"309\", 0.3717], [\"324\", 0.7435], [\"338\", 0.7435], [\"352\", 0.7435], [\"366\", 1.1152], [\"380\", 2.2305], [\"395\", 0.3717], [\"409\", 1.487], [\"423\", 0.3717], [\"437\", 0.3717], [\"451\", 1.487], [\"466\", 1.8587], [\"480\", 1.8587], [\"494\", 2.2305], [\"508\", 1.487], [\"522\", 1.8587], [\"537\", 0.7435], [\"551\", 0.7435], [\"565\", 1.8587], [\"579\", 1.1152], [\"593\", 1.1152], [\"608\", 0.3717], [\"622\", 0.3717], [\"636\", 0.7435], [\"650\", 0.7435], [\"664\", 0.7435], [\"679\", 1.1152], [\"693\", 0.7435], [\"707\", 1.487], [\"721\", 2.974], [\"735\", 0.7435], [\"750\", 0.7435], [\"764\", 0.3717], [\"778\", 0.7435], [\"792\", 2.6022], [\"806\", 0.7435], [\"821\", 0.7435], [\"835\", 0.7435], [\"849\", 0.7435], [\"863\", 0.3717], [\"877\", 0.7435], [\"892\", 0.7435], [\"906\", 0.7435], [\"920\", 0.7435], [\"934\", 7.806399999999998], [\"948\", 7.4347], [\"963\", 6.3195], [\"977\", 4.088900000000001], [\"991\", 1.8584999999999998], [\"1005\", 0.7434], [\"1019\", 1.8585999999999998], [\"1034\", 0.7434], [\"1048\", 1.1152], [\"1062\", 0.7434], [\"1076\", 1.8584999999999998], [\"1090\", 1.4868999999999999], [\"1105\", 0.7434], [\"1119\", 1.1151], [\"1133\", 0.7435], [\"1147\", 0.3717], [\"1161\", 0.3717], [\"1176\", 0.3717], [\"1190\", 0.7435], [\"1204\", 0.3717], [\"1218\", 0.3717], [\"1232\", 0.3717], [\"1247\", 0.3717], [\"1261\", 0.3717]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"40500\", 0.3717], [\"40600\", 0.3717], [\"50600\", 0.3717], [\"50800\", 0.3717], [\"55400\", 0.3717], [\"58200\", 0.3717], [\"58900\", 0.3717], [\"59000\", 0.3717], [\"59200\", 1.1152], [\"59300\", 0.3717], [\"59600\", 0.7435], [\"59700\", 1.1152], [\"59800\", 14.8699], [\"59900\", 28.9963], [\"60000\", 26.3941], [\"60100\", 12.2677], [\"60200\", 2.974], [\"60300\", 0.3717], [\"60400\", 0.7435], [\"61200\", 0.3717], [\"61300\", 0.3717], [\"61700\", 0.3717], [\"62700\", 0.3717], [\"62800\", 0.3717]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], \n s: str) -> int:\n\n mapper = [max(abs(x), abs(y)) for x, y in points]\n hash_table = defaultdict(list)\n for i, c in sorted(zip(mapper, s)):\n hash_table[c].append(i)\n \n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\n return sum(p < dict for p in mapper)\n\nwith open('user.out', 'w') as f: \n iterator = map(loads, stdin)\n s = Solution()\n while True:\n try:\n print(s.maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\n except StopIteration:\n exit()","runtime":"182"},{"code":"\ndef maxPointsInsideSquare(points: List[List[int]], \n s: str) -> int:\n\n mapper = [max(abs(x), abs(y)) for x, y in points]\n hash_table = defaultdict(list)\n for i, c in sorted(zip(mapper, s)):\n hash_table[c].append(i)\n \n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\n return sum(p < dict for p in mapper)\n\nwith open('user.out', 'w') as f: \n iterator = map(loads, stdin)\n while True:\n try:\n print(maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\n except StopIteration:\n exit()","runtime":"182"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n min_d = defaultdict(lambda: inf)\n min2 = inf\n for (x, y), c in zip(points, s):\n d = max(abs(x), abs(y)) #Chebyshev distance\n if d < min_d[c]:\n min2 = min(min2, min_d[c])\n min_d[c] = d\n else:\n min2 = min(min2, d)\n return sum(d < min2 for d in min_d.values())\n ","runtime":"196"},{"code":"class Solution: \n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n minLens = {}\n secondMin = float('inf')\n \n for point, char in zip(points, s):\n size = max(abs(point[0]), abs(point[1]))\n\n if char not in minLens:\n minLens[char] = size\n elif size < minLens[char]:\n secondMin = min(minLens[char], secondMin)\n minLens[char] = size\n else:\n secondMin = min(size, secondMin)\n \n count = 0\n for len in minLens.values():\n if len < secondMin:\n count += 1\n \n return count","runtime":"210"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n D,arr,res = defaultdict(list), [], 0\n for i,x in enumerate(points): D[s[i]].append(max(abs(x[0]), abs(x[1])))\n for tag in D.keys():\n v = D[tag]\n if len(v) < 2: continue\n v.sort()\n arr.append(v[1]-1)\n a = min(arr+[sys.maxsize])\n for v in D.values():\n for x in v:\n if x <= a: res += 1\n return res","runtime":"224"},{"code":"class Solution: \n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n minLens = {}\n secondMin = float('inf')\n \n for point, char in zip(points, s):\n size = max(abs(point[0]), abs(point[1]))\n\n if char not in minLens:\n minLens[char] = size\n elif size < minLens[char]:\n secondMin = min(minLens[char], secondMin)\n minLens[char] = size\n else:\n secondMin = min(size, secondMin)\n \n count = 0\n for len in minLens.values():\n if len < secondMin:\n count += 1\n \n return count","runtime":"238"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n t=set(s)\n maxi = len(t) #this is maximum possible answer\n \n for i in range(len(points)):\n points[i].append(s[i])\n #print(points)\n \n points.sort(key = lambda x:max(abs(x[0]),abs(x[1])))\n \n side=0\n ans=0\n \n p=set()\n \n n=len(points)\n i=0\n while i <n:\n #print(i,points[i])\n \n \n #we need to increase side\n new_side=max(abs(points[i][0]),abs(points[i][1]))\n temp=0\n while i<n and new_side==max(abs(points[i][0]),abs(points[i][1])) :\n if points[i][2] not in p:\n p.add(points[i][2])\n temp+=1\n i+=1\n else:\n #print(ans)\n return ans\n ans+=temp\n side=new_side\n \n return ans\n \n \n ","runtime":"253"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n min1 = [inf] * 26\n min2 = inf\n for i, point in enumerate(points):\n dis = max(abs(point[0]), abs(point[1]))\n tag = ord(s[i]) - ord('a')\n if dis < min1[tag]:\n min2 = min(min2, min1[tag])\n min1[tag] = dis\n elif dis < min2:\n min2 = dis\n return sum(dis < min2 for dis in min1)","runtime":"267"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n D = defaultdict(list)\n for i,x in enumerate(points):\n tag = s[i]\n D[tag].append(max(abs(x[0]), abs(x[1])))\n \n arr = []\n for tag in D.keys():\n v = D[tag]\n if len(v) < 2: continue\n v.sort()\n arr.append(v[1]-1)\n if arr: a = min(arr)\n else: a = sys.maxsize\n res = 0\n for v in D.values():\n for x in v:\n if x <= a: res += 1\n\n return res\n","runtime":"281"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\n\n for [px, py], tag in zip(points, s):\n tag_idx = ord(tag) - 97\n d = max(abs(px), abs(py))\n if d <= closest_tag[tag_idx][0]:\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\n elif d < closest_tag[tag_idx][1]:\n closest_tag[tag_idx][1] = d\n \n max_d = min(d1 - 1 for _, d1 in closest_tag)\n return sum(d0 <= max_d for d0, _ in closest_tag)\n","runtime":"295"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n # ? 2 points at the same position, with diff tag\n failed = float('inf')\n hashmap = dict()\n n = len(s)\n for i in range(n):\n l = max(abs(points[i][0]), abs(points[i][1]))\n if not s[i] in hashmap:\n hashmap[s[i]] = l\n else:\n if l > hashmap[s[i]]:\n failed = min(failed, l)\n else:\n failed = min(failed, hashmap[s[i]])\n hashmap[s[i]] = l\n \n ans = 0\n for v in hashmap.values():\n if v < failed:\n ans += 1\n \n return ans","runtime":"309"},{"code":"from typing import List\n\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n if points is None or len(points) == 0:\n return 0\n\n new_points = []\n n = len(points)\n\n for i in range(n):\n new_points.append((points[i][0], points[i][1], i))\n \n def get_edge(x, y):\n return max(abs(x), abs(y))\n \n points = sorted(new_points, key=lambda x: get_edge(x[0], x[1]))\n\n tag_set = set()\n\n result = 0\n i = 0\n \n while i < n:\n edge = get_edge(points[i][0], points[i][1])\n\n valid = True\n\n j = i\n\n while j < n and get_edge(points[j][0], points[j][1]) == edge:\n c = s[points[j][2]]\n\n if c in tag_set:\n valid = False\n break\n else:\n tag_set.add(c)\n\n j += 1\n\n if valid:\n result += j - i\n i = j\n else:\n break\n\n return result\n","runtime":"324"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n\n if len(points) == 1:\n return 1\n\n points = sorted([(max(abs(point[0]), abs(point[1])), s[i]) for i, point in enumerate(points)])\n \n tags = [points[0][1]]\n last = 0\n \n for i in range(1, len(points)):\n\n if points[i][0] != points[i-1][0]:\n last = i\n\n if points[i][1] not in tags:\n tags.append(points[i][1])\n continue\n\n return last\n \n return len(points)\n \n\n \n ","runtime":"338"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n tags = collections.defaultdict(list)\n\n for i in range(len(points)):\n # store maximum of absolute value\n tags[s[i]].append(max(abs(points[i][0]), abs(points[i][1])))\n \n for k in tags.keys():\n tags[k].sort()\n\n limit = None # Shouldn't include limit\n for k in tags.keys():\n if len(tags[k]) == 1:\n continue\n else:\n if limit is None:\n limit = tags[k][1]\n else:\n limit = min(limit, tags[k][1])\n\n if limit is None:\n return len(tags.keys())\n\n rtn = 0\n for k in tags.keys():\n if tags[k][0] < limit:\n rtn += 1\n\n return rtn","runtime":"352"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n d = dict()\n n = len(points)\n for i in range(n):\n pi = points[i]\n tagi = s[i]\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\n if tagi in d: d[tagi] += [edgei]\n else: d[tagi] = [edgei]\n mn = 9_000_000_000\n\n for tag in d:\n if len(d[tag]) > 1:\n d[tag].sort()\n tmp = d[tag][1] -1\n mn = min(mn,tmp)\n #print(d)\n #print(mn)\n\n res = 0\n for tag in d:\n if min(d[tag]) <= mn: res +=1\n return res\n ","runtime":"366"},{"code":"class Solution: \n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n minLens = {}\n secondMin = float('inf')\n \n for point, char in zip(points, s):\n size = max(abs(point[0]), abs(point[1]))\n\n if char not in minLens:\n minLens[char] = size\n elif size < minLens[char]:\n secondMin = min(minLens[char], secondMin)\n minLens[char] = size\n else:\n secondMin = min(size, secondMin)\n \n count = 0\n for len in minLens.values():\n if len < secondMin:\n count += 1\n \n return count","runtime":"380"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points = [(points[i], s[i]) for i in range(len(points))]\n\n points.sort(key = lambda x : max(abs(x[0][0]), abs(x[0][1])))\n \n distcount = dict()\n seen = set()\n for point, letter in points:\n dist = max(abs(point[0]), abs(point[1]))\n if dist in distcount:\n if letter in seen:\n del distcount[dist]\n break\n else:\n seen.add(letter)\n distcount[dist] += 1\n\n else:\n if letter in seen:\n break\n else:\n seen.add(letter)\n distcount[dist] = 1\n\n ans = 0\n\n for dist, count in distcount.items():\n ans += count\n\n return ans\n \n \n \n\n\n","runtime":"395"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n mxPoints = []\n \n for x,y in points:\n mxPoints.append(max(abs(x), abs(y)))\n \n hm = defaultdict(list)\n \n # all sizes and their tags\n sorted_sizes_with_tag = sorted(zip(mxPoints, s))\n\n # map of tag to sizes for it\n for size, tag in sorted_sizes_with_tag:\n hm[tag].append(size)\n\n not_allowed_sizes = []\n for tag, sizes in hm.items():\n if len(sizes) > 1:\n # any size bigger than first value is not allowed\n not_allowed_sizes.append(sizes[1])\n # min_size\n min_size = min(not_allowed_sizes, default=inf)\n \n return sum(mxPt < min_size for mxPt in mxPoints)","runtime":"409"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n l=[]\n d={}\n f=[]\n c=0\n t=float(\"inf\")\n for i in range(len(s)):\n \n l.append(max(abs(points[i][0]),abs(points[i][1])))\n \n for i in range(len(s)):\n if s[i] not in d:\n d[s[i]]=[l[i]]\n else:\n d[s[i]].append(l[i])\n \n for r in d:\n i=d[r]\n i.sort()\n f.extend(i)\n if len(i)>=2:\n t=min(t,i[1]-1)\n print(t)\n for i in f:\n if i<=t:\n c+=1\n return c","runtime":"423"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n l=[]\n for i in points:\n l.append(max(abs(i[0]),abs(i[1])))\n print(l)\n ind=sorted(range(len(s)) ,key=lambda i: l[i])\n print(ind)\n m,out=[],max(l)+1\n for i in ind:\n if s[i] not in m:\n m.append(s[i])\n else:\n out=l[i]\n break\n c=0\n print(out)\n for i in ind:\n if l[i] >=out:\n break\n c+=1\n return c","runtime":"437"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\n\n for [px, py], tag in zip(points, s):\n tag_idx = ord(tag) - 97\n d = max(abs(px), abs(py))\n if d <= closest_tag[tag_idx][0]:\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\n elif d < closest_tag[tag_idx][1]:\n closest_tag[tag_idx][1] = d\n \n max_d = sys.maxsize\n for _, d1 in closest_tag:\n if d1 - 1 < max_d:\n max_d = d1 - 1\n return sum(d0 <= max_d for d0, _ in closest_tag)\n\n \n # seen = set()\n # closest_points = sorted(((max(abs(p[0]), abs(p[1])), s[i]) for i, p in enumerate(points)))\n # for i, (d, t) in enumerate(closest_points):\n # if t in seen:\n # j = i - 1\n # while j > -1 and closest_points[j][0] == d:\n # j -= 1\n # return j + 1\n # seen.add(t)\n # return len(points)\n \n ","runtime":"451"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points = [(max(abs(a), abs(b)),s[i]) for i,(a,b) in enumerate(points)]\n points.sort(key=lambda p: p[0])\n tags = set()\n p = 0\n layer = 0\n last = 0\n for s,t in points:\n if t in tags:\n p += layer if last != s else 0\n layer = 0\n break\n if s == last:\n layer += 1\n else:\n p += layer\n layer = 1\n last = s\n tags.add(t)\n return p + layer","runtime":"466"},{"code":"def getOriginDistance(p):\n return max(map(abs, p[0]))\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n labeled_ps = [(points[i], s[i]) for i in range(len(s))]\n labeled_ps = sorted(labeled_ps, key = lambda p: getOriginDistance(p))\n seenLabels = set()\n count = 0\n last_count = 0\n for i, p in enumerate(labeled_ps):\n if i == 0 or getOriginDistance(p) > getOriginDistance(labeled_ps[i-1]):\n last_count = count\n if p[1] in seenLabels:\n return last_count\n seenLabels.add(p[1])\n count += 1\n return count","runtime":"480"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n myHash = defaultdict(list)\n\n for i, (x, y) in enumerate(points):\n\n myHash[max(abs(x), abs(y))].append(i)\n\n vis = set()\n res = 0\n\n for i in sorted(myHash):\n idxs = myHash[i]\n\n for j in idxs:\n if s[j] in vis:\n return res\n \n vis.add(s[j])\n\n res += len(idxs)\n\n return res\n\n","runtime":"494"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n m={}\n mi=math.inf\n for (a,b),c in zip(points,s):\n size=max(abs(a),abs(b))\n if c not in m:\n m[c]=size\n elif size<m[c]:\n mi=min(mi,m[c])\n m[c]=size\n else:\n mi=min(mi,size)\n ans=0\n for v in m.values():\n if v<mi:\n ans+=1\n return ans","runtime":"508"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n d = dict()\n n = len(points)\n secondMin = float('inf')\n\n for point, char in zip(points,s):\n size = max(abs(point[0]), abs(point[1]))\n\n if char not in d:\n d[char] = size\n \n elif size < d[char]:\n secondMin = min(d[char],secondMin)\n d[char] = size\n else:\n secondMin = min(size,secondMin)\n \n count = 0\n for size in d.values():\n if size < secondMin:\n count += 1\n return count\n\n \n ","runtime":"522"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points = [(max(abs(a), abs(b)),s[i]) for i,(a,b) in enumerate(points)]\n points.sort(key=lambda p: p[0])\n tags = set()\n m = defaultdict(int)\n p = 0\n layer = 0\n last = 0\n for s,t in points:\n if t in tags:\n p -= m[s]\n break\n tags.add(t)\n m[s] += 1\n p += 1\n return p","runtime":"537"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n new_arr = []\n n = len(s)\n for i in range(n):\n new_arr.append((points[i][0], points[i][1], s[i]))\n\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\n count = 0\n my_set = set()\n curr_length = None\n curr_run = 0\n\n for i in range(n):\n res = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\n if new_arr[i][2] in my_set and res == curr_length:\n return count\n elif new_arr[i][2] in my_set and res != curr_length:\n return count + curr_run\n elif curr_length == res:\n curr_run += 1\n else:\n count += curr_run\n curr_run = 1\n curr_length = res\n my_set.add(new_arr[i][2])\n\n return count + curr_run","runtime":"551"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n m = collections.defaultdict(list)\n for p, c in zip(points, s):\n d = max(abs(p[0]), abs(p[1]))\n m[d].append(c)\n sorted_keys = sorted(list(m.keys()))\n ans = 0\n included = set()\n for k in sorted_keys:\n including = set()\n for c in m[k]:\n if c in included or c in including:\n return ans\n including.add(c)\n included.update(including)\n ans = len(included)\n return ans\n\n","runtime":"565"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n a=[[] for i in range(26)]\n n=len(s)\n for i in range(n):\n rep=max(abs(points[i][0]),abs(points[i][1]))\n a[ord(s[i])-ord('a')].append(rep)\n print(a)\n f=0\n r=[]\n k=[]\n for i in range(26):\n a[i].sort()\n if len(a[i])>=2:\n f=1\n r.append(a[i][1]-1)\n elif len(a[i])==1:\n k.append(a[i][0])\n if f==0:\n return n\n else:\n sz=min(r)\n ans=0\n for i in range(26):\n if len(a[i])>=1:\n if(a[i][0]<=sz):\n ans+=1\n return ans","runtime":"579"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n danger=float('inf')\n collector={}\n one_points=[]\n for x in points:\n one_points.append(max(abs(x[1]),abs(x[0])))\n \n\n for i in range(len(s)):\n if s[i] in collector:\n if collector[s[i]]<one_points[i]:\n if danger>one_points[i]:\n danger=one_points[i]\n elif danger>=collector[s[i]]:\n danger=collector[s[i]]\n collector[s[i]]=one_points[i]\n else:\n collector[s[i]]=one_points[i]\n continue\n collector[s[i]]=one_points[i]\n\n return len([x for x in one_points if x<danger])","runtime":"593"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n seen = defaultdict(list)\n for i, (x, y) in enumerate(points):\n p = max(abs(x), abs(y))\n tag = s[i]\n seen[tag].append(p)\n seen[tag] = sorted(seen[tag])[:2]\n \n limit = inf\n for limits in seen.values():\n if len(limits) > 1:\n limit = min(limit, limits[1] - 1)\n \n cnt = 0\n for limits in seen.values():\n cnt += limits[0] <= limit\n\n return cnt\n\n\n\n","runtime":"608"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n secondMinSize = math.inf\n minSizes = {}\n\n for (x, y), c in zip(points, s):\n sz = max(abs(x), abs(y))\n if c not in minSizes:\n minSizes[c] = sz\n elif sz < minSizes[c]:\n secondMinSize = min(secondMinSize, minSizes[c])\n minSizes[c] = sz\n else:\n secondMinSize = min(secondMinSize, sz)\n\n return sum(sz < secondMinSize for sz in minSizes.values())","runtime":"622"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n mins = [[inf, inf] for _ in range(26)]\n\n for i,( x, y) in enumerate(points):\n dist = max(abs(x), abs(y))\n index = ord(s[i]) - ord('a')\n\n if mins[index][0] == inf:\n mins[index][0] = dist\n else:\n if dist < mins[index][0]:\n mins[index][1] = mins[index][0]\n mins[index][0] = dist\n elif dist < mins[index][1]:\n mins[index][1] = dist\n\n # mini = min(mini, mins[index][1] - 1)\n mini = min([i - 1 for _, i in mins])\n return sum([1 for x, y in mins if abs(x) <= mini and x != inf])\n","runtime":"636"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n dic = {}\n for (x, y), ch in zip(points, s):\n d = max(abs(x), abs(y))\n if d not in dic:\n dic[d] = []\n dic[d].append(ch)\n edges = sorted(list(dic.keys()))\n ans = 0\n labels = set()\n for edge in edges:\n edge_set = set(dic[edge])\n if len(dic[edge]) != len(edge_set):\n return ans\n common = labels & edge_set\n if len(common) != 0:\n return ans\n ans += len(edge_set)\n labels |= edge_set\n return ans","runtime":"650"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n my_list = list(zip(points, s))\n my_list.sort(key = lambda x: max(abs(x[0][0]), abs(x[0][1])))\n n = len(points)\n my_set = set()\n\n index = 0\n curr_dist = None\n count = 0\n c_count = 0\n\n while index < n:\n coord, char = my_list[index]\n\n # need to also deal with char already being in the set. \n # one case is if the char is in my set and same distance. then just return count\n # another case if the char is in my set and different distance. then add c_count and return count\n\n dist = max(abs(coord[0]), abs(coord[1]))\n if curr_dist != dist:\n count += c_count\n c_count = 1\n curr_dist = dist\n else:\n c_count += 1\n \n if char in my_set:\n return count\n my_set.add(char)\n\n index += 1\n \n count += c_count\n return count","runtime":"664"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n D,arr,res = defaultdict(list), [], 0\n for i,x in enumerate(points): D[s[i]].append(max(abs(x[0]), abs(x[1])))\n \n for tag in D.keys():\n v = D[tag]\n if len(v) < 2: continue\n v.sort()\n arr.append(v[1]-1)\n\n a = min(arr+[sys.maxsize])\n\n for v in D.values():\n for x in v:\n if x <= a: res += 1\n return res","runtime":"679"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n mxPoints = []\n \n for x,y in points:\n mxPoints.append(max(abs(x), abs(y)))\n \n hm = defaultdict(list)\n \n # all sizes and their tags\n sorted_sizes_with_tag = sorted(zip(mxPoints, s))\n\n # map of tag to sizes for it\n for size, tag in sorted_sizes_with_tag:\n hm[tag].append(size)\n\n # get the smallest size with this tag\n allowed_sizes = []\n for tag, sizes in hm.items():\n if len(sizes) > 1:\n allowed_sizes.append(sizes[1])\n dist = min(allowed_sizes, default=inf)\n \n return sum(mxPt < dist for mxPt in mxPoints)","runtime":"693"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], \n s: str) -> int:\n\n mxPts = [max(abs(x), abs(y)) for x, y in points]\n\n d = defaultdict(list)\n for c, tag in sorted(zip(mxPts, s)): d[tag].append(c)\n\n dist = min((arr[1] for arr in d.values()\n if len(arr) > 1), default = inf)\n\n return sum(mxPt < dist for mxPt in mxPts)","runtime":"707"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], \n s: str) -> int:\n\n mapper = [max(abs(x), abs(y)) for x, y in points]\n hash_table = defaultdict(list)\n for i, c in sorted(zip(mapper, s)):\n hash_table[c].append(i)\n \n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\n return sum(p < dict for p in mapper)\n\n","runtime":"721"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n lenToPointsList = defaultdict(list)\n for i, p in enumerate(points):\n lenToPointsList[max(abs(p[0]), abs(p[1]))].append(s[i])\n\n curSet = set()\n sortedList = list(lenToPointsList.keys())\n sortedList.sort()\n ret = len(curSet)\n for sqLen in sortedList:\n for tag in lenToPointsList[sqLen]:\n if tag in curSet:\n return ret\n curSet.add(tag)\n ret = len(curSet)\n \n return ret\n\n\n\n\n\n","runtime":"735"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n hashMap = defaultdict(list)\n for index in range(len(points)):\n char = s[index]\n point = points[index]\n hashMap[max(abs(point[0]),abs(point[1]))].append(index)\n \n visited = set()\n result = 0\n for key in sorted(hashMap)[:26]:\n arr = hashMap[key]\n for ele in arr:\n char = s[ele]\n if char in visited:\n return result \n visited.add(char)\n result += len(arr)\n return result \n ","runtime":"750"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n\n if len(points) == 1:\n return 1\n\n points = sorted([(max(abs(point[0]), abs(point[1])), s[i]) for i, point in enumerate(points)])\n \n tags = [points[0][1]]\n last = 0\n \n for i in range(1, len(points)):\n\n if points[i][0] != points[i-1][0]:\n last = i\n\n if points[i][1] not in tags:\n tags.append(points[i][1])\n continue\n\n return last\n \n return len(points)","runtime":"764"},{"code":"class Solution:\n def maxPointsInsideSquare(self, p: List[List[int]], s: str) -> int:\n n = len(p)\n for i in range(n):\n p[i]= [max(abs(p[i][0]),abs(p[i][1])),s[i]]\n p.sort()\n d = {}\n for i in range(n):\n try:\n d[p[i][1]]+=1\n i-=1\n while i>=0 and p[i][0] == p[i+1][0]:\n i-=1 \n return i+1\n except:\n d[p[i][1]] = 1\n return n\n","runtime":"778"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n l=[max(abs(e[0]),abs(e[1])) for e in points]\n p=sorted([(l[i], s[i]) for i in range(len(l))])\n found = set()\n for i,e in enumerate(p):\n if e[1] in found:\n return len(tuple(filter(lambda x:x[0]!=e[0], p[:i])))\n found.add(e[1])\n return len(l)\n # hi,lo=max(l),min(l)\n # while hi>=lo:\n # mi = (hi+lo)//2\n\n ","runtime":"792"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n new_arr = []\n n = len(s)\n for i in range(n):\n new_arr.append((points[i][0], points[i][1], s[i]))\n\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\n i = 0\n my_set = set()\n count = 0\n \n while i < n:\n curr_max = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\n curr_i = i\n while i < n and max(abs(new_arr[i][0]), abs(new_arr[i][1])) == curr_max:\n if new_arr[i][2] in my_set:\n return count\n my_set.add(new_arr[i][2])\n i += 1\n count += (i-curr_i)\n print(i-curr_i)\n\n return count","runtime":"806"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n poin = []\n n = len(points)\n for i in range(n):\n pi = points[i]\n tagi = s[i]\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\n poin += [(tagi,edgei)]\n #print(poin)\n poin.sort(key = lambda x : x[1])\n #print(poin)\n vis = set()\n edge = 0\n res = 0\n for x in poin:\n if x[0] not in vis:\n edge = x[1]\n vis.add(x[0])\n continue\n edge = x[1]-1\n break\n for x in poin:\n if x[1] > edge: break\n res += 1\n return res\n\n ","runtime":"821"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n lst = sorted([(max(abs(points[i][0]),abs(points[i][1])),s[i]) for i in range(len(s))],key = lambda x: x[0])\n res = 0\n visited = set()\n cur = lst[0][0]\n #print(lst)\n for i,(v,char) in enumerate(lst):\n if v > cur:\n res = i\n cur = v\n \n\n if char in visited:\n return res\n visited.add(char)\n\n\n return len(s)\n \n\n\n\n","runtime":"877"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n ptstag = defaultdict(set)\n top = float('inf')\n \n for (x, y), tag in zip(points, s):\n r = max(abs(x), abs(y))\n if tag in ptstag[r] and r<top:\n top = r\n ptstag[r].add(tag)\n\n visited = []\n maxi = 0\n \n for r in sorted(ptstag):\n if r>=top:\n return maxi\n tmp = 0\n for v in ptstag[r]:\n if v in visited:\n return maxi\n else:\n tmp += 1\n visited.append(v)\n maxi += tmp\n\n return maxi","runtime":"892"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n test=[max(abs(x), abs(y)) for x,y in points]\n d=defaultdict(list)\n for edge, tag in sorted((zip(test, s))):\n d[tag].append(edge)\n \n dist=min((arr[1] for arr in d.values() if len(arr)>1), default=inf)\n \n return sum(t<dist for t in test)\n \n ","runtime":"906"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n n = len(points)\n lst = [(0,float('inf'))]*26\n cur_min = float('inf')\n for i in range(n):\n cur = ord(s[i])-ord(\"a\")\n size = max(map(abs,points[i]))\n if lst[cur][0] == 0 and lst[cur][1] >= size:\n cur_min = min(cur_min,lst[cur][1])\n lst[cur] = (1,size)\n elif lst[cur][0] == 1:\n if lst[cur][1] > size:\n cur_min = min(cur_min,lst[cur][1]-1)\n lst[cur] = (1,size)\n elif lst[cur][1] == size:\n cur_min = min(cur_min,lst[cur][1]-1)\n lst[cur] = (0,size-1)\n else:\n cur_min = min(size-1,cur_min)\n count = 0\n for i in range(26):\n if lst[i][1] <= cur_min:\n count += lst[i][0]\n return count\n","runtime":"920"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n N = len(points)\n p = collections.defaultdict(list)\n\n for i, (x, y) in enumerate(points):\n p[max(abs(x), abs(y))].append(s[i])\n\n res = 0\n seen = set()\n for k in sorted(p.keys()):\n for c in p[k]:\n if c in seen:\n return res\n seen.add(c)\n res += len(p[k])\n\n return res","runtime":"934"},{"code":"from bisect import insort\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points_by_tag = [[] for _ in range(26)]\n\n for i,(x,y) in enumerate(points):\n idx = ord(s[i])-ord('a')\n dist = max(abs(x), abs(y))\n insort(points_by_tag[idx], dist)\n points_by_tag = list(filter(lambda x: x, points_by_tag))\n #print(points_by_tag)\n edge = float(\"inf\")\n for l in points_by_tag:\n if len(l)>1:\n edge = min(edge, l[1]-1)\n #print (edge)\n return sum(1 for l in points_by_tag if l[0] <= edge)\n ","runtime":"934"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n a=[[] for i in range(26)]\n n=len(s)\n for i in range(n):\n rep=max(abs(points[i][0]),abs(points[i][1]))\n a[ord(s[i])-ord('a')].append(rep)\n print(a)\n f=0\n r=[]\n k=[]\n for i in range(26):\n a[i].sort()\n if len(a[i])>=2:\n f=1\n r.append(a[i][1]-1)\n elif len(a[i])==1:\n k.append(a[i][0])\n if f==0:\n sz=max(k)\n else:\n sz=min(r)\n ans=0\n for i in range(26):\n if len(a[i])>=1:\n if(a[i][0]<=sz):\n ans+=1\n return ans","runtime":"948"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n tagToPoints = collections.defaultdict(list)\n\n for i in range(len(points)):\n # store maximum of absolute value\n tmpval = max(abs(points[i][0]), abs(points[i][1]))\n if len(tagToPoints[s[i]]) == 0:\n tagToPoints[s[i]].append(tmpval)\n elif len(tagToPoints[s[i]]) == 1:\n if tagToPoints[s[i]][0] <= tmpval:\n tagToPoints[s[i]].append(tmpval)\n else:\n tagToPoints[s[i]] = [tmpval, tagToPoints[s[i]][0]] \n else:\n if tmpval <= tagToPoints[s[i]][0]:\n tagToPoints[s[i]] = [tmpval, tagToPoints[s[i]][0]]\n else:\n tagToPoints[s[i]] = [tagToPoints[s[i]][0], min(tagToPoints[s[i]][1], tmpval)]\n\n limit = [] # Shouldn't include limit\n for k in tagToPoints.keys():\n if len(tagToPoints[k]) == 1:\n continue\n else:\n limit.append(tagToPoints[k][1])\n\n if len(limit) == 0:\n return len(tagToPoints.keys())\n\n minlimit = min(limit)\n rtn = 0\n for k in tagToPoints.keys():\n if tagToPoints[k][0] < minlimit:\n rtn += 1\n\n return rtn","runtime":"948"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n if len(set(s)) == (n := len(points)):\n return n\n d = defaultdict(set)\n upper = math.inf\n for (x, y), tag in zip(points, s):\n dist = max(abs(x), abs(y))\n if tag in d[dist]:\n upper = min(upper, dist)\n d[dist].add(tag)\n seen = set()\n for dist in sorted(d.keys()):\n if dist >= upper:\n break\n tags = d[dist]\n if seen & tags: # non-empty intersection\n return len(seen)\n seen |= tags\n return len(seen)\n ","runtime":"963"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n dict_ = defaultdict(list)\n arr = []\n for i in range(len(points)):\n dict_[max(abs(points[i][0]), abs(points[i][1]))].append(s[i])\n for key,val in dict_.items():\n arr.append(key)\n arr.sort()\n set_=set()\n print(dict_)\n print(arr)\n for dis in arr:\n if len(set(dict_[dis]))==len(dict_[dis]):\n flag=\"True\"\n for char in dict_[dis]:\n if char in set_:\n flag=\"False\"\n break\n if flag==\"False\":\n break\n else:\n for char in dict_[dis]:\n set_.add(char)\n\n else:\n break\n return len(set_)","runtime":"963"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n vals = [(c, max(abs(p[0]), abs(p[1]))) for p, c in zip(points, s)]\n vals.sort()\n min_dist = float(\"inf\")\n N = len(vals)\n filtered = []\n i = 0\n while i < N:\n if i + 1 < N and vals[i][0] == vals[i+1][0]:\n min_dist = min(min_dist, vals[i+1][1])\n filtered.append(vals[i])\n j = i + 1\n while j < N and vals[i][0] == vals[j][0]:\n j += 1\n i = j\n res = 0\n for _, d in filtered:\n if d >= min_dist:\n continue\n res += 1\n return res\n\n","runtime":"977"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n from collections import defaultdict\n if len(set(s)) == len(s):\n return len(points)\n\n l = []\n points_per_d = defaultdict(int)\n for (x, y), tag in zip(points, s):\n sqr = max(abs(x), abs(y))\n l.append((sqr, tag))\n points_per_d[sqr] += 1\n\n l.sort(key = lambda x:(x[0], x[1]))\n seen = set()\n total = 0\n\n for d, tag in l:\n if tag not in seen:\n seen.add(tag)\n else:\n for key, val in points_per_d.items():\n if key < d:\n total += val\n return total\n\n\n\n","runtime":"977"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n d = defaultdict(list)\n def secondMax(char, dist):\n x = d[char]\n if len(x)<2:\n d[char].append([dist,s[k]])\n d[char].sort()\n else:\n x.append([dist,s[k]])\n \n x.sort()\n d[char] = x[:2]\n \n \n \n \n minn = 0\n for k in range (len(points)):\n i,j = points[k]\n currDist = max(abs(i),abs(j))\n secondMax(s[k],currDist)\n minn = max(minn,currDist)\n \n \n \n for i in d:\n if len(d[i])>1:\n minn = min(minn, max(0,d[i][1][0]-1))\n \n \n ans = 0\n for i,j in points:\n if abs(i) <= minn and abs(j) <= minn:\n ans+=1\n \n return ans\n \n \n \n ","runtime":"991"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n pointsToTag = {}\n\n lenToPointsList = defaultdict(list)\n\n ret = 0\n for i, p in enumerate(points):\n pointsToTag[tuple(p)] = (s[i], max(abs(p[0]), abs(p[1])))\n\n lenToPointsList[max(abs(p[0]), abs(p[1]))].append(s[i])\n\n curSet = set()\n \n sortedList = list(lenToPointsList.keys())\n sortedList.sort()\n \n for sqLen in sortedList:\n ret = len(curSet)\n for tag in lenToPointsList[sqLen]:\n if tag in curSet:\n return ret\n curSet.add(tag)\n ret = len(curSet)\n return ret\n\n\n\n\n\n","runtime":"991"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n if len(points) == 1:\n return 1\n\n points = [[points[i][0], points[i][1], s[i]] for i in range(len(points))]\n points = sorted(points, key = lambda x:max(abs(x[0]), abs(x[1])))\n \n m, visited = defaultdict(int), set()\n curr_edge, check_edge = -1, float('inf')\n \n res = 0\n print(points)\n for i, p in enumerate(points):\n curr_edge = max(abs(p[0]), abs(p[1]))\n if p[2] in visited:\n check_edge = curr_edge\n break\n visited.add(p[2])\n m[curr_edge] += 1\n \n res = 0\n for e, val in m.items():\n if e != check_edge:\n res += val\n else:\n return res\n \n return res\n \n ","runtime":"1005"},{"code":"import numpy as np\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n def dist(p):\n return max(abs(p[0]), abs(p[1]))\n sorted_points = sorted([(i, p) for i,p in enumerate(points)], key=lambda x: dist(x[1]))\n str_set = set()\n count = 0\n tmp_count = 0\n for i, p in enumerate(sorted_points):\n sorted_index = p[0]\n tag = s[sorted_index]\n if i == 0:\n tmp_count += 1\n if i > 0:\n if dist(sorted_points[i][1]) == dist(sorted_points[i-1][1]):\n if tag in str_set:\n return count\n else:\n tmp_count += 1\n else:\n if tag in str_set:\n count += tmp_count\n return count\n else:\n count += tmp_count\n tmp_count = 1\n str_set.add(tag)\n return count + tmp_count","runtime":"1005"},{"code":"import math\nfrom typing import List\n\nclass Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], tags: str) -> int:\n n = len(points)\n max_points = 0\n seen_tags = set()\n \n \n for i in range(n):\n max_co = max(abs(points[i][0]), abs(points[i][1]))\n distance = self.euclidean_distance(max_co, max_co)\n points[i].append(int(distance))\n points[i].append(tags[i])\n \n \n points.sort(key=lambda p: p[2])\n print(points)\n i = 0\n\n while i < n:\n x, y, current_distance, current_tag = points[i]\n\n if current_tag in seen_tags:\n break\n \n point_count = 0\n j = i\n\n while j < n and points[j][2] == current_distance:\n\n tag = points[j][3]\n\n if tag in seen_tags:\n print(tag)\n print(max_points)\n return max_points\n \n print(points[j])\n \n point_count += 1\n seen_tags.add(tag)\n j += 1\n \n print()\n \n max_points += point_count\n i = j\n\n return max_points\n\n def euclidean_distance(self, x2: int, y2: int) -> float:\n x1 = y1 = 0\n dx = x2 - x1\n dy = y2 - y1\n return math.sqrt(dx ** 2 + dy ** 2)\n","runtime":"1019"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n from collections import defaultdict\n if len(set(s)) == len(s):\n return len(points)\n\n l, d = [], set()\n points_per_d = defaultdict(int)\n for (x, y), tag in zip(points, s):\n sqr = max(abs(x), abs(y))\n d.add(sqr)\n l.append((sqr, tag))\n points_per_d[sqr] += 1\n\n prev = 0\n points_per_d_cumm = {}\n for sqr in sorted(d):\n points_per_d_cumm[sqr] = prev\n prev += points_per_d[sqr]\n \n l.sort(key = lambda x:(x[0], x[1]))\n seen_tag = set()\n for d, tag in l:\n if tag not in seen_tag:\n seen_tag.add(tag)\n else:\n return points_per_d_cumm[d]\n","runtime":"1019"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n pts = sorted((max(map(abs, points[i])), points[i], s[i]) for i in range(len(points)))\n print(pts)\n tags = set()\n i = 0\n while i < len(pts):\n j = i\n while j < len(pts) and pts[i][0] == pts[j][0]:\n if pts[j][2] in tags:\n return i\n \n tags.add(pts[j][2])\n j += 1\n\n i = j\n\n return i","runtime":"1034"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n ans = 0\n def check(limit):\n vis = set()\n for (x, y), c in zip(points, s):\n if abs(x) <= limit and abs(y) <= limit:\n if c in vis:\n return True\n vis.add(c)\n nonlocal ans\n ans = len(vis)\n return False\n bisect_left(range(1000000001), True, key=check)\n return ans\n ","runtime":"1034"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n d = {}\n for c, p in zip(s, points):\n if c in d:\n d[c] = sorted(d[c] + [p], key=lambda x : max(map(abs,x)))[0:2]\n else:\n d[c] = [p]\n m_2 = [i[1] for v,i in d.items() if len(i) > 1]\n if m_2:\n m_2 = min(m_2, key=lambda x : max(map(abs,x)))\n else:\n return len(points)\n ans = 0\n for _, j in d.items():\n\n i = j[0]\n x = max(map(abs, m_2))\n if -x < i[0] < x and -x < i[1] < x:\n ans += 1\n return ans\n ","runtime":"1048"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n res = 0\n def check(size):\n vis = set()\n for (x, y), c in zip(points, s):\n if abs(x) <= size and abs(y) <= size: #this point in \n if c in vis:\n #duplicate letter\n return True \n vis.add(c)\n nonlocal res\n res = len(vis)\n return False\n bisect_left(range(1_000_000_001), True, key=check)\n return res","runtime":"1048"},{"code":"class Point:\n def __init__(self, x: int, y: int, label: str):\n self.label = label\n self.key = max(abs(x), abs(y))\n \n def __lt__(self, other: \"Point\"):\n return self.key < other.key\n\n def __repr__(self):\n return f\"Point({self.key}, {self.label})\"\n\nclass Solution:\n def maxPointsInsideSquare(self, points: list[list[int]], labels: str) -> int:\n points = [Point(x, y, label) for (x, y), label in zip(points, labels)]\n points.sort()\n\n groups = [[1, set(points[0].label)]]\n for i in range(1, len(points)):\n if points[i].key != points[i-1].key: groups.append([0, set()])\n groups[-1][0] += 1\n groups[-1][1].add(points[i].label)\n\n result, seen = 0, set()\n for count, group_seen in groups:\n if count != len(group_seen): break\n if any(g in seen for g in group_seen): break\n result += count\n seen.update(group_seen)\n return result\n","runtime":"1062"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n '''\n starting from origin expand range of square by 1 \n continue expanding until length of seen is equal to length of s or points - i.e. all points seen \n if a point that has not yet been seen is found within the new parameters\n check to see if the corresponding character is a duplicate in what has already been seen\n if it is return the length of the seen list \n otherwise increment the counter and update the map with character from seen = True\n finally returnr the length of the seen map \n \n only really need to check points where max val between x and y == sq_range\n key will be string variable\n value will be index \n update list to only be max of two values \n\n '''\n # convert points into 1d by their abs max x/y distance from center\n points = [max([abs(ele) for ele in point]) for point in points]\n counter = 0\n sq_range = min(points)\n seen = {}\n while len(seen.keys()) < len(s):\n mini_counter = 0\n indices = [i for i, x in enumerate(points) if x == sq_range]\n for index in indices:\n if s[index] in seen:\n return counter\n mini_counter+=1\n seen[s[index]] = True\n counter += mini_counter\n\n # remove used points from points, repalcing with infinity, find the next smalleset point to work with\n for i in range(len(points)):\n if points[i] == sq_range:\n points[i] = float('inf')\n # points = [point for point in points if point > sq_range]\n\n sq_range = min(points)\n\n return counter\n","runtime":"1062"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n def helper(len_):\n seen_tags = set()\n\n \n for i, (x, y) in enumerate(points):\n \n if -len_ <= x <= len_ and -len_ <= y <= len_:\n if s[i] in seen_tags:\n return 0\n\n seen_tags.add(s[i])\n \n if len(seen_tags) == 0:\n return -1\n\n return len(seen_tags)\n\n\n left = 0\n right = 10**9\n res = 0\n while left <= right:\n target_len = (left+right) // 2\n \n cur = helper(target_len)\n # print(\"target_len\", target_len, \"cur\", cur)\n if cur > 0:\n res = cur\n left = target_len + 1\n elif cur == -1:\n left = target_len + 1\n else:\n right = target_len - 1\n \n return res","runtime":"1076"},{"code":"class Solution:\n\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n n = len(points)\n if n == 1:\n return 1\n \n calcPoints = []\n for i1 in range(n):\n temp = [points[i1][0], points[i1][1], ord(s[i1])]\n calcPoints.append(temp)\n \n print(\"Before sorting:\", calcPoints)\n # Sort by the maximum of the absolute x and y coordinates\n calcPoints.sort(key=lambda a: max(abs(a[0]), abs(a[1])))\n print(\"After sorting:\", calcPoints)\n \n seen = set()\n break1 = n \n for i1 in range(n):\n value = calcPoints[i1][2]\n if value in seen:\n break1 = i1\n break\n seen.add(value)\n \n print(\"Break point index:\", break1)\n count = 0\n if break1 != n:\n maxi = max(abs(calcPoints[break1][0]), abs(calcPoints[break1][1]))\n print(\"Max value for square boundary:\", maxi)\n for i1 in range(break1):\n if abs(calcPoints[i1][0]) < maxi and abs(calcPoints[i1][1]) < maxi:\n count += 1\n print(\"Point inside square:\", calcPoints[i1])\n else:\n return n\n \n return count\n","runtime":"1076"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n point_index_list = list(sorted(set(max(abs(x), abs(y)) for x,y in points)))\n last_counter = 0\n non_stop = True\n for i, ind in enumerate(point_index_list) : \n s_ind = []\n for i, point in enumerate(points):\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\n s_ind.append(s[i])\n if len(s_ind) == len(set(s_ind)):\n last_counter = len(set(s_ind))\n if len(set(s_ind)) == len(points):\n break\n else:\n break\n return last_counter","runtime":"1090"},{"code":"class Solution:\n def check(self, side, arr, label):\n seen = set()\n for i in range(len(arr)):\n if abs(arr[i][0]) <= side and abs(arr[i][1]) <= side:\n if label[i] in seen:\n return [False, 0]\n else:\n seen.add(label[i])\n return [True, len(seen)]\n\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n n = len(points)\n left = 0\n right = 10 ** 9 + 1\n answer = 0\n while left <= right:\n mid = (left + right) // 2\n temp = self.check(mid, points, s)\n if temp[0]:\n left = mid + 1\n answer = max(answer, temp[1])\n else:\n right = mid - 1\n return answer","runtime":"1090"},{"code":"class Solution:\n\tdef maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n\t\tc = defaultdict(Counter)\n\t\tfor i, (x, y) in enumerate(points):\n\t\t\tc[max(abs(x), abs(y))][s[i]] += 1\n\t\ts = set()\n\t\tfor x in sorted(c.keys()):\n\t\t\tok = True\n\t\t\tfor k, v in c[x].items():\n\t\t\t\tif k in s or v > 1:\n\t\t\t\t\tok = False\n\t\t\t\t\tbreak\n\t\t\tif not ok: break\n\t\t\tfor k in c[x]: s.add(k)\n\t\treturn len(s)","runtime":"1105"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n squares = defaultdict(Counter)\n for p, tag in zip(points, s):\n s = max(map(abs, p))\n\n squares[s][tag] += 1\n\n current_square = Counter()\n for square in sorted(squares.keys()):\n for tag in squares[square]:\n if current_square[tag] + squares[square][tag] > 1:\n return sum(current_square.values())\n \n for tag in squares[square]:\n current_square[tag] += squares[square][tag]\n \n return sum(current_square.values())\n","runtime":"1105"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n s = list(s)\n dist = []\n d = dict()\n for i in range(len(points)):\n # dist.append((points[i][0]**2+points[i][1]**2)**0.5)\n dist.append(max(abs(points[i][0]),abs(points[i][1])))\n if d.get(max(abs(points[i][0]),abs(points[i][1]))):\n d[max(abs(points[i][0]),abs(points[i][1]))].append(s[i])\n else:\n d[max(abs(points[i][0]),abs(points[i][1]))] = [s[i]]\n t = sorted(zip(dist, s, points))\n # print(list(t))\n # dist = [x for x,_,y in t]\n # s = [x for _,x,y in t]\n points = [x for _,y,x in t]\n print(d)\n visited = dict()\n tot = 0\n i = 0\n while i < len(s):\n temp = 0\n for j in d[max(abs(points[i][0]),abs(points[i][1]))]:\n if visited.get(j):\n return tot\n visited[j] = True\n temp += 1\n tot += temp\n i += len(d[max(abs(points[i][0]),abs(points[i][1]))])\n\n # for i in s:\n # if d.get(i):\n # break\n # tot += 1\n # d[i] = True\n print(d)\n return tot\n ","runtime":"1119"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n l=0\n r=0\n ans=0\n for v in points:\n if(v[0]==0 and v[1]==0):ans=1\n r=max(r,max(abs(v[0]),abs(v[1])))\n # print(l,r)\n while(l<r):\n mid=(l+r)//2\n if(mid==l):mid+=1\n track={}\n flag=1\n for i in range(len(points)):\n if(abs(points[i][0])>mid or abs(points[i][1])>mid):continue\n track[s[i]]=track.get(s[i],0)+1\n if(track[s[i]]>1):\n flag=0\n break\n if(flag):\n l=mid\n ans=max(ans,len(track))\n else:\n r=mid-1\n return ans","runtime":"1119"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n point_index_list = sorted([max(abs(x), abs(y)) for x,y in points])\n print(point_index_list)\n last_counter = 0\n non_stop = True\n for i, ind in enumerate(point_index_list) : \n s_ind = []\n for i, point in enumerate(points):\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\n s_ind.append(s[i])\n print(s_ind)\n if len(s_ind) == len(set(s_ind)):\n last_counter = len(set(s_ind))\n if len(set(s_ind)) == len(points):\n break\n else:\n break\n return last_counter","runtime":"1133"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n def compute_squares(size):\n tags = Counter()\n total = 0\n for i in range(len(points)):\n x, y = points[i]\n if abs(x) <= size and abs(y) <= size:\n tag = s[i]\n total += 1\n tags[tag] += 1\n if tags[tag] > 1:\n return 0\n return total\n \n \n tags = defaultdict(list)\n for i in range(len(points)):\n x, y = points[i]\n tags[s[i]].append((abs(x), abs(y)))\n \n total = 0\n for tag in tags:\n size = inf\n for x, y in tags[tag]:\n size = min(size, max(x, y))\n total = max(total, compute_squares(size))\n \n return total\n \n \n ","runtime":"1147"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n left = 0\n right = int(1e9)\n ans = 0\n\n while left <= right:\n mid = left + (right - left) // 2\n visited = [0 for _ in range(26)]\n N = len(points)\n pts = 0\n ok = True\n\n for i in range(N):\n [x, y] = points[i]\n idx = ord(s[i]) - ord('a')\n\n if abs(x) <= mid and abs(y) <= mid:\n visited[idx] += 1\n pts += 1\n \n if visited[idx] > 1:\n ok = False\n break\n \n if ok:\n left = mid + 1\n else:\n right = mid - 1\n pts = 0\n\n ans = max(ans, pts)\n\n return ans","runtime":"1161"},{"code":"class Solution:\n def check_points_inside(self, value, points_name, points):\n letters = []\n for item in points_name:\n if max(abs(points[item][0]),abs(points[item][1])) <= value:\n if points_name[item] not in letters:\n letters.append(points_name[item])\n else:\n return False\n return len(letters) \n\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points_name = {}\n max_value = 0\n min_value = 0\n for i in range(len(s)):\n points_name[i] = s[i]\n max_current = max([abs(points[i][0]),abs(points[i][1])])\n if not min_value:\n min_value = max_current\n elif min_value > max_current:\n min_value = max_current\n if max_value < max_current:\n max_value = max_current\n \n \n if len(set(points_name.values())) == len(s):\n return len(s)\n \n while min_value <= max_value:\n mid_value = (min_value+max_value) // 2\n\n if self.check_points_inside(mid_value, points_name, points):\n min_value = mid_value + 1\n else:\n max_value = mid_value - 1\n \n points_found = self.check_points_inside(max_value, points_name, points)\n return points_found","runtime":"1176"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points, s):\n def count_points(side_length):\n count = 0\n for point in points:\n if -side_length <= point[0] <= side_length and -side_length <= point[1] <= side_length:\n count += 1\n return count\n \n def has_duplicate_tags(side_length):\n tags_set = set()\n for i, point in enumerate(points):\n if -side_length <= point[0] <= side_length and -side_length <= point[1] <= side_length:\n if s[i] in tags_set:\n return True\n tags_set.add(s[i])\n return False\n \n max_points = 0\n left, right = 0, 10**9\n while left <= right:\n mid = (left + right) // 2\n if not has_duplicate_tags(mid):\n max_points = count_points(mid)\n left = mid + 1\n else:\n right = mid - 1\n \n return max_points","runtime":"1190"},{"code":"class Solution:\n def check_points_inside(self, value, points_name, points):\n letters = []\n for item in points_name:\n if max(abs(points[item][0]),abs(points[item][1])) <= value:\n if points_name[item] not in letters:\n letters.append(points_name[item])\n else:\n return False\n return len(letters) \n\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n points_name = {}\n max_value = 0\n min_value = 0\n for i in range(len(s)):\n points_name[i] = s[i]\n max_current = max([abs(points[i][0]),abs(points[i][1])])\n if not min_value:\n min_value = max_current\n elif min_value > max_current:\n min_value = max_current\n if max_value < max_current:\n max_value = max_current\n \n \n if len(set(points_name.values())) == len(s):\n return len(s)\n \n while min_value <= max_value:\n print(min_value, max_value)\n mid_value = (min_value+max_value) // 2\n\n if self.check_points_inside(mid_value, points_name, points):\n min_value = mid_value + 1\n else:\n max_value = mid_value - 1\n \n points_found = self.check_points_inside(max_value, points_name, points)\n return points_found","runtime":"1204"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n lis = []\n for i in range(len(points)):\n lis.append((s[i],max(abs(points[i][0]),abs(points[i][1]))))\n n = 0\n d = {}\n Solution.timSort(lis)\n #print(lis)\n ind = 0\n t = 0\n i = lis[0][1]\n while i<lis[-1][1]+1 and ind<len(lis):\n #print(i,lis[ind],d)\n if lis[ind][1] <= i:\n if lis[ind][0] in d:\n #print('ldaskfjlas',lis[ind])\n return n\n else:\n t+=1\n \n d[lis[ind][0]]= 1\n ind+=1\n else:\n n += t\n t = 0\n i = lis[ind][1]\n #print(t,n)\n n+=t\n return n\n\n def calcMinRun(n): \n MIN_MERGE = 32\n r = 0\n while n >= MIN_MERGE: \n r |= n & 1\n n >>= 1\n return n + r \n \n \n \n # This function sorts array from left index to \n # to right index which is of size atmost RUN \n def insertionSort(arr, left, right): \n for i in range(left + 1, right + 1): \n j = i \n while j > left and arr[j][1] < arr[j - 1][1]: \n arr[j], arr[j - 1] = arr[j - 1], arr[j] \n j -= 1\n \n \n # Merge function merges the sorted runs \n def merge(arr, l, m, r): \n \n # original array is broken in two parts \n # left and right array \n len1, len2 = m - l + 1, r - m \n left, right = [], [] \n for i in range(0, len1): \n left.append(arr[l + i]) \n for i in range(0, len2): \n right.append(arr[m + 1 + i]) \n \n i, j, k = 0, 0, l \n \n # after comparing, we merge those two array \n # in larger sub array \n while i < len1 and j < len2: \n if left[i][1] <= right[j][1]: \n arr[k] = left[i] \n i += 1\n \n else: \n arr[k] = right[j] \n j += 1\n \n k += 1\n \n # Copy remaining elements of left, if any \n while i < len1: \n arr[k] = left[i] \n k += 1\n i += 1\n \n # Copy remaining element of right, if any \n while j < len2: \n arr[k] = right[j] \n k += 1\n j += 1\n \n \n# Iterative Timsort function to sort the \n# array[0...n-1] (similar to merge sort) \n def timSort(arr): \n n = len(arr) \n minRun = Solution.calcMinRun(n) \n \n # Sort individual subarrays of size RUN \n for start in range(0, n, minRun): \n end = min(start + minRun - 1, n - 1) \n Solution.insertionSort(arr, start, end) \n \n # Start merging from size RUN (or 32). It will merge \n # to form size 64, then 128, 256 and so on .... \n size = minRun \n while size < n: \n \n # Pick starting point of left sub array. We \n # are going to merge arr[left..left+size-1] \n # and arr[left+size, left+2*size-1] \n # After every merge, we increase left by 2*size \n for left in range(0, n, 2 * size): \n \n # Find ending point of left sub array \n # mid+1 is starting point of right sub array \n mid = min(n - 1, left + size - 1) \n right = min((left + 2 * size - 1), (n - 1)) \n \n # Merge sub array arr[left.....mid] & \n # arr[mid+1....right] \n if mid < right: \n Solution.merge(arr, left, mid, right) \n \n size = 2 * size \n ","runtime":"1218"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n # Expand the square using binary search??\n l, r = 0, 10 ** 9\n res = 0\n while l <= r:\n mid = l + (r-l) // 2\n # Check if a square with side length mid is valid\n a = set()\n valid = True\n for i, (x,y) in enumerate(points):\n if max(abs(x),abs(y)) <= mid:\n if s[i] in a:\n valid = False\n break\n else:\n a.add(s[i])\n\n print('trying', mid, valid, a)\n if valid:\n res = max(res, len(a))\n l = mid + 1\n else:\n r = mid - 1\n return res","runtime":"1232"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n def isValid(m):\n visit = set()\n for (x, y), c in zip(points, s):\n r = max(abs(x), abs(y))\n if r <= m:\n if c in visit:\n return False, -1 \n visit.add(c)\n return True, len(visit)\n\n l, r = 0, 10 ** 9\n res = 0 \n while l <= r:\n m = (l + r) // 2 \n valid, p = isValid(m)\n if valid:\n res = max(res, p)\n l = m + 1 \n else:\n r = m - 1 \n return res","runtime":"1247"},{"code":"class Solution:\n def isCorrect(self, mid, points, s):\n maxRange = mid/2\n hashMap = {}\n for indx,point in enumerate(points):\n x, y = point\n if x >= -maxRange and x <= maxRange and y >= -maxRange and y <= maxRange:\n if s[indx] in hashMap:\n return False\n hashMap[s[indx]] = True\n return True\n\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n hashMap = {}\n repeatingTags = False\n for x in s:\n if x in hashMap:\n repeatingTags = True\n break\n hashMap[x] = True\n if not repeatingTags:\n return len(points)\n low = 0\n high = sys.maxsize\n while low <= high:\n # print(low, high)\n mid = low + (high-low)//2\n if self.isCorrect(mid, points, s):\n low = mid+1\n else:\n high = mid-1\n maxRange = high/2\n # print(maxRange)\n res = 0\n for indx,point in enumerate(points):\n x, y = point\n if x >= -maxRange and x <= maxRange and y >= -maxRange and y <= maxRange:\n # print(x, y)\n res += 1\n return res","runtime":"1261"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], \\n s: str) -> int:\\n\\n mapper = [max(abs(x), abs(y)) for x, y in points]\\n hash_table = defaultdict(list)\\n for i, c in sorted(zip(mapper, s)):\\n hash_table[c].append(i)\\n \\n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\\n return sum(p < dict for p in mapper)\\n\\nwith open('user.out', 'w') as f: \\n iterator = map(loads, stdin)\\n s = Solution()\\n while True:\\n try:\\n print(s.maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\\n except StopIteration:\\n exit()\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"\\ndef maxPointsInsideSquare(points: List[List[int]], \\n s: str) -> int:\\n\\n mapper = [max(abs(x), abs(y)) for x, y in points]\\n hash_table = defaultdict(list)\\n for i, c in sorted(zip(mapper, s)):\\n hash_table[c].append(i)\\n \\n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\\n return sum(p < dict for p in mapper)\\n\\nwith open('user.out', 'w') as f: \\n iterator = map(loads, stdin)\\n while True:\\n try:\\n print(maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\\n except StopIteration:\\n exit()\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n min_d = defaultdict(lambda: inf)\\n min2 = inf\\n for (x, y), c in zip(points, s):\\n d = max(abs(x), abs(y)) #Chebyshev distance\\n if d < min_d[c]:\\n min2 = min(min2, min_d[c])\\n min_d[c] = d\\n else:\\n min2 = min(min2, d)\\n return sum(d < min2 for d in min_d.values())\\n \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution: \\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n minLens = {}\\n secondMin = float('inf')\\n \\n for point, char in zip(points, s):\\n size = max(abs(point[0]), abs(point[1]))\\n\\n if char not in minLens:\\n minLens[char] = size\\n elif size < minLens[char]:\\n secondMin = min(minLens[char], secondMin)\\n minLens[char] = size\\n else:\\n secondMin = min(size, secondMin)\\n \\n count = 0\\n for len in minLens.values():\\n if len < secondMin:\\n count += 1\\n \\n return count\",\n \"runtime\": \"210\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n D,arr,res = defaultdict(list), [], 0\\n for i,x in enumerate(points): D[s[i]].append(max(abs(x[0]), abs(x[1])))\\n for tag in D.keys():\\n v = D[tag]\\n if len(v) < 2: continue\\n v.sort()\\n arr.append(v[1]-1)\\n a = min(arr+[sys.maxsize])\\n for v in D.values():\\n for x in v:\\n if x <= a: res += 1\\n return res\",\n \"runtime\": \"224\"\n },\n {\n \"code\": \"class Solution: \\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n minLens = {}\\n secondMin = float('inf')\\n \\n for point, char in zip(points, s):\\n size = max(abs(point[0]), abs(point[1]))\\n\\n if char not in minLens:\\n minLens[char] = size\\n elif size < minLens[char]:\\n secondMin = min(minLens[char], secondMin)\\n minLens[char] = size\\n else:\\n secondMin = min(size, secondMin)\\n \\n count = 0\\n for len in minLens.values():\\n if len < secondMin:\\n count += 1\\n \\n return count\",\n \"runtime\": \"238\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n t=set(s)\\n maxi = len(t) #this is maximum possible answer\\n \\n for i in range(len(points)):\\n points[i].append(s[i])\\n #print(points)\\n \\n points.sort(key = lambda x:max(abs(x[0]),abs(x[1])))\\n \\n side=0\\n ans=0\\n \\n p=set()\\n \\n n=len(points)\\n i=0\\n while i <n:\\n #print(i,points[i])\\n \\n \\n #we need to increase side\\n new_side=max(abs(points[i][0]),abs(points[i][1]))\\n temp=0\\n while i<n and new_side==max(abs(points[i][0]),abs(points[i][1])) :\\n if points[i][2] not in p:\\n p.add(points[i][2])\\n temp+=1\\n i+=1\\n else:\\n #print(ans)\\n return ans\\n ans+=temp\\n side=new_side\\n \\n return ans\\n \\n \\n \",\n \"runtime\": \"253\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n min1 = [inf] * 26\\n min2 = inf\\n for i, point in enumerate(points):\\n dis = max(abs(point[0]), abs(point[1]))\\n tag = ord(s[i]) - ord('a')\\n if dis < min1[tag]:\\n min2 = min(min2, min1[tag])\\n min1[tag] = dis\\n elif dis < min2:\\n min2 = dis\\n return sum(dis < min2 for dis in min1)\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n D = defaultdict(list)\\n for i,x in enumerate(points):\\n tag = s[i]\\n D[tag].append(max(abs(x[0]), abs(x[1])))\\n \\n arr = []\\n for tag in D.keys():\\n v = D[tag]\\n if len(v) < 2: continue\\n v.sort()\\n arr.append(v[1]-1)\\n if arr: a = min(arr)\\n else: a = sys.maxsize\\n res = 0\\n for v in D.values():\\n for x in v:\\n if x <= a: res += 1\\n\\n return res\\n\",\n \"runtime\": \"281\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\\n\\n for [px, py], tag in zip(points, s):\\n tag_idx = ord(tag) - 97\\n d = max(abs(px), abs(py))\\n if d <= closest_tag[tag_idx][0]:\\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\\n elif d < closest_tag[tag_idx][1]:\\n closest_tag[tag_idx][1] = d\\n \\n max_d = min(d1 - 1 for _, d1 in closest_tag)\\n return sum(d0 <= max_d for d0, _ in closest_tag)\\n\",\n \"runtime\": \"295\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n # ? 2 points at the same position, with diff tag\\n failed = float('inf')\\n hashmap = dict()\\n n = len(s)\\n for i in range(n):\\n l = max(abs(points[i][0]), abs(points[i][1]))\\n if not s[i] in hashmap:\\n hashmap[s[i]] = l\\n else:\\n if l > hashmap[s[i]]:\\n failed = min(failed, l)\\n else:\\n failed = min(failed, hashmap[s[i]])\\n hashmap[s[i]] = l\\n \\n ans = 0\\n for v in hashmap.values():\\n if v < failed:\\n ans += 1\\n \\n return ans\",\n \"runtime\": \"309\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n if points is None or len(points) == 0:\\n return 0\\n\\n new_points = []\\n n = len(points)\\n\\n for i in range(n):\\n new_points.append((points[i][0], points[i][1], i))\\n \\n def get_edge(x, y):\\n return max(abs(x), abs(y))\\n \\n points = sorted(new_points, key=lambda x: get_edge(x[0], x[1]))\\n\\n tag_set = set()\\n\\n result = 0\\n i = 0\\n \\n while i < n:\\n edge = get_edge(points[i][0], points[i][1])\\n\\n valid = True\\n\\n j = i\\n\\n while j < n and get_edge(points[j][0], points[j][1]) == edge:\\n c = s[points[j][2]]\\n\\n if c in tag_set:\\n valid = False\\n break\\n else:\\n tag_set.add(c)\\n\\n j += 1\\n\\n if valid:\\n result += j - i\\n i = j\\n else:\\n break\\n\\n return result\\n\",\n \"runtime\": \"324\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n\\n if len(points) == 1:\\n return 1\\n\\n points = sorted([(max(abs(point[0]), abs(point[1])), s[i]) for i, point in enumerate(points)])\\n \\n tags = [points[0][1]]\\n last = 0\\n \\n for i in range(1, len(points)):\\n\\n if points[i][0] != points[i-1][0]:\\n last = i\\n\\n if points[i][1] not in tags:\\n tags.append(points[i][1])\\n continue\\n\\n return last\\n \\n return len(points)\\n \\n\\n \\n \",\n \"runtime\": \"338\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n tags = collections.defaultdict(list)\\n\\n for i in range(len(points)):\\n # store maximum of absolute value\\n tags[s[i]].append(max(abs(points[i][0]), abs(points[i][1])))\\n \\n for k in tags.keys():\\n tags[k].sort()\\n\\n limit = None # Shouldn't include limit\\n for k in tags.keys():\\n if len(tags[k]) == 1:\\n continue\\n else:\\n if limit is None:\\n limit = tags[k][1]\\n else:\\n limit = min(limit, tags[k][1])\\n\\n if limit is None:\\n return len(tags.keys())\\n\\n rtn = 0\\n for k in tags.keys():\\n if tags[k][0] < limit:\\n rtn += 1\\n\\n return rtn\",\n \"runtime\": \"352\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n d = dict()\\n n = len(points)\\n for i in range(n):\\n pi = points[i]\\n tagi = s[i]\\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\\n if tagi in d: d[tagi] += [edgei]\\n else: d[tagi] = [edgei]\\n mn = 9_000_000_000\\n\\n for tag in d:\\n if len(d[tag]) > 1:\\n d[tag].sort()\\n tmp = d[tag][1] -1\\n mn = min(mn,tmp)\\n #print(d)\\n #print(mn)\\n\\n res = 0\\n for tag in d:\\n if min(d[tag]) <= mn: res +=1\\n return res\\n \",\n \"runtime\": \"366\"\n },\n {\n \"code\": \"class Solution: \\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n minLens = {}\\n secondMin = float('inf')\\n \\n for point, char in zip(points, s):\\n size = max(abs(point[0]), abs(point[1]))\\n\\n if char not in minLens:\\n minLens[char] = size\\n elif size < minLens[char]:\\n secondMin = min(minLens[char], secondMin)\\n minLens[char] = size\\n else:\\n secondMin = min(size, secondMin)\\n \\n count = 0\\n for len in minLens.values():\\n if len < secondMin:\\n count += 1\\n \\n return count\",\n \"runtime\": \"380\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points = [(points[i], s[i]) for i in range(len(points))]\\n\\n points.sort(key = lambda x : max(abs(x[0][0]), abs(x[0][1])))\\n \\n distcount = dict()\\n seen = set()\\n for point, letter in points:\\n dist = max(abs(point[0]), abs(point[1]))\\n if dist in distcount:\\n if letter in seen:\\n del distcount[dist]\\n break\\n else:\\n seen.add(letter)\\n distcount[dist] += 1\\n\\n else:\\n if letter in seen:\\n break\\n else:\\n seen.add(letter)\\n distcount[dist] = 1\\n\\n ans = 0\\n\\n for dist, count in distcount.items():\\n ans += count\\n\\n return ans\\n \\n \\n \\n\\n\\n\",\n \"runtime\": \"395\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n mxPoints = []\\n \\n for x,y in points:\\n mxPoints.append(max(abs(x), abs(y)))\\n \\n hm = defaultdict(list)\\n \\n # all sizes and their tags\\n sorted_sizes_with_tag = sorted(zip(mxPoints, s))\\n\\n # map of tag to sizes for it\\n for size, tag in sorted_sizes_with_tag:\\n hm[tag].append(size)\\n\\n not_allowed_sizes = []\\n for tag, sizes in hm.items():\\n if len(sizes) > 1:\\n # any size bigger than first value is not allowed\\n not_allowed_sizes.append(sizes[1])\\n # min_size\\n min_size = min(not_allowed_sizes, default=inf)\\n \\n return sum(mxPt < min_size for mxPt in mxPoints)\",\n \"runtime\": \"409\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n l=[]\\n d={}\\n f=[]\\n c=0\\n t=float(\\\"inf\\\")\\n for i in range(len(s)):\\n \\n l.append(max(abs(points[i][0]),abs(points[i][1])))\\n \\n for i in range(len(s)):\\n if s[i] not in d:\\n d[s[i]]=[l[i]]\\n else:\\n d[s[i]].append(l[i])\\n \\n for r in d:\\n i=d[r]\\n i.sort()\\n f.extend(i)\\n if len(i)>=2:\\n t=min(t,i[1]-1)\\n print(t)\\n for i in f:\\n if i<=t:\\n c+=1\\n return c\",\n \"runtime\": \"423\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n l=[]\\n for i in points:\\n l.append(max(abs(i[0]),abs(i[1])))\\n print(l)\\n ind=sorted(range(len(s)) ,key=lambda i: l[i])\\n print(ind)\\n m,out=[],max(l)+1\\n for i in ind:\\n if s[i] not in m:\\n m.append(s[i])\\n else:\\n out=l[i]\\n break\\n c=0\\n print(out)\\n for i in ind:\\n if l[i] >=out:\\n break\\n c+=1\\n return c\",\n \"runtime\": \"437\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\\n\\n for [px, py], tag in zip(points, s):\\n tag_idx = ord(tag) - 97\\n d = max(abs(px), abs(py))\\n if d <= closest_tag[tag_idx][0]:\\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\\n elif d < closest_tag[tag_idx][1]:\\n closest_tag[tag_idx][1] = d\\n \\n max_d = sys.maxsize\\n for _, d1 in closest_tag:\\n if d1 - 1 < max_d:\\n max_d = d1 - 1\\n return sum(d0 <= max_d for d0, _ in closest_tag)\\n\\n \\n # seen = set()\\n # closest_points = sorted(((max(abs(p[0]), abs(p[1])), s[i]) for i, p in enumerate(points)))\\n # for i, (d, t) in enumerate(closest_points):\\n # if t in seen:\\n # j = i - 1\\n # while j > -1 and closest_points[j][0] == d:\\n # j -= 1\\n # return j + 1\\n # seen.add(t)\\n # return len(points)\\n \\n \",\n \"runtime\": \"451\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points = [(max(abs(a), abs(b)),s[i]) for i,(a,b) in enumerate(points)]\\n points.sort(key=lambda p: p[0])\\n tags = set()\\n p = 0\\n layer = 0\\n last = 0\\n for s,t in points:\\n if t in tags:\\n p += layer if last != s else 0\\n layer = 0\\n break\\n if s == last:\\n layer += 1\\n else:\\n p += layer\\n layer = 1\\n last = s\\n tags.add(t)\\n return p + layer\",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"def getOriginDistance(p):\\n return max(map(abs, p[0]))\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n labeled_ps = [(points[i], s[i]) for i in range(len(s))]\\n labeled_ps = sorted(labeled_ps, key = lambda p: getOriginDistance(p))\\n seenLabels = set()\\n count = 0\\n last_count = 0\\n for i, p in enumerate(labeled_ps):\\n if i == 0 or getOriginDistance(p) > getOriginDistance(labeled_ps[i-1]):\\n last_count = count\\n if p[1] in seenLabels:\\n return last_count\\n seenLabels.add(p[1])\\n count += 1\\n return count\",\n \"runtime\": \"480\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n myHash = defaultdict(list)\\n\\n for i, (x, y) in enumerate(points):\\n\\n myHash[max(abs(x), abs(y))].append(i)\\n\\n vis = set()\\n res = 0\\n\\n for i in sorted(myHash):\\n idxs = myHash[i]\\n\\n for j in idxs:\\n if s[j] in vis:\\n return res\\n \\n vis.add(s[j])\\n\\n res += len(idxs)\\n\\n return res\\n\\n\",\n \"runtime\": \"494\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n m={}\\n mi=math.inf\\n for (a,b),c in zip(points,s):\\n size=max(abs(a),abs(b))\\n if c not in m:\\n m[c]=size\\n elif size<m[c]:\\n mi=min(mi,m[c])\\n m[c]=size\\n else:\\n mi=min(mi,size)\\n ans=0\\n for v in m.values():\\n if v<mi:\\n ans+=1\\n return ans\",\n \"runtime\": \"508\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n d = dict()\\n n = len(points)\\n secondMin = float('inf')\\n\\n for point, char in zip(points,s):\\n size = max(abs(point[0]), abs(point[1]))\\n\\n if char not in d:\\n d[char] = size\\n \\n elif size < d[char]:\\n secondMin = min(d[char],secondMin)\\n d[char] = size\\n else:\\n secondMin = min(size,secondMin)\\n \\n count = 0\\n for size in d.values():\\n if size < secondMin:\\n count += 1\\n return count\\n\\n \\n \",\n \"runtime\": \"522\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points = [(max(abs(a), abs(b)),s[i]) for i,(a,b) in enumerate(points)]\\n points.sort(key=lambda p: p[0])\\n tags = set()\\n m = defaultdict(int)\\n p = 0\\n layer = 0\\n last = 0\\n for s,t in points:\\n if t in tags:\\n p -= m[s]\\n break\\n tags.add(t)\\n m[s] += 1\\n p += 1\\n return p\",\n \"runtime\": \"537\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n new_arr = []\\n n = len(s)\\n for i in range(n):\\n new_arr.append((points[i][0], points[i][1], s[i]))\\n\\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\\n count = 0\\n my_set = set()\\n curr_length = None\\n curr_run = 0\\n\\n for i in range(n):\\n res = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\\n if new_arr[i][2] in my_set and res == curr_length:\\n return count\\n elif new_arr[i][2] in my_set and res != curr_length:\\n return count + curr_run\\n elif curr_length == res:\\n curr_run += 1\\n else:\\n count += curr_run\\n curr_run = 1\\n curr_length = res\\n my_set.add(new_arr[i][2])\\n\\n return count + curr_run\",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n m = collections.defaultdict(list)\\n for p, c in zip(points, s):\\n d = max(abs(p[0]), abs(p[1]))\\n m[d].append(c)\\n sorted_keys = sorted(list(m.keys()))\\n ans = 0\\n included = set()\\n for k in sorted_keys:\\n including = set()\\n for c in m[k]:\\n if c in included or c in including:\\n return ans\\n including.add(c)\\n included.update(including)\\n ans = len(included)\\n return ans\\n\\n\",\n \"runtime\": \"565\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n a=[[] for i in range(26)]\\n n=len(s)\\n for i in range(n):\\n rep=max(abs(points[i][0]),abs(points[i][1]))\\n a[ord(s[i])-ord('a')].append(rep)\\n print(a)\\n f=0\\n r=[]\\n k=[]\\n for i in range(26):\\n a[i].sort()\\n if len(a[i])>=2:\\n f=1\\n r.append(a[i][1]-1)\\n elif len(a[i])==1:\\n k.append(a[i][0])\\n if f==0:\\n return n\\n else:\\n sz=min(r)\\n ans=0\\n for i in range(26):\\n if len(a[i])>=1:\\n if(a[i][0]<=sz):\\n ans+=1\\n return ans\",\n \"runtime\": \"579\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n danger=float('inf')\\n collector={}\\n one_points=[]\\n for x in points:\\n one_points.append(max(abs(x[1]),abs(x[0])))\\n \\n\\n for i in range(len(s)):\\n if s[i] in collector:\\n if collector[s[i]]<one_points[i]:\\n if danger>one_points[i]:\\n danger=one_points[i]\\n elif danger>=collector[s[i]]:\\n danger=collector[s[i]]\\n collector[s[i]]=one_points[i]\\n else:\\n collector[s[i]]=one_points[i]\\n continue\\n collector[s[i]]=one_points[i]\\n\\n return len([x for x in one_points if x<danger])\",\n \"runtime\": \"593\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n seen = defaultdict(list)\\n for i, (x, y) in enumerate(points):\\n p = max(abs(x), abs(y))\\n tag = s[i]\\n seen[tag].append(p)\\n seen[tag] = sorted(seen[tag])[:2]\\n \\n limit = inf\\n for limits in seen.values():\\n if len(limits) > 1:\\n limit = min(limit, limits[1] - 1)\\n \\n cnt = 0\\n for limits in seen.values():\\n cnt += limits[0] <= limit\\n\\n return cnt\\n\\n\\n\\n\",\n \"runtime\": \"608\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n secondMinSize = math.inf\\n minSizes = {}\\n\\n for (x, y), c in zip(points, s):\\n sz = max(abs(x), abs(y))\\n if c not in minSizes:\\n minSizes[c] = sz\\n elif sz < minSizes[c]:\\n secondMinSize = min(secondMinSize, minSizes[c])\\n minSizes[c] = sz\\n else:\\n secondMinSize = min(secondMinSize, sz)\\n\\n return sum(sz < secondMinSize for sz in minSizes.values())\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n mins = [[inf, inf] for _ in range(26)]\\n\\n for i,( x, y) in enumerate(points):\\n dist = max(abs(x), abs(y))\\n index = ord(s[i]) - ord('a')\\n\\n if mins[index][0] == inf:\\n mins[index][0] = dist\\n else:\\n if dist < mins[index][0]:\\n mins[index][1] = mins[index][0]\\n mins[index][0] = dist\\n elif dist < mins[index][1]:\\n mins[index][1] = dist\\n\\n # mini = min(mini, mins[index][1] - 1)\\n mini = min([i - 1 for _, i in mins])\\n return sum([1 for x, y in mins if abs(x) <= mini and x != inf])\\n\",\n \"runtime\": \"636\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n dic = {}\\n for (x, y), ch in zip(points, s):\\n d = max(abs(x), abs(y))\\n if d not in dic:\\n dic[d] = []\\n dic[d].append(ch)\\n edges = sorted(list(dic.keys()))\\n ans = 0\\n labels = set()\\n for edge in edges:\\n edge_set = set(dic[edge])\\n if len(dic[edge]) != len(edge_set):\\n return ans\\n common = labels & edge_set\\n if len(common) != 0:\\n return ans\\n ans += len(edge_set)\\n labels |= edge_set\\n return ans\",\n \"runtime\": \"650\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n my_list = list(zip(points, s))\\n my_list.sort(key = lambda x: max(abs(x[0][0]), abs(x[0][1])))\\n n = len(points)\\n my_set = set()\\n\\n index = 0\\n curr_dist = None\\n count = 0\\n c_count = 0\\n\\n while index < n:\\n coord, char = my_list[index]\\n\\n # need to also deal with char already being in the set. \\n # one case is if the char is in my set and same distance. then just return count\\n # another case if the char is in my set and different distance. then add c_count and return count\\n\\n dist = max(abs(coord[0]), abs(coord[1]))\\n if curr_dist != dist:\\n count += c_count\\n c_count = 1\\n curr_dist = dist\\n else:\\n c_count += 1\\n \\n if char in my_set:\\n return count\\n my_set.add(char)\\n\\n index += 1\\n \\n count += c_count\\n return count\",\n \"runtime\": \"664\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n D,arr,res = defaultdict(list), [], 0\\n for i,x in enumerate(points): D[s[i]].append(max(abs(x[0]), abs(x[1])))\\n \\n for tag in D.keys():\\n v = D[tag]\\n if len(v) < 2: continue\\n v.sort()\\n arr.append(v[1]-1)\\n\\n a = min(arr+[sys.maxsize])\\n\\n for v in D.values():\\n for x in v:\\n if x <= a: res += 1\\n return res\",\n \"runtime\": \"679\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n mxPoints = []\\n \\n for x,y in points:\\n mxPoints.append(max(abs(x), abs(y)))\\n \\n hm = defaultdict(list)\\n \\n # all sizes and their tags\\n sorted_sizes_with_tag = sorted(zip(mxPoints, s))\\n\\n # map of tag to sizes for it\\n for size, tag in sorted_sizes_with_tag:\\n hm[tag].append(size)\\n\\n # get the smallest size with this tag\\n allowed_sizes = []\\n for tag, sizes in hm.items():\\n if len(sizes) > 1:\\n allowed_sizes.append(sizes[1])\\n dist = min(allowed_sizes, default=inf)\\n \\n return sum(mxPt < dist for mxPt in mxPoints)\",\n \"runtime\": \"693\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], \\n s: str) -> int:\\n\\n mxPts = [max(abs(x), abs(y)) for x, y in points]\\n\\n d = defaultdict(list)\\n for c, tag in sorted(zip(mxPts, s)): d[tag].append(c)\\n\\n dist = min((arr[1] for arr in d.values()\\n if len(arr) > 1), default = inf)\\n\\n return sum(mxPt < dist for mxPt in mxPts)\",\n \"runtime\": \"707\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], \\n s: str) -> int:\\n\\n mapper = [max(abs(x), abs(y)) for x, y in points]\\n hash_table = defaultdict(list)\\n for i, c in sorted(zip(mapper, s)):\\n hash_table[c].append(i)\\n \\n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\\n return sum(p < dict for p in mapper)\\n\\n\",\n \"runtime\": \"721\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n lenToPointsList = defaultdict(list)\\n for i, p in enumerate(points):\\n lenToPointsList[max(abs(p[0]), abs(p[1]))].append(s[i])\\n\\n curSet = set()\\n sortedList = list(lenToPointsList.keys())\\n sortedList.sort()\\n ret = len(curSet)\\n for sqLen in sortedList:\\n for tag in lenToPointsList[sqLen]:\\n if tag in curSet:\\n return ret\\n curSet.add(tag)\\n ret = len(curSet)\\n \\n return ret\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"735\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n hashMap = defaultdict(list)\\n for index in range(len(points)):\\n char = s[index]\\n point = points[index]\\n hashMap[max(abs(point[0]),abs(point[1]))].append(index)\\n \\n visited = set()\\n result = 0\\n for key in sorted(hashMap)[:26]:\\n arr = hashMap[key]\\n for ele in arr:\\n char = s[ele]\\n if char in visited:\\n return result \\n visited.add(char)\\n result += len(arr)\\n return result \\n \",\n \"runtime\": \"750\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n\\n if len(points) == 1:\\n return 1\\n\\n points = sorted([(max(abs(point[0]), abs(point[1])), s[i]) for i, point in enumerate(points)])\\n \\n tags = [points[0][1]]\\n last = 0\\n \\n for i in range(1, len(points)):\\n\\n if points[i][0] != points[i-1][0]:\\n last = i\\n\\n if points[i][1] not in tags:\\n tags.append(points[i][1])\\n continue\\n\\n return last\\n \\n return len(points)\",\n \"runtime\": \"764\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, p: List[List[int]], s: str) -> int:\\n n = len(p)\\n for i in range(n):\\n p[i]= [max(abs(p[i][0]),abs(p[i][1])),s[i]]\\n p.sort()\\n d = {}\\n for i in range(n):\\n try:\\n d[p[i][1]]+=1\\n i-=1\\n while i>=0 and p[i][0] == p[i+1][0]:\\n i-=1 \\n return i+1\\n except:\\n d[p[i][1]] = 1\\n return n\\n\",\n \"runtime\": \"778\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n l=[max(abs(e[0]),abs(e[1])) for e in points]\\n p=sorted([(l[i], s[i]) for i in range(len(l))])\\n found = set()\\n for i,e in enumerate(p):\\n if e[1] in found:\\n return len(tuple(filter(lambda x:x[0]!=e[0], p[:i])))\\n found.add(e[1])\\n return len(l)\\n # hi,lo=max(l),min(l)\\n # while hi>=lo:\\n # mi = (hi+lo)//2\\n\\n \",\n \"runtime\": \"792\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n new_arr = []\\n n = len(s)\\n for i in range(n):\\n new_arr.append((points[i][0], points[i][1], s[i]))\\n\\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\\n i = 0\\n my_set = set()\\n count = 0\\n \\n while i < n:\\n curr_max = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\\n curr_i = i\\n while i < n and max(abs(new_arr[i][0]), abs(new_arr[i][1])) == curr_max:\\n if new_arr[i][2] in my_set:\\n return count\\n my_set.add(new_arr[i][2])\\n i += 1\\n count += (i-curr_i)\\n print(i-curr_i)\\n\\n return count\",\n \"runtime\": \"806\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n poin = []\\n n = len(points)\\n for i in range(n):\\n pi = points[i]\\n tagi = s[i]\\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\\n poin += [(tagi,edgei)]\\n #print(poin)\\n poin.sort(key = lambda x : x[1])\\n #print(poin)\\n vis = set()\\n edge = 0\\n res = 0\\n for x in poin:\\n if x[0] not in vis:\\n edge = x[1]\\n vis.add(x[0])\\n continue\\n edge = x[1]-1\\n break\\n for x in poin:\\n if x[1] > edge: break\\n res += 1\\n return res\\n\\n \",\n \"runtime\": \"821\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n lst = sorted([(max(abs(points[i][0]),abs(points[i][1])),s[i]) for i in range(len(s))],key = lambda x: x[0])\\n res = 0\\n visited = set()\\n cur = lst[0][0]\\n #print(lst)\\n for i,(v,char) in enumerate(lst):\\n if v > cur:\\n res = i\\n cur = v\\n \\n\\n if char in visited:\\n return res\\n visited.add(char)\\n\\n\\n return len(s)\\n \\n\\n\\n\\n\",\n \"runtime\": \"877\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n ptstag = defaultdict(set)\\n top = float('inf')\\n \\n for (x, y), tag in zip(points, s):\\n r = max(abs(x), abs(y))\\n if tag in ptstag[r] and r<top:\\n top = r\\n ptstag[r].add(tag)\\n\\n visited = []\\n maxi = 0\\n \\n for r in sorted(ptstag):\\n if r>=top:\\n return maxi\\n tmp = 0\\n for v in ptstag[r]:\\n if v in visited:\\n return maxi\\n else:\\n tmp += 1\\n visited.append(v)\\n maxi += tmp\\n\\n return maxi\",\n \"runtime\": \"892\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n test=[max(abs(x), abs(y)) for x,y in points]\\n d=defaultdict(list)\\n for edge, tag in sorted((zip(test, s))):\\n d[tag].append(edge)\\n \\n dist=min((arr[1] for arr in d.values() if len(arr)>1), default=inf)\\n \\n return sum(t<dist for t in test)\\n \\n \",\n \"runtime\": \"906\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n n = len(points)\\n lst = [(0,float('inf'))]*26\\n cur_min = float('inf')\\n for i in range(n):\\n cur = ord(s[i])-ord(\\\"a\\\")\\n size = max(map(abs,points[i]))\\n if lst[cur][0] == 0 and lst[cur][1] >= size:\\n cur_min = min(cur_min,lst[cur][1])\\n lst[cur] = (1,size)\\n elif lst[cur][0] == 1:\\n if lst[cur][1] > size:\\n cur_min = min(cur_min,lst[cur][1]-1)\\n lst[cur] = (1,size)\\n elif lst[cur][1] == size:\\n cur_min = min(cur_min,lst[cur][1]-1)\\n lst[cur] = (0,size-1)\\n else:\\n cur_min = min(size-1,cur_min)\\n count = 0\\n for i in range(26):\\n if lst[i][1] <= cur_min:\\n count += lst[i][0]\\n return count\\n\",\n \"runtime\": \"920\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n N = len(points)\\n p = collections.defaultdict(list)\\n\\n for i, (x, y) in enumerate(points):\\n p[max(abs(x), abs(y))].append(s[i])\\n\\n res = 0\\n seen = set()\\n for k in sorted(p.keys()):\\n for c in p[k]:\\n if c in seen:\\n return res\\n seen.add(c)\\n res += len(p[k])\\n\\n return res\",\n \"runtime\": \"934\"\n },\n {\n \"code\": \"from bisect import insort\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points_by_tag = [[] for _ in range(26)]\\n\\n for i,(x,y) in enumerate(points):\\n idx = ord(s[i])-ord('a')\\n dist = max(abs(x), abs(y))\\n insort(points_by_tag[idx], dist)\\n points_by_tag = list(filter(lambda x: x, points_by_tag))\\n #print(points_by_tag)\\n edge = float(\\\"inf\\\")\\n for l in points_by_tag:\\n if len(l)>1:\\n edge = min(edge, l[1]-1)\\n #print (edge)\\n return sum(1 for l in points_by_tag if l[0] <= edge)\\n \",\n \"runtime\": \"934\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n a=[[] for i in range(26)]\\n n=len(s)\\n for i in range(n):\\n rep=max(abs(points[i][0]),abs(points[i][1]))\\n a[ord(s[i])-ord('a')].append(rep)\\n print(a)\\n f=0\\n r=[]\\n k=[]\\n for i in range(26):\\n a[i].sort()\\n if len(a[i])>=2:\\n f=1\\n r.append(a[i][1]-1)\\n elif len(a[i])==1:\\n k.append(a[i][0])\\n if f==0:\\n sz=max(k)\\n else:\\n sz=min(r)\\n ans=0\\n for i in range(26):\\n if len(a[i])>=1:\\n if(a[i][0]<=sz):\\n ans+=1\\n return ans\",\n \"runtime\": \"948\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n tagToPoints = collections.defaultdict(list)\\n\\n for i in range(len(points)):\\n # store maximum of absolute value\\n tmpval = max(abs(points[i][0]), abs(points[i][1]))\\n if len(tagToPoints[s[i]]) == 0:\\n tagToPoints[s[i]].append(tmpval)\\n elif len(tagToPoints[s[i]]) == 1:\\n if tagToPoints[s[i]][0] <= tmpval:\\n tagToPoints[s[i]].append(tmpval)\\n else:\\n tagToPoints[s[i]] = [tmpval, tagToPoints[s[i]][0]] \\n else:\\n if tmpval <= tagToPoints[s[i]][0]:\\n tagToPoints[s[i]] = [tmpval, tagToPoints[s[i]][0]]\\n else:\\n tagToPoints[s[i]] = [tagToPoints[s[i]][0], min(tagToPoints[s[i]][1], tmpval)]\\n\\n limit = [] # Shouldn't include limit\\n for k in tagToPoints.keys():\\n if len(tagToPoints[k]) == 1:\\n continue\\n else:\\n limit.append(tagToPoints[k][1])\\n\\n if len(limit) == 0:\\n return len(tagToPoints.keys())\\n\\n minlimit = min(limit)\\n rtn = 0\\n for k in tagToPoints.keys():\\n if tagToPoints[k][0] < minlimit:\\n rtn += 1\\n\\n return rtn\",\n \"runtime\": \"948\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n if len(set(s)) == (n := len(points)):\\n return n\\n d = defaultdict(set)\\n upper = math.inf\\n for (x, y), tag in zip(points, s):\\n dist = max(abs(x), abs(y))\\n if tag in d[dist]:\\n upper = min(upper, dist)\\n d[dist].add(tag)\\n seen = set()\\n for dist in sorted(d.keys()):\\n if dist >= upper:\\n break\\n tags = d[dist]\\n if seen & tags: # non-empty intersection\\n return len(seen)\\n seen |= tags\\n return len(seen)\\n \",\n \"runtime\": \"963\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n dict_ = defaultdict(list)\\n arr = []\\n for i in range(len(points)):\\n dict_[max(abs(points[i][0]), abs(points[i][1]))].append(s[i])\\n for key,val in dict_.items():\\n arr.append(key)\\n arr.sort()\\n set_=set()\\n print(dict_)\\n print(arr)\\n for dis in arr:\\n if len(set(dict_[dis]))==len(dict_[dis]):\\n flag=\\\"True\\\"\\n for char in dict_[dis]:\\n if char in set_:\\n flag=\\\"False\\\"\\n break\\n if flag==\\\"False\\\":\\n break\\n else:\\n for char in dict_[dis]:\\n set_.add(char)\\n\\n else:\\n break\\n return len(set_)\",\n \"runtime\": \"963\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n vals = [(c, max(abs(p[0]), abs(p[1]))) for p, c in zip(points, s)]\\n vals.sort()\\n min_dist = float(\\\"inf\\\")\\n N = len(vals)\\n filtered = []\\n i = 0\\n while i < N:\\n if i + 1 < N and vals[i][0] == vals[i+1][0]:\\n min_dist = min(min_dist, vals[i+1][1])\\n filtered.append(vals[i])\\n j = i + 1\\n while j < N and vals[i][0] == vals[j][0]:\\n j += 1\\n i = j\\n res = 0\\n for _, d in filtered:\\n if d >= min_dist:\\n continue\\n res += 1\\n return res\\n\\n\",\n \"runtime\": \"977\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n from collections import defaultdict\\n if len(set(s)) == len(s):\\n return len(points)\\n\\n l = []\\n points_per_d = defaultdict(int)\\n for (x, y), tag in zip(points, s):\\n sqr = max(abs(x), abs(y))\\n l.append((sqr, tag))\\n points_per_d[sqr] += 1\\n\\n l.sort(key = lambda x:(x[0], x[1]))\\n seen = set()\\n total = 0\\n\\n for d, tag in l:\\n if tag not in seen:\\n seen.add(tag)\\n else:\\n for key, val in points_per_d.items():\\n if key < d:\\n total += val\\n return total\\n\\n\\n\\n\",\n \"runtime\": \"977\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n d = defaultdict(list)\\n def secondMax(char, dist):\\n x = d[char]\\n if len(x)<2:\\n d[char].append([dist,s[k]])\\n d[char].sort()\\n else:\\n x.append([dist,s[k]])\\n \\n x.sort()\\n d[char] = x[:2]\\n \\n \\n \\n \\n minn = 0\\n for k in range (len(points)):\\n i,j = points[k]\\n currDist = max(abs(i),abs(j))\\n secondMax(s[k],currDist)\\n minn = max(minn,currDist)\\n \\n \\n \\n for i in d:\\n if len(d[i])>1:\\n minn = min(minn, max(0,d[i][1][0]-1))\\n \\n \\n ans = 0\\n for i,j in points:\\n if abs(i) <= minn and abs(j) <= minn:\\n ans+=1\\n \\n return ans\\n \\n \\n \\n \",\n \"runtime\": \"991\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n pointsToTag = {}\\n\\n lenToPointsList = defaultdict(list)\\n\\n ret = 0\\n for i, p in enumerate(points):\\n pointsToTag[tuple(p)] = (s[i], max(abs(p[0]), abs(p[1])))\\n\\n lenToPointsList[max(abs(p[0]), abs(p[1]))].append(s[i])\\n\\n curSet = set()\\n \\n sortedList = list(lenToPointsList.keys())\\n sortedList.sort()\\n \\n for sqLen in sortedList:\\n ret = len(curSet)\\n for tag in lenToPointsList[sqLen]:\\n if tag in curSet:\\n return ret\\n curSet.add(tag)\\n ret = len(curSet)\\n return ret\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"991\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n if len(points) == 1:\\n return 1\\n\\n points = [[points[i][0], points[i][1], s[i]] for i in range(len(points))]\\n points = sorted(points, key = lambda x:max(abs(x[0]), abs(x[1])))\\n \\n m, visited = defaultdict(int), set()\\n curr_edge, check_edge = -1, float('inf')\\n \\n res = 0\\n print(points)\\n for i, p in enumerate(points):\\n curr_edge = max(abs(p[0]), abs(p[1]))\\n if p[2] in visited:\\n check_edge = curr_edge\\n break\\n visited.add(p[2])\\n m[curr_edge] += 1\\n \\n res = 0\\n for e, val in m.items():\\n if e != check_edge:\\n res += val\\n else:\\n return res\\n \\n return res\\n \\n \",\n \"runtime\": \"1005\"\n },\n {\n \"code\": \"import numpy as np\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n def dist(p):\\n return max(abs(p[0]), abs(p[1]))\\n sorted_points = sorted([(i, p) for i,p in enumerate(points)], key=lambda x: dist(x[1]))\\n str_set = set()\\n count = 0\\n tmp_count = 0\\n for i, p in enumerate(sorted_points):\\n sorted_index = p[0]\\n tag = s[sorted_index]\\n if i == 0:\\n tmp_count += 1\\n if i > 0:\\n if dist(sorted_points[i][1]) == dist(sorted_points[i-1][1]):\\n if tag in str_set:\\n return count\\n else:\\n tmp_count += 1\\n else:\\n if tag in str_set:\\n count += tmp_count\\n return count\\n else:\\n count += tmp_count\\n tmp_count = 1\\n str_set.add(tag)\\n return count + tmp_count\",\n \"runtime\": \"1005\"\n },\n {\n \"code\": \"import math\\nfrom typing import List\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], tags: str) -> int:\\n n = len(points)\\n max_points = 0\\n seen_tags = set()\\n \\n \\n for i in range(n):\\n max_co = max(abs(points[i][0]), abs(points[i][1]))\\n distance = self.euclidean_distance(max_co, max_co)\\n points[i].append(int(distance))\\n points[i].append(tags[i])\\n \\n \\n points.sort(key=lambda p: p[2])\\n print(points)\\n i = 0\\n\\n while i < n:\\n x, y, current_distance, current_tag = points[i]\\n\\n if current_tag in seen_tags:\\n break\\n \\n point_count = 0\\n j = i\\n\\n while j < n and points[j][2] == current_distance:\\n\\n tag = points[j][3]\\n\\n if tag in seen_tags:\\n print(tag)\\n print(max_points)\\n return max_points\\n \\n print(points[j])\\n \\n point_count += 1\\n seen_tags.add(tag)\\n j += 1\\n \\n print()\\n \\n max_points += point_count\\n i = j\\n\\n return max_points\\n\\n def euclidean_distance(self, x2: int, y2: int) -> float:\\n x1 = y1 = 0\\n dx = x2 - x1\\n dy = y2 - y1\\n return math.sqrt(dx ** 2 + dy ** 2)\\n\",\n \"runtime\": \"1019\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n from collections import defaultdict\\n if len(set(s)) == len(s):\\n return len(points)\\n\\n l, d = [], set()\\n points_per_d = defaultdict(int)\\n for (x, y), tag in zip(points, s):\\n sqr = max(abs(x), abs(y))\\n d.add(sqr)\\n l.append((sqr, tag))\\n points_per_d[sqr] += 1\\n\\n prev = 0\\n points_per_d_cumm = {}\\n for sqr in sorted(d):\\n points_per_d_cumm[sqr] = prev\\n prev += points_per_d[sqr]\\n \\n l.sort(key = lambda x:(x[0], x[1]))\\n seen_tag = set()\\n for d, tag in l:\\n if tag not in seen_tag:\\n seen_tag.add(tag)\\n else:\\n return points_per_d_cumm[d]\\n\",\n \"runtime\": \"1019\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n pts = sorted((max(map(abs, points[i])), points[i], s[i]) for i in range(len(points)))\\n print(pts)\\n tags = set()\\n i = 0\\n while i < len(pts):\\n j = i\\n while j < len(pts) and pts[i][0] == pts[j][0]:\\n if pts[j][2] in tags:\\n return i\\n \\n tags.add(pts[j][2])\\n j += 1\\n\\n i = j\\n\\n return i\",\n \"runtime\": \"1034\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n ans = 0\\n def check(limit):\\n vis = set()\\n for (x, y), c in zip(points, s):\\n if abs(x) <= limit and abs(y) <= limit:\\n if c in vis:\\n return True\\n vis.add(c)\\n nonlocal ans\\n ans = len(vis)\\n return False\\n bisect_left(range(1000000001), True, key=check)\\n return ans\\n \",\n \"runtime\": \"1034\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n d = {}\\n for c, p in zip(s, points):\\n if c in d:\\n d[c] = sorted(d[c] + [p], key=lambda x : max(map(abs,x)))[0:2]\\n else:\\n d[c] = [p]\\n m_2 = [i[1] for v,i in d.items() if len(i) > 1]\\n if m_2:\\n m_2 = min(m_2, key=lambda x : max(map(abs,x)))\\n else:\\n return len(points)\\n ans = 0\\n for _, j in d.items():\\n\\n i = j[0]\\n x = max(map(abs, m_2))\\n if -x < i[0] < x and -x < i[1] < x:\\n ans += 1\\n return ans\\n \",\n \"runtime\": \"1048\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n res = 0\\n def check(size):\\n vis = set()\\n for (x, y), c in zip(points, s):\\n if abs(x) <= size and abs(y) <= size: #this point in \\n if c in vis:\\n #duplicate letter\\n return True \\n vis.add(c)\\n nonlocal res\\n res = len(vis)\\n return False\\n bisect_left(range(1_000_000_001), True, key=check)\\n return res\",\n \"runtime\": \"1048\"\n },\n {\n \"code\": \"class Point:\\n def __init__(self, x: int, y: int, label: str):\\n self.label = label\\n self.key = max(abs(x), abs(y))\\n \\n def __lt__(self, other: \\\"Point\\\"):\\n return self.key < other.key\\n\\n def __repr__(self):\\n return f\\\"Point({self.key}, {self.label})\\\"\\n\\nclass Solution:\\n def maxPointsInsideSquare(self, points: list[list[int]], labels: str) -> int:\\n points = [Point(x, y, label) for (x, y), label in zip(points, labels)]\\n points.sort()\\n\\n groups = [[1, set(points[0].label)]]\\n for i in range(1, len(points)):\\n if points[i].key != points[i-1].key: groups.append([0, set()])\\n groups[-1][0] += 1\\n groups[-1][1].add(points[i].label)\\n\\n result, seen = 0, set()\\n for count, group_seen in groups:\\n if count != len(group_seen): break\\n if any(g in seen for g in group_seen): break\\n result += count\\n seen.update(group_seen)\\n return result\\n\",\n \"runtime\": \"1062\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n '''\\n starting from origin expand range of square by 1 \\n continue expanding until length of seen is equal to length of s or points - i.e. all points seen \\n if a point that has not yet been seen is found within the new parameters\\n check to see if the corresponding character is a duplicate in what has already been seen\\n if it is return the length of the seen list \\n otherwise increment the counter and update the map with character from seen = True\\n finally returnr the length of the seen map \\n \\n only really need to check points where max val between x and y == sq_range\\n key will be string variable\\n value will be index \\n update list to only be max of two values \\n\\n '''\\n # convert points into 1d by their abs max x/y distance from center\\n points = [max([abs(ele) for ele in point]) for point in points]\\n counter = 0\\n sq_range = min(points)\\n seen = {}\\n while len(seen.keys()) < len(s):\\n mini_counter = 0\\n indices = [i for i, x in enumerate(points) if x == sq_range]\\n for index in indices:\\n if s[index] in seen:\\n return counter\\n mini_counter+=1\\n seen[s[index]] = True\\n counter += mini_counter\\n\\n # remove used points from points, repalcing with infinity, find the next smalleset point to work with\\n for i in range(len(points)):\\n if points[i] == sq_range:\\n points[i] = float('inf')\\n # points = [point for point in points if point > sq_range]\\n\\n sq_range = min(points)\\n\\n return counter\\n\",\n \"runtime\": \"1062\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n def helper(len_):\\n seen_tags = set()\\n\\n \\n for i, (x, y) in enumerate(points):\\n \\n if -len_ <= x <= len_ and -len_ <= y <= len_:\\n if s[i] in seen_tags:\\n return 0\\n\\n seen_tags.add(s[i])\\n \\n if len(seen_tags) == 0:\\n return -1\\n\\n return len(seen_tags)\\n\\n\\n left = 0\\n right = 10**9\\n res = 0\\n while left <= right:\\n target_len = (left+right) // 2\\n \\n cur = helper(target_len)\\n # print(\\\"target_len\\\", target_len, \\\"cur\\\", cur)\\n if cur > 0:\\n res = cur\\n left = target_len + 1\\n elif cur == -1:\\n left = target_len + 1\\n else:\\n right = target_len - 1\\n \\n return res\",\n \"runtime\": \"1076\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n n = len(points)\\n if n == 1:\\n return 1\\n \\n calcPoints = []\\n for i1 in range(n):\\n temp = [points[i1][0], points[i1][1], ord(s[i1])]\\n calcPoints.append(temp)\\n \\n print(\\\"Before sorting:\\\", calcPoints)\\n # Sort by the maximum of the absolute x and y coordinates\\n calcPoints.sort(key=lambda a: max(abs(a[0]), abs(a[1])))\\n print(\\\"After sorting:\\\", calcPoints)\\n \\n seen = set()\\n break1 = n \\n for i1 in range(n):\\n value = calcPoints[i1][2]\\n if value in seen:\\n break1 = i1\\n break\\n seen.add(value)\\n \\n print(\\\"Break point index:\\\", break1)\\n count = 0\\n if break1 != n:\\n maxi = max(abs(calcPoints[break1][0]), abs(calcPoints[break1][1]))\\n print(\\\"Max value for square boundary:\\\", maxi)\\n for i1 in range(break1):\\n if abs(calcPoints[i1][0]) < maxi and abs(calcPoints[i1][1]) < maxi:\\n count += 1\\n print(\\\"Point inside square:\\\", calcPoints[i1])\\n else:\\n return n\\n \\n return count\\n\",\n \"runtime\": \"1076\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n point_index_list = list(sorted(set(max(abs(x), abs(y)) for x,y in points)))\\n last_counter = 0\\n non_stop = True\\n for i, ind in enumerate(point_index_list) : \\n s_ind = []\\n for i, point in enumerate(points):\\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\\n s_ind.append(s[i])\\n if len(s_ind) == len(set(s_ind)):\\n last_counter = len(set(s_ind))\\n if len(set(s_ind)) == len(points):\\n break\\n else:\\n break\\n return last_counter\",\n \"runtime\": \"1090\"\n },\n {\n \"code\": \"class Solution:\\n def check(self, side, arr, label):\\n seen = set()\\n for i in range(len(arr)):\\n if abs(arr[i][0]) <= side and abs(arr[i][1]) <= side:\\n if label[i] in seen:\\n return [False, 0]\\n else:\\n seen.add(label[i])\\n return [True, len(seen)]\\n\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n n = len(points)\\n left = 0\\n right = 10 ** 9 + 1\\n answer = 0\\n while left <= right:\\n mid = (left + right) // 2\\n temp = self.check(mid, points, s)\\n if temp[0]:\\n left = mid + 1\\n answer = max(answer, temp[1])\\n else:\\n right = mid - 1\\n return answer\",\n \"runtime\": \"1090\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n\\t\\tc = defaultdict(Counter)\\n\\t\\tfor i, (x, y) in enumerate(points):\\n\\t\\t\\tc[max(abs(x), abs(y))][s[i]] += 1\\n\\t\\ts = set()\\n\\t\\tfor x in sorted(c.keys()):\\n\\t\\t\\tok = True\\n\\t\\t\\tfor k, v in c[x].items():\\n\\t\\t\\t\\tif k in s or v > 1:\\n\\t\\t\\t\\t\\tok = False\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\tif not ok: break\\n\\t\\t\\tfor k in c[x]: s.add(k)\\n\\t\\treturn len(s)\",\n \"runtime\": \"1105\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n squares = defaultdict(Counter)\\n for p, tag in zip(points, s):\\n s = max(map(abs, p))\\n\\n squares[s][tag] += 1\\n\\n current_square = Counter()\\n for square in sorted(squares.keys()):\\n for tag in squares[square]:\\n if current_square[tag] + squares[square][tag] > 1:\\n return sum(current_square.values())\\n \\n for tag in squares[square]:\\n current_square[tag] += squares[square][tag]\\n \\n return sum(current_square.values())\\n\",\n \"runtime\": \"1105\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n s = list(s)\\n dist = []\\n d = dict()\\n for i in range(len(points)):\\n # dist.append((points[i][0]**2+points[i][1]**2)**0.5)\\n dist.append(max(abs(points[i][0]),abs(points[i][1])))\\n if d.get(max(abs(points[i][0]),abs(points[i][1]))):\\n d[max(abs(points[i][0]),abs(points[i][1]))].append(s[i])\\n else:\\n d[max(abs(points[i][0]),abs(points[i][1]))] = [s[i]]\\n t = sorted(zip(dist, s, points))\\n # print(list(t))\\n # dist = [x for x,_,y in t]\\n # s = [x for _,x,y in t]\\n points = [x for _,y,x in t]\\n print(d)\\n visited = dict()\\n tot = 0\\n i = 0\\n while i < len(s):\\n temp = 0\\n for j in d[max(abs(points[i][0]),abs(points[i][1]))]:\\n if visited.get(j):\\n return tot\\n visited[j] = True\\n temp += 1\\n tot += temp\\n i += len(d[max(abs(points[i][0]),abs(points[i][1]))])\\n\\n # for i in s:\\n # if d.get(i):\\n # break\\n # tot += 1\\n # d[i] = True\\n print(d)\\n return tot\\n \",\n \"runtime\": \"1119\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n l=0\\n r=0\\n ans=0\\n for v in points:\\n if(v[0]==0 and v[1]==0):ans=1\\n r=max(r,max(abs(v[0]),abs(v[1])))\\n # print(l,r)\\n while(l<r):\\n mid=(l+r)//2\\n if(mid==l):mid+=1\\n track={}\\n flag=1\\n for i in range(len(points)):\\n if(abs(points[i][0])>mid or abs(points[i][1])>mid):continue\\n track[s[i]]=track.get(s[i],0)+1\\n if(track[s[i]]>1):\\n flag=0\\n break\\n if(flag):\\n l=mid\\n ans=max(ans,len(track))\\n else:\\n r=mid-1\\n return ans\",\n \"runtime\": \"1119\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n point_index_list = sorted([max(abs(x), abs(y)) for x,y in points])\\n print(point_index_list)\\n last_counter = 0\\n non_stop = True\\n for i, ind in enumerate(point_index_list) : \\n s_ind = []\\n for i, point in enumerate(points):\\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\\n s_ind.append(s[i])\\n print(s_ind)\\n if len(s_ind) == len(set(s_ind)):\\n last_counter = len(set(s_ind))\\n if len(set(s_ind)) == len(points):\\n break\\n else:\\n break\\n return last_counter\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n def compute_squares(size):\\n tags = Counter()\\n total = 0\\n for i in range(len(points)):\\n x, y = points[i]\\n if abs(x) <= size and abs(y) <= size:\\n tag = s[i]\\n total += 1\\n tags[tag] += 1\\n if tags[tag] > 1:\\n return 0\\n return total\\n \\n \\n tags = defaultdict(list)\\n for i in range(len(points)):\\n x, y = points[i]\\n tags[s[i]].append((abs(x), abs(y)))\\n \\n total = 0\\n for tag in tags:\\n size = inf\\n for x, y in tags[tag]:\\n size = min(size, max(x, y))\\n total = max(total, compute_squares(size))\\n \\n return total\\n \\n \\n \",\n \"runtime\": \"1147\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n left = 0\\n right = int(1e9)\\n ans = 0\\n\\n while left <= right:\\n mid = left + (right - left) // 2\\n visited = [0 for _ in range(26)]\\n N = len(points)\\n pts = 0\\n ok = True\\n\\n for i in range(N):\\n [x, y] = points[i]\\n idx = ord(s[i]) - ord('a')\\n\\n if abs(x) <= mid and abs(y) <= mid:\\n visited[idx] += 1\\n pts += 1\\n \\n if visited[idx] > 1:\\n ok = False\\n break\\n \\n if ok:\\n left = mid + 1\\n else:\\n right = mid - 1\\n pts = 0\\n\\n ans = max(ans, pts)\\n\\n return ans\",\n \"runtime\": \"1161\"\n },\n {\n \"code\": \"class Solution:\\n def check_points_inside(self, value, points_name, points):\\n letters = []\\n for item in points_name:\\n if max(abs(points[item][0]),abs(points[item][1])) <= value:\\n if points_name[item] not in letters:\\n letters.append(points_name[item])\\n else:\\n return False\\n return len(letters) \\n\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points_name = {}\\n max_value = 0\\n min_value = 0\\n for i in range(len(s)):\\n points_name[i] = s[i]\\n max_current = max([abs(points[i][0]),abs(points[i][1])])\\n if not min_value:\\n min_value = max_current\\n elif min_value > max_current:\\n min_value = max_current\\n if max_value < max_current:\\n max_value = max_current\\n \\n \\n if len(set(points_name.values())) == len(s):\\n return len(s)\\n \\n while min_value <= max_value:\\n mid_value = (min_value+max_value) // 2\\n\\n if self.check_points_inside(mid_value, points_name, points):\\n min_value = mid_value + 1\\n else:\\n max_value = mid_value - 1\\n \\n points_found = self.check_points_inside(max_value, points_name, points)\\n return points_found\",\n \"runtime\": \"1176\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points, s):\\n def count_points(side_length):\\n count = 0\\n for point in points:\\n if -side_length <= point[0] <= side_length and -side_length <= point[1] <= side_length:\\n count += 1\\n return count\\n \\n def has_duplicate_tags(side_length):\\n tags_set = set()\\n for i, point in enumerate(points):\\n if -side_length <= point[0] <= side_length and -side_length <= point[1] <= side_length:\\n if s[i] in tags_set:\\n return True\\n tags_set.add(s[i])\\n return False\\n \\n max_points = 0\\n left, right = 0, 10**9\\n while left <= right:\\n mid = (left + right) // 2\\n if not has_duplicate_tags(mid):\\n max_points = count_points(mid)\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n return max_points\",\n \"runtime\": \"1190\"\n },\n {\n \"code\": \"class Solution:\\n def check_points_inside(self, value, points_name, points):\\n letters = []\\n for item in points_name:\\n if max(abs(points[item][0]),abs(points[item][1])) <= value:\\n if points_name[item] not in letters:\\n letters.append(points_name[item])\\n else:\\n return False\\n return len(letters) \\n\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n points_name = {}\\n max_value = 0\\n min_value = 0\\n for i in range(len(s)):\\n points_name[i] = s[i]\\n max_current = max([abs(points[i][0]),abs(points[i][1])])\\n if not min_value:\\n min_value = max_current\\n elif min_value > max_current:\\n min_value = max_current\\n if max_value < max_current:\\n max_value = max_current\\n \\n \\n if len(set(points_name.values())) == len(s):\\n return len(s)\\n \\n while min_value <= max_value:\\n print(min_value, max_value)\\n mid_value = (min_value+max_value) // 2\\n\\n if self.check_points_inside(mid_value, points_name, points):\\n min_value = mid_value + 1\\n else:\\n max_value = mid_value - 1\\n \\n points_found = self.check_points_inside(max_value, points_name, points)\\n return points_found\",\n \"runtime\": \"1204\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n lis = []\\n for i in range(len(points)):\\n lis.append((s[i],max(abs(points[i][0]),abs(points[i][1]))))\\n n = 0\\n d = {}\\n Solution.timSort(lis)\\n #print(lis)\\n ind = 0\\n t = 0\\n i = lis[0][1]\\n while i<lis[-1][1]+1 and ind<len(lis):\\n #print(i,lis[ind],d)\\n if lis[ind][1] <= i:\\n if lis[ind][0] in d:\\n #print('ldaskfjlas',lis[ind])\\n return n\\n else:\\n t+=1\\n \\n d[lis[ind][0]]= 1\\n ind+=1\\n else:\\n n += t\\n t = 0\\n i = lis[ind][1]\\n #print(t,n)\\n n+=t\\n return n\\n\\n def calcMinRun(n): \\n MIN_MERGE = 32\\n r = 0\\n while n >= MIN_MERGE: \\n r |= n & 1\\n n >>= 1\\n return n + r \\n \\n \\n \\n # This function sorts array from left index to \\n # to right index which is of size atmost RUN \\n def insertionSort(arr, left, right): \\n for i in range(left + 1, right + 1): \\n j = i \\n while j > left and arr[j][1] < arr[j - 1][1]: \\n arr[j], arr[j - 1] = arr[j - 1], arr[j] \\n j -= 1\\n \\n \\n # Merge function merges the sorted runs \\n def merge(arr, l, m, r): \\n \\n # original array is broken in two parts \\n # left and right array \\n len1, len2 = m - l + 1, r - m \\n left, right = [], [] \\n for i in range(0, len1): \\n left.append(arr[l + i]) \\n for i in range(0, len2): \\n right.append(arr[m + 1 + i]) \\n \\n i, j, k = 0, 0, l \\n \\n # after comparing, we merge those two array \\n # in larger sub array \\n while i < len1 and j < len2: \\n if left[i][1] <= right[j][1]: \\n arr[k] = left[i] \\n i += 1\\n \\n else: \\n arr[k] = right[j] \\n j += 1\\n \\n k += 1\\n \\n # Copy remaining elements of left, if any \\n while i < len1: \\n arr[k] = left[i] \\n k += 1\\n i += 1\\n \\n # Copy remaining element of right, if any \\n while j < len2: \\n arr[k] = right[j] \\n k += 1\\n j += 1\\n \\n \\n# Iterative Timsort function to sort the \\n# array[0...n-1] (similar to merge sort) \\n def timSort(arr): \\n n = len(arr) \\n minRun = Solution.calcMinRun(n) \\n \\n # Sort individual subarrays of size RUN \\n for start in range(0, n, minRun): \\n end = min(start + minRun - 1, n - 1) \\n Solution.insertionSort(arr, start, end) \\n \\n # Start merging from size RUN (or 32). It will merge \\n # to form size 64, then 128, 256 and so on .... \\n size = minRun \\n while size < n: \\n \\n # Pick starting point of left sub array. We \\n # are going to merge arr[left..left+size-1] \\n # and arr[left+size, left+2*size-1] \\n # After every merge, we increase left by 2*size \\n for left in range(0, n, 2 * size): \\n \\n # Find ending point of left sub array \\n # mid+1 is starting point of right sub array \\n mid = min(n - 1, left + size - 1) \\n right = min((left + 2 * size - 1), (n - 1)) \\n \\n # Merge sub array arr[left.....mid] & \\n # arr[mid+1....right] \\n if mid < right: \\n Solution.merge(arr, left, mid, right) \\n \\n size = 2 * size \\n \",\n \"runtime\": \"1218\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n # Expand the square using binary search??\\n l, r = 0, 10 ** 9\\n res = 0\\n while l <= r:\\n mid = l + (r-l) // 2\\n # Check if a square with side length mid is valid\\n a = set()\\n valid = True\\n for i, (x,y) in enumerate(points):\\n if max(abs(x),abs(y)) <= mid:\\n if s[i] in a:\\n valid = False\\n break\\n else:\\n a.add(s[i])\\n\\n print('trying', mid, valid, a)\\n if valid:\\n res = max(res, len(a))\\n l = mid + 1\\n else:\\n r = mid - 1\\n return res\",\n \"runtime\": \"1232\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n def isValid(m):\\n visit = set()\\n for (x, y), c in zip(points, s):\\n r = max(abs(x), abs(y))\\n if r <= m:\\n if c in visit:\\n return False, -1 \\n visit.add(c)\\n return True, len(visit)\\n\\n l, r = 0, 10 ** 9\\n res = 0 \\n while l <= r:\\n m = (l + r) // 2 \\n valid, p = isValid(m)\\n if valid:\\n res = max(res, p)\\n l = m + 1 \\n else:\\n r = m - 1 \\n return res\",\n \"runtime\": \"1247\"\n },\n {\n \"code\": \"class Solution:\\n def isCorrect(self, mid, points, s):\\n maxRange = mid/2\\n hashMap = {}\\n for indx,point in enumerate(points):\\n x, y = point\\n if x >= -maxRange and x <= maxRange and y >= -maxRange and y <= maxRange:\\n if s[indx] in hashMap:\\n return False\\n hashMap[s[indx]] = True\\n return True\\n\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n hashMap = {}\\n repeatingTags = False\\n for x in s:\\n if x in hashMap:\\n repeatingTags = True\\n break\\n hashMap[x] = True\\n if not repeatingTags:\\n return len(points)\\n low = 0\\n high = sys.maxsize\\n while low <= high:\\n # print(low, high)\\n mid = low + (high-low)//2\\n if self.isCorrect(mid, points, s):\\n low = mid+1\\n else:\\n high = mid-1\\n maxRange = high/2\\n # print(maxRange)\\n res = 0\\n for indx,point in enumerate(points):\\n x, y = point\\n if x >= -maxRange and x <= maxRange and y >= -maxRange and y <= maxRange:\\n # print(x, y)\\n res += 1\\n return res\",\n \"runtime\": \"1261\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":89,"string":"89"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], \n s: str) -> int:\n\n mapper = [max(abs(x), abs(y)) for x, y in points]\n hash_table = defaultdict(list)\n for i, c in sorted(zip(mapper, s)):\n hash_table[c].append(i)\n \n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\n return sum(p < dict for p in mapper)\n\nwith open('user.out', 'w') as f: \n iterator = map(loads, stdin)\n s = Solution()\n while True:\n try:\n print(s.maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\n except StopIteration:\n exit()","memory":"40500"},{"code":"\ndef maxPointsInsideSquare(points: List[List[int]], \n s: str) -> int:\n\n mapper = [max(abs(x), abs(y)) for x, y in points]\n hash_table = defaultdict(list)\n for i, c in sorted(zip(mapper, s)):\n hash_table[c].append(i)\n \n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\n return sum(p < dict for p in mapper)\n\nwith open('user.out', 'w') as f: \n iterator = map(loads, stdin)\n while True:\n try:\n print(maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\n except StopIteration:\n exit()","memory":"40600"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n side = 10**9\n lim = {}\n for i in range(len(s)):\n points[i] = max(abs(points[i][0]), abs(points[i][1]))\n for i in range(len(s)):\n cur_lim = points[i]\n if s[i] not in lim:\n lim[s[i]] = (1 << 31, 1 << 31)\n a0, a1 = lim[s[i]]\n if cur_lim <= a0:\n lim[s[i]] = (cur_lim, a0)\n elif cur_lim < a1:\n lim[s[i]] = (a0, cur_lim)\n if lim[s[i]][1] == 0:\n return 0\n for key, (_, sec) in lim.items():\n side = min(side, sec - 1)\n ans = 0\n for i in points:\n if i <= side:\n ans += 1\n return ans","memory":"50600"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n side = 1 << 31\n lim = {}\n for i in range(len(s)):\n points[i] = max(abs(points[i][0]), abs(points[i][1]))\n for i in range(len(s)):\n cur_lim = points[i]\n s_i = s[i]\n if s_i not in lim:\n lim[s_i] = (1 << 31, 1 << 31)\n a0, a1 = lim[s_i]\n if cur_lim <= a0:\n lim[s_i] = (cur_lim, a0)\n elif cur_lim < a1:\n lim[s_i] = (a0, cur_lim)\n if lim[s_i][1] == 0:\n return 0\n for key, (_, sec) in lim.items():\n side = min(side, sec - 1)\n ans = 0\n for i in points:\n if i <= side:\n ans += 1\n return ans","memory":"50800"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n s_list = list(s)\n counter = 0\n for [x, y] in points:\n if x == y and x == 0:\n counter += 1\n \n set_indexes_to_zero = set()\n\n for i in range(len(s_list) - 1):\n if s_list[i] == -1:\n continue\n set_same_tags = set()\n for j in range(i+1, len(s_list)):\n if s_list[i] == s_list[j]:\n set_same_tags.add(i)\n set_same_tags.add(j)\n if set_same_tags:\n list_max = [max([abs(x) for x in points[index]]) for index in set_same_tags]\n list_max_second = sorted(list_max)[1]\n for index, [x, y] in enumerate(points):\n if max(abs(x), abs(y)) >= list_max_second:\n set_indexes_to_zero.add(index)\n for i in range(len(s_list)):\n if i in set_same_tags:\n s_list[i] = -1\n\n for index in set_indexes_to_zero:\n points[index] = [0, 0] \n\n x_max_y_max_max = max(max([abs(x) for [x, y] in points]), max([abs(y) for [x, y] in points]))\n \n\n for index, [x, y] in enumerate(points):\n if max(abs(x), abs(y)) <= x_max_y_max_max and [x, y] != [0,0]:\n counter += 1 \n print(\"half size: \", x_max_y_max_max)\n return counter","memory":"55400"},{"code":"class Solution:\n def maxPointsInsideSquare(self, p: List[List[int]], s: str) -> int:\n n = len(p)\n for i in range(n):\n p[i]= [max(abs(p[i][0]),abs(p[i][1])),s[i]]\n p.sort()\n d = {}\n for i in range(n):\n try:\n d[p[i][1]]+=1\n i-=1\n while i>=0 and p[i][0] == p[i+1][0]:\n i-=1 \n return i+1\n except:\n d[p[i][1]] = 1\n return n\n","memory":"58200"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n new_arr = []\n n = len(s)\n for i in range(n):\n new_arr.append((points[i][0], points[i][1], s[i]))\n\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\n count = 0\n my_set = set()\n curr_length = None\n curr_run = 0\n\n for i in range(n):\n res = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\n if new_arr[i][2] in my_set and res == curr_length:\n return count\n elif new_arr[i][2] in my_set and res != curr_length:\n return count + curr_run\n elif curr_length == res:\n curr_run += 1\n else:\n count += curr_run\n curr_run = 1\n curr_length = res\n my_set.add(new_arr[i][2])\n\n return count + curr_run","memory":"58900"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n ans = 0\n p_dict = defaultdict(list)\n for t, (x,y) in zip(s, points):\n r = max(abs(x), abs(y))\n p_dict[r].append(t)\n \n # 2,a 2,a\n curr = set()\n for k, tags in sorted(p_dict.items()):\n # print(f\"k: {k} val: {tags}\")\n s_tags = set(tags)\n if len(s_tags) < len(tags):\n break\n if curr.intersection(s_tags):\n break\n curr.update(s_tags)\n ans += len(tags)\n return ans\n ","memory":"59000"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n a=[[] for i in range(26)]\n n=len(s)\n for i in range(n):\n rep=max(abs(points[i][0]),abs(points[i][1]))\n a[ord(s[i])-ord('a')].append(rep)\n print(a)\n f=0\n r=[]\n k=[]\n for i in range(26):\n a[i].sort()\n if len(a[i])>=2:\n f=1\n r.append(a[i][1]-1)\n elif len(a[i])==1:\n k.append(a[i][0])\n if f==0:\n sz=max(k)\n else:\n sz=min(r)\n ans=0\n for i in range(26):\n if len(a[i])>=1:\n if(a[i][0]<=sz):\n ans+=1\n return ans","memory":"59200"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n '''\n starting from origin expand range of square by 1 \n continue expanding until length of seen is equal to length of s or points - i.e. all points seen \n if a point that has not yet been seen is found within the new parameters\n check to see if the corresponding character is a duplicate in what has already been seen\n if it is return the length of the seen list \n otherwise increment the counter and update the map with character from seen = True\n finally returnr the length of the seen map \n \n only really need to check points where max val between x and y == sq_range\n key will be string variable\n value will be index \n update list to only be max of two values \n\n '''\n # convert points into 1d by their abs max x/y distance from center\n points = [max([abs(ele) for ele in point]) for point in points]\n counter = 0\n sq_range = min(points)\n seen = {}\n while len(seen.keys()) < len(s):\n mini_counter = 0\n indices = [i for i, x in enumerate(points) if x == sq_range]\n for index in indices:\n if s[index] in seen:\n return counter\n mini_counter+=1\n seen[s[index]] = True\n counter += mini_counter\n\n # remove used points from points, repalcing with infinity, find the next smalleset point to work with\n for i in range(len(points)):\n if points[i] == sq_range:\n points[i] = float('inf')\n # points = [point for point in points if point > sq_range]\n\n sq_range = min(points)\n\n return counter\n","memory":"59300"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n point_index_list = points.copy()\n ind = min([max(abs(p[0]), abs(p[1])) for p in point_index_list])\n print(ind)\n last_counter = 0\n counter_points = 0\n non_stop = True\n while (non_stop):\n points_list =set()\n s_ind = set()\n last_counter = counter_points\n counter_points = 0\n for i, point in enumerate(points):\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\n counter_points += 1\n points_list.add(i)\n s_ind.add(s[i])\n if point in point_index_list and len(point_index_list) > 0:\n point_index_list.remove(point)\n if len(s_ind) == len(points_list):\n if len(point_index_list) == 0:\n last_counter = counter_points\n non_stop = False\n break\n ind = min([max(abs(p[0]), abs(p[1])) for p in point_index_list])\n if len(points_list) == len(points):\n last_counter = counter_points\n non_stop = False\n else:\n non_stop = False\n return last_counter","memory":"59600"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n numPoints = 0\n maxLength = 10 ** 9\n tags = defaultdict(lambda: [10 ** 9 + 1])\n for point, tag in zip(points, s):\n tags[tag].append(max(abs(point[0]), abs(point[1])))\n tags[tag].sort()\n if len(tags[tag]) > 2: tags[tag].pop()\n for dist in tags.values(): maxLength = min(maxLength, dist[1] - 1)\n for dist in tags.values(): numPoints += dist[0] <= maxLength\n return numPoints","memory":"59700"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n poin = []\n n = len(points)\n for i in range(n):\n pi = points[i]\n tagi = s[i]\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\n poin += [(tagi,edgei)]\n #print(poin)\n poin.sort(key = lambda x : x[1])\n #print(poin)\n vis = set()\n edge = 0\n res = 0\n for x in poin:\n if x[0] not in vis:\n edge = x[1]\n vis.add(x[0])\n continue\n edge = x[1]-1\n break\n for x in poin:\n if x[1] > edge: break\n res += 1\n return res\n\n ","memory":"59800"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n \n myHash = defaultdict(list)\n\n for i, (x, y) in enumerate(points):\n\n myHash[max(abs(x), abs(y))].append(i)\n\n vis = set()\n res = 0\n\n for i in sorted(myHash):\n idxs = myHash[i]\n\n for j in idxs:\n if s[j] in vis:\n return res\n \n vis.add(s[j])\n\n res += len(idxs)\n\n return res\n\n","memory":"59900"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\n\n for [px, py], tag in zip(points, s):\n tag_idx = ord(tag) - 97\n d = max(abs(px), abs(py))\n if d <= closest_tag[tag_idx][0]:\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\n elif d < closest_tag[tag_idx][1]:\n closest_tag[tag_idx][1] = d\n \n max_d = sys.maxsize\n for _, d1 in closest_tag:\n if d1 - 1 < max_d:\n max_d = d1 - 1\n return sum(d0 <= max_d for d0, _ in closest_tag)\n\n \n # seen = set()\n # closest_points = sorted(((max(abs(p[0]), abs(p[1])), s[i]) for i, p in enumerate(points)))\n # for i, (d, t) in enumerate(closest_points):\n # if t in seen:\n # j = i - 1\n # while j > -1 and closest_points[j][0] == d:\n # j -= 1\n # return j + 1\n # seen.add(t)\n # return len(points)\n \n ","memory":"60000"},{"code":"class Solution: \n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n minLens = {}\n secondMin = float('inf')\n \n for point, char in zip(points, s):\n size = max(abs(point[0]), abs(point[1]))\n\n if char not in minLens:\n minLens[char] = size\n elif size < minLens[char]:\n secondMin = min(minLens[char], secondMin)\n minLens[char] = size\n else:\n secondMin = min(size, secondMin)\n \n count = 0\n for len in minLens.values():\n if len < secondMin:\n count += 1\n \n return count","memory":"60100"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n d = dict()\n n = len(points)\n for i in range(n):\n pi = points[i]\n tagi = s[i]\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\n if tagi in d: d[tagi] += [edgei]\n else: d[tagi] = [edgei]\n mn = 9_000_000_000\n\n for tag in d:\n if len(d[tag]) > 1:\n d[tag].sort()\n tmp = d[tag][1] -1\n mn = min(mn,tmp)\n #print(d)\n #print(mn)\n\n res = 0\n for tag in d:\n if min(d[tag]) <= mn: res +=1\n return res\n ","memory":"60200"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n maxRange = 0\n tagsDict = defaultdict(list)\n possibleRange = []\n # you actually only care about their s, coord\n for i in range(len(points)):\n x, y = points[i]\n maxRange = max(x, y, maxRange)\n # s : x, y\n tagsDict[s[i]].append(max(abs(x), abs(y)))\n possibleRange.append(max(abs(x), abs(y)))\n\n for t in tagsDict:\n tagsDict[t].sort()\n \n bestAns = 0\n possibleRange.sort()\n \n for p in possibleRange:\n # i, i, i, i\n currAns = 0\n for t in tagsDict:\n if len(tagsDict[t]) > 1:\n if 0 < tagsDict[t][1] <= p:\n return bestAns\n if 0 <= tagsDict[t][0] <= p:\n currAns +=1\n bestAns = max(currAns, bestAns)\n\n return bestAns","memory":"60300"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n dic = defaultdict(list)\n keys,seen = set(), set()\n tot = 0\n\n for i, (x,y) in enumerate(points):\n k = max(abs(x), abs(y))\n dic[k].append((x,y,i))\n keys.add(k)\n \n keys = list(sorted(keys))\n for k in keys:\n temp = 0\n for x,y,i in dic[k]:\n if s[i] in seen: return tot\n seen.add(s[i])\n temp += 1\n tot += temp\n\n return tot","memory":"61700"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n from collections import defaultdict\n if len(set(s)) == len(s):\n return len(points)\n\n l, d = [], set()\n points_per_d = defaultdict(int)\n for (x, y), tag in zip(points, s):\n sqr = max(abs(x), abs(y))\n d.add(sqr)\n l.append((sqr, tag))\n points_per_d[sqr] += 1\n\n prev = 0\n points_per_d_cumm = {}\n for sqr in sorted(d):\n points_per_d_cumm[sqr] = prev\n prev += points_per_d[sqr]\n \n l.sort(key = lambda x:(x[0], x[1]))\n seen_tag = set()\n for d, tag in l:\n if tag not in seen_tag:\n seen_tag.add(tag)\n else:\n return points_per_d_cumm[d]\n","memory":"62700"},{"code":"class Solution:\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\n s = list(s)\n dist = []\n d = dict()\n for i in range(len(points)):\n # dist.append((points[i][0]**2+points[i][1]**2)**0.5)\n dist.append(max(abs(points[i][0]),abs(points[i][1])))\n if d.get(max(abs(points[i][0]),abs(points[i][1]))):\n d[max(abs(points[i][0]),abs(points[i][1]))].append(s[i])\n else:\n d[max(abs(points[i][0]),abs(points[i][1]))] = [s[i]]\n t = sorted(zip(dist, s, points))\n # print(list(t))\n # dist = [x for x,_,y in t]\n # s = [x for _,x,y in t]\n points = [x for _,y,x in t]\n print(d)\n visited = dict()\n tot = 0\n i = 0\n while i < len(s):\n temp = 0\n for j in d[max(abs(points[i][0]),abs(points[i][1]))]:\n if visited.get(j):\n return tot\n visited[j] = True\n temp += 1\n tot += temp\n i += len(d[max(abs(points[i][0]),abs(points[i][1]))])\n\n # for i in s:\n # if d.get(i):\n # break\n # tot += 1\n # d[i] = True\n print(d)\n return tot\n ","memory":"62800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], \\n s: str) -> int:\\n\\n mapper = [max(abs(x), abs(y)) for x, y in points]\\n hash_table = defaultdict(list)\\n for i, c in sorted(zip(mapper, s)):\\n hash_table[c].append(i)\\n \\n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\\n return sum(p < dict for p in mapper)\\n\\nwith open('user.out', 'w') as f: \\n iterator = map(loads, stdin)\\n s = Solution()\\n while True:\\n try:\\n print(s.maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\\n except StopIteration:\\n exit()\",\n \"memory\": \"40500\"\n },\n {\n \"code\": \"\\ndef maxPointsInsideSquare(points: List[List[int]], \\n s: str) -> int:\\n\\n mapper = [max(abs(x), abs(y)) for x, y in points]\\n hash_table = defaultdict(list)\\n for i, c in sorted(zip(mapper, s)):\\n hash_table[c].append(i)\\n \\n dict = min((dic[1] for dic in hash_table.values() if len(dic) > 1), default=inf)\\n return sum(p < dict for p in mapper)\\n\\nwith open('user.out', 'w') as f: \\n iterator = map(loads, stdin)\\n while True:\\n try:\\n print(maxPointsInsideSquare(next(iterator), next(iterator)), file=f)\\n except StopIteration:\\n exit()\",\n \"memory\": \"40600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n side = 10**9\\n lim = {}\\n for i in range(len(s)):\\n points[i] = max(abs(points[i][0]), abs(points[i][1]))\\n for i in range(len(s)):\\n cur_lim = points[i]\\n if s[i] not in lim:\\n lim[s[i]] = (1 << 31, 1 << 31)\\n a0, a1 = lim[s[i]]\\n if cur_lim <= a0:\\n lim[s[i]] = (cur_lim, a0)\\n elif cur_lim < a1:\\n lim[s[i]] = (a0, cur_lim)\\n if lim[s[i]][1] == 0:\\n return 0\\n for key, (_, sec) in lim.items():\\n side = min(side, sec - 1)\\n ans = 0\\n for i in points:\\n if i <= side:\\n ans += 1\\n return ans\",\n \"memory\": \"50600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n side = 1 << 31\\n lim = {}\\n for i in range(len(s)):\\n points[i] = max(abs(points[i][0]), abs(points[i][1]))\\n for i in range(len(s)):\\n cur_lim = points[i]\\n s_i = s[i]\\n if s_i not in lim:\\n lim[s_i] = (1 << 31, 1 << 31)\\n a0, a1 = lim[s_i]\\n if cur_lim <= a0:\\n lim[s_i] = (cur_lim, a0)\\n elif cur_lim < a1:\\n lim[s_i] = (a0, cur_lim)\\n if lim[s_i][1] == 0:\\n return 0\\n for key, (_, sec) in lim.items():\\n side = min(side, sec - 1)\\n ans = 0\\n for i in points:\\n if i <= side:\\n ans += 1\\n return ans\",\n \"memory\": \"50800\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n s_list = list(s)\\n counter = 0\\n for [x, y] in points:\\n if x == y and x == 0:\\n counter += 1\\n \\n set_indexes_to_zero = set()\\n\\n for i in range(len(s_list) - 1):\\n if s_list[i] == -1:\\n continue\\n set_same_tags = set()\\n for j in range(i+1, len(s_list)):\\n if s_list[i] == s_list[j]:\\n set_same_tags.add(i)\\n set_same_tags.add(j)\\n if set_same_tags:\\n list_max = [max([abs(x) for x in points[index]]) for index in set_same_tags]\\n list_max_second = sorted(list_max)[1]\\n for index, [x, y] in enumerate(points):\\n if max(abs(x), abs(y)) >= list_max_second:\\n set_indexes_to_zero.add(index)\\n for i in range(len(s_list)):\\n if i in set_same_tags:\\n s_list[i] = -1\\n\\n for index in set_indexes_to_zero:\\n points[index] = [0, 0] \\n\\n x_max_y_max_max = max(max([abs(x) for [x, y] in points]), max([abs(y) for [x, y] in points]))\\n \\n\\n for index, [x, y] in enumerate(points):\\n if max(abs(x), abs(y)) <= x_max_y_max_max and [x, y] != [0,0]:\\n counter += 1 \\n print(\\\"half size: \\\", x_max_y_max_max)\\n return counter\",\n \"memory\": \"55400\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, p: List[List[int]], s: str) -> int:\\n n = len(p)\\n for i in range(n):\\n p[i]= [max(abs(p[i][0]),abs(p[i][1])),s[i]]\\n p.sort()\\n d = {}\\n for i in range(n):\\n try:\\n d[p[i][1]]+=1\\n i-=1\\n while i>=0 and p[i][0] == p[i+1][0]:\\n i-=1 \\n return i+1\\n except:\\n d[p[i][1]] = 1\\n return n\\n\",\n \"memory\": \"58200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n new_arr = []\\n n = len(s)\\n for i in range(n):\\n new_arr.append((points[i][0], points[i][1], s[i]))\\n\\n new_arr.sort(key = lambda x: max(abs(x[0]), abs(x[1])))\\n count = 0\\n my_set = set()\\n curr_length = None\\n curr_run = 0\\n\\n for i in range(n):\\n res = max(abs(new_arr[i][0]), abs(new_arr[i][1]))\\n if new_arr[i][2] in my_set and res == curr_length:\\n return count\\n elif new_arr[i][2] in my_set and res != curr_length:\\n return count + curr_run\\n elif curr_length == res:\\n curr_run += 1\\n else:\\n count += curr_run\\n curr_run = 1\\n curr_length = res\\n my_set.add(new_arr[i][2])\\n\\n return count + curr_run\",\n \"memory\": \"58900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n ans = 0\\n p_dict = defaultdict(list)\\n for t, (x,y) in zip(s, points):\\n r = max(abs(x), abs(y))\\n p_dict[r].append(t)\\n \\n # 2,a 2,a\\n curr = set()\\n for k, tags in sorted(p_dict.items()):\\n # print(f\\\"k: {k} val: {tags}\\\")\\n s_tags = set(tags)\\n if len(s_tags) < len(tags):\\n break\\n if curr.intersection(s_tags):\\n break\\n curr.update(s_tags)\\n ans += len(tags)\\n return ans\\n \",\n \"memory\": \"59000\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n a=[[] for i in range(26)]\\n n=len(s)\\n for i in range(n):\\n rep=max(abs(points[i][0]),abs(points[i][1]))\\n a[ord(s[i])-ord('a')].append(rep)\\n print(a)\\n f=0\\n r=[]\\n k=[]\\n for i in range(26):\\n a[i].sort()\\n if len(a[i])>=2:\\n f=1\\n r.append(a[i][1]-1)\\n elif len(a[i])==1:\\n k.append(a[i][0])\\n if f==0:\\n sz=max(k)\\n else:\\n sz=min(r)\\n ans=0\\n for i in range(26):\\n if len(a[i])>=1:\\n if(a[i][0]<=sz):\\n ans+=1\\n return ans\",\n \"memory\": \"59200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n '''\\n starting from origin expand range of square by 1 \\n continue expanding until length of seen is equal to length of s or points - i.e. all points seen \\n if a point that has not yet been seen is found within the new parameters\\n check to see if the corresponding character is a duplicate in what has already been seen\\n if it is return the length of the seen list \\n otherwise increment the counter and update the map with character from seen = True\\n finally returnr the length of the seen map \\n \\n only really need to check points where max val between x and y == sq_range\\n key will be string variable\\n value will be index \\n update list to only be max of two values \\n\\n '''\\n # convert points into 1d by their abs max x/y distance from center\\n points = [max([abs(ele) for ele in point]) for point in points]\\n counter = 0\\n sq_range = min(points)\\n seen = {}\\n while len(seen.keys()) < len(s):\\n mini_counter = 0\\n indices = [i for i, x in enumerate(points) if x == sq_range]\\n for index in indices:\\n if s[index] in seen:\\n return counter\\n mini_counter+=1\\n seen[s[index]] = True\\n counter += mini_counter\\n\\n # remove used points from points, repalcing with infinity, find the next smalleset point to work with\\n for i in range(len(points)):\\n if points[i] == sq_range:\\n points[i] = float('inf')\\n # points = [point for point in points if point > sq_range]\\n\\n sq_range = min(points)\\n\\n return counter\\n\",\n \"memory\": \"59300\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n point_index_list = points.copy()\\n ind = min([max(abs(p[0]), abs(p[1])) for p in point_index_list])\\n print(ind)\\n last_counter = 0\\n counter_points = 0\\n non_stop = True\\n while (non_stop):\\n points_list =set()\\n s_ind = set()\\n last_counter = counter_points\\n counter_points = 0\\n for i, point in enumerate(points):\\n if abs(point[0]) <= ind and abs(point[1]) <= ind :\\n counter_points += 1\\n points_list.add(i)\\n s_ind.add(s[i])\\n if point in point_index_list and len(point_index_list) > 0:\\n point_index_list.remove(point)\\n if len(s_ind) == len(points_list):\\n if len(point_index_list) == 0:\\n last_counter = counter_points\\n non_stop = False\\n break\\n ind = min([max(abs(p[0]), abs(p[1])) for p in point_index_list])\\n if len(points_list) == len(points):\\n last_counter = counter_points\\n non_stop = False\\n else:\\n non_stop = False\\n return last_counter\",\n \"memory\": \"59600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n numPoints = 0\\n maxLength = 10 ** 9\\n tags = defaultdict(lambda: [10 ** 9 + 1])\\n for point, tag in zip(points, s):\\n tags[tag].append(max(abs(point[0]), abs(point[1])))\\n tags[tag].sort()\\n if len(tags[tag]) > 2: tags[tag].pop()\\n for dist in tags.values(): maxLength = min(maxLength, dist[1] - 1)\\n for dist in tags.values(): numPoints += dist[0] <= maxLength\\n return numPoints\",\n \"memory\": \"59700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n poin = []\\n n = len(points)\\n for i in range(n):\\n pi = points[i]\\n tagi = s[i]\\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\\n poin += [(tagi,edgei)]\\n #print(poin)\\n poin.sort(key = lambda x : x[1])\\n #print(poin)\\n vis = set()\\n edge = 0\\n res = 0\\n for x in poin:\\n if x[0] not in vis:\\n edge = x[1]\\n vis.add(x[0])\\n continue\\n edge = x[1]-1\\n break\\n for x in poin:\\n if x[1] > edge: break\\n res += 1\\n return res\\n\\n \",\n \"memory\": \"59800\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n \\n myHash = defaultdict(list)\\n\\n for i, (x, y) in enumerate(points):\\n\\n myHash[max(abs(x), abs(y))].append(i)\\n\\n vis = set()\\n res = 0\\n\\n for i in sorted(myHash):\\n idxs = myHash[i]\\n\\n for j in idxs:\\n if s[j] in vis:\\n return res\\n \\n vis.add(s[j])\\n\\n res += len(idxs)\\n\\n return res\\n\\n\",\n \"memory\": \"59900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n closest_tag = [[sys.maxsize] * 2 for _ in range(26)]\\n\\n for [px, py], tag in zip(points, s):\\n tag_idx = ord(tag) - 97\\n d = max(abs(px), abs(py))\\n if d <= closest_tag[tag_idx][0]:\\n closest_tag[tag_idx][0], closest_tag[tag_idx][1] = d, closest_tag[tag_idx][0]\\n elif d < closest_tag[tag_idx][1]:\\n closest_tag[tag_idx][1] = d\\n \\n max_d = sys.maxsize\\n for _, d1 in closest_tag:\\n if d1 - 1 < max_d:\\n max_d = d1 - 1\\n return sum(d0 <= max_d for d0, _ in closest_tag)\\n\\n \\n # seen = set()\\n # closest_points = sorted(((max(abs(p[0]), abs(p[1])), s[i]) for i, p in enumerate(points)))\\n # for i, (d, t) in enumerate(closest_points):\\n # if t in seen:\\n # j = i - 1\\n # while j > -1 and closest_points[j][0] == d:\\n # j -= 1\\n # return j + 1\\n # seen.add(t)\\n # return len(points)\\n \\n \",\n \"memory\": \"60000\"\n },\n {\n \"code\": \"class Solution: \\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n minLens = {}\\n secondMin = float('inf')\\n \\n for point, char in zip(points, s):\\n size = max(abs(point[0]), abs(point[1]))\\n\\n if char not in minLens:\\n minLens[char] = size\\n elif size < minLens[char]:\\n secondMin = min(minLens[char], secondMin)\\n minLens[char] = size\\n else:\\n secondMin = min(size, secondMin)\\n \\n count = 0\\n for len in minLens.values():\\n if len < secondMin:\\n count += 1\\n \\n return count\",\n \"memory\": \"60100\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n d = dict()\\n n = len(points)\\n for i in range(n):\\n pi = points[i]\\n tagi = s[i]\\n edgei = max(abs(pi[0]), abs(pi[1])) * 2\\n if tagi in d: d[tagi] += [edgei]\\n else: d[tagi] = [edgei]\\n mn = 9_000_000_000\\n\\n for tag in d:\\n if len(d[tag]) > 1:\\n d[tag].sort()\\n tmp = d[tag][1] -1\\n mn = min(mn,tmp)\\n #print(d)\\n #print(mn)\\n\\n res = 0\\n for tag in d:\\n if min(d[tag]) <= mn: res +=1\\n return res\\n \",\n \"memory\": \"60200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n maxRange = 0\\n tagsDict = defaultdict(list)\\n possibleRange = []\\n # you actually only care about their s, coord\\n for i in range(len(points)):\\n x, y = points[i]\\n maxRange = max(x, y, maxRange)\\n # s : x, y\\n tagsDict[s[i]].append(max(abs(x), abs(y)))\\n possibleRange.append(max(abs(x), abs(y)))\\n\\n for t in tagsDict:\\n tagsDict[t].sort()\\n \\n bestAns = 0\\n possibleRange.sort()\\n \\n for p in possibleRange:\\n # i, i, i, i\\n currAns = 0\\n for t in tagsDict:\\n if len(tagsDict[t]) > 1:\\n if 0 < tagsDict[t][1] <= p:\\n return bestAns\\n if 0 <= tagsDict[t][0] <= p:\\n currAns +=1\\n bestAns = max(currAns, bestAns)\\n\\n return bestAns\",\n \"memory\": \"60300\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n dic = defaultdict(list)\\n keys,seen = set(), set()\\n tot = 0\\n\\n for i, (x,y) in enumerate(points):\\n k = max(abs(x), abs(y))\\n dic[k].append((x,y,i))\\n keys.add(k)\\n \\n keys = list(sorted(keys))\\n for k in keys:\\n temp = 0\\n for x,y,i in dic[k]:\\n if s[i] in seen: return tot\\n seen.add(s[i])\\n temp += 1\\n tot += temp\\n\\n return tot\",\n \"memory\": \"61700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n from collections import defaultdict\\n if len(set(s)) == len(s):\\n return len(points)\\n\\n l, d = [], set()\\n points_per_d = defaultdict(int)\\n for (x, y), tag in zip(points, s):\\n sqr = max(abs(x), abs(y))\\n d.add(sqr)\\n l.append((sqr, tag))\\n points_per_d[sqr] += 1\\n\\n prev = 0\\n points_per_d_cumm = {}\\n for sqr in sorted(d):\\n points_per_d_cumm[sqr] = prev\\n prev += points_per_d[sqr]\\n \\n l.sort(key = lambda x:(x[0], x[1]))\\n seen_tag = set()\\n for d, tag in l:\\n if tag not in seen_tag:\\n seen_tag.add(tag)\\n else:\\n return points_per_d_cumm[d]\\n\",\n \"memory\": \"62700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPointsInsideSquare(self, points: List[List[int]], s: str) -> int:\\n s = list(s)\\n dist = []\\n d = dict()\\n for i in range(len(points)):\\n # dist.append((points[i][0]**2+points[i][1]**2)**0.5)\\n dist.append(max(abs(points[i][0]),abs(points[i][1])))\\n if d.get(max(abs(points[i][0]),abs(points[i][1]))):\\n d[max(abs(points[i][0]),abs(points[i][1]))].append(s[i])\\n else:\\n d[max(abs(points[i][0]),abs(points[i][1]))] = [s[i]]\\n t = sorted(zip(dist, s, points))\\n # print(list(t))\\n # dist = [x for x,_,y in t]\\n # s = [x for _,x,y in t]\\n points = [x for _,y,x in t]\\n print(d)\\n visited = dict()\\n tot = 0\\n i = 0\\n while i < len(s):\\n temp = 0\\n for j in d[max(abs(points[i][0]),abs(points[i][1]))]:\\n if visited.get(j):\\n return tot\\n visited[j] = True\\n temp += 1\\n tot += temp\\n i += len(d[max(abs(points[i][0]),abs(points[i][1]))])\\n\\n # for i in s:\\n # if d.get(i):\\n # break\\n # tot += 1\\n # d[i] = True\\n print(d)\\n return tot\\n \",\n \"memory\": \"62800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":21,"string":"21"}}},{"rowIdx":2437,"cells":{"question_id":{"kind":"number","value":3313,"string":"3,313"},"name":{"kind":"string","value":"maximum-strength-of-k-disjoint-subarrays"},"content":{"kind":"string","value":"<p>You are given an array of integers <code>nums</code> with length <code>n</code>, and a positive <strong>odd</strong> integer <code>k</code>.</p>\n\n<p>Select exactly <b><code>k</code></b> disjoint <span data-keyword=\"subarray-nonempty\">subarrays</span> <b><code>sub<sub>1</sub>, sub<sub>2</sub>, ..., sub<sub>k</sub></code></b> from <code>nums</code> such that the last element of <code>sub<sub>i</sub></code> appears before the first element of <code>sub<sub>{i+1}</sub></code> for all <code>1 <= i <= k-1</code>. The goal is to maximize their combined strength.</p>\n\n<p>The strength of the selected subarrays is defined as:</p>\n\n<p><code>strength = k * sum(sub<sub>1</sub>)- (k - 1) * sum(sub<sub>2</sub>) + (k - 2) * sum(sub<sub>3</sub>) - ... - 2 * sum(sub<sub>{k-1}</sub>) + sum(sub<sub>k</sub>)</code></p>\n\n<p>where <b><code>sum(sub<sub>i</sub>)</code></b> is the sum of the elements in the <code>i</code>-th subarray.</p>\n\n<p>Return the <strong>maximum</strong> possible strength that can be obtained from selecting exactly <b><code>k</code></b> disjoint subarrays from <code>nums</code>.</p>\n\n<p><strong>Note</strong> that the chosen subarrays <strong>don't</strong> need to cover the entire array.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,-1,2], k = 3</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">22</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The best possible way to select 3 subarrays is: nums[0..2], nums[3..3], and nums[4..4]. The strength is calculated as follows:</p>\n\n<p><code>strength = 3 * (1 + 2 + 3) - 2 * (-1) + 2 = 22</code></p>\n\n<p> </p>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [12,-2,-2,-2,-2], k = 5</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">64</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The only possible way to select 5 disjoint subarrays is: nums[0..0], nums[1..1], nums[2..2], nums[3..3], and nums[4..4]. The strength is calculated as follows:</p>\n\n<p><code>strength = 5 * 12 - 4 * (-2) + 3 * (-2) - 2 * (-2) + (-2) = 64</code></p>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [-1,-2,-3], k = </span>1</p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">-1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The best possible way to select 1 subarray is: nums[0..0]. The strength is -1.</p>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 10<sup>4</sup></code></li>\n\t<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>1 <= k <= n</code></li>\n\t<li><code>1 <= n * k <= 10<sup>6</sup></code></li>\n\t<li><code>k</code> is odd.</li>\n</ul>\n"},"acRate":{"kind":"number","value":27.997735092991853,"string":"27.997735"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","dynamic-programming","prefix-sum"],"string":"[\n \"array\",\n \"dynamic-programming\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1504\", 2.0408], [\"1541\", 2.0408], [\"1636\", 2.0408], [\"1670\", 2.0408], [\"1753\", 2.0408], [\"2177\", 2.0408], [\"2178\", 2.0408], [\"2187\", 2.0408], [\"2191\", 2.0408], [\"2202\", 4.0816], [\"2205\", 2.0408], [\"2212\", 2.0408], [\"2270\", 2.0408], [\"2301\", 2.0408], [\"2315\", 2.0408], [\"2587\", 2.0408], [\"2895\", 2.0408], [\"2957\", 2.0408], [\"3297\", 2.0408], [\"3395\", 2.0408], [\"3495\", 2.0408], [\"4125\", 2.0408], [\"4310\", 2.0408], [\"6312\", 2.0408], [\"6425\", 2.0408], [\"6639\", 2.0408], [\"6758\", 2.0408], [\"7042\", 2.0408], [\"7766\", 2.0408], [\"8729\", 2.0408], [\"8825\", 2.0408], [\"8983\", 2.0408], [\"9060\", 2.0408], [\"9184\", 2.0408], [\"9189\", 2.0408], [\"10076\", 2.0408], [\"10105\", 2.0408], [\"12990\", 2.0408], [\"13464\", 2.0408], [\"14520\", 2.0408], [\"14599\", 2.0408], [\"15063\", 2.0408], [\"15076\", 2.0408], [\"15254\", 2.0408], [\"15859\", 2.0408]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17900\", 2.0408], [\"18000\", 6.1224], [\"18100\", 2.0408], [\"18200\", 4.0816], [\"18400\", 2.0408], [\"18800\", 2.0408], [\"63400\", 2.0408], [\"63500\", 6.1224], [\"63600\", 8.1633], [\"63700\", 2.0408], [\"63800\", 4.0816], [\"64400\", 2.0408], [\"64500\", 2.0408], [\"64599\", 2.0408], [\"64700\", 2.0408], [\"69000\", 2.0408], [\"144600\", 2.0408], [\"160200\", 2.0408], [\"167500\", 2.0408], [\"168400\", 2.0408], [\"191500\", 2.0408], [\"191700\", 8.1633], [\"191800\", 2.0408], [\"201800\", 2.0408], [\"202800\", 4.0816], [\"202900\", 2.0408], [\"206900\", 2.0408], [\"207800\", 2.0408], [\"231800\", 2.0408], [\"233300\", 2.0408], [\"233400\", 4.0816], [\"256300\", 2.0408]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n number = -1_000_000_000_000_000\n dp=[[number]*len(nums) for i in range(k)]\n dp[0][0]=nums[0]*k\n for i in range(1,len(nums)):\n dp[0][i]=max(dp[0][i-1]+nums[i]*k,nums[i]*k)\n for i in range(1,k):\n check=k-i if i%2==0 else i-k\n for j in range(i,len(nums)):\n dp[i][j]=nums[j]*check+max(dp[i-1][j-1],dp[i][j-1])\n\n ret=-1000000000000000\n for i in range(len(nums)):\n ret=max(ret,dp[k-1][i])\n\n return ret","runtime":"1504"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n # Initialize a very small number for comparison\n MIN_VALUE = -1_000_000_000_000_000\n # Initialize the dp table with minimum values\n dp = [[MIN_VALUE] * len(nums) for _ in range(k)]\n # Base case: Fill the first row of the dp table\n dp[0][0] = nums[0] * k\n\n # Fill the first row of dp table\n for i in range(1, len(nums)):\n dp[0][i] = max(dp[0][i - 1] + nums[i] * k, nums[i] * k)\n\n # Fill the rest of the dp table\n for i in range(1, k):\n # Determine the multiplier based on the parity of i\n multiplier = k - i if i % 2 == 0 else i - k\n for j in range(i, len(nums)):\n dp[i][j] = nums[j] * multiplier + max(dp[i - 1][j - 1], dp[i][j - 1])\n\n # Find the maximum value in the last row of dp table\n max_strength = MIN_VALUE\n for i in range(len(nums)):\n max_strength = max(max_strength, dp[k - 1][i])\n\n return max_strength","runtime":"1541"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[float('-inf')] * k for _ in range(n)]\n dp[0][0] = nums[0] * k\n for j in range(1, n):\n dp[j][0] = max(nums[j] * k, dp[j - 1][0] + nums[j]*k)\n \n for i in range(1, k):\n x = k - i\n sign = 1 if x % 2 else -1\n for j in range(i, n):\n dp[j][i] = x*sign*nums[j] + max(dp[j - 1][i], dp[j - 1][i - 1])\n \n return max([dp[j][-1] for j in range(n)])","runtime":"1636"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n nums.reverse()\n\n # dp[i][j] is max strength of array nums[0:j+1] with i subarrays and contains last element \n dp = [[-float('inf')] * len(nums) for _ in range(k + 1)]\n\n dp[1][0] = nums[0]\n curr_sum = nums[0]\n for last_index in range(1, len(nums)):\n curr_sum = max(curr_sum + nums[last_index], nums[last_index])\n dp[1][last_index] = max(dp[1][last_index - 1], curr_sum)\n\n for subs in range(2, k + 1):\n sign = 1 if subs % 2 == 1 else -1\n dp[subs][subs - 1] = nums[subs - 1] * subs * sign + dp[subs - 1][subs - 2]\n\n for last_index in range(subs, len(nums)):\n dp[subs][last_index] = nums[last_index] * subs * sign + max(\n dp[subs][last_index - 1],\n dp[subs - 1][last_index - 1]\n )\n \n return max(dp[k])","runtime":"1670"},{"code":"class Solution:\n def maximumStrength(self, nums, k):\n n = len(nums)\n large_negative = -10**12 # Large negative value to initialize dp for impossible states\n \n # Initialize the previous row (base case)\n prev = [0] * (n + 1)\n \n # Iterate over the number of subarrays to select (i subarrays)\n for i in range(k):\n # Determine the multiplier x for the current subarray\n x = (k - i) * (1 if i % 2 == 0 else -1)\n \n # Initialize the current dp row\n dp = [large_negative] * (n + 1)\n \n left = i # Initialize the left pointer for the current subarray\n comp_sum = 0 # Sum of elements in the current subarray from left to right\n \n # Iterate through possible subarray endpoints (right pointers)\n for right in range(i, n):\n # Update the left pointer if it's better to start a new subarray at `right`\n if prev[right] > comp_sum * x + prev[left]:\n left = right\n comp_sum = 0 # Reset sum since we are starting a new subarray\n \n # Add the current element to the subarray sum\n comp_sum += nums[right]\n \n # Update dp[right + 1] to be the maximum of either:\n # 1. The previous state (not taking this subarray),\n # 2. The new subarray ending at `right` starting from `left`\n dp[right + 1] = max(dp[right], comp_sum * x + prev[left])\n \n # Move to the next subarray, so the current dp becomes the new prev row\n prev = dp\n \n # The result will be stored in prev[n], which is the maximum strength for k subarrays\n return prev[n]","runtime":"1753"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n # Kadane DP\n n = len(nums)\n dp = [[0] * (n+1) for _ in range(k+1)]\n for i in range(1, k+1):\n p = k+1-i if i & 1 else i-1-k\n mx, t = float(\"-inf\"), float(\"-inf\")\n for j in range(i-1, n):\n # Kadane\n # t => max sum up to j with j in subarray[i]\n # Each nums[j] is either in subarray[i] (ends with nums[j-1]) \n # or the start of subarray[i]\n t = max(t + nums[j] * p, dp[i-1][j] + nums[j] * p)\n mx = max(mx, t)\n dp[i][j+1] = mx\n return dp[-1][-1]\n # dp(n, k) = max(dp(n-t, k-1) + f(n-t+1, n))\n ''' TLE\n n = len(nums)\n f = [[None] * n for _ in range(n)]\n for i in range(n):\n mx, mn = float(\"-inf\"), float(\"inf\")\n tmx, tmn = 0, 0\n for j in range(i, n):\n tmx = max(tmx + nums[j], nums[j])\n tmn = min(tmn + nums[j], nums[j])\n mx, mn = max(tmx, mx), min(tmn, mn)\n f[i][j] = [mx, mn]\n\n dp = [[float(\"-inf\")] * n for _ in range(k)]\n dp[0] = [x[0] * k for x in f[0]]\n for t in range(1, k):\n ev = -1 if t & 1 else 1\n for j in range(t, n):\n for i in range(j-1, -1, -1):\n p = max(f[i+1][j][0] * ev, f[i+1][j][1] * ev)\n dp[t][j] = max(dp[t][j], dp[t-1][i] + p * (k-t))\n return dp[-1][-1]\n '''","runtime":"2177"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1] ","runtime":"2178"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1] ","runtime":"2187"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1] ","runtime":"2191"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxSum = curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxSum = dp[i][j + 1] = max(maxSum, curr)\n return dp[-1][-1] ","runtime":"2202"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1] ","runtime":"2205"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxSum = curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxSum = dp[i][j + 1] = max(maxSum, curr)\n return dp[-1][-1]","runtime":"2212"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n for k2 in range(1, k+1):\n prev = dp.copy()\n for i in range(n-1,-1,-1):\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\n dp[n-k2+1] = -math.inf\n return max(dp)","runtime":"2270"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n for k2 in range(1, k+1):\n prev = dp.copy()\n for i in range(n-1,-1,-1):\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\n dp[n-k2+1] = -math.inf\n return max(dp)","runtime":"2301"},{"code":"class Solution:\n def maximumStrength(self, A: List[int], k: int) -> int:\n # n = len(A)\n # def get_sign(x):\n # if x%2 == 1:\n # return x\n # return -x\n \n # memo = {}\n\n # def dfs(idx, k, new):\n # if k == 0 and new == 1:\n # return 0\n # if idx == n or n-idx+1<k:\n # return float(\"-inf\")\n # if (idx, k, new) in memo:\n # return memo[(idx, k, new)]\n \n # ans = float(\"-inf\")\n # if new == 1:\n # # start new subarray\n # ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # # start new subarray and end it\n # ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # # skip element\n # ans = max(ans, dfs(idx+1, k, 1))\n # else:\n # # continue subarray to next element\n # ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # # stop subarray on this element\n # ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # # skip element\n # ans = max(ans, dfs(idx+1, k-1, 1))\n \n # memo[(idx, k, new)] = ans\n # return memo[(idx, k, new)]\n \n # return dfs(0, k, 1)\n\n n = len(A)\n dp = [0]*(n+1)\n for k2 in range(1, k+1):\n prev = dp.copy()\n for i in range(n-1,-1,-1):\n dp[i]=A[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\n dp[n-k2+1] = -math.inf\n return max(dp)","runtime":"2315"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n # dp[i][j] is max strength using j subarrays in nums[:i]\n # Add extra value for each dimension for i = 0 and j = 0 cases\n # Set dp[i][0] and dp[0][j] to 0\n dp = [[0] * (k+1)] + [[-float(inf)] * (k+1) for _ in range(n)] \n for i in range(n+1): \n dp[i][0] = 0\n \n max_strength = -float('inf')\n for i in range(1,n+1):\n for j in range(1, min(k,i)+1): # Can have at most k subarrays or i if i < k \n sign = 1 if j & 1 else -1 \n\n v1 = dp[i-1][j] + sign * (k-j+1) * nums[i-1]\n v2 = dp[i-1][j-1] + sign * (k-j+1) * nums[i-1]\n\n dp[i][j] = max(v1,v2)\n\n max_strength = max(max_strength, dp[i][-1]) # Take max across all dp[i][-1] for max strength\n \n return max_strength","runtime":"2587"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n # dp = [[[-float(\"inf\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\n dp = [[-float(\"inf\") for _ in range(2)] for _ in range(k + 1)] \n dp[0][0] = 0\n\n for i in range(n - 1, -1, -1):\n for j in range(k, -1, -1):\n dp[j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[j - 1][0] if j > 0 else -float(\"inf\"), dp[j][1])\n dp[j][0] = max(dp[j][0], dp[j][1])\n\n return dp[k][0]\n ","runtime":"2895"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[-float(\"inf\") for _ in range(2)] for _ in range(k + 1)] \n dp[0][0] = 0\n\n for i in range(n - 1, -1, -1):\n for j in range(k, -1, -1):\n dp[j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[j - 1][0] if j > 0 else -float(\"inf\"), dp[j][1])\n dp[j][0] = max(dp[j][0], dp[j][1])\n\n return dp[k][0]\n ","runtime":"2957"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n INF = 10000000000000000\n\n # Initialize the prefix sum array\n sum_vals = [0] * (n + 1)\n f = [-INF] * (k + 1)\n g = [-INF] * (k + 1)\n g[0] = 0 # Base case\n\n for i in range(1, n + 1):\n f[0] = 0 # Reset f[0] for each i\n sum_vals[i] = sum_vals[i - 1] + nums[i - 1] # Calculate prefix sum\n\n for j in range(1, k + 1):\n t = (1 if j % 2 == 1 else -1) * sum_vals[i] * (k - j + 1)\n\n f[j] = max(f[j], g[j - 1] + t)\n g[j - 1] = max(g[j - 1], f[j - 1] - t)\n\n return f[k]","runtime":"3297"},{"code":"class Solution:\n import math \n from functools import lru_cache\n def maximumStrength(self, nums: List[int], k: int) -> int:\n values=[[-math.inf]*len(nums) for _ in range(k)]\n @lru_cache(maxsize=100000)\n def maxx(a):\n if a==-1:\n return 0\n return maxx(a-1)+nums[a]\n for l in range(k,0,-1):\n for i in range(len(nums)):\n if l==k:\n values[k-l][i]=max(maxx(i-1)+nums[i]*l,nums[i]*l,values[k-l][i-1]+nums[i]*l)\n elif i>=k-l:\n values[k-l][i]=max(values[k-l-1][i-1]+nums[i]*l*(-1)**(l+1),values[k-l][i-1]+nums[i]*l*(-1)**(l+1))\n return max(values[-1])","runtime":"3395"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], K: int) -> int:\n n = len(nums)\n dp = [[-inf]*(K+1) for _ in range(n+1)]\n for i in range(n+1):\n dp[i][0] = 0\n prefs = list(accumulate(nums,initial=0))\n for k in range(1,K+1):\n G = (1 if k%2 else -1)*(K-k+1)\n b = -inf\n for i in range(n):\n if k>i+1:\n dp[i][k] = -inf\n b = max(b,dp[i-1][k-1]-G*prefs[i]) \n dp[i][k] = max(dp[i-1][k],G*prefs[i+1]+b)\n return dp[n-1][K]\n\n\n\n ","runtime":"3495"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[-inf]*2 for _ in range(k+1)]\n dp[0][0] = dp[0][1] = 0\n for i in range(len(nums)-1, -1, -1): \n for j in range(k, 0, -1): \n cand = pow(-1, k-j)*nums[i]*j + max(dp[j][1], dp[j-1][0])\n dp[j][0] = max(cand, dp[j][0])\n dp[j][1] = max(cand, dp[j-1][0])\n return dp[k][0]","runtime":"4125"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int: \n n = len(nums)\n dp = [[0 for _ in range(n + 1)] for _ in range(k + 1)]\n # dp[k][n] n: ptr of nums, k: more division needed\n for i in range(1, k + 1):\n dp[i][-1] = -inf\n for i in range(1, k + 1): # need\n lg = -inf\n for j in range(n - 1, -1, -1): # ptr\n # ans = dp[i][j + 1]\n lg = max(lg + (-1) ** (i + 1) * nums[j] * i, dp[i - 1][j + 1] + (-1) ** (i + 1) * nums[j] * i)\n dp[i][j] = max(lg, dp[i][j + 1])\n # tmp = 0\n # if i == 2:\n # h = 1\n # for x in range(j, n):\n # tmp += nums[x]\n # ans = max(ans, dp[i - 1][x + 1] + (-1) ** (i + 1) * tmp * i)\n # dp[i][j] = ans\n \n return dp[k][0]","runtime":"4310"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[0,0] for j in range(k+1)] for i in range(n+1)]\n for j in range(k+1):\n dp[n][j] = [-float('inf'),-float('inf')]\n dp[n][0] = [0,0]\n for i in range(n-1,-1,-1):\n for j in range(1,k+1):\n gain = nums[i]*int(2*((k-j+1)%2-0.5))*j\n dp[i][j][1] = gain + max(dp[i+1][j-1][0],dp[i+1][j][1])\n dp[i][j][0] = max(dp[i+1][j][0],dp[i][j][1])\n return dp[0][k][0]","runtime":"6312"},{"code":"import math\nclass Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[(-math.inf,math.inf) for i in range(len(nums))] for j in range(k+1)]\n for i in range(len(nums)):\n dp[0][i] = (0,0)\n dp[1][-1] = (nums[-1],nums[-1])\n for i in reversed(range(len(nums)-1)):\n for j in range(1,k+1):\n max_strength_j,min_strength_j = dp[j][i+1]\n max_strength_d,min_strength_d = dp[j-1][i+1]\n max_connect_subarray = j*nums[i] + max_strength_j\n max_disjoint_subarray = j*nums[i] + -min_strength_d\n min_connect_subarray = j*nums[i] + min_strength_j\n min_disjoint_subarray = j*nums[i] + -max_strength_d\n max_strength = max(max_connect_subarray,max_disjoint_subarray)\n min_strength = min(min_connect_subarray,min_disjoint_subarray)\n dp[j][i] = (max_strength,min_strength)\n #print(dp)\n return max(dp[k], key=lambda x:x[0])[0]\n","runtime":"6425"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n nums = [0] + nums\n dp = [[[-inf]*2 for _ in range(k+1)] for _ in range(n+1)]\n for i in range(0, n+1):\n dp[i][0][0] = 0\n for i in range(1, n+1):\n for j in range(1, k+1):\n if j % 2:\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) + nums[i] * (k+1-j)\n else:\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) - nums[i] * (k+1-j) \n # print(i, j, dp[i][j][0], dp[i][j][1])\n return max(dp[n][k][0], dp[n][k][1])\n ","runtime":"6639"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \n @cache\n def calc(take, i, k):\n \n if i == len(nums):\n if take and k == 1:\n return 0\n return -float('inf')\n \n if k == 0:\n return 0\n \n temp = nums[i]*k\n \n if k%2 == 0:\n temp = -temp\n \n if take: \n return max(calc(False, i, k-1), calc(True, i+1, k) + temp)\n \n return max(calc(False, i+1, k), calc(True, i+1, k) + temp)\n\n\n def calc2():\n dp = [[{True: -float('inf'), False:(-float('inf'))} for i in range(k+1)] for j in range(len(nums)+1)]\n \n for i in range(len(nums)+1):\n dp[i][0][True] = 0\n dp[i][0][False] = 0\n \n dp[len(nums)][1][True] = 0\n\n for i in range(len(nums)-1, -1, -1):\n for j in range(1, k+1):\n\n temp = nums[i]*j\n \n if j%2 == 0:\n temp = -temp\n\n dp[i][j][True] = max(dp[i][j-1][False], dp[i+1][j][True] + temp)\n dp[i][j][False] = max(dp[i+1][j][False], dp[i+1][j][True] + temp)\n \n # print(dp)\n \n # print()\n\n return dp[0][k][False]\n\n return calc2()\n\n # return calc(False, 0, k)","runtime":"6758"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[-inf] * 2 for _ in range(k + 1)] for _ in range(2)]\n dp[n & 1][0] = [0, 0]\n for i in range(n - 1, -1, -1):\n for r in range(k + 1):\n for s in range(2):\n if r + s == 0:\n dp[i & 1][r][s] = 0 \n elif not s:\n dp[i & 1][r][s] = max(\n -(-1)**r * r * nums[i] + dp[~i & 1][r - 1][1],\n dp[~i & 1][r][0],\n )\n else:\n dp[i & 1][r][s] = max(\n (-1)**r * (r + 1) * nums[i] + dp[~i & 1][r][1],\n dp[i & 1][r][0],\n )\n return dp[0][k][0]","runtime":"7042"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], kk: int) -> int:\n n=len(nums)\n dp=[[[-sys.maxsize]*2 for _ in range(kk+1)] for _ in range(n+1)]\n dp[n][0][1]=0\n for i in range(n-1,-1,-1):\n for k in range(kk+1):\n for j in range(2):\n #ignore curr index case\n if not j: dp[i][k][j]=max(dp[i+1][k][j],dp[i+1][k][j^1])\n else:\n #max(end curr subarray here,don't end here)\n dp[i][k][j]=max((dp[i+1][k-1][j] if k-1>=0 else -sys.maxsize),dp[i+1][k][j])+(k*(-1 if (kk-k+2)%2 else 1)*nums[i])\n return max(dp[0][kk])\n ","runtime":"7766"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \"\"\"\n Let dp[i][j][k==0/1] denote the maximum strength of choosing j subarrays from the elements nums_i, ... nums_{len(nums) - 1} where k represents if we select the ith element\n dp[i][j][1] = nums[i] * get(j) + max(dp[i + 1][j - 1][0], dp[i + 1][j][1]) where get(j) = j if j is odd, else -j\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\n \"\"\"\n n = len(nums)\n dp = [[[-float(\"inf\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\n dp[n][0][0] = 0\n\n for i in range(n - 1, -1, -1):\n for j in range(0, k + 1):\n dp[i][j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[i + 1][j - 1][0] if j > 0 else float(\"-inf\"), dp[i + 1][j][1])\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\n\n return dp[0][k][0]\n ","runtime":"8729"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])\n","runtime":"8825"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","runtime":"8983"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","runtime":"9060"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","runtime":"9184"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 0\n for i, x in enumerate(nums, 1): \n for j in range(k + 1): \n sign = 1 if j & 1 else -1\n # 如果第i个数不被选\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\n dp[i][j][1] = dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1)\n # 如果第i个数被选，此时如果第i−1个数与第i个数 不在 同一个子数组中\n if j: \n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\n return max(dp[n][k])","runtime":"9189"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n @cache\n def dp(i, k, p):\n if k == 0: return 0\n if i >= n: \n return 0 if k == 1 and p else -inf\n\n sign = 1 if k & 1 else -1\n take = dp(i+1, k, 1) + sign*k*nums[i]\n\n if p & 1:\n dont = dp(i, k-1, 0) \n else:\n dont = dp(i+1, k, 0)\n\n return max(take, dont)\n\n res = dp(0, k, 0)\n dp.cache_clear()\n return res","runtime":"10076"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 0\n for i, x in enumerate(nums, 1): \n for j in range(k + 1): \n sign = 1 if j & 1 else -1\n # 如果第i个数不被选\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\n dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1))\n if j: \n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\n return max(dp[n][k])","runtime":"10105"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \n memo=[[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\n def dp(i, k, empty):\n if len(nums)-i+1<k:\n return -inf\n \n if i==len(nums):\n if k==1 and empty==0:\n return 0\n return -inf\n \n if memo[i][k][empty] != -inf:\n return memo[i][k][empty]\n \n if empty:\n sign = 1 if k%2==1 else -1\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\n include = startNew\n skip = dp(i+1, k, 1)\n else:\n sign=1 if k%2==1 else -1\n include = dp(i+1, k, 0) + sign * nums[i] * k\n \n if k-1==0:\n startNew = 0\n skip = 0\n else:\n sign = 1 if (k-1)%2==1 else -1\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\n skip = dp(i+1, k-1, 1)\n \n memo[i][k][empty] = max(startNew, include, skip)\n \n return memo[i][k][empty]\n \n return dp(0,k,1)","runtime":"12990"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \n memo = [[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\n def dp(i, k, empty):\n if len(nums)-i+1<k:\n return -inf\n \n if i==len(nums):\n if k==1 and empty==0:\n return 0\n return -inf\n \n if memo[i][k][empty] != -inf:\n return memo[i][k][empty]\n \n if empty:\n sign = 1 if k%2==1 else -1\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\n include = startNew\n skip = dp(i+1, k, 1)\n else:\n sign = 1 if k%2==1 else -1\n include = dp(i+1, k, 0) + sign * nums[i] * k\n \n if k-1==0:\n startNew = 0\n skip = 0\n else:\n sign = 1 if (k-1)%2==1 else -1\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\n skip = dp(i+1, k-1, 1)\n \n memo[i][k][empty] = max(startNew, include, skip)\n \n return memo[i][k][empty]\n \n return dp(0,k,1)","runtime":"13464"},{"code":"class Solution:\n def maximumStrength(self, nums, k):\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\n \n def solve(i, k, started, nums):\n if k == 0:\n return 0\n \n if i == len(nums):\n if k == 1 and started:\n return 0\n return -1e15\n \n if dp[i][k][started] != -1e16:\n return dp[i][k][started]\n \n ans = -1e15\n \n if started:\n ans = solve(i, k - 1, False, nums)\n \n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\n \n if not started:\n ans = max(solve(i + 1, k, False, nums), ans)\n \n dp[i][k][started] = ans\n return ans\n \n return solve(0, k, False, nums)","runtime":"14520"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n '''\n * find k disjoint subarrays\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n\n * find the maximum alternating sum of all k disjoint subarray strengths\n ======\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \n\n * so at each index, I can choose to take or skip the current element. \n take: \n but If I take, should I continue or start fresh subarray from the next element? \n skip: \n dont take the current element and just move on.. \n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\n * so there's 3 choices at each index.. pick them maximum among at each state\n * so try them all => correct, but tle!\n =====\n\n\n '''\n\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\n\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\n\n def helper(idx, rem_k, keep_going): \n if rem_k == 0: \n return 0 # formed k subarrays\n if idx >= len(nums): # exhausted\n return minus_inf # base case\n\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\n return table[idx][rem_k][keep_going]\n\n # take: but If I take, should I continue or start fresh subarray from the next element? \n # skip: dont take the current element and just move on.. \n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n take_current = nums[idx] * rem_k * sign\n table[idx][rem_k][keep_going] = max(\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n take_current + helper(idx + 1, rem_k, True), # dont end here\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n )\n return table[idx][rem_k][keep_going]\n \n return helper(0, k, False)\n\n\n\n #### correct but tle:\n # @cache\n # def helper(idx, rem_k, keep_going): \n # if rem_k == 0: \n # return 0 # formed k subarrays\n # if idx >= len(nums): # exhausted\n # return -inf # base case\n\n # # take: but If I take, should I continue or start fresh subarray from the next element? \n # # skip: dont take the current element and just move on.. \n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n # take_current = nums[idx] * rem_k * sign\n # return max(\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n # take_current + helper(idx + 1, rem_k, True), # dont end here\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n # )\n\n # return helper(0, k, False)\n","runtime":"14599"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n '''\n * find k disjoint subarrays\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n\n * find the maximum alternating sum of all k disjoint subarray strengths\n ======\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \n\n * so at each index, I can choose to take or skip the current element. \n take: \n but If I take, should I continue or start fresh subarray from the next element? \n skip: \n dont take the current element and just move on.. \n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\n * so there's 3 choices at each index.. pick them maximum among at each state\n * so try them all => correct, but tle!\n =====\n * manual caching and using some very large number instead of -inf => works! => but more like forcing it to get to work for all the cases...\n * see if there's a better approch => re-solve later!\n\n\n '''\n\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\n\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\n\n def helper(idx, rem_k, keep_going): \n if rem_k == 0: \n return 0 # formed k subarrays\n if idx >= len(nums): # exhausted\n return minus_inf # base case\n\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\n return table[idx][rem_k][keep_going]\n\n # take: but If I take, should I continue or start fresh subarray from the next element? \n # skip: dont take the current element and just move on.. \n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n take_current = nums[idx] * rem_k * sign\n table[idx][rem_k][keep_going] = max(\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n take_current + helper(idx + 1, rem_k, True), # dont end here\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n )\n return table[idx][rem_k][keep_going]\n \n return helper(0, k, False)\n\n\n\n #### correct but tle:\n # @cache\n # def helper(idx, rem_k, keep_going): \n # if rem_k == 0: \n # return 0 # formed k subarrays\n # if idx >= len(nums): # exhausted\n # return -inf # base case\n\n # # take: but If I take, should I continue or start fresh subarray from the next element? \n # # skip: dont take the current element and just move on.. \n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n # take_current = nums[idx] * rem_k * sign\n # return max(\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n # take_current + helper(idx + 1, rem_k, True), # dont end here\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n # )\n\n # return helper(0, k, False)\n","runtime":"15063"},{"code":"# # def recur_func(idx, k, nums, start_new, dp):\n# # if k == 0:\n# # return 0\n\n# # if idx >= len(nums):\n# # return -1*int(1e20)\n \n# # if (idx, k, start_new) in dp:\n# # return dp[(idx, k, start_new)]\n\n# # take = -1*int(1e20)\n# # not_take = -1*int(1e20)\n# # # not_take\n# # if start_new == True:\n# # not_take = recur_func(idx + 1, k, nums, True, dp)\n \n# # # take and create_new\n# # if k%2 == 0:\n# # take = recur_func(idx + 1, k-1, nums, True, dp) - nums[idx]*k\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) - nums[idx]*k)\n# # else:\n# # take = recur_func(idx + 1, k-1, nums, True, dp) + nums[idx]*k\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) + nums[idx]*k)\n\n\n# # dp[(idx, k, start_new)] = max(take, not_take)\n# # return dp[(idx, k, start_new)]\n\n# class Solution:\n# def maximumStrength(self, nums: List[int], k: int) -> int:\n# n = len(nums)\n# dp = [[[-1*int(1e20) for z in range(2)]for subs in range(k + 1)]for i in range(n + 1)]\n \n# for idx in range(n):\n# for subs in range(k+1):\n# take = -1*int(1e20)\n# not_take = -1*int(1e20)\n# for start_new in range(2):\n# # take = -1*int(1e20)\n# # not_take = -1*int(1e20)\n# if start_new == 1:\n# not_take = dp[idx + 1][subs][1]\n \n# if subs%2 == 0:\n# take = dp[idx + 1][subs - 1][1] - nums[idx]*k\n# take = max(take, dp[idx + 1][subs][0] - nums[idx]*k)\n# else:\n# take = dp[idx + 1][subs - 1][1] + nums[idx]*k\n# take = max(take, dp[idx + 1][subs][0] + nums[idx]*k)\n \n# dp[idx][subs][start_new] = max(take, not_take)\n\n# # if dp[0][k][1] == -1\n# return dp[0][k][1]\n\nclass Solution:\n def maximumStrength(self, nums, k):\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\n \n def solve(i, k, started, nums):\n if k == 0:\n return 0\n \n if i == len(nums):\n if k == 1 and started:\n return 0\n return -1e15\n \n if dp[i][k][started] != -1e16:\n return dp[i][k][started]\n \n ans = -1e15\n \n if started:\n ans = solve(i, k - 1, False, nums)\n \n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\n \n if not started:\n ans = max(solve(i + 1, k, False, nums), ans)\n \n dp[i][k][started] = ans\n return ans\n \n return solve(0, k, False, nums)","runtime":"15076"},{"code":"class Solution:\n def maximumStrength(self, A: List[int], k: int) -> int:\n n = len(A)\n def get_sign(x):\n if x%2 == 1:\n return x\n return -x\n\n MIN = 10**9 * n * -1 \n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\n\n def dfs(idx, k, new):\n if k == 0 and new == 1:\n return 0\n if idx == n or n-idx+1<k:\n return -inf\n\n if memo[idx][k][new] != -MIN:\n return memo[idx][k][new]\n \n ans = -inf\n if new == 1:\n # start new subarray\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # start new subarray and end it\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k, 1))\n else:\n # continue subarray to next element\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # stop subarray on this element\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k-1, 1))\n \n memo[idx][k][new] = ans\n return ans\n \n return dfs(0, k, 1)","runtime":"15859"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n number = -1_000_000_000_000_000\\n dp=[[number]*len(nums) for i in range(k)]\\n dp[0][0]=nums[0]*k\\n for i in range(1,len(nums)):\\n dp[0][i]=max(dp[0][i-1]+nums[i]*k,nums[i]*k)\\n for i in range(1,k):\\n check=k-i if i%2==0 else i-k\\n for j in range(i,len(nums)):\\n dp[i][j]=nums[j]*check+max(dp[i-1][j-1],dp[i][j-1])\\n\\n ret=-1000000000000000\\n for i in range(len(nums)):\\n ret=max(ret,dp[k-1][i])\\n\\n return ret\",\n \"runtime\": \"1504\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n # Initialize a very small number for comparison\\n MIN_VALUE = -1_000_000_000_000_000\\n # Initialize the dp table with minimum values\\n dp = [[MIN_VALUE] * len(nums) for _ in range(k)]\\n # Base case: Fill the first row of the dp table\\n dp[0][0] = nums[0] * k\\n\\n # Fill the first row of dp table\\n for i in range(1, len(nums)):\\n dp[0][i] = max(dp[0][i - 1] + nums[i] * k, nums[i] * k)\\n\\n # Fill the rest of the dp table\\n for i in range(1, k):\\n # Determine the multiplier based on the parity of i\\n multiplier = k - i if i % 2 == 0 else i - k\\n for j in range(i, len(nums)):\\n dp[i][j] = nums[j] * multiplier + max(dp[i - 1][j - 1], dp[i][j - 1])\\n\\n # Find the maximum value in the last row of dp table\\n max_strength = MIN_VALUE\\n for i in range(len(nums)):\\n max_strength = max(max_strength, dp[k - 1][i])\\n\\n return max_strength\",\n \"runtime\": \"1541\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[float('-inf')] * k for _ in range(n)]\\n dp[0][0] = nums[0] * k\\n for j in range(1, n):\\n dp[j][0] = max(nums[j] * k, dp[j - 1][0] + nums[j]*k)\\n \\n for i in range(1, k):\\n x = k - i\\n sign = 1 if x % 2 else -1\\n for j in range(i, n):\\n dp[j][i] = x*sign*nums[j] + max(dp[j - 1][i], dp[j - 1][i - 1])\\n \\n return max([dp[j][-1] for j in range(n)])\",\n \"runtime\": \"1636\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n nums.reverse()\\n\\n # dp[i][j] is max strength of array nums[0:j+1] with i subarrays and contains last element \\n dp = [[-float('inf')] * len(nums) for _ in range(k + 1)]\\n\\n dp[1][0] = nums[0]\\n curr_sum = nums[0]\\n for last_index in range(1, len(nums)):\\n curr_sum = max(curr_sum + nums[last_index], nums[last_index])\\n dp[1][last_index] = max(dp[1][last_index - 1], curr_sum)\\n\\n for subs in range(2, k + 1):\\n sign = 1 if subs % 2 == 1 else -1\\n dp[subs][subs - 1] = nums[subs - 1] * subs * sign + dp[subs - 1][subs - 2]\\n\\n for last_index in range(subs, len(nums)):\\n dp[subs][last_index] = nums[last_index] * subs * sign + max(\\n dp[subs][last_index - 1],\\n dp[subs - 1][last_index - 1]\\n )\\n \\n return max(dp[k])\",\n \"runtime\": \"1670\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums, k):\\n n = len(nums)\\n large_negative = -10**12 # Large negative value to initialize dp for impossible states\\n \\n # Initialize the previous row (base case)\\n prev = [0] * (n + 1)\\n \\n # Iterate over the number of subarrays to select (i subarrays)\\n for i in range(k):\\n # Determine the multiplier x for the current subarray\\n x = (k - i) * (1 if i % 2 == 0 else -1)\\n \\n # Initialize the current dp row\\n dp = [large_negative] * (n + 1)\\n \\n left = i # Initialize the left pointer for the current subarray\\n comp_sum = 0 # Sum of elements in the current subarray from left to right\\n \\n # Iterate through possible subarray endpoints (right pointers)\\n for right in range(i, n):\\n # Update the left pointer if it's better to start a new subarray at `right`\\n if prev[right] > comp_sum * x + prev[left]:\\n left = right\\n comp_sum = 0 # Reset sum since we are starting a new subarray\\n \\n # Add the current element to the subarray sum\\n comp_sum += nums[right]\\n \\n # Update dp[right + 1] to be the maximum of either:\\n # 1. The previous state (not taking this subarray),\\n # 2. The new subarray ending at `right` starting from `left`\\n dp[right + 1] = max(dp[right], comp_sum * x + prev[left])\\n \\n # Move to the next subarray, so the current dp becomes the new prev row\\n prev = dp\\n \\n # The result will be stored in prev[n], which is the maximum strength for k subarrays\\n return prev[n]\",\n \"runtime\": \"1753\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n # Kadane DP\\n n = len(nums)\\n dp = [[0] * (n+1) for _ in range(k+1)]\\n for i in range(1, k+1):\\n p = k+1-i if i & 1 else i-1-k\\n mx, t = float(\\\"-inf\\\"), float(\\\"-inf\\\")\\n for j in range(i-1, n):\\n # Kadane\\n # t => max sum up to j with j in subarray[i]\\n # Each nums[j] is either in subarray[i] (ends with nums[j-1]) \\n # or the start of subarray[i]\\n t = max(t + nums[j] * p, dp[i-1][j] + nums[j] * p)\\n mx = max(mx, t)\\n dp[i][j+1] = mx\\n return dp[-1][-1]\\n # dp(n, k) = max(dp(n-t, k-1) + f(n-t+1, n))\\n ''' TLE\\n n = len(nums)\\n f = [[None] * n for _ in range(n)]\\n for i in range(n):\\n mx, mn = float(\\\"-inf\\\"), float(\\\"inf\\\")\\n tmx, tmn = 0, 0\\n for j in range(i, n):\\n tmx = max(tmx + nums[j], nums[j])\\n tmn = min(tmn + nums[j], nums[j])\\n mx, mn = max(tmx, mx), min(tmn, mn)\\n f[i][j] = [mx, mn]\\n\\n dp = [[float(\\\"-inf\\\")] * n for _ in range(k)]\\n dp[0] = [x[0] * k for x in f[0]]\\n for t in range(1, k):\\n ev = -1 if t & 1 else 1\\n for j in range(t, n):\\n for i in range(j-1, -1, -1):\\n p = max(f[i+1][j][0] * ev, f[i+1][j][1] * ev)\\n dp[t][j] = max(dp[t][j], dp[t-1][i] + p * (k-t))\\n return dp[-1][-1]\\n '''\",\n \"runtime\": \"2177\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1] \",\n \"runtime\": \"2178\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1] \",\n \"runtime\": \"2187\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1] \",\n \"runtime\": \"2191\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxSum = curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxSum = dp[i][j + 1] = max(maxSum, curr)\\n return dp[-1][-1] \",\n \"runtime\": \"2202\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1] \",\n \"runtime\": \"2205\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxSum = curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxSum = dp[i][j + 1] = max(maxSum, curr)\\n return dp[-1][-1]\",\n \"runtime\": \"2212\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n for k2 in range(1, k+1):\\n prev = dp.copy()\\n for i in range(n-1,-1,-1):\\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\\n dp[n-k2+1] = -math.inf\\n return max(dp)\",\n \"runtime\": \"2270\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n for k2 in range(1, k+1):\\n prev = dp.copy()\\n for i in range(n-1,-1,-1):\\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\\n dp[n-k2+1] = -math.inf\\n return max(dp)\",\n \"runtime\": \"2301\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, A: List[int], k: int) -> int:\\n # n = len(A)\\n # def get_sign(x):\\n # if x%2 == 1:\\n # return x\\n # return -x\\n \\n # memo = {}\\n\\n # def dfs(idx, k, new):\\n # if k == 0 and new == 1:\\n # return 0\\n # if idx == n or n-idx+1<k:\\n # return float(\\\"-inf\\\")\\n # if (idx, k, new) in memo:\\n # return memo[(idx, k, new)]\\n \\n # ans = float(\\\"-inf\\\")\\n # if new == 1:\\n # # start new subarray\\n # ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # # start new subarray and end it\\n # ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # # skip element\\n # ans = max(ans, dfs(idx+1, k, 1))\\n # else:\\n # # continue subarray to next element\\n # ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # # stop subarray on this element\\n # ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # # skip element\\n # ans = max(ans, dfs(idx+1, k-1, 1))\\n \\n # memo[(idx, k, new)] = ans\\n # return memo[(idx, k, new)]\\n \\n # return dfs(0, k, 1)\\n\\n n = len(A)\\n dp = [0]*(n+1)\\n for k2 in range(1, k+1):\\n prev = dp.copy()\\n for i in range(n-1,-1,-1):\\n dp[i]=A[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\\n dp[n-k2+1] = -math.inf\\n return max(dp)\",\n \"runtime\": \"2315\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n # dp[i][j] is max strength using j subarrays in nums[:i]\\n # Add extra value for each dimension for i = 0 and j = 0 cases\\n # Set dp[i][0] and dp[0][j] to 0\\n dp = [[0] * (k+1)] + [[-float(inf)] * (k+1) for _ in range(n)] \\n for i in range(n+1): \\n dp[i][0] = 0\\n \\n max_strength = -float('inf')\\n for i in range(1,n+1):\\n for j in range(1, min(k,i)+1): # Can have at most k subarrays or i if i < k \\n sign = 1 if j & 1 else -1 \\n\\n v1 = dp[i-1][j] + sign * (k-j+1) * nums[i-1]\\n v2 = dp[i-1][j-1] + sign * (k-j+1) * nums[i-1]\\n\\n dp[i][j] = max(v1,v2)\\n\\n max_strength = max(max_strength, dp[i][-1]) # Take max across all dp[i][-1] for max strength\\n \\n return max_strength\",\n \"runtime\": \"2587\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n # dp = [[[-float(\\\"inf\\\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp = [[-float(\\\"inf\\\") for _ in range(2)] for _ in range(k + 1)] \\n dp[0][0] = 0\\n\\n for i in range(n - 1, -1, -1):\\n for j in range(k, -1, -1):\\n dp[j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[j - 1][0] if j > 0 else -float(\\\"inf\\\"), dp[j][1])\\n dp[j][0] = max(dp[j][0], dp[j][1])\\n\\n return dp[k][0]\\n \",\n \"runtime\": \"2895\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[-float(\\\"inf\\\") for _ in range(2)] for _ in range(k + 1)] \\n dp[0][0] = 0\\n\\n for i in range(n - 1, -1, -1):\\n for j in range(k, -1, -1):\\n dp[j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[j - 1][0] if j > 0 else -float(\\\"inf\\\"), dp[j][1])\\n dp[j][0] = max(dp[j][0], dp[j][1])\\n\\n return dp[k][0]\\n \",\n \"runtime\": \"2957\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n INF = 10000000000000000\\n\\n # Initialize the prefix sum array\\n sum_vals = [0] * (n + 1)\\n f = [-INF] * (k + 1)\\n g = [-INF] * (k + 1)\\n g[0] = 0 # Base case\\n\\n for i in range(1, n + 1):\\n f[0] = 0 # Reset f[0] for each i\\n sum_vals[i] = sum_vals[i - 1] + nums[i - 1] # Calculate prefix sum\\n\\n for j in range(1, k + 1):\\n t = (1 if j % 2 == 1 else -1) * sum_vals[i] * (k - j + 1)\\n\\n f[j] = max(f[j], g[j - 1] + t)\\n g[j - 1] = max(g[j - 1], f[j - 1] - t)\\n\\n return f[k]\",\n \"runtime\": \"3297\"\n },\n {\n \"code\": \"class Solution:\\n import math \\n from functools import lru_cache\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n values=[[-math.inf]*len(nums) for _ in range(k)]\\n @lru_cache(maxsize=100000)\\n def maxx(a):\\n if a==-1:\\n return 0\\n return maxx(a-1)+nums[a]\\n for l in range(k,0,-1):\\n for i in range(len(nums)):\\n if l==k:\\n values[k-l][i]=max(maxx(i-1)+nums[i]*l,nums[i]*l,values[k-l][i-1]+nums[i]*l)\\n elif i>=k-l:\\n values[k-l][i]=max(values[k-l-1][i-1]+nums[i]*l*(-1)**(l+1),values[k-l][i-1]+nums[i]*l*(-1)**(l+1))\\n return max(values[-1])\",\n \"runtime\": \"3395\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], K: int) -> int:\\n n = len(nums)\\n dp = [[-inf]*(K+1) for _ in range(n+1)]\\n for i in range(n+1):\\n dp[i][0] = 0\\n prefs = list(accumulate(nums,initial=0))\\n for k in range(1,K+1):\\n G = (1 if k%2 else -1)*(K-k+1)\\n b = -inf\\n for i in range(n):\\n if k>i+1:\\n dp[i][k] = -inf\\n b = max(b,dp[i-1][k-1]-G*prefs[i]) \\n dp[i][k] = max(dp[i-1][k],G*prefs[i+1]+b)\\n return dp[n-1][K]\\n\\n\\n\\n \",\n \"runtime\": \"3495\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[-inf]*2 for _ in range(k+1)]\\n dp[0][0] = dp[0][1] = 0\\n for i in range(len(nums)-1, -1, -1): \\n for j in range(k, 0, -1): \\n cand = pow(-1, k-j)*nums[i]*j + max(dp[j][1], dp[j-1][0])\\n dp[j][0] = max(cand, dp[j][0])\\n dp[j][1] = max(cand, dp[j-1][0])\\n return dp[k][0]\",\n \"runtime\": \"4125\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int: \\n n = len(nums)\\n dp = [[0 for _ in range(n + 1)] for _ in range(k + 1)]\\n # dp[k][n] n: ptr of nums, k: more division needed\\n for i in range(1, k + 1):\\n dp[i][-1] = -inf\\n for i in range(1, k + 1): # need\\n lg = -inf\\n for j in range(n - 1, -1, -1): # ptr\\n # ans = dp[i][j + 1]\\n lg = max(lg + (-1) ** (i + 1) * nums[j] * i, dp[i - 1][j + 1] + (-1) ** (i + 1) * nums[j] * i)\\n dp[i][j] = max(lg, dp[i][j + 1])\\n # tmp = 0\\n # if i == 2:\\n # h = 1\\n # for x in range(j, n):\\n # tmp += nums[x]\\n # ans = max(ans, dp[i - 1][x + 1] + (-1) ** (i + 1) * tmp * i)\\n # dp[i][j] = ans\\n \\n return dp[k][0]\",\n \"runtime\": \"4310\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[0,0] for j in range(k+1)] for i in range(n+1)]\\n for j in range(k+1):\\n dp[n][j] = [-float('inf'),-float('inf')]\\n dp[n][0] = [0,0]\\n for i in range(n-1,-1,-1):\\n for j in range(1,k+1):\\n gain = nums[i]*int(2*((k-j+1)%2-0.5))*j\\n dp[i][j][1] = gain + max(dp[i+1][j-1][0],dp[i+1][j][1])\\n dp[i][j][0] = max(dp[i+1][j][0],dp[i][j][1])\\n return dp[0][k][0]\",\n \"runtime\": \"6312\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[(-math.inf,math.inf) for i in range(len(nums))] for j in range(k+1)]\\n for i in range(len(nums)):\\n dp[0][i] = (0,0)\\n dp[1][-1] = (nums[-1],nums[-1])\\n for i in reversed(range(len(nums)-1)):\\n for j in range(1,k+1):\\n max_strength_j,min_strength_j = dp[j][i+1]\\n max_strength_d,min_strength_d = dp[j-1][i+1]\\n max_connect_subarray = j*nums[i] + max_strength_j\\n max_disjoint_subarray = j*nums[i] + -min_strength_d\\n min_connect_subarray = j*nums[i] + min_strength_j\\n min_disjoint_subarray = j*nums[i] + -max_strength_d\\n max_strength = max(max_connect_subarray,max_disjoint_subarray)\\n min_strength = min(min_connect_subarray,min_disjoint_subarray)\\n dp[j][i] = (max_strength,min_strength)\\n #print(dp)\\n return max(dp[k], key=lambda x:x[0])[0]\\n\",\n \"runtime\": \"6425\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n nums = [0] + nums\\n dp = [[[-inf]*2 for _ in range(k+1)] for _ in range(n+1)]\\n for i in range(0, n+1):\\n dp[i][0][0] = 0\\n for i in range(1, n+1):\\n for j in range(1, k+1):\\n if j % 2:\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) + nums[i] * (k+1-j)\\n else:\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) - nums[i] * (k+1-j) \\n # print(i, j, dp[i][j][0], dp[i][j][1])\\n return max(dp[n][k][0], dp[n][k][1])\\n \",\n \"runtime\": \"6639\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\n @cache\\n def calc(take, i, k):\\n \\n if i == len(nums):\\n if take and k == 1:\\n return 0\\n return -float('inf')\\n \\n if k == 0:\\n return 0\\n \\n temp = nums[i]*k\\n \\n if k%2 == 0:\\n temp = -temp\\n \\n if take: \\n return max(calc(False, i, k-1), calc(True, i+1, k) + temp)\\n \\n return max(calc(False, i+1, k), calc(True, i+1, k) + temp)\\n\\n\\n def calc2():\\n dp = [[{True: -float('inf'), False:(-float('inf'))} for i in range(k+1)] for j in range(len(nums)+1)]\\n \\n for i in range(len(nums)+1):\\n dp[i][0][True] = 0\\n dp[i][0][False] = 0\\n \\n dp[len(nums)][1][True] = 0\\n\\n for i in range(len(nums)-1, -1, -1):\\n for j in range(1, k+1):\\n\\n temp = nums[i]*j\\n \\n if j%2 == 0:\\n temp = -temp\\n\\n dp[i][j][True] = max(dp[i][j-1][False], dp[i+1][j][True] + temp)\\n dp[i][j][False] = max(dp[i+1][j][False], dp[i+1][j][True] + temp)\\n \\n # print(dp)\\n \\n # print()\\n\\n return dp[0][k][False]\\n\\n return calc2()\\n\\n # return calc(False, 0, k)\",\n \"runtime\": \"6758\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[-inf] * 2 for _ in range(k + 1)] for _ in range(2)]\\n dp[n & 1][0] = [0, 0]\\n for i in range(n - 1, -1, -1):\\n for r in range(k + 1):\\n for s in range(2):\\n if r + s == 0:\\n dp[i & 1][r][s] = 0 \\n elif not s:\\n dp[i & 1][r][s] = max(\\n -(-1)**r * r * nums[i] + dp[~i & 1][r - 1][1],\\n dp[~i & 1][r][0],\\n )\\n else:\\n dp[i & 1][r][s] = max(\\n (-1)**r * (r + 1) * nums[i] + dp[~i & 1][r][1],\\n dp[i & 1][r][0],\\n )\\n return dp[0][k][0]\",\n \"runtime\": \"7042\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], kk: int) -> int:\\n n=len(nums)\\n dp=[[[-sys.maxsize]*2 for _ in range(kk+1)] for _ in range(n+1)]\\n dp[n][0][1]=0\\n for i in range(n-1,-1,-1):\\n for k in range(kk+1):\\n for j in range(2):\\n #ignore curr index case\\n if not j: dp[i][k][j]=max(dp[i+1][k][j],dp[i+1][k][j^1])\\n else:\\n #max(end curr subarray here,don't end here)\\n dp[i][k][j]=max((dp[i+1][k-1][j] if k-1>=0 else -sys.maxsize),dp[i+1][k][j])+(k*(-1 if (kk-k+2)%2 else 1)*nums[i])\\n return max(dp[0][kk])\\n \",\n \"runtime\": \"7766\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n Let dp[i][j][k==0/1] denote the maximum strength of choosing j subarrays from the elements nums_i, ... nums_{len(nums) - 1} where k represents if we select the ith element\\n dp[i][j][1] = nums[i] * get(j) + max(dp[i + 1][j - 1][0], dp[i + 1][j][1]) where get(j) = j if j is odd, else -j\\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\\n \\\"\\\"\\\"\\n n = len(nums)\\n dp = [[[-float(\\\"inf\\\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp[n][0][0] = 0\\n\\n for i in range(n - 1, -1, -1):\\n for j in range(0, k + 1):\\n dp[i][j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[i + 1][j - 1][0] if j > 0 else float(\\\"-inf\\\"), dp[i + 1][j][1])\\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\\n\\n return dp[0][k][0]\\n \",\n \"runtime\": \"8729\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\\n\",\n \"runtime\": \"8825\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"runtime\": \"8983\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"runtime\": \"9060\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"runtime\": \"9184\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp[0][0][0] = 0\\n for i, x in enumerate(nums, 1): \\n for j in range(k + 1): \\n sign = 1 if j & 1 else -1\\n # 如果第i个数不被选\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\\n dp[i][j][1] = dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1)\\n # 如果第i个数被选，此时如果第i−1个数与第i个数 不在 同一个子数组中\\n if j: \\n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\\n return max(dp[n][k])\",\n \"runtime\": \"9189\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n @cache\\n def dp(i, k, p):\\n if k == 0: return 0\\n if i >= n: \\n return 0 if k == 1 and p else -inf\\n\\n sign = 1 if k & 1 else -1\\n take = dp(i+1, k, 1) + sign*k*nums[i]\\n\\n if p & 1:\\n dont = dp(i, k-1, 0) \\n else:\\n dont = dp(i+1, k, 0)\\n\\n return max(take, dont)\\n\\n res = dp(0, k, 0)\\n dp.cache_clear()\\n return res\",\n \"runtime\": \"10076\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp[0][0][0] = 0\\n for i, x in enumerate(nums, 1): \\n for j in range(k + 1): \\n sign = 1 if j & 1 else -1\\n # 如果第i个数不被选\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\\n dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1))\\n if j: \\n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\\n return max(dp[n][k])\",\n \"runtime\": \"10105\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\n memo=[[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\\n def dp(i, k, empty):\\n if len(nums)-i+1<k:\\n return -inf\\n \\n if i==len(nums):\\n if k==1 and empty==0:\\n return 0\\n return -inf\\n \\n if memo[i][k][empty] != -inf:\\n return memo[i][k][empty]\\n \\n if empty:\\n sign = 1 if k%2==1 else -1\\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\\n include = startNew\\n skip = dp(i+1, k, 1)\\n else:\\n sign=1 if k%2==1 else -1\\n include = dp(i+1, k, 0) + sign * nums[i] * k\\n \\n if k-1==0:\\n startNew = 0\\n skip = 0\\n else:\\n sign = 1 if (k-1)%2==1 else -1\\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\\n skip = dp(i+1, k-1, 1)\\n \\n memo[i][k][empty] = max(startNew, include, skip)\\n \\n return memo[i][k][empty]\\n \\n return dp(0,k,1)\",\n \"runtime\": \"12990\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\n memo = [[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\\n def dp(i, k, empty):\\n if len(nums)-i+1<k:\\n return -inf\\n \\n if i==len(nums):\\n if k==1 and empty==0:\\n return 0\\n return -inf\\n \\n if memo[i][k][empty] != -inf:\\n return memo[i][k][empty]\\n \\n if empty:\\n sign = 1 if k%2==1 else -1\\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\\n include = startNew\\n skip = dp(i+1, k, 1)\\n else:\\n sign = 1 if k%2==1 else -1\\n include = dp(i+1, k, 0) + sign * nums[i] * k\\n \\n if k-1==0:\\n startNew = 0\\n skip = 0\\n else:\\n sign = 1 if (k-1)%2==1 else -1\\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\\n skip = dp(i+1, k-1, 1)\\n \\n memo[i][k][empty] = max(startNew, include, skip)\\n \\n return memo[i][k][empty]\\n \\n return dp(0,k,1)\",\n \"runtime\": \"13464\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums, k):\\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\\n \\n def solve(i, k, started, nums):\\n if k == 0:\\n return 0\\n \\n if i == len(nums):\\n if k == 1 and started:\\n return 0\\n return -1e15\\n \\n if dp[i][k][started] != -1e16:\\n return dp[i][k][started]\\n \\n ans = -1e15\\n \\n if started:\\n ans = solve(i, k - 1, False, nums)\\n \\n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\\n \\n if not started:\\n ans = max(solve(i + 1, k, False, nums), ans)\\n \\n dp[i][k][started] = ans\\n return ans\\n \\n return solve(0, k, False, nums)\",\n \"runtime\": \"14520\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n '''\\n * find k disjoint subarrays\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n\\n * find the maximum alternating sum of all k disjoint subarray strengths\\n ======\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \\n\\n * so at each index, I can choose to take or skip the current element. \\n take: \\n but If I take, should I continue or start fresh subarray from the next element? \\n skip: \\n dont take the current element and just move on.. \\n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\\n * so there's 3 choices at each index.. pick them maximum among at each state\\n * so try them all => correct, but tle!\\n =====\\n\\n\\n '''\\n\\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\\n\\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\\n\\n def helper(idx, rem_k, keep_going): \\n if rem_k == 0: \\n return 0 # formed k subarrays\\n if idx >= len(nums): # exhausted\\n return minus_inf # base case\\n\\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\\n return table[idx][rem_k][keep_going]\\n\\n # take: but If I take, should I continue or start fresh subarray from the next element? \\n # skip: dont take the current element and just move on.. \\n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n take_current = nums[idx] * rem_k * sign\\n table[idx][rem_k][keep_going] = max(\\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n take_current + helper(idx + 1, rem_k, True), # dont end here\\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n )\\n return table[idx][rem_k][keep_going]\\n \\n return helper(0, k, False)\\n\\n\\n\\n #### correct but tle:\\n # @cache\\n # def helper(idx, rem_k, keep_going): \\n # if rem_k == 0: \\n # return 0 # formed k subarrays\\n # if idx >= len(nums): # exhausted\\n # return -inf # base case\\n\\n # # take: but If I take, should I continue or start fresh subarray from the next element? \\n # # skip: dont take the current element and just move on.. \\n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n # take_current = nums[idx] * rem_k * sign\\n # return max(\\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n # take_current + helper(idx + 1, rem_k, True), # dont end here\\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n # )\\n\\n # return helper(0, k, False)\\n\",\n \"runtime\": \"14599\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n '''\\n * find k disjoint subarrays\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n\\n * find the maximum alternating sum of all k disjoint subarray strengths\\n ======\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \\n\\n * so at each index, I can choose to take or skip the current element. \\n take: \\n but If I take, should I continue or start fresh subarray from the next element? \\n skip: \\n dont take the current element and just move on.. \\n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\\n * so there's 3 choices at each index.. pick them maximum among at each state\\n * so try them all => correct, but tle!\\n =====\\n * manual caching and using some very large number instead of -inf => works! => but more like forcing it to get to work for all the cases...\\n * see if there's a better approch => re-solve later!\\n\\n\\n '''\\n\\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\\n\\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\\n\\n def helper(idx, rem_k, keep_going): \\n if rem_k == 0: \\n return 0 # formed k subarrays\\n if idx >= len(nums): # exhausted\\n return minus_inf # base case\\n\\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\\n return table[idx][rem_k][keep_going]\\n\\n # take: but If I take, should I continue or start fresh subarray from the next element? \\n # skip: dont take the current element and just move on.. \\n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n take_current = nums[idx] * rem_k * sign\\n table[idx][rem_k][keep_going] = max(\\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n take_current + helper(idx + 1, rem_k, True), # dont end here\\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n )\\n return table[idx][rem_k][keep_going]\\n \\n return helper(0, k, False)\\n\\n\\n\\n #### correct but tle:\\n # @cache\\n # def helper(idx, rem_k, keep_going): \\n # if rem_k == 0: \\n # return 0 # formed k subarrays\\n # if idx >= len(nums): # exhausted\\n # return -inf # base case\\n\\n # # take: but If I take, should I continue or start fresh subarray from the next element? \\n # # skip: dont take the current element and just move on.. \\n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n # take_current = nums[idx] * rem_k * sign\\n # return max(\\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n # take_current + helper(idx + 1, rem_k, True), # dont end here\\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n # )\\n\\n # return helper(0, k, False)\\n\",\n \"runtime\": \"15063\"\n },\n {\n \"code\": \"# # def recur_func(idx, k, nums, start_new, dp):\\n# # if k == 0:\\n# # return 0\\n\\n# # if idx >= len(nums):\\n# # return -1*int(1e20)\\n \\n# # if (idx, k, start_new) in dp:\\n# # return dp[(idx, k, start_new)]\\n\\n# # take = -1*int(1e20)\\n# # not_take = -1*int(1e20)\\n# # # not_take\\n# # if start_new == True:\\n# # not_take = recur_func(idx + 1, k, nums, True, dp)\\n \\n# # # take and create_new\\n# # if k%2 == 0:\\n# # take = recur_func(idx + 1, k-1, nums, True, dp) - nums[idx]*k\\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) - nums[idx]*k)\\n# # else:\\n# # take = recur_func(idx + 1, k-1, nums, True, dp) + nums[idx]*k\\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) + nums[idx]*k)\\n\\n\\n# # dp[(idx, k, start_new)] = max(take, not_take)\\n# # return dp[(idx, k, start_new)]\\n\\n# class Solution:\\n# def maximumStrength(self, nums: List[int], k: int) -> int:\\n# n = len(nums)\\n# dp = [[[-1*int(1e20) for z in range(2)]for subs in range(k + 1)]for i in range(n + 1)]\\n \\n# for idx in range(n):\\n# for subs in range(k+1):\\n# take = -1*int(1e20)\\n# not_take = -1*int(1e20)\\n# for start_new in range(2):\\n# # take = -1*int(1e20)\\n# # not_take = -1*int(1e20)\\n# if start_new == 1:\\n# not_take = dp[idx + 1][subs][1]\\n \\n# if subs%2 == 0:\\n# take = dp[idx + 1][subs - 1][1] - nums[idx]*k\\n# take = max(take, dp[idx + 1][subs][0] - nums[idx]*k)\\n# else:\\n# take = dp[idx + 1][subs - 1][1] + nums[idx]*k\\n# take = max(take, dp[idx + 1][subs][0] + nums[idx]*k)\\n \\n# dp[idx][subs][start_new] = max(take, not_take)\\n\\n# # if dp[0][k][1] == -1\\n# return dp[0][k][1]\\n\\nclass Solution:\\n def maximumStrength(self, nums, k):\\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\\n \\n def solve(i, k, started, nums):\\n if k == 0:\\n return 0\\n \\n if i == len(nums):\\n if k == 1 and started:\\n return 0\\n return -1e15\\n \\n if dp[i][k][started] != -1e16:\\n return dp[i][k][started]\\n \\n ans = -1e15\\n \\n if started:\\n ans = solve(i, k - 1, False, nums)\\n \\n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\\n \\n if not started:\\n ans = max(solve(i + 1, k, False, nums), ans)\\n \\n dp[i][k][started] = ans\\n return ans\\n \\n return solve(0, k, False, nums)\",\n \"runtime\": \"15076\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, A: List[int], k: int) -> int:\\n n = len(A)\\n def get_sign(x):\\n if x%2 == 1:\\n return x\\n return -x\\n\\n MIN = 10**9 * n * -1 \\n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\\n\\n def dfs(idx, k, new):\\n if k == 0 and new == 1:\\n return 0\\n if idx == n or n-idx+1<k:\\n return -inf\\n\\n if memo[idx][k][new] != -MIN:\\n return memo[idx][k][new]\\n \\n ans = -inf\\n if new == 1:\\n # start new subarray\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # start new subarray and end it\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k, 1))\\n else:\\n # continue subarray to next element\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # stop subarray on this element\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k-1, 1))\\n \\n memo[idx][k][new] = ans\\n return ans\\n \\n return dfs(0, k, 1)\",\n \"runtime\": \"15859\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":44,"string":"44"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[-inf]*2 for _ in range(k+1)]\n dp[0][0] = dp[0][1] = 0\n for i in range(len(nums)-1, -1, -1): \n for j in range(k, 0, -1): \n cand = pow(-1, k-j)*nums[i]*j + max(dp[j][1], dp[j-1][0])\n dp[j][0] = max(cand, dp[j][0])\n dp[j][1] = max(cand, dp[j-1][0])\n return dp[k][0]","memory":"17900"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n INF = 10000000000000000\n\n # Initialize the prefix sum array\n sum_vals = [0] * (n + 1)\n f = [-INF] * (k + 1)\n g = [-INF] * (k + 1)\n g[0] = 0 # Base case\n\n for i in range(1, n + 1):\n f[0] = 0 # Reset f[0] for each i\n sum_vals[i] = sum_vals[i - 1] + nums[i - 1] # Calculate prefix sum\n\n for j in range(1, k + 1):\n t = (1 if j % 2 == 1 else -1) * sum_vals[i] * (k - j + 1)\n\n f[j] = max(f[j], g[j - 1] + t)\n g[j - 1] = max(g[j - 1], f[j - 1] - t)\n\n return f[k]","memory":"18000"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[-inf] * 2 for _ in range(k + 1)] for _ in range(2)]\n dp[n & 1][0] = [0, 0]\n for i in range(n - 1, -1, -1):\n for r in range(k + 1):\n for s in range(2):\n if r + s == 0:\n dp[i & 1][r][s] = 0 \n elif not s:\n dp[i & 1][r][s] = max(\n -(-1)**r * r * nums[i] + dp[~i & 1][r - 1][1],\n dp[~i & 1][r][0],\n )\n else:\n dp[i & 1][r][s] = max(\n (-1)**r * (r + 1) * nums[i] + dp[~i & 1][r][1],\n dp[i & 1][r][0],\n )\n return dp[0][k][0]","memory":"18100"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n for k2 in range(1, k+1):\n prev = dp.copy()\n for i in range(n-1,-1,-1):\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\n dp[n-k2+1] = -math.inf\n return max(dp)","memory":"18200"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n for k2 in range(1, k+1):\n prev = dp.copy()\n for i in range(n-1,-1,-1):\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\n dp[n-k2+1] = -math.inf\n return max(dp)","memory":"18400"},{"code":"class Solution:\n def maximumStrength(self, nums, k):\n n = len(nums)\n large_negative = -10**12 # Large negative value to initialize dp for impossible states\n \n # Initialize the previous row (base case)\n prev = [0] * (n + 1)\n \n # Iterate over the number of subarrays to select (i subarrays)\n for i in range(k):\n # Determine the multiplier x for the current subarray\n x = (k - i) * (1 if i % 2 == 0 else -1)\n \n # Initialize the current dp row\n dp = [large_negative] * (n + 1)\n \n left = i # Initialize the left pointer for the current subarray\n comp_sum = 0 # Sum of elements in the current subarray from left to right\n \n # Iterate through possible subarray endpoints (right pointers)\n for right in range(i, n):\n # Update the left pointer if it's better to start a new subarray at `right`\n if prev[right] > comp_sum * x + prev[left]:\n left = right\n comp_sum = 0 # Reset sum since we are starting a new subarray\n \n # Add the current element to the subarray sum\n comp_sum += nums[right]\n \n # Update dp[right + 1] to be the maximum of either:\n # 1. The previous state (not taking this subarray),\n # 2. The new subarray ending at `right` starting from `left`\n dp[right + 1] = max(dp[right], comp_sum * x + prev[left])\n \n # Move to the next subarray, so the current dp becomes the new prev row\n prev = dp\n \n # The result will be stored in prev[n], which is the maximum strength for k subarrays\n return prev[n]","memory":"18800"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1] ","memory":"63400"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n nums.reverse()\n\n # dp[i][j] is max strength of array nums[0:j+1] with i subarrays and contains last element \n dp = [[-float('inf')] * len(nums) for _ in range(k + 1)]\n\n dp[1][0] = nums[0]\n curr_sum = nums[0]\n for last_index in range(1, len(nums)):\n curr_sum = max(curr_sum + nums[last_index], nums[last_index])\n dp[1][last_index] = max(dp[1][last_index - 1], curr_sum)\n\n for subs in range(2, k + 1):\n sign = 1 if subs % 2 == 1 else -1\n dp[subs][subs - 1] = nums[subs - 1] * subs * sign + dp[subs - 1][subs - 2]\n\n for last_index in range(subs, len(nums)):\n dp[subs][last_index] = nums[last_index] * subs * sign + max(\n dp[subs][last_index - 1],\n dp[subs - 1][last_index - 1]\n )\n \n return max(dp[k])","memory":"63500"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxSum = curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxSum = dp[i][j + 1] = max(maxSum, curr)\n return dp[-1][-1]","memory":"63500"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxSum = curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxSum = dp[i][j + 1] = max(maxSum, curr)\n return dp[-1][-1] ","memory":"63600"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\n for i in range(1, k + 1):\n maxsum = -float('inf')\n curr = -float('inf')\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\n for j in range(i - 1, len(nums)):\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\n maxsum = max(maxsum, curr)\n dp[i][j + 1] = maxsum\n return dp[-1][-1]","memory":"63700"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n # Initialize a very small number for comparison\n MIN_VALUE = -1_000_000_000_000_000\n # Initialize the dp table with minimum values\n dp = [[MIN_VALUE] * len(nums) for _ in range(k)]\n # Base case: Fill the first row of the dp table\n dp[0][0] = nums[0] * k\n\n # Fill the first row of dp table\n for i in range(1, len(nums)):\n dp[0][i] = max(dp[0][i - 1] + nums[i] * k, nums[i] * k)\n\n # Fill the rest of the dp table\n for i in range(1, k):\n # Determine the multiplier based on the parity of i\n multiplier = k - i if i % 2 == 0 else i - k\n for j in range(i, len(nums)):\n dp[i][j] = nums[j] * multiplier + max(dp[i - 1][j - 1], dp[i][j - 1])\n\n # Find the maximum value in the last row of dp table\n max_strength = MIN_VALUE\n for i in range(len(nums)):\n max_strength = max(max_strength, dp[k - 1][i])\n\n return max_strength","memory":"63800"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int: \n n = len(nums)\n dp = [[0 for _ in range(n + 1)] for _ in range(k + 1)]\n # dp[k][n] n: ptr of nums, k: more division needed\n for i in range(1, k + 1):\n dp[i][-1] = -inf\n for i in range(1, k + 1): # need\n lg = -inf\n for j in range(n - 1, -1, -1): # ptr\n # ans = dp[i][j + 1]\n lg = max(lg + (-1) ** (i + 1) * nums[j] * i, dp[i - 1][j + 1] + (-1) ** (i + 1) * nums[j] * i)\n dp[i][j] = max(lg, dp[i][j + 1])\n # tmp = 0\n # if i == 2:\n # h = 1\n # for x in range(j, n):\n # tmp += nums[x]\n # ans = max(ans, dp[i - 1][x + 1] + (-1) ** (i + 1) * tmp * i)\n # dp[i][j] = ans\n \n return dp[k][0]","memory":"64400"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[float('-inf')] * k for _ in range(n)]\n dp[0][0] = nums[0] * k\n for j in range(1, n):\n dp[j][0] = max(nums[j] * k, dp[j - 1][0] + nums[j]*k)\n \n for i in range(1, k):\n x = k - i\n sign = 1 if x % 2 else -1\n for j in range(i, n):\n dp[j][i] = x*sign*nums[j] + max(dp[j - 1][i], dp[j - 1][i - 1])\n \n return max([dp[j][-1] for j in range(n)])","memory":"64500"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], K: int) -> int:\n n = len(nums)\n dp = [[-inf]*(K+1) for _ in range(n+1)]\n for i in range(n+1):\n dp[i][0] = 0\n prefs = list(accumulate(nums,initial=0))\n for k in range(1,K+1):\n G = (1 if k%2 else -1)*(K-k+1)\n b = -inf\n for i in range(n):\n if k>i+1:\n dp[i][k] = -inf\n b = max(b,dp[i-1][k-1]-G*prefs[i]) \n dp[i][k] = max(dp[i-1][k],G*prefs[i+1]+b)\n return dp[n-1][K]\n\n\n\n ","memory":"64599"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n # dp[i][j] is max strength using j subarrays in nums[:i]\n # Add extra value for each dimension for i = 0 and j = 0 cases\n # Set dp[i][0] and dp[0][j] to 0\n dp = [[0] * (k+1)] + [[-float(inf)] * (k+1) for _ in range(n)] \n for i in range(n+1): \n dp[i][0] = 0\n \n max_strength = -float('inf')\n for i in range(1,n+1):\n for j in range(1, min(k,i)+1): # Can have at most k subarrays or i if i < k \n sign = 1 if j & 1 else -1 \n\n v1 = dp[i-1][j] + sign * (k-j+1) * nums[i-1]\n v2 = dp[i-1][j-1] + sign * (k-j+1) * nums[i-1]\n\n dp[i][j] = max(v1,v2)\n\n max_strength = max(max_strength, dp[i][-1]) # Take max across all dp[i][-1] for max strength\n \n return max_strength","memory":"64700"},{"code":"class Solution:\n import math \n from functools import lru_cache\n def maximumStrength(self, nums: List[int], k: int) -> int:\n values=[[-math.inf]*len(nums) for _ in range(k)]\n @lru_cache(maxsize=100000)\n def maxx(a):\n if a==-1:\n return 0\n return maxx(a-1)+nums[a]\n for l in range(k,0,-1):\n for i in range(len(nums)):\n if l==k:\n values[k-l][i]=max(maxx(i-1)+nums[i]*l,nums[i]*l,values[k-l][i-1]+nums[i]*l)\n elif i>=k-l:\n values[k-l][i]=max(values[k-l-1][i-1]+nums[i]*l*(-1)**(l+1),values[k-l][i-1]+nums[i]*l*(-1)**(l+1))\n return max(values[-1])","memory":"69000"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[0,0] for j in range(k+1)] for i in range(n+1)]\n for j in range(k+1):\n dp[n][j] = [-float('inf'),-float('inf')]\n dp[n][0] = [0,0]\n for i in range(n-1,-1,-1):\n for j in range(1,k+1):\n gain = nums[i]*int(2*((k-j+1)%2-0.5))*j\n dp[i][j][1] = gain + max(dp[i+1][j-1][0],dp[i+1][j][1])\n dp[i][j][0] = max(dp[i+1][j][0],dp[i][j][1])\n return dp[0][k][0]","memory":"144600"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n nums = [0] + nums\n dp = [[[-inf]*2 for _ in range(k+1)] for _ in range(n+1)]\n for i in range(0, n+1):\n dp[i][0][0] = 0\n for i in range(1, n+1):\n for j in range(1, k+1):\n if j % 2:\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) + nums[i] * (k+1-j)\n else:\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) - nums[i] * (k+1-j) \n # print(i, j, dp[i][j][0], dp[i][j][1])\n return max(dp[n][k][0], dp[n][k][1])\n ","memory":"160200"},{"code":"import math\nclass Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[(-math.inf,math.inf) for i in range(len(nums))] for j in range(k+1)]\n for i in range(len(nums)):\n dp[0][i] = (0,0)\n dp[1][-1] = (nums[-1],nums[-1])\n for i in reversed(range(len(nums)-1)):\n for j in range(1,k+1):\n max_strength_j,min_strength_j = dp[j][i+1]\n max_strength_d,min_strength_d = dp[j-1][i+1]\n max_connect_subarray = j*nums[i] + max_strength_j\n max_disjoint_subarray = j*nums[i] + -min_strength_d\n min_connect_subarray = j*nums[i] + min_strength_j\n min_disjoint_subarray = j*nums[i] + -max_strength_d\n max_strength = max(max_connect_subarray,max_disjoint_subarray)\n min_strength = min(min_connect_subarray,min_disjoint_subarray)\n dp[j][i] = (max_strength,min_strength)\n #print(dp)\n return max(dp[k], key=lambda x:x[0])[0]\n","memory":"167500"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], kk: int) -> int:\n n=len(nums)\n dp=[[[-sys.maxsize]*2 for _ in range(kk+1)] for _ in range(n+1)]\n dp[n][0][1]=0\n for i in range(n-1,-1,-1):\n for k in range(kk+1):\n for j in range(2):\n #ignore curr index case\n if not j: dp[i][k][j]=max(dp[i+1][k][j],dp[i+1][k][j^1])\n else:\n #max(end curr subarray here,don't end here)\n dp[i][k][j]=max((dp[i+1][k-1][j] if k-1>=0 else -sys.maxsize),dp[i+1][k][j])+(k*(-1 if (kk-k+2)%2 else 1)*nums[i])\n return max(dp[0][kk])\n ","memory":"168400"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\n dp[0][0][0] = 0\n for i, x in enumerate(nums, 1): \n for j in range(k + 1): \n sign = 1 if j & 1 else -1\n # 如果第i个数不被选\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\n dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1))\n if j: \n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\n return max(dp[n][k])","memory":"191500"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","memory":"191700"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","memory":"191700"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\n f[0][0][0] = 0\n for i, x in enumerate(nums, 1):\n for j in range(k + 1):\n sign = 1 if j & 1 else -1\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\n if j:\n f[i][j][1] = max(\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\n )\n return max(f[n][k])","memory":"191800"},{"code":"# # def recur_func(idx, k, nums, start_new, dp):\n# # if k == 0:\n# # return 0\n\n# # if idx >= len(nums):\n# # return -1*int(1e20)\n \n# # if (idx, k, start_new) in dp:\n# # return dp[(idx, k, start_new)]\n\n# # take = -1*int(1e20)\n# # not_take = -1*int(1e20)\n# # # not_take\n# # if start_new == True:\n# # not_take = recur_func(idx + 1, k, nums, True, dp)\n \n# # # take and create_new\n# # if k%2 == 0:\n# # take = recur_func(idx + 1, k-1, nums, True, dp) - nums[idx]*k\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) - nums[idx]*k)\n# # else:\n# # take = recur_func(idx + 1, k-1, nums, True, dp) + nums[idx]*k\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) + nums[idx]*k)\n\n\n# # dp[(idx, k, start_new)] = max(take, not_take)\n# # return dp[(idx, k, start_new)]\n\n# class Solution:\n# def maximumStrength(self, nums: List[int], k: int) -> int:\n# n = len(nums)\n# dp = [[[-1*int(1e20) for z in range(2)]for subs in range(k + 1)]for i in range(n + 1)]\n \n# for idx in range(n):\n# for subs in range(k+1):\n# take = -1*int(1e20)\n# not_take = -1*int(1e20)\n# for start_new in range(2):\n# # take = -1*int(1e20)\n# # not_take = -1*int(1e20)\n# if start_new == 1:\n# not_take = dp[idx + 1][subs][1]\n \n# if subs%2 == 0:\n# take = dp[idx + 1][subs - 1][1] - nums[idx]*k\n# take = max(take, dp[idx + 1][subs][0] - nums[idx]*k)\n# else:\n# take = dp[idx + 1][subs - 1][1] + nums[idx]*k\n# take = max(take, dp[idx + 1][subs][0] + nums[idx]*k)\n \n# dp[idx][subs][start_new] = max(take, not_take)\n\n# # if dp[0][k][1] == -1\n# return dp[0][k][1]\n\nclass Solution:\n def maximumStrength(self, nums, k):\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\n \n def solve(i, k, started, nums):\n if k == 0:\n return 0\n \n if i == len(nums):\n if k == 1 and started:\n return 0\n return -1e15\n \n if dp[i][k][started] != -1e16:\n return dp[i][k][started]\n \n ans = -1e15\n \n if started:\n ans = solve(i, k - 1, False, nums)\n \n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\n \n if not started:\n ans = max(solve(i + 1, k, False, nums), ans)\n \n dp[i][k][started] = ans\n return ans\n \n return solve(0, k, False, nums)","memory":"201800"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n '''\n * find k disjoint subarrays\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n\n * find the maximum alternating sum of all k disjoint subarray strengths\n ======\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \n\n * so at each index, I can choose to take or skip the current element. \n take: \n but If I take, should I continue or start fresh subarray from the next element? \n skip: \n dont take the current element and just move on.. \n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\n * so there's 3 choices at each index.. pick them maximum among at each state\n * so try them all => correct, but tle!\n =====\n\n\n '''\n\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\n\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\n\n def helper(idx, rem_k, keep_going): \n if rem_k == 0: \n return 0 # formed k subarrays\n if idx >= len(nums): # exhausted\n return minus_inf # base case\n\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\n return table[idx][rem_k][keep_going]\n\n # take: but If I take, should I continue or start fresh subarray from the next element? \n # skip: dont take the current element and just move on.. \n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n take_current = nums[idx] * rem_k * sign\n table[idx][rem_k][keep_going] = max(\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n take_current + helper(idx + 1, rem_k, True), # dont end here\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n )\n return table[idx][rem_k][keep_going]\n \n return helper(0, k, False)\n\n\n\n #### correct but tle:\n # @cache\n # def helper(idx, rem_k, keep_going): \n # if rem_k == 0: \n # return 0 # formed k subarrays\n # if idx >= len(nums): # exhausted\n # return -inf # base case\n\n # # take: but If I take, should I continue or start fresh subarray from the next element? \n # # skip: dont take the current element and just move on.. \n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n # take_current = nums[idx] * rem_k * sign\n # return max(\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n # take_current + helper(idx + 1, rem_k, True), # dont end here\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n # )\n\n # return helper(0, k, False)\n","memory":"202800"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n '''\n * find k disjoint subarrays\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n\n * find the maximum alternating sum of all k disjoint subarray strengths\n ======\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \n\n * so at each index, I can choose to take or skip the current element. \n take: \n but If I take, should I continue or start fresh subarray from the next element? \n skip: \n dont take the current element and just move on.. \n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\n * so there's 3 choices at each index.. pick them maximum among at each state\n * so try them all => correct, but tle!\n =====\n * manual caching and using some very large number instead of -inf => works! => but more like forcing it to get to work for all the cases...\n * see if there's a better approch => re-solve later!\n\n\n '''\n\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\n\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\n\n def helper(idx, rem_k, keep_going): \n if rem_k == 0: \n return 0 # formed k subarrays\n if idx >= len(nums): # exhausted\n return minus_inf # base case\n\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\n return table[idx][rem_k][keep_going]\n\n # take: but If I take, should I continue or start fresh subarray from the next element? \n # skip: dont take the current element and just move on.. \n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n take_current = nums[idx] * rem_k * sign\n table[idx][rem_k][keep_going] = max(\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n take_current + helper(idx + 1, rem_k, True), # dont end here\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n )\n return table[idx][rem_k][keep_going]\n \n return helper(0, k, False)\n\n\n\n #### correct but tle:\n # @cache\n # def helper(idx, rem_k, keep_going): \n # if rem_k == 0: \n # return 0 # formed k subarrays\n # if idx >= len(nums): # exhausted\n # return -inf # base case\n\n # # take: but If I take, should I continue or start fresh subarray from the next element? \n # # skip: dont take the current element and just move on.. \n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\n # take_current = nums[idx] * rem_k * sign\n # return max(\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \n # take_current + helper(idx + 1, rem_k, True), # dont end here\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\n # )\n\n # return helper(0, k, False)\n","memory":"202800"},{"code":"class Solution:\n def maximumStrength(self, nums, k):\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\n \n def solve(i, k, started, nums):\n if k == 0:\n return 0\n \n if i == len(nums):\n if k == 1 and started:\n return 0\n return -1e15\n \n if dp[i][k][started] != -1e16:\n return dp[i][k][started]\n \n ans = -1e15\n \n if started:\n ans = solve(i, k - 1, False, nums)\n \n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\n \n if not started:\n ans = max(solve(i + 1, k, False, nums), ans)\n \n dp[i][k][started] = ans\n return ans\n \n return solve(0, k, False, nums)","memory":"202900"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n dp = [[[-1e17] * 2 for _ in range(k + 1)] for _ in range(len(nums))]\n def dfs(i, k, started):\n if k == 0: return 0\n if i == len(nums): return -1e16\n if dp[i][k][started] != -1e17: return dp[i][k][started]\n chooseend = (1 if k % 2 else -1) * k * nums[i] + dfs(i + 1, k - 1, False)\n choosestart = (1 if k % 2 else -1) * k * nums[i] + dfs(i + 1, k, True)\n skip = dfs(i + 1, k, False) if not started else -1e16\n dp[i][k][started] = max(chooseend, choosestart, skip)\n return dp[i][k][started]\n return dfs(0, k, False)","memory":"206900"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \"\"\"\n Let dp[i][j][k==0/1] denote the maximum strength of choosing j subarrays from the elements nums_i, ... nums_{len(nums) - 1} where k represents if we select the ith element\n dp[i][j][1] = nums[i] * get(j) + max(dp[i + 1][j - 1][0], dp[i + 1][j][1]) where get(j) = j if j is odd, else -j\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\n \"\"\"\n n = len(nums)\n dp = [[[-float(\"inf\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\n dp[n][0][0] = 0\n\n for i in range(n - 1, -1, -1):\n for j in range(0, k + 1):\n dp[i][j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[i + 1][j - 1][0] if j > 0 else float(\"-inf\"), dp[i + 1][j][1])\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\n\n return dp[0][k][0]\n ","memory":"207800"},{"code":"class Solution:\n def maximumStrength(self, A: List[int], k: int) -> int:\n n = len(A)\n def get_sign(x):\n if x%2 == 1:\n return x\n return -x\n\n MIN = 10**9 * n * -1 \n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\n\n def dfs(idx, k, new):\n if k == 0 and new == 1:\n return 0\n if idx == n or n-idx+1<k:\n return -inf\n\n if memo[idx][k][new] != -MIN:\n return memo[idx][k][new]\n \n ans = -inf\n if new == 1:\n # start new subarray\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # start new subarray and end it\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k, 1))\n else:\n # continue subarray to next element\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # stop subarray on this element\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k-1, 1))\n \n memo[idx][k][new] = ans\n return ans\n \n return dfs(0, k, 1)","memory":"231800"},{"code":"class Solution:\n def maximumStrength(self, A: List[int], k: int) -> int:\n n = len(A)\n def get_sign(x):\n if x%2 == 1:\n return x\n return -x\n\n MIN = 10**9 * n * -1 \n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\n\n def dfs(idx, k, new):\n if k == 0 and new == 1:\n return 0\n if idx == n or n-idx+1<k:\n return -inf\n\n if memo[idx][k][new] != -MIN:\n return memo[idx][k][new]\n \n ans = -inf\n if new == 1:\n # start new subarray\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # start new subarray and end it\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k, 1))\n else:\n # continue subarray to next element\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # stop subarray on this element\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k-1, 1))\n \n memo[idx][k][new] = ans\n return ans\n \n return dfs(0, k, 1)","memory":"233300"},{"code":"class Solution:\n def maximumStrength(self, A: List[int], k: int) -> int:\n n = len(A)\n def get_sign(x):\n if x%2 == 1:\n return x\n return -x\n\n MIN = 10**9 * n * -1 \n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\n\n def dfs(idx, k, new):\n if k == 0 and new == 1:\n return 0\n if idx == n or n-idx+1<k:\n return -inf\n\n if memo[idx][k][new] != -MIN:\n return memo[idx][k][new]\n \n ans = -inf\n if new == 1:\n # start new subarray\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # start new subarray and end it\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k, 1))\n else:\n # continue subarray to next element\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\n # stop subarray on this element\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\n # skip element\n ans = max(ans, dfs(idx+1, k-1, 1))\n \n memo[idx][k][new] = ans\n return ans\n \n return dfs(0, k, 1)","memory":"233400"},{"code":"class Solution:\n def maximumStrength(self, nums: List[int], k: int) -> int:\n \n memo = [[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\n def dp(i, k, empty):\n if len(nums)-i+1<k:\n return -inf\n \n if i==len(nums):\n if k==1 and empty==0:\n return 0\n return -inf\n \n if memo[i][k][empty] != -inf:\n return memo[i][k][empty]\n \n if empty:\n sign = 1 if k%2==1 else -1\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\n include = startNew\n skip = dp(i+1, k, 1)\n else:\n sign = 1 if k%2==1 else -1\n include = dp(i+1, k, 0) + sign * nums[i] * k\n \n if k-1==0:\n startNew = 0\n skip = 0\n else:\n sign = 1 if (k-1)%2==1 else -1\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\n skip = dp(i+1, k-1, 1)\n \n memo[i][k][empty] = max(startNew, include, skip)\n \n return memo[i][k][empty]\n \n return dp(0,k,1)","memory":"256300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[-inf]*2 for _ in range(k+1)]\\n dp[0][0] = dp[0][1] = 0\\n for i in range(len(nums)-1, -1, -1): \\n for j in range(k, 0, -1): \\n cand = pow(-1, k-j)*nums[i]*j + max(dp[j][1], dp[j-1][0])\\n dp[j][0] = max(cand, dp[j][0])\\n dp[j][1] = max(cand, dp[j-1][0])\\n return dp[k][0]\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n INF = 10000000000000000\\n\\n # Initialize the prefix sum array\\n sum_vals = [0] * (n + 1)\\n f = [-INF] * (k + 1)\\n g = [-INF] * (k + 1)\\n g[0] = 0 # Base case\\n\\n for i in range(1, n + 1):\\n f[0] = 0 # Reset f[0] for each i\\n sum_vals[i] = sum_vals[i - 1] + nums[i - 1] # Calculate prefix sum\\n\\n for j in range(1, k + 1):\\n t = (1 if j % 2 == 1 else -1) * sum_vals[i] * (k - j + 1)\\n\\n f[j] = max(f[j], g[j - 1] + t)\\n g[j - 1] = max(g[j - 1], f[j - 1] - t)\\n\\n return f[k]\",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[-inf] * 2 for _ in range(k + 1)] for _ in range(2)]\\n dp[n & 1][0] = [0, 0]\\n for i in range(n - 1, -1, -1):\\n for r in range(k + 1):\\n for s in range(2):\\n if r + s == 0:\\n dp[i & 1][r][s] = 0 \\n elif not s:\\n dp[i & 1][r][s] = max(\\n -(-1)**r * r * nums[i] + dp[~i & 1][r - 1][1],\\n dp[~i & 1][r][0],\\n )\\n else:\\n dp[i & 1][r][s] = max(\\n (-1)**r * (r + 1) * nums[i] + dp[~i & 1][r][1],\\n dp[i & 1][r][0],\\n )\\n return dp[0][k][0]\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n for k2 in range(1, k+1):\\n prev = dp.copy()\\n for i in range(n-1,-1,-1):\\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\\n dp[n-k2+1] = -math.inf\\n return max(dp)\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n for k2 in range(1, k+1):\\n prev = dp.copy()\\n for i in range(n-1,-1,-1):\\n dp[i]=nums[i]*k2*(-1)**(k-k2) + max(dp[i+1], prev[i+1])\\n dp[n-k2+1] = -math.inf\\n return max(dp)\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums, k):\\n n = len(nums)\\n large_negative = -10**12 # Large negative value to initialize dp for impossible states\\n \\n # Initialize the previous row (base case)\\n prev = [0] * (n + 1)\\n \\n # Iterate over the number of subarrays to select (i subarrays)\\n for i in range(k):\\n # Determine the multiplier x for the current subarray\\n x = (k - i) * (1 if i % 2 == 0 else -1)\\n \\n # Initialize the current dp row\\n dp = [large_negative] * (n + 1)\\n \\n left = i # Initialize the left pointer for the current subarray\\n comp_sum = 0 # Sum of elements in the current subarray from left to right\\n \\n # Iterate through possible subarray endpoints (right pointers)\\n for right in range(i, n):\\n # Update the left pointer if it's better to start a new subarray at `right`\\n if prev[right] > comp_sum * x + prev[left]:\\n left = right\\n comp_sum = 0 # Reset sum since we are starting a new subarray\\n \\n # Add the current element to the subarray sum\\n comp_sum += nums[right]\\n \\n # Update dp[right + 1] to be the maximum of either:\\n # 1. The previous state (not taking this subarray),\\n # 2. The new subarray ending at `right` starting from `left`\\n dp[right + 1] = max(dp[right], comp_sum * x + prev[left])\\n \\n # Move to the next subarray, so the current dp becomes the new prev row\\n prev = dp\\n \\n # The result will be stored in prev[n], which is the maximum strength for k subarrays\\n return prev[n]\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1] \",\n \"memory\": \"63400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n nums.reverse()\\n\\n # dp[i][j] is max strength of array nums[0:j+1] with i subarrays and contains last element \\n dp = [[-float('inf')] * len(nums) for _ in range(k + 1)]\\n\\n dp[1][0] = nums[0]\\n curr_sum = nums[0]\\n for last_index in range(1, len(nums)):\\n curr_sum = max(curr_sum + nums[last_index], nums[last_index])\\n dp[1][last_index] = max(dp[1][last_index - 1], curr_sum)\\n\\n for subs in range(2, k + 1):\\n sign = 1 if subs % 2 == 1 else -1\\n dp[subs][subs - 1] = nums[subs - 1] * subs * sign + dp[subs - 1][subs - 2]\\n\\n for last_index in range(subs, len(nums)):\\n dp[subs][last_index] = nums[last_index] * subs * sign + max(\\n dp[subs][last_index - 1],\\n dp[subs - 1][last_index - 1]\\n )\\n \\n return max(dp[k])\",\n \"memory\": \"63500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxSum = curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxSum = dp[i][j + 1] = max(maxSum, curr)\\n return dp[-1][-1]\",\n \"memory\": \"63500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxSum = curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxSum = dp[i][j + 1] = max(maxSum, curr)\\n return dp[-1][-1] \",\n \"memory\": \"63600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (len(nums) + 1) for _ in range(k + 1)]\\n for i in range(1, k + 1):\\n maxsum = -float('inf')\\n curr = -float('inf')\\n multiplier = k + 1 - i if i % 2 == 1 else i - 1 - k\\n for j in range(i - 1, len(nums)):\\n curr = max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier)\\n maxsum = max(maxsum, curr)\\n dp[i][j + 1] = maxsum\\n return dp[-1][-1]\",\n \"memory\": \"63700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n # Initialize a very small number for comparison\\n MIN_VALUE = -1_000_000_000_000_000\\n # Initialize the dp table with minimum values\\n dp = [[MIN_VALUE] * len(nums) for _ in range(k)]\\n # Base case: Fill the first row of the dp table\\n dp[0][0] = nums[0] * k\\n\\n # Fill the first row of dp table\\n for i in range(1, len(nums)):\\n dp[0][i] = max(dp[0][i - 1] + nums[i] * k, nums[i] * k)\\n\\n # Fill the rest of the dp table\\n for i in range(1, k):\\n # Determine the multiplier based on the parity of i\\n multiplier = k - i if i % 2 == 0 else i - k\\n for j in range(i, len(nums)):\\n dp[i][j] = nums[j] * multiplier + max(dp[i - 1][j - 1], dp[i][j - 1])\\n\\n # Find the maximum value in the last row of dp table\\n max_strength = MIN_VALUE\\n for i in range(len(nums)):\\n max_strength = max(max_strength, dp[k - 1][i])\\n\\n return max_strength\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int: \\n n = len(nums)\\n dp = [[0 for _ in range(n + 1)] for _ in range(k + 1)]\\n # dp[k][n] n: ptr of nums, k: more division needed\\n for i in range(1, k + 1):\\n dp[i][-1] = -inf\\n for i in range(1, k + 1): # need\\n lg = -inf\\n for j in range(n - 1, -1, -1): # ptr\\n # ans = dp[i][j + 1]\\n lg = max(lg + (-1) ** (i + 1) * nums[j] * i, dp[i - 1][j + 1] + (-1) ** (i + 1) * nums[j] * i)\\n dp[i][j] = max(lg, dp[i][j + 1])\\n # tmp = 0\\n # if i == 2:\\n # h = 1\\n # for x in range(j, n):\\n # tmp += nums[x]\\n # ans = max(ans, dp[i - 1][x + 1] + (-1) ** (i + 1) * tmp * i)\\n # dp[i][j] = ans\\n \\n return dp[k][0]\",\n \"memory\": \"64400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[float('-inf')] * k for _ in range(n)]\\n dp[0][0] = nums[0] * k\\n for j in range(1, n):\\n dp[j][0] = max(nums[j] * k, dp[j - 1][0] + nums[j]*k)\\n \\n for i in range(1, k):\\n x = k - i\\n sign = 1 if x % 2 else -1\\n for j in range(i, n):\\n dp[j][i] = x*sign*nums[j] + max(dp[j - 1][i], dp[j - 1][i - 1])\\n \\n return max([dp[j][-1] for j in range(n)])\",\n \"memory\": \"64500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], K: int) -> int:\\n n = len(nums)\\n dp = [[-inf]*(K+1) for _ in range(n+1)]\\n for i in range(n+1):\\n dp[i][0] = 0\\n prefs = list(accumulate(nums,initial=0))\\n for k in range(1,K+1):\\n G = (1 if k%2 else -1)*(K-k+1)\\n b = -inf\\n for i in range(n):\\n if k>i+1:\\n dp[i][k] = -inf\\n b = max(b,dp[i-1][k-1]-G*prefs[i]) \\n dp[i][k] = max(dp[i-1][k],G*prefs[i+1]+b)\\n return dp[n-1][K]\\n\\n\\n\\n \",\n \"memory\": \"64599\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n # dp[i][j] is max strength using j subarrays in nums[:i]\\n # Add extra value for each dimension for i = 0 and j = 0 cases\\n # Set dp[i][0] and dp[0][j] to 0\\n dp = [[0] * (k+1)] + [[-float(inf)] * (k+1) for _ in range(n)] \\n for i in range(n+1): \\n dp[i][0] = 0\\n \\n max_strength = -float('inf')\\n for i in range(1,n+1):\\n for j in range(1, min(k,i)+1): # Can have at most k subarrays or i if i < k \\n sign = 1 if j & 1 else -1 \\n\\n v1 = dp[i-1][j] + sign * (k-j+1) * nums[i-1]\\n v2 = dp[i-1][j-1] + sign * (k-j+1) * nums[i-1]\\n\\n dp[i][j] = max(v1,v2)\\n\\n max_strength = max(max_strength, dp[i][-1]) # Take max across all dp[i][-1] for max strength\\n \\n return max_strength\",\n \"memory\": \"64700\"\n },\n {\n \"code\": \"class Solution:\\n import math \\n from functools import lru_cache\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n values=[[-math.inf]*len(nums) for _ in range(k)]\\n @lru_cache(maxsize=100000)\\n def maxx(a):\\n if a==-1:\\n return 0\\n return maxx(a-1)+nums[a]\\n for l in range(k,0,-1):\\n for i in range(len(nums)):\\n if l==k:\\n values[k-l][i]=max(maxx(i-1)+nums[i]*l,nums[i]*l,values[k-l][i-1]+nums[i]*l)\\n elif i>=k-l:\\n values[k-l][i]=max(values[k-l-1][i-1]+nums[i]*l*(-1)**(l+1),values[k-l][i-1]+nums[i]*l*(-1)**(l+1))\\n return max(values[-1])\",\n \"memory\": \"69000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[0,0] for j in range(k+1)] for i in range(n+1)]\\n for j in range(k+1):\\n dp[n][j] = [-float('inf'),-float('inf')]\\n dp[n][0] = [0,0]\\n for i in range(n-1,-1,-1):\\n for j in range(1,k+1):\\n gain = nums[i]*int(2*((k-j+1)%2-0.5))*j\\n dp[i][j][1] = gain + max(dp[i+1][j-1][0],dp[i+1][j][1])\\n dp[i][j][0] = max(dp[i+1][j][0],dp[i][j][1])\\n return dp[0][k][0]\",\n \"memory\": \"144600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n nums = [0] + nums\\n dp = [[[-inf]*2 for _ in range(k+1)] for _ in range(n+1)]\\n for i in range(0, n+1):\\n dp[i][0][0] = 0\\n for i in range(1, n+1):\\n for j in range(1, k+1):\\n if j % 2:\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) + nums[i] * (k+1-j)\\n else:\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n dp[i][j][1] = max(dp[i-1][j-1][0], dp[i-1][j-1][1], dp[i-1][j][1]) - nums[i] * (k+1-j) \\n # print(i, j, dp[i][j][0], dp[i][j][1])\\n return max(dp[n][k][0], dp[n][k][1])\\n \",\n \"memory\": \"160200\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[(-math.inf,math.inf) for i in range(len(nums))] for j in range(k+1)]\\n for i in range(len(nums)):\\n dp[0][i] = (0,0)\\n dp[1][-1] = (nums[-1],nums[-1])\\n for i in reversed(range(len(nums)-1)):\\n for j in range(1,k+1):\\n max_strength_j,min_strength_j = dp[j][i+1]\\n max_strength_d,min_strength_d = dp[j-1][i+1]\\n max_connect_subarray = j*nums[i] + max_strength_j\\n max_disjoint_subarray = j*nums[i] + -min_strength_d\\n min_connect_subarray = j*nums[i] + min_strength_j\\n min_disjoint_subarray = j*nums[i] + -max_strength_d\\n max_strength = max(max_connect_subarray,max_disjoint_subarray)\\n min_strength = min(min_connect_subarray,min_disjoint_subarray)\\n dp[j][i] = (max_strength,min_strength)\\n #print(dp)\\n return max(dp[k], key=lambda x:x[0])[0]\\n\",\n \"memory\": \"167500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], kk: int) -> int:\\n n=len(nums)\\n dp=[[[-sys.maxsize]*2 for _ in range(kk+1)] for _ in range(n+1)]\\n dp[n][0][1]=0\\n for i in range(n-1,-1,-1):\\n for k in range(kk+1):\\n for j in range(2):\\n #ignore curr index case\\n if not j: dp[i][k][j]=max(dp[i+1][k][j],dp[i+1][k][j^1])\\n else:\\n #max(end curr subarray here,don't end here)\\n dp[i][k][j]=max((dp[i+1][k-1][j] if k-1>=0 else -sys.maxsize),dp[i+1][k][j])+(k*(-1 if (kk-k+2)%2 else 1)*nums[i])\\n return max(dp[0][kk])\\n \",\n \"memory\": \"168400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[[-float('inf'), -float('inf')] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp[0][0][0] = 0\\n for i, x in enumerate(nums, 1): \\n for j in range(k + 1): \\n sign = 1 if j & 1 else -1\\n # 如果第i个数不被选\\n dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1])\\n # 如果第i个数被选，此时如果第i−1个数与第i个数位于同一个子数组中\\n dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + sign * nums[i-1] * (k - j + 1))\\n if j: \\n dp[i][j][1] = max(dp[i][j][1], max(dp[i-1][j-1]) + sign * nums[i-1] * (k - j + 1))\\n return max(dp[n][k])\",\n \"memory\": \"191500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"memory\": \"191700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"memory\": \"191700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[[-inf, -inf] for _ in range(k + 1)] for _ in range(n + 1)]\\n f[0][0][0] = 0\\n for i, x in enumerate(nums, 1):\\n for j in range(k + 1):\\n sign = 1 if j & 1 else -1\\n f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1])\\n f[i][j][1] = max(f[i][j][1], f[i - 1][j][1] + sign * x * (k - j + 1))\\n if j:\\n f[i][j][1] = max(\\n f[i][j][1], max(f[i - 1][j - 1]) + sign * x * (k - j + 1)\\n )\\n return max(f[n][k])\",\n \"memory\": \"191800\"\n },\n {\n \"code\": \"# # def recur_func(idx, k, nums, start_new, dp):\\n# # if k == 0:\\n# # return 0\\n\\n# # if idx >= len(nums):\\n# # return -1*int(1e20)\\n \\n# # if (idx, k, start_new) in dp:\\n# # return dp[(idx, k, start_new)]\\n\\n# # take = -1*int(1e20)\\n# # not_take = -1*int(1e20)\\n# # # not_take\\n# # if start_new == True:\\n# # not_take = recur_func(idx + 1, k, nums, True, dp)\\n \\n# # # take and create_new\\n# # if k%2 == 0:\\n# # take = recur_func(idx + 1, k-1, nums, True, dp) - nums[idx]*k\\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) - nums[idx]*k)\\n# # else:\\n# # take = recur_func(idx + 1, k-1, nums, True, dp) + nums[idx]*k\\n# # take = max(take, recur_func(idx + 1, k, nums, False, dp) + nums[idx]*k)\\n\\n\\n# # dp[(idx, k, start_new)] = max(take, not_take)\\n# # return dp[(idx, k, start_new)]\\n\\n# class Solution:\\n# def maximumStrength(self, nums: List[int], k: int) -> int:\\n# n = len(nums)\\n# dp = [[[-1*int(1e20) for z in range(2)]for subs in range(k + 1)]for i in range(n + 1)]\\n \\n# for idx in range(n):\\n# for subs in range(k+1):\\n# take = -1*int(1e20)\\n# not_take = -1*int(1e20)\\n# for start_new in range(2):\\n# # take = -1*int(1e20)\\n# # not_take = -1*int(1e20)\\n# if start_new == 1:\\n# not_take = dp[idx + 1][subs][1]\\n \\n# if subs%2 == 0:\\n# take = dp[idx + 1][subs - 1][1] - nums[idx]*k\\n# take = max(take, dp[idx + 1][subs][0] - nums[idx]*k)\\n# else:\\n# take = dp[idx + 1][subs - 1][1] + nums[idx]*k\\n# take = max(take, dp[idx + 1][subs][0] + nums[idx]*k)\\n \\n# dp[idx][subs][start_new] = max(take, not_take)\\n\\n# # if dp[0][k][1] == -1\\n# return dp[0][k][1]\\n\\nclass Solution:\\n def maximumStrength(self, nums, k):\\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\\n \\n def solve(i, k, started, nums):\\n if k == 0:\\n return 0\\n \\n if i == len(nums):\\n if k == 1 and started:\\n return 0\\n return -1e15\\n \\n if dp[i][k][started] != -1e16:\\n return dp[i][k][started]\\n \\n ans = -1e15\\n \\n if started:\\n ans = solve(i, k - 1, False, nums)\\n \\n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\\n \\n if not started:\\n ans = max(solve(i + 1, k, False, nums), ans)\\n \\n dp[i][k][started] = ans\\n return ans\\n \\n return solve(0, k, False, nums)\",\n \"memory\": \"201800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n '''\\n * find k disjoint subarrays\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n\\n * find the maximum alternating sum of all k disjoint subarray strengths\\n ======\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \\n\\n * so at each index, I can choose to take or skip the current element. \\n take: \\n but If I take, should I continue or start fresh subarray from the next element? \\n skip: \\n dont take the current element and just move on.. \\n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\\n * so there's 3 choices at each index.. pick them maximum among at each state\\n * so try them all => correct, but tle!\\n =====\\n\\n\\n '''\\n\\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\\n\\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\\n\\n def helper(idx, rem_k, keep_going): \\n if rem_k == 0: \\n return 0 # formed k subarrays\\n if idx >= len(nums): # exhausted\\n return minus_inf # base case\\n\\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\\n return table[idx][rem_k][keep_going]\\n\\n # take: but If I take, should I continue or start fresh subarray from the next element? \\n # skip: dont take the current element and just move on.. \\n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n take_current = nums[idx] * rem_k * sign\\n table[idx][rem_k][keep_going] = max(\\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n take_current + helper(idx + 1, rem_k, True), # dont end here\\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n )\\n return table[idx][rem_k][keep_going]\\n \\n return helper(0, k, False)\\n\\n\\n\\n #### correct but tle:\\n # @cache\\n # def helper(idx, rem_k, keep_going): \\n # if rem_k == 0: \\n # return 0 # formed k subarrays\\n # if idx >= len(nums): # exhausted\\n # return -inf # base case\\n\\n # # take: but If I take, should I continue or start fresh subarray from the next element? \\n # # skip: dont take the current element and just move on.. \\n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n # take_current = nums[idx] * rem_k * sign\\n # return max(\\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n # take_current + helper(idx + 1, rem_k, True), # dont end here\\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n # )\\n\\n # return helper(0, k, False)\\n\",\n \"memory\": \"202800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n '''\\n * find k disjoint subarrays\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n\\n * find the maximum alternating sum of all k disjoint subarray strengths\\n ======\\n * strength of ith subarray is (-1)**(k+1) * sum(subarray)\\n => this is same as multiplying each element in this ith subbarray with with k - i and summing it all (alternating signs based on ith subarray is even or odd).. \\n\\n * so at each index, I can choose to take or skip the current element. \\n take: \\n but If I take, should I continue or start fresh subarray from the next element? \\n skip: \\n dont take the current element and just move on.. \\n but I can only skip if the concluded that previous subarray has already ended.. ie., only start candidates can be ignored / skipped.. in other cases just invalidate this option\\n * so there's 3 choices at each index.. pick them maximum among at each state\\n * so try them all => correct, but tle!\\n =====\\n * manual caching and using some very large number instead of -inf => works! => but more like forcing it to get to work for all the cases...\\n * see if there's a better approch => re-solve later!\\n\\n\\n '''\\n\\n minus_inf = int(-1e15) ### using inf hit tle; so set something very large instead along with manual caching\\n\\n table = [[[minus_inf] * 2 for _ in range(k+1)] for _ in range(len(nums))]\\n\\n def helper(idx, rem_k, keep_going): \\n if rem_k == 0: \\n return 0 # formed k subarrays\\n if idx >= len(nums): # exhausted\\n return minus_inf # base case\\n\\n if table[idx][rem_k][keep_going] != minus_inf: # found best answer for this state already..\\n return table[idx][rem_k][keep_going]\\n\\n # take: but If I take, should I continue or start fresh subarray from the next element? \\n # skip: dont take the current element and just move on.. \\n sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n take_current = nums[idx] * rem_k * sign\\n table[idx][rem_k][keep_going] = max(\\n take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n take_current + helper(idx + 1, rem_k, True), # dont end here\\n helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n )\\n return table[idx][rem_k][keep_going]\\n \\n return helper(0, k, False)\\n\\n\\n\\n #### correct but tle:\\n # @cache\\n # def helper(idx, rem_k, keep_going): \\n # if rem_k == 0: \\n # return 0 # formed k subarrays\\n # if idx >= len(nums): # exhausted\\n # return -inf # base case\\n\\n # # take: but If I take, should I continue or start fresh subarray from the next element? \\n # # skip: dont take the current element and just move on.. \\n # sign = 1 if rem_k % 2 != 0 else -1 # alternate signs correctly\\n # take_current = nums[idx] * rem_k * sign\\n # return max(\\n # take_current + helper(idx + 1, rem_k - 1, False), # end here; decrease k power for next.. \\n # take_current + helper(idx + 1, rem_k, True), # dont end here\\n # helper(idx + 1, rem_k, keep_going) if keep_going == False else -inf # just move on and ignore this only if the previous has already eneded.. only start candidates can be ignored.. in other cases just invalidate this option\\n # )\\n\\n # return helper(0, k, False)\\n\",\n \"memory\": \"202800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums, k):\\n dp = [[[-1e16 for _ in range(2)] for _ in range(k + 1)] for _ in range(len(nums))]\\n \\n def solve(i, k, started, nums):\\n if k == 0:\\n return 0\\n \\n if i == len(nums):\\n if k == 1 and started:\\n return 0\\n return -1e15\\n \\n if dp[i][k][started] != -1e16:\\n return dp[i][k][started]\\n \\n ans = -1e15\\n \\n if started:\\n ans = solve(i, k - 1, False, nums)\\n \\n ans = max((-1 if k % 2 == 0 else 1) * k * nums[i] + solve(i + 1, k, True, nums), ans)\\n \\n if not started:\\n ans = max(solve(i + 1, k, False, nums), ans)\\n \\n dp[i][k][started] = ans\\n return ans\\n \\n return solve(0, k, False, nums)\",\n \"memory\": \"202900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n dp = [[[-1e17] * 2 for _ in range(k + 1)] for _ in range(len(nums))]\\n def dfs(i, k, started):\\n if k == 0: return 0\\n if i == len(nums): return -1e16\\n if dp[i][k][started] != -1e17: return dp[i][k][started]\\n chooseend = (1 if k % 2 else -1) * k * nums[i] + dfs(i + 1, k - 1, False)\\n choosestart = (1 if k % 2 else -1) * k * nums[i] + dfs(i + 1, k, True)\\n skip = dfs(i + 1, k, False) if not started else -1e16\\n dp[i][k][started] = max(chooseend, choosestart, skip)\\n return dp[i][k][started]\\n return dfs(0, k, False)\",\n \"memory\": \"206900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n Let dp[i][j][k==0/1] denote the maximum strength of choosing j subarrays from the elements nums_i, ... nums_{len(nums) - 1} where k represents if we select the ith element\\n dp[i][j][1] = nums[i] * get(j) + max(dp[i + 1][j - 1][0], dp[i + 1][j][1]) where get(j) = j if j is odd, else -j\\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\\n \\\"\\\"\\\"\\n n = len(nums)\\n dp = [[[-float(\\\"inf\\\") for _ in range(2)] for _ in range(k + 1)] for _ in range(n + 1)]\\n dp[n][0][0] = 0\\n\\n for i in range(n - 1, -1, -1):\\n for j in range(0, k + 1):\\n dp[i][j][1] = nums[i] * (-j if (j % 2 == 0) else j) + max(dp[i + 1][j - 1][0] if j > 0 else float(\\\"-inf\\\"), dp[i + 1][j][1])\\n dp[i][j][0] = max(dp[i + 1][j][0], dp[i][j][1])\\n\\n return dp[0][k][0]\\n \",\n \"memory\": \"207800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, A: List[int], k: int) -> int:\\n n = len(A)\\n def get_sign(x):\\n if x%2 == 1:\\n return x\\n return -x\\n\\n MIN = 10**9 * n * -1 \\n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\\n\\n def dfs(idx, k, new):\\n if k == 0 and new == 1:\\n return 0\\n if idx == n or n-idx+1<k:\\n return -inf\\n\\n if memo[idx][k][new] != -MIN:\\n return memo[idx][k][new]\\n \\n ans = -inf\\n if new == 1:\\n # start new subarray\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # start new subarray and end it\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k, 1))\\n else:\\n # continue subarray to next element\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # stop subarray on this element\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k-1, 1))\\n \\n memo[idx][k][new] = ans\\n return ans\\n \\n return dfs(0, k, 1)\",\n \"memory\": \"231800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, A: List[int], k: int) -> int:\\n n = len(A)\\n def get_sign(x):\\n if x%2 == 1:\\n return x\\n return -x\\n\\n MIN = 10**9 * n * -1 \\n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\\n\\n def dfs(idx, k, new):\\n if k == 0 and new == 1:\\n return 0\\n if idx == n or n-idx+1<k:\\n return -inf\\n\\n if memo[idx][k][new] != -MIN:\\n return memo[idx][k][new]\\n \\n ans = -inf\\n if new == 1:\\n # start new subarray\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # start new subarray and end it\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k, 1))\\n else:\\n # continue subarray to next element\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # stop subarray on this element\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k-1, 1))\\n \\n memo[idx][k][new] = ans\\n return ans\\n \\n return dfs(0, k, 1)\",\n \"memory\": \"233300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, A: List[int], k: int) -> int:\\n n = len(A)\\n def get_sign(x):\\n if x%2 == 1:\\n return x\\n return -x\\n\\n MIN = 10**9 * n * -1 \\n memo = [[[-MIN,-MIN] for _ in range(k+1)] for _ in range(len(A))]\\n\\n def dfs(idx, k, new):\\n if k == 0 and new == 1:\\n return 0\\n if idx == n or n-idx+1<k:\\n return -inf\\n\\n if memo[idx][k][new] != -MIN:\\n return memo[idx][k][new]\\n \\n ans = -inf\\n if new == 1:\\n # start new subarray\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # start new subarray and end it\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k, 1))\\n else:\\n # continue subarray to next element\\n ans = max(ans, dfs(idx+1, k, 0) + get_sign(k)*A[idx])\\n # stop subarray on this element\\n ans = max(ans, dfs(idx+1, k-1, 1) + get_sign(k)*A[idx])\\n # skip element\\n ans = max(ans, dfs(idx+1, k-1, 1))\\n \\n memo[idx][k][new] = ans\\n return ans\\n \\n return dfs(0, k, 1)\",\n \"memory\": \"233400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumStrength(self, nums: List[int], k: int) -> int:\\n \\n memo = [[[-inf,-inf] for _ in range(k+1)] for _ in range(len(nums))]\\n def dp(i, k, empty):\\n if len(nums)-i+1<k:\\n return -inf\\n \\n if i==len(nums):\\n if k==1 and empty==0:\\n return 0\\n return -inf\\n \\n if memo[i][k][empty] != -inf:\\n return memo[i][k][empty]\\n \\n if empty:\\n sign = 1 if k%2==1 else -1\\n startNew = dp(i+1, k, 0) + sign * nums[i] * k\\n include = startNew\\n skip = dp(i+1, k, 1)\\n else:\\n sign = 1 if k%2==1 else -1\\n include = dp(i+1, k, 0) + sign * nums[i] * k\\n \\n if k-1==0:\\n startNew = 0\\n skip = 0\\n else:\\n sign = 1 if (k-1)%2==1 else -1\\n startNew = dp(i+1, k-1, 0) + sign * nums[i] * (k-1)\\n skip = dp(i+1, k-1, 1)\\n \\n memo[i][k][empty] = max(startNew, include, skip)\\n \\n return memo[i][k][empty]\\n \\n return dp(0,k,1)\",\n \"memory\": \"256300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":35,"string":"35"}}},{"rowIdx":2438,"cells":{"question_id":{"kind":"number","value":3337,"string":"3,337"},"name":{"kind":"string","value":"count-substrings-starting-and-ending-with-given-character"},"content":{"kind":"string","value":"<p>You are given a string <code>s</code> and a character <code>c</code>. Return <em>the total number of <span data-keyword=\"substring-nonempty\">substrings</span> of </em><code>s</code><em> that start and end with </em><code>c</code><em>.</em></p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">s = "abada", c = "a"</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">6</span></p>\n\n<p><strong>Explanation:</strong> Substrings starting and ending with <code>"a"</code> are: <code>"<strong><u>a</u></strong>bada"</code>, <code>"<u><strong>aba</strong></u>da"</code>, <code>"<u><strong>abada</strong></u>"</code>, <code>"ab<u><strong>a</strong></u>da"</code>, <code>"ab<u><strong>ada</strong></u>"</code>, <code>"abad<u><strong>a</strong></u>"</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">s = "zzz", c = "z"</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">6</span></p>\n\n<p><strong>Explanation:</strong> There are a total of <code>6</code> substrings in <code>s</code> and all start and end with <code>"z"</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length <= 10<sup>5</sup></code></li>\n\t<li><code>s</code> and <code>c</code> consist only of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":48.937688282860314,"string":"48.937688"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["math","string","counting"],"string":"[\n \"math\",\n \"string\",\n \"counting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"26\", 1.2048], [\"27\", 0.4016], [\"29\", 0.4016], [\"30\", 0.4016], [\"31\", 0.8032], [\"32\", 2.008], [\"33\", 1.2048], [\"34\", 2.008], [\"35\", 1.2048], [\"36\", 2.8112], [\"37\", 2.4096], [\"38\", 4.8193], [\"39\", 4.8193], [\"40\", 2.008], [\"41\", 3.2129], [\"42\", 4.8193], [\"43\", 1.6064], [\"44\", 1.2048], [\"45\", 3.6145], [\"46\", 4.8193], [\"47\", 1.6064], [\"48\", 2.8112], [\"49\", 1.6064], [\"50\", 4.0161], [\"51\", 2.4096], [\"52\", 3.6145], [\"53\", 3.2129], [\"54\", 2.8112], [\"55\", 4.8193], [\"56\", 2.4096], [\"57\", 2.8112], [\"58\", 2.8112], [\"59\", 0.8032], [\"60\", 2.008], [\"61\", 2.8112], [\"63\", 1.2048], [\"64\", 1.2048], [\"65\", 0.4016], [\"66\", 0.4016], [\"67\", 0.8032], [\"68\", 0.4016], [\"69\", 1.2048], [\"70\", 0.4016], [\"72\", 0.8032], [\"73\", 0.8032], [\"74\", 0.8032]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17100\", 8.4337], [\"17200\", 43.3735], [\"17300\", 32.9317], [\"17400\", 3.6145], [\"17800\", 0.4016], [\"17900\", 0.4016], [\"18100\", 0.4016], [\"18200\", 0.4016], [\"21200\", 3.6145]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n m = s.count(c)\n return m * (m + 1) // 2","runtime":"26"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = s.count(c)\n return n*(n+1)//2\n ","runtime":"27"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = s.count(c)\n return n * (n + 1) // 2 ","runtime":"29"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = s.count(c)\n return int((n * (n+1)) / 2)","runtime":"30"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n cnt = s.count(c)\n return cnt * (cnt + 1) // 2","runtime":"31"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n k = s.count(c)\n return k * (k + 1) // 2\n \n \n ","runtime":"31"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = s.count(c)\n return int(count*((count+1)/2))","runtime":"32"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n return (n:=s.count(c))*(n+1)//2","runtime":"33"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n i=0\n j=0\n cou=s.count(c)\n return int(cou*((cou+1)/2))\n \n '''while((i<len(s)) and (j<len(s))):\n if(s[i]==c and s[j]==c):\n cou+=1\n j+=1\n if(j==len(s)):\n i+=1\n j=i\n return cou'''","runtime":"34"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n m = s.count(c)\n return m * ((m + 1)) // 2","runtime":"35"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n cnt = s.count(c)\n return cnt + cnt * (cnt - 1) // 2","runtime":"36"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n \n n = s.count(c)\n \n return n*(n+1)//2","runtime":"37"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0\n for letter in s:\n if letter == c:\n count += 1\n \n return (count * (count + 1)) // 2","runtime":"38"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n res=s.count(c)\n \n return (res*(res+1))//2","runtime":"39"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n val = s.count(c)\n return (val * (val + 1))//2","runtime":"40"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = s.count(c)\n\n return n * (n + 1) // 2","runtime":"41"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = s.count(c)\n return int(count*((count+1)/2))","runtime":"42"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n counts = Counter(s)\n return (counts[c] * (counts[c] + 1)) // 2","runtime":"43"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n charCount = 0\n for i in s:\n if i == c:\n charCount += 1\n return charCount * (charCount + 1) // 2","runtime":"44"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n positions = []\n ans = 0\n for i in range(len(s)):\n if s[i] == c:\n positions.append(i)\n n = len(positions)\n return n + (n*(n-1)) // 2","runtime":"45"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n num=0\n li=[]\n num=s.count(c)\n temp=num-1\n while(temp>0):\n num+=temp\n temp-=1 \n return num ","runtime":"46"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = len(s)\n ct = 0\n for i in range(n):\n if c == s[i]:\n ct += 1\n return ct*(ct+1)//2","runtime":"47"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n \n cnt = Counter(s)[c]\n # print()\n return (cnt * (cnt + 1)) // 2","runtime":"48"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n idx = []\n n = len(s)\n for i in range(n):\n if s[i] == c:\n idx.append(i)\n \n # print(idx)\n\n res = len(idx)\n\n return (res*(res + 1))//2","runtime":"51"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0 # Frequency of 'c' encountered so far\n for ch in s:\n if ch == c:\n count += 1\n\n # Calculate combinations using the formula for unordered pairs\n return count * (count - 1) // 2 + count # Add single-character substrings\n ","runtime":"52"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0 # Frequency of 'c' encountered so far\n for ch in s:\n if ch == c:\n count += 1\n # Calculate combinations using the formula for unordered pairs\n return count * (count - 1) // 2 + count # Add single-character substrings\n ","runtime":"53"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n occurence = 0\n\n for i in range(len(s)):\n if s[i] == c:\n occurence += 1\n\n return (occurence + 1) * occurence // 2","runtime":"54"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n cnt = 0\n ans = 0\n for i in range(len(s)):\n if s[i]==c:\n cnt+=1\n ans+=cnt \n\n return ans","runtime":"55"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n \n # based on the hints\n m = Counter(s)[c]\n return m * (m + 1) // 2","runtime":"56"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0\n ans = 0\n\n for char in s:\n if char == c:\n count += 1\n ans += count\n return ans","runtime":"57"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n ans, cc = 0, 0\n for x in s:\n if x == c:\n cc += 1\n ans += cc\n return ans","runtime":"58"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n \n res = 0\n cur = 0\n\n for ch in s:\n if ch == c:\n cur += 1\n res += cur\n return res","runtime":"59"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = 0\n for i in range(len(s)):\n if s[i] == c:\n n += 1\n return n + (n*(n-1)) // 2","runtime":"60"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n ans = 0\n x = 0\n for i in s:\n if i==c:\n ans+=x\n ans+=1\n x+=1\n return ans","runtime":"61"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0\n for i in range(len(s)):\n if s[i] == c:\n count+=1\n return sum(range(1, count+1))","runtime":"63"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n\n counts = Counter(s)\n N = counts[c]\n return N * (N+1) // 2 # triangle number 5 + 4 + 3 + 2 + 1\n","runtime":"64"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n counts = Counter(s)\n char_counts = counts[c]\n return sum(range(1, char_counts + 1))\n \n res = char_counts\n for i in range(1, char_counts+1):\n res += char_counts - i\n \n return res","runtime":"65"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n c_count = 0\n for idx, val in enumerate(s):\n if val == c:\n c_count += 1\n\n count = 0 \n for idx, val in enumerate(s):\n if val != c:\n continue\n else:\n #count += 1\n count += c_count\n c_count -= 1\n return count\n\n\n ","runtime":"66"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n pos = []\n\n lenn = len(s)\n for i in range(lenn):\n if s[i] == c: pos.append(i)\n\n print(pos)\n n = len(pos)\n temp = (n * (n - 1)) / 2\n print(temp, n)\n \n\n\n return int(temp + n)","runtime":"67"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = sum(int(c == x) for x in s)\n return count * (count + 1) // 2","runtime":"68"},{"code":"class Solution:\n countSubstrings = lambda self, A, T: Counter(A)[T] * (Counter(A)[T] + 1) // 2","runtime":"69"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = len(s)\n i = ans = cnt = 0\n while i < n:\n if s[i] == c:\n cnt += 1\n ans += cnt\n i += 1\n return ans","runtime":"70"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n left = 0\n right = len(s) - 1\n \n count = 0\n \n while left <= right:\n if s[left] == c:\n count += 1\n \n left += 1\n \n result = 0\n \n while count != 0:\n result += count\n count -= 1\n \n return result","runtime":"72"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n \n hs = defaultdict(int)\n cnt = 0\n\n for x in s:\n if c == x:\n hs[x] += 1\n cnt += (hs[x] - 1)\n return cnt + hs[c]","runtime":"73"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0\n c_ind = [i for i in range(len(s)) if s[i] == c]\n for i in range(len(c_ind)):\n count += len(c_ind) - i\n return count","runtime":"74"}],"string":"[\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n m = s.count(c)\\n return m * (m + 1) // 2\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = s.count(c)\\n return n*(n+1)//2\\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = s.count(c)\\n return n * (n + 1) // 2 \",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = s.count(c)\\n return int((n * (n+1)) / 2)\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n cnt = s.count(c)\\n return cnt * (cnt + 1) // 2\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n k = s.count(c)\\n return k * (k + 1) // 2\\n \\n \\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = s.count(c)\\n return int(count*((count+1)/2))\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n return (n:=s.count(c))*(n+1)//2\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n i=0\\n j=0\\n cou=s.count(c)\\n return int(cou*((cou+1)/2))\\n \\n '''while((i<len(s)) and (j<len(s))):\\n if(s[i]==c and s[j]==c):\\n cou+=1\\n j+=1\\n if(j==len(s)):\\n i+=1\\n j=i\\n return cou'''\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n m = s.count(c)\\n return m * ((m + 1)) // 2\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n cnt = s.count(c)\\n return cnt + cnt * (cnt - 1) // 2\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n \\n n = s.count(c)\\n \\n return n*(n+1)//2\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0\\n for letter in s:\\n if letter == c:\\n count += 1\\n \\n return (count * (count + 1)) // 2\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n res=s.count(c)\\n \\n return (res*(res+1))//2\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n val = s.count(c)\\n return (val * (val + 1))//2\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = s.count(c)\\n\\n return n * (n + 1) // 2\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = s.count(c)\\n return int(count*((count+1)/2))\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n counts = Counter(s)\\n return (counts[c] * (counts[c] + 1)) // 2\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n charCount = 0\\n for i in s:\\n if i == c:\\n charCount += 1\\n return charCount * (charCount + 1) // 2\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n positions = []\\n ans = 0\\n for i in range(len(s)):\\n if s[i] == c:\\n positions.append(i)\\n n = len(positions)\\n return n + (n*(n-1)) // 2\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n num=0\\n li=[]\\n num=s.count(c)\\n temp=num-1\\n while(temp>0):\\n num+=temp\\n temp-=1 \\n return num \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = len(s)\\n ct = 0\\n for i in range(n):\\n if c == s[i]:\\n ct += 1\\n return ct*(ct+1)//2\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n \\n cnt = Counter(s)[c]\\n # print()\\n return (cnt * (cnt + 1)) // 2\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n idx = []\\n n = len(s)\\n for i in range(n):\\n if s[i] == c:\\n idx.append(i)\\n \\n # print(idx)\\n\\n res = len(idx)\\n\\n return (res*(res + 1))//2\",\n \"runtime\": \"51\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0 # Frequency of 'c' encountered so far\\n for ch in s:\\n if ch == c:\\n count += 1\\n\\n # Calculate combinations using the formula for unordered pairs\\n return count * (count - 1) // 2 + count # Add single-character substrings\\n \",\n \"runtime\": \"52\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0 # Frequency of 'c' encountered so far\\n for ch in s:\\n if ch == c:\\n count += 1\\n # Calculate combinations using the formula for unordered pairs\\n return count * (count - 1) // 2 + count # Add single-character substrings\\n \",\n \"runtime\": \"53\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n occurence = 0\\n\\n for i in range(len(s)):\\n if s[i] == c:\\n occurence += 1\\n\\n return (occurence + 1) * occurence // 2\",\n \"runtime\": \"54\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n cnt = 0\\n ans = 0\\n for i in range(len(s)):\\n if s[i]==c:\\n cnt+=1\\n ans+=cnt \\n\\n return ans\",\n \"runtime\": \"55\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n \\n # based on the hints\\n m = Counter(s)[c]\\n return m * (m + 1) // 2\",\n \"runtime\": \"56\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0\\n ans = 0\\n\\n for char in s:\\n if char == c:\\n count += 1\\n ans += count\\n return ans\",\n \"runtime\": \"57\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n ans, cc = 0, 0\\n for x in s:\\n if x == c:\\n cc += 1\\n ans += cc\\n return ans\",\n \"runtime\": \"58\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n \\n res = 0\\n cur = 0\\n\\n for ch in s:\\n if ch == c:\\n cur += 1\\n res += cur\\n return res\",\n \"runtime\": \"59\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = 0\\n for i in range(len(s)):\\n if s[i] == c:\\n n += 1\\n return n + (n*(n-1)) // 2\",\n \"runtime\": \"60\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n ans = 0\\n x = 0\\n for i in s:\\n if i==c:\\n ans+=x\\n ans+=1\\n x+=1\\n return ans\",\n \"runtime\": \"61\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0\\n for i in range(len(s)):\\n if s[i] == c:\\n count+=1\\n return sum(range(1, count+1))\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n\\n counts = Counter(s)\\n N = counts[c]\\n return N * (N+1) // 2 # triangle number 5 + 4 + 3 + 2 + 1\\n\",\n \"runtime\": \"64\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n counts = Counter(s)\\n char_counts = counts[c]\\n return sum(range(1, char_counts + 1))\\n \\n res = char_counts\\n for i in range(1, char_counts+1):\\n res += char_counts - i\\n \\n return res\",\n \"runtime\": \"65\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n c_count = 0\\n for idx, val in enumerate(s):\\n if val == c:\\n c_count += 1\\n\\n count = 0 \\n for idx, val in enumerate(s):\\n if val != c:\\n continue\\n else:\\n #count += 1\\n count += c_count\\n c_count -= 1\\n return count\\n\\n\\n \",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n pos = []\\n\\n lenn = len(s)\\n for i in range(lenn):\\n if s[i] == c: pos.append(i)\\n\\n print(pos)\\n n = len(pos)\\n temp = (n * (n - 1)) / 2\\n print(temp, n)\\n \\n\\n\\n return int(temp + n)\",\n \"runtime\": \"67\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = sum(int(c == x) for x in s)\\n return count * (count + 1) // 2\",\n \"runtime\": \"68\"\n },\n {\n \"code\": \"class Solution:\\n countSubstrings = lambda self, A, T: Counter(A)[T] * (Counter(A)[T] + 1) // 2\",\n \"runtime\": \"69\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = len(s)\\n i = ans = cnt = 0\\n while i < n:\\n if s[i] == c:\\n cnt += 1\\n ans += cnt\\n i += 1\\n return ans\",\n \"runtime\": \"70\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n left = 0\\n right = len(s) - 1\\n \\n count = 0\\n \\n while left <= right:\\n if s[left] == c:\\n count += 1\\n \\n left += 1\\n \\n result = 0\\n \\n while count != 0:\\n result += count\\n count -= 1\\n \\n return result\",\n \"runtime\": \"72\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n \\n hs = defaultdict(int)\\n cnt = 0\\n\\n for x in s:\\n if c == x:\\n hs[x] += 1\\n cnt += (hs[x] - 1)\\n return cnt + hs[c]\",\n \"runtime\": \"73\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0\\n c_ind = [i for i in range(len(s)) if s[i] == c]\\n for i in range(len(c_ind)):\\n count += len(c_ind) - i\\n return count\",\n \"runtime\": \"74\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":45,"string":"45"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n cnt = 0\n ans = 0\n for i in range(len(s)):\n if s[i]==c:\n cnt+=1\n ans+=cnt \n\n return ans","memory":"17100"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n occurence = 0\n\n for i in range(len(s)):\n if s[i] == c:\n occurence += 1\n\n return (occurence + 1) * occurence // 2","memory":"17200"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n ans=0\n cnt=Counter()\n for i in s:\n cnt[i]+=1\n if c==i:\n ans+=cnt[i]\n return ans","memory":"17300"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = s.count(c)\n\n return n * (n + 1) // 2","memory":"17300"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n res=s.count(c)\n \n return (res*(res+1))//2","memory":"17400"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = sum([s[i]==c for i in range(len(s))])\n return (count * (count + 1)) // 2","memory":"17800"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count = 0\n for char in s:\n if char == c:\n count +=1\n if count <= 1:\n return count\n if count == 2:\n return 3\n return factorial(count) // factorial(2) // factorial(count-2) + count","memory":"17900"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n count=0\n l=list(s)\n for i in range(len(l)):\n if l[i]==c:\n count+=1\n return int((count*(count+1))/2)","memory":"18100"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n n = sum([1 for ch in s if ch == c])\n\n return n * (n + 1) // 2\n\n # 5 + 4 + 3 + 2 + 1\n","memory":"18200"},{"code":"class Solution:\n def countSubstrings(self, s: str, c: str) -> int:\n idx = []\n n = len(s)\n for i in range(n):\n if s[i] == c:\n idx.append(i)\n \n # print(idx)\n\n res = len(idx)\n\n return (res*(res + 1))//2","memory":"21200"}],"string":"[\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n cnt = 0\\n ans = 0\\n for i in range(len(s)):\\n if s[i]==c:\\n cnt+=1\\n ans+=cnt \\n\\n return ans\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n occurence = 0\\n\\n for i in range(len(s)):\\n if s[i] == c:\\n occurence += 1\\n\\n return (occurence + 1) * occurence // 2\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n ans=0\\n cnt=Counter()\\n for i in s:\\n cnt[i]+=1\\n if c==i:\\n ans+=cnt[i]\\n return ans\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = s.count(c)\\n\\n return n * (n + 1) // 2\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n res=s.count(c)\\n \\n return (res*(res+1))//2\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = sum([s[i]==c for i in range(len(s))])\\n return (count * (count + 1)) // 2\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count = 0\\n for char in s:\\n if char == c:\\n count +=1\\n if count <= 1:\\n return count\\n if count == 2:\\n return 3\\n return factorial(count) // factorial(2) // factorial(count-2) + count\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n count=0\\n l=list(s)\\n for i in range(len(l)):\\n if l[i]==c:\\n count+=1\\n return int((count*(count+1))/2)\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n n = sum([1 for ch in s if ch == c])\\n\\n return n * (n + 1) // 2\\n\\n # 5 + 4 + 3 + 2 + 1\\n\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def countSubstrings(self, s: str, c: str) -> int:\\n idx = []\\n n = len(s)\\n for i in range(n):\\n if s[i] == c:\\n idx.append(i)\\n \\n # print(idx)\\n\\n res = len(idx)\\n\\n return (res*(res + 1))//2\",\n \"memory\": \"21200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":2439,"cells":{"question_id":{"kind":"number","value":3360,"string":"3,360"},"name":{"kind":"string","value":"minimum-deletions-to-make-string-k-special"},"content":{"kind":"string","value":"<p>You are given a string <code>word</code> and an integer <code>k</code>.</p>\n\n<p>We consider <code>word</code> to be <strong>k-special</strong> if <code>|freq(word[i]) - freq(word[j])| <= k</code> for all indices <code>i</code> and <code>j</code> in the string.</p>\n\n<p>Here, <code>freq(x)</code> denotes the <span data-keyword=\"frequency-letter\">frequency</span> of the character <code>x</code> in <code>word</code>, and <code>|y|</code> denotes the absolute value of <code>y</code>.</p>\n\n<p>Return <em>the <strong>minimum</strong> number of characters you need to delete to make</em> <code>word</code> <strong><em>k-special</em></strong>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">word = "aabcaba", k = 0</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">3</span></p>\n\n<p><strong>Explanation:</strong> We can make <code>word</code> <code>0</code>-special by deleting <code>2</code> occurrences of <code>"a"</code> and <code>1</code> occurrence of <code>"c"</code>. Therefore, <code>word</code> becomes equal to <code>"baba"</code> where <code>freq('a') == freq('b') == 2</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">word = "dabdcbdcdcd", k = 2</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">2</span></p>\n\n<p><strong>Explanation:</strong> We can make <code>word</code> <code>2</code>-special by deleting <code>1</code> occurrence of <code>"a"</code> and <code>1</code> occurrence of <code>"d"</code>. Therefore, <code>word</code> becomes equal to "bdcbdcdcd" where <code>freq('b') == 2</code>, <code>freq('c') == 3</code>, and <code>freq('d') == 4</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">word = "aaabaaa", k = 2</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">1</span></p>\n\n<p><strong>Explanation:</strong> We can make <code>word</code> <code>2</code>-special by deleting <code>1</code> occurrence of <code>"b"</code>. Therefore, <code>word</code> becomes equal to <code>"aaaaaa"</code> where each letter's frequency is now uniformly <code>6</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= word.length <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= k <= 10<sup>5</sup></code></li>\n\t<li><code>word</code> consists only of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":44.17710611784981,"string":"44.177106"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["hash-table","string","greedy","sorting","counting"],"string":"[\n \"hash-table\",\n \"string\",\n \"greedy\",\n \"sorting\",\n \"counting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"63\", 4.3957999999999995], [\"74\", 4.9453000000000005], [\"86\", 7.1432], [\"97\", 32.418], [\"108\", 11.538800000000002], [\"119\", 1.0989], [\"130\", 3.2969], [\"142\", 10.989200000000002], [\"153\", 4.9453], [\"164\", 1.6484999999999999], [\"175\", 1.099], [\"187\", 0.5495], [\"198\", 2.198], [\"209\", 0.5495], [\"220\", 0.5495], [\"231\", 0.5495], [\"243\", 0.5495], [\"254\", 0.5495], [\"265\", 0.5495], [\"276\", 0.5495], [\"288\", 0.5495], [\"299\", 0.5495], [\"310\", 0.5495], [\"321\", 0.5495], [\"333\", 0.5495], [\"344\", 0.5495], [\"355\", 0.5495], [\"366\", 0.5495]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17300\", 1.0989], [\"17400\", 7.1429], [\"17500\", 31.3187], [\"17600\", 39.011], [\"17700\", 3.8462], [\"17800\", 7.6923]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n lst = [] \n for char in set(word):\n lst.append(word.count(char))\n # Now, lst records the frequency of every char in word\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\n # We adopt the brute force approach: traverse every frequency x \n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\n minn = float('inf')\n for i in range(len(lst)):\n delete = 0\n upper = lst[i] + k # lower bound is lst[i] itself\n for j in range(len(lst)):\n if lst[i] <= lst[j] <= upper:\n continue\n if lst[j] < lst[i]:\n delete += lst[j]\n elif lst[j] > upper:\n delete += (lst[j]-upper)\n minn = min(delete, minn)\n return minn","runtime":"63"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n lst = []\n ans = 0\n for char in set(word):\n lst.append(word.count(char))\n minn = float('inf')\n # print(lst)\n for i in range(len(lst)):\n delete = 0\n upper = lst[i] + k\n for j in range(len(lst)):\n if lst[i] <= lst[j] <= upper:\n continue\n if lst[j] < lst[i]:\n delete += lst[j]\n elif lst[j] > upper:\n delete += (lst[j]-upper)\n # print(lst[i], upper, lower, delete)\n minn = min(delete, minn)\n return minn","runtime":"63"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n lst = [] \n for char in set(word):\n lst.append(word.count(char))\n # Now, lst records the frequency of every char in word\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\n # We adopt the brute force approach: traverse every frequency x \n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\n minn = float('inf')\n for i in range(len(lst)):\n delete = 0\n upper = lst[i] + k # lower bound is lst[i] itself\n for j in range(len(lst)):\n if lst[i] <= lst[j] <= upper:\n continue\n if lst[j] < lst[i]:\n delete += lst[j]\n elif lst[j] > upper:\n delete += (lst[j]-upper)\n minn = min(delete, minn)\n return minn","runtime":"74"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n lst = [] \n for char in set(word):\n lst.append(word.count(char))\n # Now, lst records the frequency of every char in word\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\n # We adopt the brute force approach: traverse every frequency x \n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\n minn = float('inf')\n for i in range(len(lst)):\n delete = 0\n upper = lst[i] + k # lower bound is lst[i] itself\n for j in range(len(lst)):\n if lst[i] <= lst[j] <= upper:\n continue\n if lst[j] < lst[i]:\n delete += lst[j]\n elif lst[j] > upper:\n delete += (lst[j]-upper)\n minn = min(delete, minn)\n return minn","runtime":"74"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = list(Counter(word).values())\n ans = len(word)\n for start in set(freq):\n end = start + k\n ans = min(ans, sum((f - end if f > end else 0) if f >= start else f for f in freq))\n return ans","runtime":"86"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n # count the min deletion needed if we never change a char's frequency and having it be the min frequency, \n # then ans is minimum res for each unique char\n # this is because the answer must have at least a char that is unch and is smallest count. \n\n freq = Counter(word).values()\n\n res = float(\"inf\")\n for anchor_freq in freq:\n anchor_count = 0\n for other_freq in freq:\n anchor_count += other_freq if other_freq < anchor_freq else max(0, other_freq - (anchor_freq + k))\n res = min(anchor_count, res)\n \n return res\n","runtime":"86"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n \"\"\"\n Let x be the element with smallest frequency that appears in our final string. It is obviously we never want\n to decerement x. We can fix x and iterate through the rest of the characters in the string. Time complexity O(26^2) = O(1)\n \"\"\"\n freqs = sorted(list(Counter(word).values()))\n prefix = freqs.copy()\n for i in range(1, len(prefix)):\n prefix[i] += prefix[i - 1]\n\n res = float(\"inf\")\n for i, freq in enumerate(freqs):\n cur = prefix[i - 1] if i > 0 else 0\n for j in range(i, len(freqs)):\n cur += max(0, freqs[j] - freqs[i] - k)\n res = min(res, cur)\n return res\n","runtime":"97"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n C = collections.Counter(word)\n freq = sorted(set(C.values()))\n ret = len(word)\n for low in freq:\n remain = sum(min(C[ch],low+k) for ch in C if C[ch]>=low)\n ret = min(ret,len(word)-remain)\n return ret","runtime":"97"},{"code":"class Solution:\n def minimumDeletions(self, s: str, k: int) -> int:\n occ = Counter(s)\n tot = 0\n \n v = list(occ.values())\n v.sort()\n n = len(v)\n\n cum = v.copy()\n for i in range(1, n):\n cum[i] += cum[i-1]\n \n i = 0\n j = 0\n ans = 1e9\n\n while j < n:\n if v[j] - v[i] <= k:\n j += 1\n else:\n del_ = 0\n if i:\n del_ += cum[i-1]\n cnt = n-j\n del_ += (cum[n-1] - cum[j-1]) - cnt*(v[i]+k)\n ans = min(del_, ans)\n i += 1\n\n del_ = 0\n if i:\n del_ += cum[i-1]\n cnt = n-j\n del_ += (cum[n-1] - cum[j-1]) - cnt*(v[i]+k)\n ans = min(del_, ans)\n\n return ans","runtime":"108"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n cnt = collections.Counter(word).values()\n res = float('inf')\n for x in cnt:\n res = min(res, sum(max(abs(x - c) - k, 0) if c >= x else c for c in cnt))\n return res","runtime":"108"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n for char in word:\n freq[char] = freq.get(char, 0) + 1\n \n counts = sorted(freq.values())\n min_deletions = float('inf')\n \n for i in range(len(counts)):\n target = counts[i]\n deletions = sum(max(0, count - (target + k)) for count in counts[i:])\n deletions += sum(counts[:i])\n min_deletions = min(min_deletions, deletions)\n \n return min_deletions","runtime":"119"},{"code":"from collections import defaultdict\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n ans = inf\n hm = defaultdict(int)\n\n for i in word:\n hm[i] += 1\n\n count = sorted(hm.values())\n n = len(count)\n\n for i in range(n):\n total = 0\n for j in range(0,i):\n total += count[j]\n\n for j in range(i + 1, n):\n if count[j] - count[i] > k:\n total += count[j] - count[i] - k\n\n ans = min(ans, total)\n\n return ans","runtime":"130"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n for char in word:\n freq[char] = freq.get(char, 0)+1\n \n \n frequencies = sorted(freq.values())\n min_del = inf\n \n for i in range(len(frequencies) - 1, -1, -1):\n trgt = frequencies[i]\n dels = 0\n for f in frequencies:\n if f>trgt+k:\n dels += f - (trgt+k)\n elif f<trgt:\n dels += f\n min_del = min(min_del, dels)\n if min_del == 0:\n break\n return min_del if min_del != float('inf') else 0\n","runtime":"130"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n counts = defaultdict(lambda: 0)\n\n for c in word:\n counts[c] += 1\n\n counts = sorted(counts.values())\n\n before = []\n island = counts[0:1]\n after = counts[1:]\n\n min_deletions = None\n\n while len(after) > 0:\n if len(island) == 0:\n island = after[0:1]\n after = after[1:]\n\n after_updated = []\n for c in after:\n if c - island[0] <= k:\n island.append(c)\n else:\n after_updated.append(c)\n after = after_updated\n \n deletions = sum(before) + sum(map(lambda x: x - (island[0] + k), after))\n if min_deletions is None or deletions < min_deletions:\n min_deletions = deletions\n\n before.append(island[0])\n island = island[1:]\n \n return min_deletions if min_deletions is not None else 0","runtime":"142"},{"code":"class Solution:\n def minimumDeletions(self, s: str, k: int) -> int:\n c = [0] * 26\n for i in map(ord, s):\n c[i - 97] += 1\n\n ans = inf\n for i in c:\n if i == 0: continue\n cur = 0\n ik = i + k\n for j in c:\n if j == 0: continue\n if j < i: cur += j\n elif j > ik: cur += j - ik\n if cur > ans: break\n else:\n ans = cur\n return ans","runtime":"142"},{"code":"class Solution:\n def minimumDeletions(self, w: str, k: int) -> int:\n d = {}\n for i in w:\n d[i] = d.get(i, 0) + 1\n ck = [d[i] for i in d]\n ck.sort()\n\n def solve(ar):\n ct = 0\n while ar:\n x = ar[-1]\n if x - ar[0] > k:\n ct += x - (ar[0] + k)\n ar.pop()\n return ct\n ans = float('inf')\n ct = 0\n for i in range(len(ck)):\n kk = solve(ck[i:])\n ans = min(ans ,ct +kk )\n ct += ck[i]\n return ans","runtime":"153"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n frequency = {}\n for letter in word:\n if letter in frequency:\n frequency[letter]+=1\n else:\n frequency[letter]=1\n \n freqs = frequency.values()\n freqs = sorted(freqs)\n n = len(freqs)\n print(freqs)\n ans = len(word)\n for i in range(n):\n sumLow = 0\n low = 0\n while(low < i):\n sumLow+=freqs[low]\n low+=1\n \n high = n-1\n sumHigh = 0\n while(freqs[high] > freqs[i]+k):\n sumHigh+=(freqs[high]-freqs[i]-k)\n high-=1\n \n ans = min(ans, sumLow+sumHigh)\n return ans\n","runtime":"153"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freqLi = sorted(map(word.count, set(word)))\n\n minDeletions = len(word) + 1\n for kLowerB in range(0, max(max(freqLi) - k + 1, 1)):\n kUpperB = kLowerB + k\n deletions = 0\n for n in freqLi:\n if n < kLowerB:\n deletions += n\n elif n > kUpperB:\n deletions += (n - kUpperB)\n minDeletions = min(minDeletions, deletions)\n\n return minDeletions\n\n ","runtime":"164"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n # given a min and a max freq: either bring the min freq to zero, or bring the max down to min+k, then recursively apply with the new max freq or new min freq (dp), there are only 26 possible characters, so the complexity is at most 26**2\n freqs = [0] * 26\n for char in word:\n freqs[ord(char) - ord(\"a\")] += 1\n self.freqs = sorted(freqs)\n self.k = k\n return self.dp(0, 25)\n @cache\n def dp(self, minIndex: int, maxIndex: int) -> int:\n if minIndex == maxIndex:\n return 0\n if self.freqs[maxIndex] <= self.freqs[minIndex] + self.k:\n return 0\n return min(self.freqs[minIndex] + self.dp(minIndex+1, maxIndex), self.freqs[maxIndex] - self.freqs[minIndex] - self.k + self.dp(minIndex, maxIndex-1))","runtime":"164"},{"code":"# 2,3,5,6,3\n# 2,2,2,2,2,2,2,18\n\n# x1*2, x2*4, x3*6, .... ,xi*18\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n if len(word) <= 1:\n return 0\n counts = {}\n for _,c in enumerate(word):\n if c not in counts:\n counts[c] = 1\n else:\n counts[c] += 1\n \n minCount = -1\n for count in counts.values():\n deletions = 0\n for c in counts.values():\n if c < count:\n deletions += c\n if c > count+k:\n deletions += (c-count-k)\n if minCount < 0 or deletions < minCount:\n minCount = deletions\n\n return minCount\n\n\n ","runtime":"175"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freqs = [0] * 26\n for c in word:\n freqs[ord(c) - ord('a')] += 1\n freqs.sort(reverse=True)\n res = len(word)\n for a in freqs:\n c = 0\n for b in freqs:\n c += b if b < a else max(0, b - (a + k))\n res = min(res, c)\n return res","runtime":"175"},{"code":"def recur_func(i, j, arr, k, dp):\n if i > j:\n return 0\n \n if arr[j][1] - arr[i][1] <= k:\n return 0\n \n if dp[i][j] != -1:\n return dp[i][j]\n\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\n\n temp = arr[j][1] - arr[i][1] - k\n arr[j][1] -= (temp)\n case2 = temp + recur_func(i, j-1, arr, k, dp)\n arr[j][1] += (temp)\n\n dp[i][j] = min(case1, case2)\n return dp[i][j]\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n n = len(word)\n\n for i in range(n):\n if word[i] not in freq:\n freq[word[i]] = 1\n else:\n freq[word[i]] += 1\n\n arr = []\n for key in freq:\n arr.append([key, freq[key]])\n \n arr = sorted(arr, key = lambda x : x[1])\n print(arr)\n\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\n return recur_func(0, len(arr) - 1, arr, k, dp)\n\n ","runtime":"187"},{"code":"from collections import Counter\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n # freqLi = sorted(map(word.count, set(word)))\n freqLi = sorted(Counter(word).values())\n\n minDeletions = len(word) + 1\n for kLowerB in range(0, max(max(freqLi) - k + 1, 1)):\n kUpperB = kLowerB + k\n deletions = 0\n for n in freqLi:\n if n < kLowerB:\n deletions += n\n elif n > kUpperB:\n deletions += (n - kUpperB)\n minDeletions = min(minDeletions, deletions)\n\n return minDeletions\n\n ","runtime":"198"},{"code":"def recur_func(i, j, arr, k, dp):\n # base case\n if i > j:\n return 0\n \n if arr[j][1] - arr[i][1] <= k:\n return 0\n \n # cache check\n if dp[i][j] != -1:\n return dp[i][j]\n\n # transition\n # deleting frequency of ith index character\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\n\n # deleting the frequency of jth index character such that difference between them <= k\n temp = arr[j][1] - arr[i][1] - k\n arr[j][1] -= (temp)\n case2 = temp + recur_func(i, j-1, arr, k, dp)\n arr[j][1] += (temp)\n \n # save and return \n dp[i][j] = min(case1, case2)\n return dp[i][j]\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n n = len(word)\n\n for i in range(n):\n if word[i] not in freq:\n freq[word[i]] = 1\n else:\n freq[word[i]] += 1\n\n arr = []\n for key in freq:\n arr.append([key, freq[key]])\n \n arr = sorted(arr, key = lambda x : x[1])\n # print(arr)\n\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\n return recur_func(0, len(arr) - 1, arr, k, dp)\n\n ","runtime":"198"},{"code":"from collections import Counter\nimport operator\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n min_deletions = 10 ** 20\n char_counts = Counter()\n for c in word:\n char_counts[c] += 1\n char_counts = sorted(char_counts.items(), key=operator.itemgetter(1))\n already_deleted = 0\n for i in range(0, len(char_counts) - 1):\n c1, count1 = char_counts[i]\n deletions = 0\n for j in range(i + 1, len(char_counts)):\n c2, count2 = char_counts[j]\n if count2 - count1 > k:\n deletions += (count2 - count1) - k\n min_deletions = min(min_deletions, deletions + already_deleted)\n already_deleted += count1\n min_deletions = min(min_deletions, already_deleted)\n return min_deletions\n ","runtime":"209"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n \n count = Counter(word)\n ma_count = max(count.values())\n mi_count = ma_count-k\n \n if mi_count<=0:\n return 0\n \n ans = len(word)\n \n while mi_count>=0:\n total_del = 0\n for k,v in count.items():\n if v>ma_count:\n total_del += (v-ma_count)\n elif v<mi_count:\n total_del += v\n ans = min(ans,total_del)\n mi_count-=1\n ma_count-=1\n \n return ans","runtime":"220"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n \n count = Counter(word)\n #print(count)\n ma_count = max(count.values())\n mi_count = ma_count-k\n \n if mi_count<=0:\n return 0\n \n ans = len(word)\n \n while mi_count>=0:\n total_del = 0\n for k,v in count.items():\n if v>ma_count:\n total_del += (v-ma_count)\n elif v<mi_count:\n total_del += v\n ans = min(ans,total_del)\n #print(mi_count,ma_count,ans)\n mi_count-=1\n ma_count-=1\n \n return ans","runtime":"231"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/3000-3099/3085.Minimum%20Deletions%20to%20Make%20String%20K-Special\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n mx = max(nums)\n return min(f(v) for v in range(mx + 1))","runtime":"265"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n cnt = Counter() \n \n for c in word:\n cnt[c] += 1\n \n maxcnt = max([m for _, m in cnt.items()]) \n if k >= maxcnt:\n return 0\n \n nums = [0] * (maxcnt + 2) \n prefnums = [0] * (maxcnt + 2) \n preftotal = [0] * (maxcnt + 2) \n \n for i, m in cnt.items():\n \n nums[m] += 1\n \n for i in range(1, maxcnt+2):\n preftotal[i] = preftotal[i-1] + i*nums[i] \n prefnums[i] = prefnums[i-1] + nums[i] \n \n n = len(word)\n remain = n\n ans = remain\n \n for i in range(1, maxcnt+1-k):\n right = (preftotal[-1] - preftotal[i+k]) - (prefnums[-1] - prefnums[i+k]) * (i+k) \n ans = min(ans, n - remain + right) \n remain -= nums[i] *i\n #print(i, ans, right, remain) \n #print(nums) \n #print(prefnums) \n #print(preftotal) \n return ans","runtime":"276"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n counts = list(collections.Counter(word).values())\n\n def cands():\n hi = max(counts)\n for lo in range(hi - k + 1):\n left = sum(x - (lo + k) for x in counts if x > lo + k)\n right = sum(x for x in counts if x < lo)\n yield left + right\n \n return min(cands(), default=0)","runtime":"288"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n AB=[word[0]]\n count=[1]\n for i in range(1,len(word)):\n if word[i] in AB:\n j=AB.index(word[i])\n count[j]+=1\n else:\n AB.append(word[i])\n count.append(1)\n count.sort()\n L=len(count)\n Sum=[count[0]]\n S=count[0]\n for i in range(1,L):\n S+=count[i]\n Sum.append(S)\n Min=count[0]\n Max=count[-1]\n def find(v):\n for i in range(0,L):\n if count[i]>v:\n return i\n return -1\n if find(count[0]+k)==-1:\n return 0\n else:\n j=find(count[0]+k)\n M=Sum[-1]-Sum[j-1]-(count[0]+k)*(L-j)\n for i in range(1,L):\n s=count[i]\n t=count[i]+k\n left=Sum[i-1]\n right=0\n if find(count[i]+k)!=-1:\n j=find(count[i]+k)\n right=Sum[-1]-Sum[j-1]-(count[i]+k)*(L-j)\n current=left+right\n if current<M:\n M=current\n return M\n ","runtime":"299"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n counts = list(collections.Counter(word).values())\n\n def cands():\n hi = max(counts)\n for lo in range(hi + 1):\n left = sum(x - (lo + k) for x in counts if x > lo + k)\n right = sum(x for x in counts if x < lo)\n yield left + right\n \n return min(cands())","runtime":"310"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n return min(f(v) for v in range(len(word) + 1))","runtime":"321"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n return min(f(v) for v in range(len(word) + 1))","runtime":"333"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n return min(f(v) for v in range(len(word) + 1))","runtime":"344"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n return min(f(v) for v in range(len(word) + 1))","runtime":"355"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n def f(v: int) -> int:\n ans = 0\n for x in nums:\n if x < v:\n ans += x\n elif x > v + k:\n ans += x - v - k\n return ans\n\n nums = Counter(word).values()\n return min(f(v) for v in range(len(word) + 1))","runtime":"366"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n lst = [] \\n for char in set(word):\\n lst.append(word.count(char))\\n # Now, lst records the frequency of every char in word\\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\\n # We adopt the brute force approach: traverse every frequency x \\n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\\n minn = float('inf')\\n for i in range(len(lst)):\\n delete = 0\\n upper = lst[i] + k # lower bound is lst[i] itself\\n for j in range(len(lst)):\\n if lst[i] <= lst[j] <= upper:\\n continue\\n if lst[j] < lst[i]:\\n delete += lst[j]\\n elif lst[j] > upper:\\n delete += (lst[j]-upper)\\n minn = min(delete, minn)\\n return minn\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n lst = []\\n ans = 0\\n for char in set(word):\\n lst.append(word.count(char))\\n minn = float('inf')\\n # print(lst)\\n for i in range(len(lst)):\\n delete = 0\\n upper = lst[i] + k\\n for j in range(len(lst)):\\n if lst[i] <= lst[j] <= upper:\\n continue\\n if lst[j] < lst[i]:\\n delete += lst[j]\\n elif lst[j] > upper:\\n delete += (lst[j]-upper)\\n # print(lst[i], upper, lower, delete)\\n minn = min(delete, minn)\\n return minn\",\n \"runtime\": \"63\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n lst = [] \\n for char in set(word):\\n lst.append(word.count(char))\\n # Now, lst records the frequency of every char in word\\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\\n # We adopt the brute force approach: traverse every frequency x \\n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\\n minn = float('inf')\\n for i in range(len(lst)):\\n delete = 0\\n upper = lst[i] + k # lower bound is lst[i] itself\\n for j in range(len(lst)):\\n if lst[i] <= lst[j] <= upper:\\n continue\\n if lst[j] < lst[i]:\\n delete += lst[j]\\n elif lst[j] > upper:\\n delete += (lst[j]-upper)\\n minn = min(delete, minn)\\n return minn\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n lst = [] \\n for char in set(word):\\n lst.append(word.count(char))\\n # Now, lst records the frequency of every char in word\\n # find the minimum number of deletions so that any pair of these numbers have a difference <= k\\n # We adopt the brute force approach: traverse every frequency x \\n # compute the min number of deletion for every x so that every other frequency falls into x's range: [x, x+k]\\n # smaller than [x, x+k] => delete all, larger than [x, x+k] => delete to x+k\\n minn = float('inf')\\n for i in range(len(lst)):\\n delete = 0\\n upper = lst[i] + k # lower bound is lst[i] itself\\n for j in range(len(lst)):\\n if lst[i] <= lst[j] <= upper:\\n continue\\n if lst[j] < lst[i]:\\n delete += lst[j]\\n elif lst[j] > upper:\\n delete += (lst[j]-upper)\\n minn = min(delete, minn)\\n return minn\",\n \"runtime\": \"74\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = list(Counter(word).values())\\n ans = len(word)\\n for start in set(freq):\\n end = start + k\\n ans = min(ans, sum((f - end if f > end else 0) if f >= start else f for f in freq))\\n return ans\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n # count the min deletion needed if we never change a char's frequency and having it be the min frequency, \\n # then ans is minimum res for each unique char\\n # this is because the answer must have at least a char that is unch and is smallest count. \\n\\n freq = Counter(word).values()\\n\\n res = float(\\\"inf\\\")\\n for anchor_freq in freq:\\n anchor_count = 0\\n for other_freq in freq:\\n anchor_count += other_freq if other_freq < anchor_freq else max(0, other_freq - (anchor_freq + k))\\n res = min(anchor_count, res)\\n \\n return res\\n\",\n \"runtime\": \"86\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n \\\"\\\"\\\"\\n Let x be the element with smallest frequency that appears in our final string. It is obviously we never want\\n to decerement x. We can fix x and iterate through the rest of the characters in the string. Time complexity O(26^2) = O(1)\\n \\\"\\\"\\\"\\n freqs = sorted(list(Counter(word).values()))\\n prefix = freqs.copy()\\n for i in range(1, len(prefix)):\\n prefix[i] += prefix[i - 1]\\n\\n res = float(\\\"inf\\\")\\n for i, freq in enumerate(freqs):\\n cur = prefix[i - 1] if i > 0 else 0\\n for j in range(i, len(freqs)):\\n cur += max(0, freqs[j] - freqs[i] - k)\\n res = min(res, cur)\\n return res\\n\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n C = collections.Counter(word)\\n freq = sorted(set(C.values()))\\n ret = len(word)\\n for low in freq:\\n remain = sum(min(C[ch],low+k) for ch in C if C[ch]>=low)\\n ret = min(ret,len(word)-remain)\\n return ret\",\n \"runtime\": \"97\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, s: str, k: int) -> int:\\n occ = Counter(s)\\n tot = 0\\n \\n v = list(occ.values())\\n v.sort()\\n n = len(v)\\n\\n cum = v.copy()\\n for i in range(1, n):\\n cum[i] += cum[i-1]\\n \\n i = 0\\n j = 0\\n ans = 1e9\\n\\n while j < n:\\n if v[j] - v[i] <= k:\\n j += 1\\n else:\\n del_ = 0\\n if i:\\n del_ += cum[i-1]\\n cnt = n-j\\n del_ += (cum[n-1] - cum[j-1]) - cnt*(v[i]+k)\\n ans = min(del_, ans)\\n i += 1\\n\\n del_ = 0\\n if i:\\n del_ += cum[i-1]\\n cnt = n-j\\n del_ += (cum[n-1] - cum[j-1]) - cnt*(v[i]+k)\\n ans = min(del_, ans)\\n\\n return ans\",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n cnt = collections.Counter(word).values()\\n res = float('inf')\\n for x in cnt:\\n res = min(res, sum(max(abs(x - c) - k, 0) if c >= x else c for c in cnt))\\n return res\",\n \"runtime\": \"108\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n for char in word:\\n freq[char] = freq.get(char, 0) + 1\\n \\n counts = sorted(freq.values())\\n min_deletions = float('inf')\\n \\n for i in range(len(counts)):\\n target = counts[i]\\n deletions = sum(max(0, count - (target + k)) for count in counts[i:])\\n deletions += sum(counts[:i])\\n min_deletions = min(min_deletions, deletions)\\n \\n return min_deletions\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n ans = inf\\n hm = defaultdict(int)\\n\\n for i in word:\\n hm[i] += 1\\n\\n count = sorted(hm.values())\\n n = len(count)\\n\\n for i in range(n):\\n total = 0\\n for j in range(0,i):\\n total += count[j]\\n\\n for j in range(i + 1, n):\\n if count[j] - count[i] > k:\\n total += count[j] - count[i] - k\\n\\n ans = min(ans, total)\\n\\n return ans\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n for char in word:\\n freq[char] = freq.get(char, 0)+1\\n \\n \\n frequencies = sorted(freq.values())\\n min_del = inf\\n \\n for i in range(len(frequencies) - 1, -1, -1):\\n trgt = frequencies[i]\\n dels = 0\\n for f in frequencies:\\n if f>trgt+k:\\n dels += f - (trgt+k)\\n elif f<trgt:\\n dels += f\\n min_del = min(min_del, dels)\\n if min_del == 0:\\n break\\n return min_del if min_del != float('inf') else 0\\n\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n counts = defaultdict(lambda: 0)\\n\\n for c in word:\\n counts[c] += 1\\n\\n counts = sorted(counts.values())\\n\\n before = []\\n island = counts[0:1]\\n after = counts[1:]\\n\\n min_deletions = None\\n\\n while len(after) > 0:\\n if len(island) == 0:\\n island = after[0:1]\\n after = after[1:]\\n\\n after_updated = []\\n for c in after:\\n if c - island[0] <= k:\\n island.append(c)\\n else:\\n after_updated.append(c)\\n after = after_updated\\n \\n deletions = sum(before) + sum(map(lambda x: x - (island[0] + k), after))\\n if min_deletions is None or deletions < min_deletions:\\n min_deletions = deletions\\n\\n before.append(island[0])\\n island = island[1:]\\n \\n return min_deletions if min_deletions is not None else 0\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, s: str, k: int) -> int:\\n c = [0] * 26\\n for i in map(ord, s):\\n c[i - 97] += 1\\n\\n ans = inf\\n for i in c:\\n if i == 0: continue\\n cur = 0\\n ik = i + k\\n for j in c:\\n if j == 0: continue\\n if j < i: cur += j\\n elif j > ik: cur += j - ik\\n if cur > ans: break\\n else:\\n ans = cur\\n return ans\",\n \"runtime\": \"142\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, w: str, k: int) -> int:\\n d = {}\\n for i in w:\\n d[i] = d.get(i, 0) + 1\\n ck = [d[i] for i in d]\\n ck.sort()\\n\\n def solve(ar):\\n ct = 0\\n while ar:\\n x = ar[-1]\\n if x - ar[0] > k:\\n ct += x - (ar[0] + k)\\n ar.pop()\\n return ct\\n ans = float('inf')\\n ct = 0\\n for i in range(len(ck)):\\n kk = solve(ck[i:])\\n ans = min(ans ,ct +kk )\\n ct += ck[i]\\n return ans\",\n \"runtime\": \"153\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n frequency = {}\\n for letter in word:\\n if letter in frequency:\\n frequency[letter]+=1\\n else:\\n frequency[letter]=1\\n \\n freqs = frequency.values()\\n freqs = sorted(freqs)\\n n = len(freqs)\\n print(freqs)\\n ans = len(word)\\n for i in range(n):\\n sumLow = 0\\n low = 0\\n while(low < i):\\n sumLow+=freqs[low]\\n low+=1\\n \\n high = n-1\\n sumHigh = 0\\n while(freqs[high] > freqs[i]+k):\\n sumHigh+=(freqs[high]-freqs[i]-k)\\n high-=1\\n \\n ans = min(ans, sumLow+sumHigh)\\n return ans\\n\",\n \"runtime\": \"153\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freqLi = sorted(map(word.count, set(word)))\\n\\n minDeletions = len(word) + 1\\n for kLowerB in range(0, max(max(freqLi) - k + 1, 1)):\\n kUpperB = kLowerB + k\\n deletions = 0\\n for n in freqLi:\\n if n < kLowerB:\\n deletions += n\\n elif n > kUpperB:\\n deletions += (n - kUpperB)\\n minDeletions = min(minDeletions, deletions)\\n\\n return minDeletions\\n\\n \",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n # given a min and a max freq: either bring the min freq to zero, or bring the max down to min+k, then recursively apply with the new max freq or new min freq (dp), there are only 26 possible characters, so the complexity is at most 26**2\\n freqs = [0] * 26\\n for char in word:\\n freqs[ord(char) - ord(\\\"a\\\")] += 1\\n self.freqs = sorted(freqs)\\n self.k = k\\n return self.dp(0, 25)\\n @cache\\n def dp(self, minIndex: int, maxIndex: int) -> int:\\n if minIndex == maxIndex:\\n return 0\\n if self.freqs[maxIndex] <= self.freqs[minIndex] + self.k:\\n return 0\\n return min(self.freqs[minIndex] + self.dp(minIndex+1, maxIndex), self.freqs[maxIndex] - self.freqs[minIndex] - self.k + self.dp(minIndex, maxIndex-1))\",\n \"runtime\": \"164\"\n },\n {\n \"code\": \"# 2,3,5,6,3\\n# 2,2,2,2,2,2,2,18\\n\\n# x1*2, x2*4, x3*6, .... ,xi*18\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n if len(word) <= 1:\\n return 0\\n counts = {}\\n for _,c in enumerate(word):\\n if c not in counts:\\n counts[c] = 1\\n else:\\n counts[c] += 1\\n \\n minCount = -1\\n for count in counts.values():\\n deletions = 0\\n for c in counts.values():\\n if c < count:\\n deletions += c\\n if c > count+k:\\n deletions += (c-count-k)\\n if minCount < 0 or deletions < minCount:\\n minCount = deletions\\n\\n return minCount\\n\\n\\n \",\n \"runtime\": \"175\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freqs = [0] * 26\\n for c in word:\\n freqs[ord(c) - ord('a')] += 1\\n freqs.sort(reverse=True)\\n res = len(word)\\n for a in freqs:\\n c = 0\\n for b in freqs:\\n c += b if b < a else max(0, b - (a + k))\\n res = min(res, c)\\n return res\",\n \"runtime\": \"175\"\n },\n {\n \"code\": \"def recur_func(i, j, arr, k, dp):\\n if i > j:\\n return 0\\n \\n if arr[j][1] - arr[i][1] <= k:\\n return 0\\n \\n if dp[i][j] != -1:\\n return dp[i][j]\\n\\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\\n\\n temp = arr[j][1] - arr[i][1] - k\\n arr[j][1] -= (temp)\\n case2 = temp + recur_func(i, j-1, arr, k, dp)\\n arr[j][1] += (temp)\\n\\n dp[i][j] = min(case1, case2)\\n return dp[i][j]\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n n = len(word)\\n\\n for i in range(n):\\n if word[i] not in freq:\\n freq[word[i]] = 1\\n else:\\n freq[word[i]] += 1\\n\\n arr = []\\n for key in freq:\\n arr.append([key, freq[key]])\\n \\n arr = sorted(arr, key = lambda x : x[1])\\n print(arr)\\n\\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\\n return recur_func(0, len(arr) - 1, arr, k, dp)\\n\\n \",\n \"runtime\": \"187\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n # freqLi = sorted(map(word.count, set(word)))\\n freqLi = sorted(Counter(word).values())\\n\\n minDeletions = len(word) + 1\\n for kLowerB in range(0, max(max(freqLi) - k + 1, 1)):\\n kUpperB = kLowerB + k\\n deletions = 0\\n for n in freqLi:\\n if n < kLowerB:\\n deletions += n\\n elif n > kUpperB:\\n deletions += (n - kUpperB)\\n minDeletions = min(minDeletions, deletions)\\n\\n return minDeletions\\n\\n \",\n \"runtime\": \"198\"\n },\n {\n \"code\": \"def recur_func(i, j, arr, k, dp):\\n # base case\\n if i > j:\\n return 0\\n \\n if arr[j][1] - arr[i][1] <= k:\\n return 0\\n \\n # cache check\\n if dp[i][j] != -1:\\n return dp[i][j]\\n\\n # transition\\n # deleting frequency of ith index character\\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\\n\\n # deleting the frequency of jth index character such that difference between them <= k\\n temp = arr[j][1] - arr[i][1] - k\\n arr[j][1] -= (temp)\\n case2 = temp + recur_func(i, j-1, arr, k, dp)\\n arr[j][1] += (temp)\\n \\n # save and return \\n dp[i][j] = min(case1, case2)\\n return dp[i][j]\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n n = len(word)\\n\\n for i in range(n):\\n if word[i] not in freq:\\n freq[word[i]] = 1\\n else:\\n freq[word[i]] += 1\\n\\n arr = []\\n for key in freq:\\n arr.append([key, freq[key]])\\n \\n arr = sorted(arr, key = lambda x : x[1])\\n # print(arr)\\n\\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\\n return recur_func(0, len(arr) - 1, arr, k, dp)\\n\\n \",\n \"runtime\": \"198\"\n },\n {\n \"code\": \"from collections import Counter\\nimport operator\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n min_deletions = 10 ** 20\\n char_counts = Counter()\\n for c in word:\\n char_counts[c] += 1\\n char_counts = sorted(char_counts.items(), key=operator.itemgetter(1))\\n already_deleted = 0\\n for i in range(0, len(char_counts) - 1):\\n c1, count1 = char_counts[i]\\n deletions = 0\\n for j in range(i + 1, len(char_counts)):\\n c2, count2 = char_counts[j]\\n if count2 - count1 > k:\\n deletions += (count2 - count1) - k\\n min_deletions = min(min_deletions, deletions + already_deleted)\\n already_deleted += count1\\n min_deletions = min(min_deletions, already_deleted)\\n return min_deletions\\n \",\n \"runtime\": \"209\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n \\n count = Counter(word)\\n ma_count = max(count.values())\\n mi_count = ma_count-k\\n \\n if mi_count<=0:\\n return 0\\n \\n ans = len(word)\\n \\n while mi_count>=0:\\n total_del = 0\\n for k,v in count.items():\\n if v>ma_count:\\n total_del += (v-ma_count)\\n elif v<mi_count:\\n total_del += v\\n ans = min(ans,total_del)\\n mi_count-=1\\n ma_count-=1\\n \\n return ans\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n \\n count = Counter(word)\\n #print(count)\\n ma_count = max(count.values())\\n mi_count = ma_count-k\\n \\n if mi_count<=0:\\n return 0\\n \\n ans = len(word)\\n \\n while mi_count>=0:\\n total_del = 0\\n for k,v in count.items():\\n if v>ma_count:\\n total_del += (v-ma_count)\\n elif v<mi_count:\\n total_del += v\\n ans = min(ans,total_del)\\n #print(mi_count,ma_count,ans)\\n mi_count-=1\\n ma_count-=1\\n \\n return ans\",\n \"runtime\": \"231\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/3000-3099/3085.Minimum%20Deletions%20to%20Make%20String%20K-Special\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n mx = max(nums)\\n return min(f(v) for v in range(mx + 1))\",\n \"runtime\": \"265\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n cnt = Counter() \\n \\n for c in word:\\n cnt[c] += 1\\n \\n maxcnt = max([m for _, m in cnt.items()]) \\n if k >= maxcnt:\\n return 0\\n \\n nums = [0] * (maxcnt + 2) \\n prefnums = [0] * (maxcnt + 2) \\n preftotal = [0] * (maxcnt + 2) \\n \\n for i, m in cnt.items():\\n \\n nums[m] += 1\\n \\n for i in range(1, maxcnt+2):\\n preftotal[i] = preftotal[i-1] + i*nums[i] \\n prefnums[i] = prefnums[i-1] + nums[i] \\n \\n n = len(word)\\n remain = n\\n ans = remain\\n \\n for i in range(1, maxcnt+1-k):\\n right = (preftotal[-1] - preftotal[i+k]) - (prefnums[-1] - prefnums[i+k]) * (i+k) \\n ans = min(ans, n - remain + right) \\n remain -= nums[i] *i\\n #print(i, ans, right, remain) \\n #print(nums) \\n #print(prefnums) \\n #print(preftotal) \\n return ans\",\n \"runtime\": \"276\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n counts = list(collections.Counter(word).values())\\n\\n def cands():\\n hi = max(counts)\\n for lo in range(hi - k + 1):\\n left = sum(x - (lo + k) for x in counts if x > lo + k)\\n right = sum(x for x in counts if x < lo)\\n yield left + right\\n \\n return min(cands(), default=0)\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n AB=[word[0]]\\n count=[1]\\n for i in range(1,len(word)):\\n if word[i] in AB:\\n j=AB.index(word[i])\\n count[j]+=1\\n else:\\n AB.append(word[i])\\n count.append(1)\\n count.sort()\\n L=len(count)\\n Sum=[count[0]]\\n S=count[0]\\n for i in range(1,L):\\n S+=count[i]\\n Sum.append(S)\\n Min=count[0]\\n Max=count[-1]\\n def find(v):\\n for i in range(0,L):\\n if count[i]>v:\\n return i\\n return -1\\n if find(count[0]+k)==-1:\\n return 0\\n else:\\n j=find(count[0]+k)\\n M=Sum[-1]-Sum[j-1]-(count[0]+k)*(L-j)\\n for i in range(1,L):\\n s=count[i]\\n t=count[i]+k\\n left=Sum[i-1]\\n right=0\\n if find(count[i]+k)!=-1:\\n j=find(count[i]+k)\\n right=Sum[-1]-Sum[j-1]-(count[i]+k)*(L-j)\\n current=left+right\\n if current<M:\\n M=current\\n return M\\n \",\n \"runtime\": \"299\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n counts = list(collections.Counter(word).values())\\n\\n def cands():\\n hi = max(counts)\\n for lo in range(hi + 1):\\n left = sum(x - (lo + k) for x in counts if x > lo + k)\\n right = sum(x for x in counts if x < lo)\\n yield left + right\\n \\n return min(cands())\",\n \"runtime\": \"310\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n return min(f(v) for v in range(len(word) + 1))\",\n \"runtime\": \"321\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n return min(f(v) for v in range(len(word) + 1))\",\n \"runtime\": \"333\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n return min(f(v) for v in range(len(word) + 1))\",\n \"runtime\": \"344\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n return min(f(v) for v in range(len(word) + 1))\",\n \"runtime\": \"355\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n def f(v: int) -> int:\\n ans = 0\\n for x in nums:\\n if x < v:\\n ans += x\\n elif x > v + k:\\n ans += x - v - k\\n return ans\\n\\n nums = Counter(word).values()\\n return min(f(v) for v in range(len(word) + 1))\",\n \"runtime\": \"366\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":37,"string":"37"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n frequency = {}\n for letter in word:\n if letter in frequency:\n frequency[letter]+=1\n else:\n frequency[letter]=1\n \n freqs = frequency.values()\n freqs = sorted(freqs)\n n = len(freqs)\n print(freqs)\n ans = len(word)\n for i in range(n):\n sumLow = 0\n low = 0\n while(low < i):\n sumLow+=freqs[low]\n low+=1\n \n high = n-1\n sumHigh = 0\n while(freqs[high] > freqs[i]+k):\n sumHigh+=(freqs[high]-freqs[i]-k)\n high-=1\n \n ans = min(ans, sumLow+sumHigh)\n return ans\n","memory":"17300"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freqs = [0] * 26\n for c in word:\n freqs[ord(c) - ord('a')] += 1\n freqs.sort(reverse=True)\n res = len(word)\n for a in freqs:\n c = 0\n for b in freqs:\n c += b if b < a else max(0, b - (a + k))\n res = min(res, c)\n return res","memory":"17400"},{"code":"class Solution:\n def minimumDeletions(self, s: str, k: int) -> int:\n c = [0] * 26\n for i in map(ord, s):\n c[i - 97] += 1\n\n ans = inf\n for i in c:\n cur = 0\n ik = i + k\n for j in c:\n if j < i: cur += j\n elif j > ik: cur += j - ik\n if cur > ans: break\n else:\n ans = cur\n return ans","memory":"17500"},{"code":"class Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = defaultdict(int) # 26 distinct keys\n for c in word: # O(word.length)\n freq[c] += 1\n \n min_deletions = 10**6\n\n for c, f in freq.items(): # O(26)\n tot_deletions = 0\n for c2, f2 in freq.items(): # O(26)\n if c2 == c:\n continue\n if f2 < f:\n tot_deletions += f2\n continue \n deletions = f2 - f - k\n tot_deletions += max(deletions, 0)\n \n min_deletions = min(min_deletions, tot_deletions)\n # tot = O(word.length + 26 * 26)\n return min_deletions\n\n\n\n\n ","memory":"17600"},{"code":"def recur_func(i, j, arr, k):\n if i > j:\n return 0\n \n if arr[j][1] - arr[i][1] <= k:\n return 0\n \n case1 = arr[i][1] + recur_func(i+1, j, arr, k)\n\n temp = arr[j][1] - arr[i][1] - k\n arr[j][1] -= (temp)\n case2 = temp + recur_func(i, j-1, arr, k)\n arr[j][1] += (temp)\n\n return min(case1, case2)\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n n = len(word)\n\n for i in range(n):\n if word[i] not in freq:\n freq[word[i]] = 1\n else:\n freq[word[i]] += 1\n\n arr = []\n for key in freq:\n arr.append([key, freq[key]])\n \n arr = sorted(arr, key = lambda x : x[1])\n print(arr)\n\n return recur_func(0, len(arr) - 1, arr, k)\n\n ","memory":"17700"},{"code":"def recur_func(i, j, arr, k, dp):\n if i > j:\n return 0\n \n if arr[j][1] - arr[i][1] <= k:\n return 0\n \n if dp[i][j] != -1:\n return dp[i][j]\n\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\n\n temp = arr[j][1] - arr[i][1] - k\n arr[j][1] -= (temp)\n case2 = temp + recur_func(i, j-1, arr, k, dp)\n arr[j][1] += (temp)\n\n dp[i][j] = min(case1, case2)\n return dp[i][j]\n\nclass Solution:\n def minimumDeletions(self, word: str, k: int) -> int:\n freq = {}\n n = len(word)\n\n for i in range(n):\n if word[i] not in freq:\n freq[word[i]] = 1\n else:\n freq[word[i]] += 1\n\n arr = []\n for key in freq:\n arr.append([key, freq[key]])\n \n arr = sorted(arr, key = lambda x : x[1])\n print(arr)\n\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\n return recur_func(0, len(arr) - 1, arr, k, dp)\n\n ","memory":"17800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n frequency = {}\\n for letter in word:\\n if letter in frequency:\\n frequency[letter]+=1\\n else:\\n frequency[letter]=1\\n \\n freqs = frequency.values()\\n freqs = sorted(freqs)\\n n = len(freqs)\\n print(freqs)\\n ans = len(word)\\n for i in range(n):\\n sumLow = 0\\n low = 0\\n while(low < i):\\n sumLow+=freqs[low]\\n low+=1\\n \\n high = n-1\\n sumHigh = 0\\n while(freqs[high] > freqs[i]+k):\\n sumHigh+=(freqs[high]-freqs[i]-k)\\n high-=1\\n \\n ans = min(ans, sumLow+sumHigh)\\n return ans\\n\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freqs = [0] * 26\\n for c in word:\\n freqs[ord(c) - ord('a')] += 1\\n freqs.sort(reverse=True)\\n res = len(word)\\n for a in freqs:\\n c = 0\\n for b in freqs:\\n c += b if b < a else max(0, b - (a + k))\\n res = min(res, c)\\n return res\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, s: str, k: int) -> int:\\n c = [0] * 26\\n for i in map(ord, s):\\n c[i - 97] += 1\\n\\n ans = inf\\n for i in c:\\n cur = 0\\n ik = i + k\\n for j in c:\\n if j < i: cur += j\\n elif j > ik: cur += j - ik\\n if cur > ans: break\\n else:\\n ans = cur\\n return ans\",\n \"memory\": \"17500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = defaultdict(int) # 26 distinct keys\\n for c in word: # O(word.length)\\n freq[c] += 1\\n \\n min_deletions = 10**6\\n\\n for c, f in freq.items(): # O(26)\\n tot_deletions = 0\\n for c2, f2 in freq.items(): # O(26)\\n if c2 == c:\\n continue\\n if f2 < f:\\n tot_deletions += f2\\n continue \\n deletions = f2 - f - k\\n tot_deletions += max(deletions, 0)\\n \\n min_deletions = min(min_deletions, tot_deletions)\\n # tot = O(word.length + 26 * 26)\\n return min_deletions\\n\\n\\n\\n\\n \",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"def recur_func(i, j, arr, k):\\n if i > j:\\n return 0\\n \\n if arr[j][1] - arr[i][1] <= k:\\n return 0\\n \\n case1 = arr[i][1] + recur_func(i+1, j, arr, k)\\n\\n temp = arr[j][1] - arr[i][1] - k\\n arr[j][1] -= (temp)\\n case2 = temp + recur_func(i, j-1, arr, k)\\n arr[j][1] += (temp)\\n\\n return min(case1, case2)\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n n = len(word)\\n\\n for i in range(n):\\n if word[i] not in freq:\\n freq[word[i]] = 1\\n else:\\n freq[word[i]] += 1\\n\\n arr = []\\n for key in freq:\\n arr.append([key, freq[key]])\\n \\n arr = sorted(arr, key = lambda x : x[1])\\n print(arr)\\n\\n return recur_func(0, len(arr) - 1, arr, k)\\n\\n \",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"def recur_func(i, j, arr, k, dp):\\n if i > j:\\n return 0\\n \\n if arr[j][1] - arr[i][1] <= k:\\n return 0\\n \\n if dp[i][j] != -1:\\n return dp[i][j]\\n\\n case1 = arr[i][1] + recur_func(i+1, j, arr, k, dp)\\n\\n temp = arr[j][1] - arr[i][1] - k\\n arr[j][1] -= (temp)\\n case2 = temp + recur_func(i, j-1, arr, k, dp)\\n arr[j][1] += (temp)\\n\\n dp[i][j] = min(case1, case2)\\n return dp[i][j]\\n\\nclass Solution:\\n def minimumDeletions(self, word: str, k: int) -> int:\\n freq = {}\\n n = len(word)\\n\\n for i in range(n):\\n if word[i] not in freq:\\n freq[word[i]] = 1\\n else:\\n freq[word[i]] += 1\\n\\n arr = []\\n for key in freq:\\n arr.append([key, freq[key]])\\n \\n arr = sorted(arr, key = lambda x : x[1])\\n print(arr)\\n\\n dp = [[-1 for j in range(len(arr))]for i in range(len(arr))]\\n return recur_func(0, len(arr) - 1, arr, k, dp)\\n\\n \",\n \"memory\": \"17800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":6,"string":"6"}}},{"rowIdx":2440,"cells":{"question_id":{"kind":"number","value":3327,"string":"3,327"},"name":{"kind":"string","value":"minimum-moves-to-pick-k-ones"},"content":{"kind":"string","value":"<p>You are given a binary array <code>nums</code> of length <code>n</code>, a <strong>positive</strong> integer <code>k</code> and a <strong>non-negative</strong> integer <code>maxChanges</code>.</p>\n\n<p>Alice plays a game, where the goal is for Alice to pick up <code>k</code> ones from <code>nums</code> using the <strong>minimum</strong> number of <strong>moves</strong>. When the game starts, Alice picks up any index <code>aliceIndex</code> in the range <code>[0, n - 1]</code> and stands there. If <code>nums[aliceIndex] == 1</code> , Alice picks up the one and <code>nums[aliceIndex]</code> becomes <code>0</code>(this <strong>does not</strong> count as a move). After this, Alice can make <strong>any</strong> number of <strong>moves</strong> (<strong>including</strong> <strong>zero</strong>) where in each move Alice must perform <strong>exactly</strong> one of the following actions:</p>\n\n<ul>\n\t<li>Select any index <code>j != aliceIndex</code> such that <code>nums[j] == 0</code> and set <code>nums[j] = 1</code>. This action can be performed <strong>at</strong> <strong>most</strong> <code>maxChanges</code> times.</li>\n\t<li>Select any two adjacent indices <code>x</code> and <code>y</code> (<code>|x - y| == 1</code>) such that <code>nums[x] == 1</code>, <code>nums[y] == 0</code>, then swap their values (set <code>nums[y] = 1</code> and <code>nums[x] = 0</code>). If <code>y == aliceIndex</code>, Alice picks up the one after this move and <code>nums[y]</code> becomes <code>0</code>.</li>\n</ul>\n\n<p>Return <em>the <strong>minimum</strong> number of moves required by Alice to pick <strong>exactly </strong></em><code>k</code> <em>ones</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">3</span></p>\n\n<p><strong>Explanation:</strong> Alice can pick up <code>3</code> ones in <code>3</code> moves, if Alice performs the following actions in each move when standing at <code>aliceIndex == 1</code>:</p>\n\n<ul>\n\t<li>At the start of the game Alice picks up the one and <code>nums[1]</code> becomes <code>0</code>. <code>nums</code> becomes <code>[1,<strong><u>0</u></strong>,0,0,0,1,1,0,0,1]</code>.</li>\n\t<li>Select <code>j == 2</code> and perform an action of the first type. <code>nums</code> becomes <code>[1,<strong><u>0</u></strong>,1,0,0,1,1,0,0,1]</code></li>\n\t<li>Select <code>x == 2</code> and <code>y == 1</code>, and perform an action of the second type. <code>nums</code> becomes <code>[1,<strong><u>1</u></strong>,0,0,0,1,1,0,0,1]</code>. As <code>y == aliceIndex</code>, Alice picks up the one and <code>nums</code> becomes <code>[1,<strong><u>0</u></strong>,0,0,0,1,1,0,0,1]</code>.</li>\n\t<li>Select <code>x == 0</code> and <code>y == 1</code>, and perform an action of the second type. <code>nums</code> becomes <code>[0,<strong><u>1</u></strong>,0,0,0,1,1,0,0,1]</code>. As <code>y == aliceIndex</code>, Alice picks up the one and <code>nums</code> becomes <code>[0,<strong><u>0</u></strong>,0,0,0,1,1,0,0,1]</code>.</li>\n</ul>\n\n<p>Note that it may be possible for Alice to pick up <code>3</code> ones using some other sequence of <code>3</code> moves.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\" style=\"border-color: var(--border-tertiary); border-left-width: 2px; color: var(--text-secondary); font-size: .875rem; margin-bottom: 1rem; margin-top: 1rem; overflow: visible; padding-left: 1rem;\">\n<p><strong>Input: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">nums = [0,0,0,0], k = 2, maxChanges = 3</span></p>\n\n<p><strong>Output: </strong><span class=\"example-io\" style=\"font-family: Menlo,sans-serif; font-size: 0.85rem;\">4</span></p>\n\n<p><strong>Explanation:</strong> Alice can pick up <code>2</code> ones in <code>4</code> moves, if Alice performs the following actions in each move when standing at <code>aliceIndex == 0</code>:</p>\n\n<ul>\n\t<li>Select <code>j == 1</code> and perform an action of the first type. <code>nums</code> becomes <code>[<strong><u>0</u></strong>,1,0,0]</code>.</li>\n\t<li>Select <code>x == 1</code> and <code>y == 0</code>, and perform an action of the second type. <code>nums</code> becomes <code>[<strong><u>1</u></strong>,0,0,0]</code>. As <code>y == aliceIndex</code>, Alice picks up the one and <code>nums</code> becomes <code>[<strong><u>0</u></strong>,0,0,0]</code>.</li>\n\t<li>Select <code>j == 1</code> again and perform an action of the first type. <code>nums</code> becomes <code>[<strong><u>0</u></strong>,1,0,0]</code>.</li>\n\t<li>Select <code>x == 1</code> and <code>y == 0</code> again, and perform an action of the second type. <code>nums</code> becomes <code>[<strong><u>1</u></strong>,0,0,0]</code>. As <code>y == aliceIndex</code>, Alice picks up the one and <code>nums</code> becomes <code>[<strong><u>0</u></strong>,0,0,0]</code>.</li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= n <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= nums[i] <= 1</code></li>\n\t<li><code>1 <= k <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= maxChanges <= 10<sup>5</sup></code></li>\n\t<li><code>maxChanges + sum(nums) >= k</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":23.459539717891612,"string":"23.45954"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","greedy","sliding-window","prefix-sum"],"string":"[\n \"array\",\n \"greedy\",\n \"sliding-window\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"500\", 16.438000000000002], [\"541\", 19.1777], [\"581\", 21.9174], [\"622\", 23.287499999999998], [\"663\", 6.164199999999999], [\"703\", 0.6849], [\"744\", 0.6849], [\"785\", 0.6849], [\"826\", 0.6849], [\"866\", 0.6849], [\"907\", 0.6849], [\"948\", 0.6849], [\"988\", 0.6849], [\"1029\", 0.6849], [\"1070\", 0.6849], [\"1111\", 0.6849]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19700\", 1.3699], [\"22400\", 1.3699], [\"22500\", 2.0548], [\"22600\", 2.0548], [\"22700\", 0.6849], [\"23000\", 0.6849], [\"23400\", 0.6849], [\"23500\", 8.2192], [\"23600\", 2.0548], [\"25700\", 4.1096], [\"25800\", 4.1096], [\"25900\", 2.0548], [\"26000\", 2.7397], [\"26400\", 1.3699], [\"26500\", 6.1644], [\"26600\", 18.4932], [\"26700\", 10.9589], [\"26800\", 1.3699], [\"27200\", 1.3699], [\"27300\", 9.589], [\"27400\", 9.589]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n\n t = max((len(list(g)) for k, g in groupby(nums) if k == 1), default=0)\n t = min(t, 3)\n\n if k - maxChanges <= t:\n if k <= t:\n return k - 1\n if t > 0:\n return 2*(k - t) + t-1\n return 2*k\n \n k -= maxChanges\n res = inf\n\n psums = list(accumulate((i for i, x in enumerate(nums) if x==1), initial=0))\n for i in range(k, len(psums)):\n j = i-(k+1)//2\n res = min(res, (psums[i]-psums[i-k//2]) - (psums[j]-psums[j-k//2]))\n return res + 2*maxChanges\n\n\n","runtime":"500"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n s = \"\".join(map(str, nums))\n if \"111\" in s:\n maxcon = 3\n elif \"11\" in s:\n maxcon = 2\n elif \"1\" in s:\n maxcon = 1\n else:\n maxcon = 0\n\n if maxcon > k:\n maxcon = k\n if maxChanges >= k - maxcon:\n return (k - maxcon) * 2 + max(0, maxcon - 1)\n\n res = maxChanges * 2\n k -= maxChanges\n idxes = [i for i in range(len(nums)) if nums[i] == 1]\n pmid = k // 2\n left = 0\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\n for right in range(k, len(idxes)):\n cdiff -= idxes[pmid] - idxes[left]\n left += 1\n cdiff += idxes[right] - idxes[pmid + 1]\n move_d = idxes[pmid + 1] - idxes[pmid]\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\n mdiff = min(mdiff, cdiff)\n pmid += 1\n res += mdiff\n return res\nres=2\nk=4\nidxes=0,1,2,3,4\npmid=3\nleft=1\ncdiff=4\nmdiff=4\nmove_d=1\nright=4","runtime":"500"},{"code":"\"\"\"\nIntuitions\n1. There are 2 optimal ways of getting a point.\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\n This costs 2 operations.\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\n This costs dist(alice_index, one_index) many operations. \n2. There can be at most 3 operations costing < 2 operations for (b) if we have \n <= 3 consecutive ones.\n\nAlgorithm\n1. Count the number of consecutive ones up to 3.\n2. If k <= m, we only need k - 1 moves.\n3. \n\"\"\"\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n pos = []\n \n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\n # requiring less than 2 operations).\n m = 0\n \n # compute m (just counting the max consecutive ones up to length 3).\n for i, num in enumerate(nums):\n if num == 0:\n continue \n pos.append(i)\n m = max(m, 1)\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\n m = 3\n elif i > 0 and nums[i - 1] == 1:\n m = max(m, 2)\n \n # here, we are greedy and prefer using as little moves as possible\n # optimally, we want to use operations costing 0 (start at 1), \n # 1 (move adjacent 1), or 2 (use operation (a)).\n if m >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n return k - 1\n elif m + max_changes >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n # for the remaining operations, use the 2 move operations. \n return max(m - 1, 0) + (k - m) * 2\n \n k -= max_changes\n n = len(pos)\n prefix = [0] + list(accumulate(pos))\n res = float(\"inf\")\n \n for i in range(n - k + 1):\n j = i + k\n median = i + k // 2\n idx = pos[median]\n left = idx * (median - i) - (prefix[median] - prefix[i])\n right = prefix[j] - prefix[median] - idx * (j - median)\n res = min(res, left + right)\n \n return max_changes * 2 + res\n ","runtime":"541"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n\n s = \"\".join(map(str, nums))\n if \"111\" in s:\n max_cons = 3\n elif \"11\" in s:\n max_cons = 2\n elif \"1\" in s:\n max_cons = 1\n else:\n max_cons = 0\n\n if max_cons > k:\n max_cons = k\n if max_changes >= k - max_cons:\n return (k - max_cons) * 2 + max(0, max_cons - 1)\n\n one_idxs = [idx for idx, num in enumerate(nums) if num == 1]\n if not one_idxs:\n return k*2\n # print('one_idxs',one_idxs)\n # return \n prefix_sums = [x for x in one_idxs]\n prefix_sums[0] = one_idxs[0]\n for i in range(1, len(one_idxs)):\n prefix_sums[i] += prefix_sums[i - 1]\n\n def get_sum(left, right):\n if right < left:\n return 0\n if left == 0:\n return prefix_sums[right]\n return prefix_sums[right] - prefix_sums[left - 1]\n min_cost = float('inf')\n for change in range(max_changes,max_changes+1):\n rem_k = k - change\n cost_change = change * 2\n if rem_k > len(one_idxs):\n continue\n left = 0\n right = max(0,rem_k - 1)\n cost_swap = float('inf')\n # print(\"START\", left,right, 'change',change,'rem_k',rem_k),\n while right < len(one_idxs):\n mid = (left + right) // 2\n # print(left,mid,right)\n cost_left = (mid-left)*one_idxs[mid] - get_sum(left,mid-1)\n # print('(mid-left)*one_idxs[mid]',(mid-left)*one_idxs[mid])\n # print('get_sum(left,mid-1)',get_sum(left,mid-1))\n cost_right = get_sum(mid+1, right) - (right-mid)*one_idxs[mid]\n # print('rem_k',rem_k, 'left', left,'mid',mid,'right', right,'cost_left',cost_left,'cost_right',cost_right )\n # print()\n cost_swap = min(cost_swap, cost_left+cost_right)\n right +=1\n left += 1\n # print('change',change, 'cost_change',cost_change, 'cost_swap',cost_swap)\n min_cost = min(min_cost, cost_change+cost_swap)\n return min_cost\n \n \n\n # 0 3 6 12 15\n # m\n # 6\n # m\n \n # sums of \n return 0","runtime":"541"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n nums = [i for i, a in enumerate(nums) if a]\n n = len(nums)\n nums = [0] + list(accumulate(nums))\n m = max(0, k - maxChanges)\n res = inf\n for j in range(m, min(n, m + 3, k) + 1):\n for i in range(n - j + 1):\n cur = nums[i + j] - nums[i + j - j // 2] - (nums[i + j // 2] - nums[i])\n res = min(res, cur + (k - j) * 2)\n return res\n\n \"\"\"\n ans = inf\n prefix = [0]\n for i in range(len(nums)):\n if nums[i] == 1:\n prefix.append(prefix[-1] + i)\n # case all zero\n if len(prefix) == 1:\n return k * 2\n # numbers that must use op2\n min_ws = max(k - maxChanges, 0)\n # if ws > min_ws+3, the cost must be greater than 2 -> some op2 should be replace with op1\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\n for ws in range(min_ws, max_ws + 1):\n for start_idx in range(len(prefix) - ws):\n end_idx = start_idx + ws\n mid_left = (start_idx + end_idx) // 2\n mid_right = (start_idx + end_idx + 1) // 2\n # cost = min dis sum from start_idx to end_idx\n cost = prefix[end_idx] - prefix[mid_left] - (prefix[mid_right] - prefix[start_idx])\n # fill rest with op1\n cost += (k - ws) * 2\n ans = min(ans, cost)\n return ans \"\"\"","runtime":"581"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n if sum(nums) + maxChanges < k:\n return 0\n\n if k == 1 and sum(nums) >= 1:\n return 0\n\n ans = float('inf')\n\n for i in range(len(nums) - 2):\n if nums[i] == nums[i+1] == nums[i+2] == 1:\n if k == 2:\n return 1\n if k == 3:\n return 2\n rem = k-3\n moves = 2\n if maxChanges >= rem:\n moves += 2*rem\n return moves\n\n for i in range(len(nums) - 1):\n if nums[i] == nums[i+1] == 1:\n if k == 2:\n return 1\n rem = k-2\n moves = 1\n if maxChanges >= rem:\n moves += 2*rem\n return moves\n\n if sum(nums) >= 1:\n if maxChanges >= k-1:\n return 2*(k-1)\n else:\n if maxChanges >= k:\n return 2*k\n\n # print(\"huhee\")\n idx = []\n running_sum = 0\n prefix = []\n for i in range(len(nums)):\n if nums[i] == 1:\n running_sum += i\n idx.append(i)\n prefix.append(running_sum)\n\n\n # print(idx)\n \n moves = 2*maxChanges\n rem = k - maxChanges\n\n # print(rem, moves)\n\n l = 0\n best_possible_of_rest = float('inf')\n for r in range(rem-1, len(idx)):\n mid = (r+l)//2\n if l > 0:\n diff = abs(prefix[mid] - prefix[l-1] - (idx[mid]*(mid - l + 1))) + abs(prefix[r] - prefix[mid] - idx[mid]*(r-mid))\n else:\n diff = abs(prefix[mid] - 0 - (idx[mid]*(mid - l + 1))) + abs(prefix[r] - prefix[mid] - idx[mid]*(r-mid))\n best_possible_of_rest = min(best_possible_of_rest, diff)\n l += 1\n\n # print(best_possible_of_rest)\n moves += best_possible_of_rest\n\n return moves\n\n\n\n \n\n ","runtime":"581"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ans = float(\"inf\")\n\n for i in range(n):\n curr = nums[i]\n move = 0\n if i > 0 and nums[i - 1] == 1:\n curr += 1\n move += 1\n if i < n - 1 and nums[i + 1] == 1 and curr < k:\n curr += 1\n move += 1\n if curr + maxChanges >= k:\n ans = min(ans, move + (k - curr) * 2)\n if curr + maxChanges >= k:\n return max(0, ans)\n\n arr = [i for i, v in enumerate(nums) if v == 1]\n target = k - maxChanges\n l, r = 0, target - 1\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges * 2\n ans = min(ans, prev)\n for i in range(1, len(arr)):\n diff = arr[i] - arr[i - 1]\n left_count, right_count = i - l, r - i + 1\n curr = prev + (left_count - right_count) * diff\n while r + 1 < len(arr) and arr[r + 1] - arr[i] <= arr[i] - arr[l]:\n curr -= arr[i] - arr[l]\n curr += arr[r + 1] - arr[i]\n r += 1\n l += 1\n ans = min(ans, curr)\n prev = curr\n return max(0, ans)\n\n ","runtime":"622"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n \n # SLIDING WINDOW AND PREFIX SUMS ( Note THAT TRICK Below )\n\n n = len(nums)\n\n max_consecutive = 0\n for i in range(n):\n cnt = 0\n for j in range(3):\n if i + j < n and nums[i + j] == 1:\n cnt += 1\n else:\n break\n max_consecutive = max(max_consecutive, cnt)\n\n if max_consecutive + max_changes >= k:\n if k <= max_consecutive:\n return k - 1\n\n req_changes = k - max_consecutive\n ans = req_changes * 2\n if max_consecutive > 0:\n ans += max_consecutive - 1\n return ans\n\n def converge(l, r, pos, ones, prefix):\n # VERY VERY USEFUL as IT TAKES only O(N)\n left = (pos - l + 1) * ones[pos] - (prefix[pos] - prefix[l - 1])\n right = (prefix[r] - prefix[pos]) - (r - pos) * ones[pos]\n\n return left + right\n\n ones = [-1]\n prefix = [0]\n for i in range(n):\n if nums[i] == 1:\n ones.append(i)\n prefix.append(prefix[-1] + i)\n\n req_1 = k - max_changes\n ans = float('inf')\n\n for l in range(1, len(ones) - req_1 + 1):\n r = l + req_1 - 1\n best_pos = (l + r) // 2\n ans = min(ans, converge(l, r, best_pos, ones, prefix))\n\n return ans + max_changes * 2","runtime":"622"},{"code":"\"\"\"\nIntuitions\n1. There are 2 optimal ways of getting a point.\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\n This costs 2 operations.\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\n This costs dist(alice_index, one_index) many operations. \n2. There can be at most 3 operations costing < 2 operations for (b) if we have \n <= 3 consecutive ones.\n\"\"\"\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n pos = []\n \n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\n # requiring less than 2 operations).\n m = 0\n \n # compute m (just counting the max consecutive ones up to length 3).\n for i, num in enumerate(nums):\n if num == 0:\n continue \n pos.append(i)\n m = max(m, 1)\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\n m = 3\n elif i > 0 and nums[i - 1] == 1:\n m = max(m, 2)\n \n # here, we are greedy and prefer using as little moves as possible\n # optimally, we want to use operations costing 0 (start at 1), \n # 1 (move adjacent 1), or 2 (use operation (a)).\n if m >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n return k - 1\n elif m + max_changes >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n # for the remaining operations, use the 2 move operations. \n return max(m - 1, 0) + (k - m) * 2\n \n # we can use between [0, max_changes] many operations costing 2 moves.\n n = len(pos)\n prefix = [0] + list(accumulate(pos))\n res = float(\"inf\")\n \n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\n for x in range(max_changes - m, max_changes + 1):\n required_window_size = k - x\n for i in range(max(n - required_window_size + 1, 0)):\n j = i + required_window_size\n median = i + required_window_size // 2\n idx = pos[median]\n \n # we are at idx = pos[median].\n # (1) assume we are at 0 instead. For each median - i points strictly prior \n # to median (i.e. ignoring median), it takes idx moves to move to idx.\n # Hence, idx * (median - i).\n # (2) but we don't start at 0. Instead, we start at pos[i], pos[i + 1], etc.\n # So, we want to subtract pos[i] + pos[i + 1] + ... + pos[median - 1].\n # This is prefix[median] - prefix[i].\n \n #\n # For more clarify, for each i <= a < median\n # idx = pos[median] = (pos[median] - pos[a]) + (pos[a] - 0)\n # = (pos[median] - pos[a]) + pos[a]\n # really, we just want is just (pos[median] - pos[a]).\n # step (1) computes pos[median] * idx = sum(pos[median] - pos[a] + pos[a])\n # step (2) computes sum(pos[median] - pos[a]) = pos[median] * idx - sum(pos[a]).\n # \n left = idx * (median - i) - (prefix[median] - prefix[i])\n \n # we are at idx = pos[median]\n # (1) assume we are at 0 instead. It takes prefix[j] - prefix[median] to traverse\n # to the point that we should end up at. This accounts for dist(0, median) + \n # dist(median, point). \n # (2) but we don't start at 0, and for each point, we've overcounted by idx.\n # hence, we subtract idx * (j - median) away.\n right = prefix[j] - prefix[median] - idx * (j - median)\n res = min(res, left + right + 2 * x)\n return res ","runtime":"663"},{"code":"\"\"\"\nIntuitions\n1. There are 2 optimal ways of getting a point.\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\n This costs 2 operations.\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\n This costs dist(alice_index, one_index) many operations. \n2. There can be at most 3 operations costing < 2 operations for (b) if we have \n <= 3 consecutive ones.\n\"\"\"\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n pos = []\n \n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\n # requiring less than 2 operations).\n m = 0\n \n # compute m (just counting the max consecutive ones up to length 3).\n for i, num in enumerate(nums):\n if num == 0:\n continue \n pos.append(i)\n m = max(m, 1)\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\n m = 3\n elif i > 0 and nums[i - 1] == 1:\n m = max(m, 2)\n \n # here, we are greedy and prefer using as little moves as possible\n # optimally, we want to use operations costing 0 (start at 1), \n # 1 (move adjacent 1), or 2 (use operation (a)).\n if m >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n return k - 1\n elif m + max_changes >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n # for the remaining operations, use the 2 move operations. \n return max(m - 1, 0) + (k - m) * 2\n \n # we can use between [0, max_changes] many operations costing 2 moves.\n n = len(pos)\n prefix = [0] + list(accumulate(pos))\n res = float(\"inf\")\n \n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\n for x in range(max_changes - m, max_changes + 1):\n required_window_size = k - x\n for i in range(max(n - required_window_size + 1, 0)):\n j = i + required_window_size\n median = i + required_window_size // 2\n idx = pos[median]\n \n # we are at idx = pos[median].\n # (1) assume we are at 0 instead. For each median - i points strictly prior \n # to median (i.e. ignoring median), it takes idx moves to move to idx.\n # Hence, idx * (median - i).\n # (2) but we don't start at 0. Instead, we start at pos[i], pos[i + 1], etc.\n # So, we want to subtract pos[i] + pos[i + 1] + ... + pos[median - 1].\n # This is prefix[median] - prefix[i].\n \n #\n # For more clarify, for each i <= a < median\n # idx = pos[median] = (pos[median] - pos[a]) + (pos[a] - 0)\n # = (pos[median] - pos[a]) + pos[a]\n # really, we just want is just (pos[median] - pos[a]).\n # step (1) computes pos[median] * idx = sum(pos[median] - pos[a] + pos[a])\n # step (2) computes sum(pos[median] - pos[a]) = pos[median] * idx - sum(pos[a]).\n # \n left = idx * (median - i) - (prefix[median] - prefix[i])\n \n\n right = prefix[j] - prefix[median] - idx * (j - median)\n res = min(res, left + right + 2 * x)\n return res ","runtime":"663"},{"code":"class Solution:\n def __init__(self):\n self.n = 0\n self.ones = []\n self.prefix = []\n\n def Converge(self, l, r, pos):\n lft = (pos - l + 1) * self.ones[pos] - (self.prefix[pos] - self.prefix[l - 1])\n rgt = (self.prefix[r] - self.prefix[pos]) - (r - pos) * self.ones[pos]\n return lft + rgt\n\n def minimumMoves(self, nums, k, maxChanges):\n self.n = len(nums)\n max_consecutive = 0\n\n # Find maximum number of consecutive ones in any segment of up to 3 elements\n for i in range(self.n):\n cnt = 0\n for j in range(3):\n if i + j < self.n and nums[i + j] == 1:\n cnt += 1\n else:\n break\n max_consecutive = max(max_consecutive, cnt)\n\n # If max consecutive ones plus max changes is greater than or equal to k\n if max_consecutive + maxChanges >= k:\n if k <= max_consecutive:\n return k - 1\n \n req_changes = k - max_consecutive\n ans = req_changes * 2\n if max_consecutive > 0:\n ans += max_consecutive - 1\n return ans\n\n # Populate ones and prefix arrays\n self.ones = [-1]\n self.prefix = [0]\n for i in range(self.n):\n if nums[i] == 1:\n self.ones.append(i)\n self.prefix.append(self.prefix[-1] + i)\n print(self.ones, self.prefix)\n req_1 = k - maxChanges\n ans = float('inf')\n\n for l in range(1, len(self.ones) - req_1 + 1):\n r = l + req_1 - 1\n best_pos = (l + r) // 2\n print(json.dumps({\"converge\": self.Converge(l,r,best_pos)}))\n ans = min(ans, self.Converge(l, r, best_pos))\n\n return ans + maxChanges * 2\n\n# Example usage:\n# sol = Solution()\n# result = sol.minimumMoves([1, 0, 1, 0, 1], 3, 1)\n# print(result)\n","runtime":"703"},{"code":"import numpy as np\nfrom typing import List\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n \n res = np.inf\n n = len(nums)\n ones_index = [i for i in range(n) if nums[i] == 1]\n\n def integrateCloseNeighborsAndMaxMoves(ind):\n score = 0\n moves = 0\n if nums[ind] == 1:\n score += 1\n\n if ind - 1 >= 0 and nums[ind-1] == 1 and score <k:\n moves += 1\n score += 1\n if ind + 1 < n and nums[ind+1] == 1 and score <k:\n moves += 1\n score +=1\n \n if score < k and maxChanges > 0:\n diff = min(k - score, maxChanges)\n score += diff \n moves += 2 * diff\n\n return (score, moves)\n \n def compute_nearest_neighbors(ind, left, nb_left, right, score):\n\n if needed <= 0:\n return (0,0,0,0)\n\n if ind == 0:\n nb_left = 1 if nums[ind] == 1 else 0\n left = 0 if nums[ind] == 1 else -1\n right = needed - 1\n score = sum(ones_index[:needed])\n\n else:\n score += nb_left\n score -= needed - nb_left\n\n if nums[ind] == 1:\n nb_left += 1\n if left == -1:\n left = 0\n\n while nb_left > 0 and right + 1 < len(ones_index) and ind-ones_index[left] >= ones_index[right + 1] - ind:\n score -= ind-ones_index[left]\n left += 1\n nb_left -= 1\n score += ones_index[right + 1] - ind\n right += 1\n\n return (left, nb_left, right, score)\n \n left, nb_left, right, score = None, None, None, None\n needed = k - maxChanges\n for i in range(n):\n \n #situation everything works with close points\n s,m = integrateCloseNeighborsAndMaxMoves(i)\n if s >= k:\n res = min(res, m)\n \n #situation need to fetch closest k - maxMoves neighbors\n m = 2 * maxChanges\n left, nb_left, right, score = compute_nearest_neighbors(i, left, nb_left, right, score) \n m += score\n\n res = min(res, m)\n \n return res","runtime":"744"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n index_of_ones = [i for i, num in enumerate(nums) if num == 1]\n n = len(index_of_ones)\n print(n)\n prefix_sum = [0] * (n+1)\n for i in range(1, n+1):\n prefix_sum[i] = prefix_sum[i-1] + index_of_ones[i-1]\n \n min_step2 = max(0, k-maxChanges)\n max_step2 = min(k, min_step2+3)\n\n res = inf\n for l in range(min_step2, max_step2+1):\n for left in range(n-l+1):\n right = left + l # [ )\n \n moves = (k - l) * 2 # step1\n print(right, left + (l + 1)// 2, left + l//2 , left)\n moves += prefix_sum[right] - prefix_sum[left + (l+1) // 2] - (prefix_sum[left + l // 2] - prefix_sum[left])\n res = min(res, moves)\n return res","runtime":"785"},{"code":"\nSearchResult = namedtuple('SearchResult','points,cost')\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n \n nums = [0] + nums + [0]\n N = len(nums)\n marked = []\n bisect_memo = [0]*N\n for i,x in enumerate(nums):\n bisect_memo[i] = len(marked)\n if 1 == x:\n marked.append(i)\n \n if 0 == len(marked):\n return k*2 # we can only apply rule1 for all the points\n\n # make the prefix memo\n presum = [0] + list(accumulate(marked))\n\n def calcCost(lidx,ii,ptNeeded):\n iidx = bisect_memo[ii]\n if lidx > iidx:\n lidx = iidx\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\n points = (ridx+1)-lidx\n if points < ptNeeded:\n return SearchResult(0,0)\n \n cost = 0\n lpt = iidx-lidx\n assert(lpt >= 0)\n cost += lpt*ii - (presum[iidx] - presum[lidx])\n if ridx >= iidx:\n rpt = (ridx+1)-iidx\n assert(rpt >= 0)\n cost += (presum[ridx+1] - presum[iidx]) - rpt*ii\n return SearchResult(points,cost)\n\n def cntSet(ii,ptNeeded):\n # calculate number of items set between i-mid to i+mid\n more = ptNeeded-nums[ii]\n mid = (more>>1) + (more&1)\n\n iidx = bisect_memo[ii]\n\n lidx = max(0,iidx-mid)\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\n points = (ridx+1)-lidx\n if points < ptNeeded:\n lidx = max(0,ridx-ptNeeded+1)\n\n ptA,costA = calcCost(lidx,ii,ptNeeded)\n ptB,costB = calcCost(lidx+1,ii,ptNeeded)\n\n\n if ptA != ptNeeded:\n ptA,costA = ptB,costB\n \n if ptB == ptNeeded:\n costA = min(costA,costB)\n\n if ptA < ptNeeded:\n return SearchResult(0,0)\n return SearchResult(ptA,costA)\n \n \n INF = float('Inf')\n result = N*k\n for i in range(1,N-1):\n kk,ct = k,0\n kk -= nums[i]\n if 0 == kk:\n return ct\n kk -= nums[i-1]\n ct += nums[i-1]\n if 0 == kk:\n return ct\n kk -= nums[i+1]\n ct += nums[i+1]\n appl = min(kk,maxChanges)\n kk -= appl\n ct += appl*2\n if 0 == kk:\n assert(ct >= 0)\n result = min(result,ct)\n #print(i,'No need bisect', ct)\n else:\n assert(kk > 0)\n kk,ct = k,0\n kk -= appl\n ct += appl*2\n res = cntSet(i,kk)\n assert(res.cost >= 0)\n assert(ct >= 0)\n #print(i,res,kk)\n if res.points == kk:\n result = min(result,res.cost+ct)\n return result\n ","runtime":"826"},{"code":"SearchResult = namedtuple('SearchResult','points,cost')\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n \n nums = [0] + nums + [0]\n N = len(nums)\n marked = []\n bisect_memo = [0]*N\n for i,x in enumerate(nums):\n bisect_memo[i] = len(marked)\n if 1 == x:\n marked.append(i)\n \n if 0 == len(marked):\n return k*2 # we can only apply rule1 for all the points\n\n # make the prefix memo\n presum = [0] + list(accumulate(marked))\n\n def calcCost(lidx,ii,ptNeeded):\n iidx = bisect_memo[ii]\n if lidx > iidx:\n lidx = iidx\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\n points = (ridx+1)-lidx\n if points < ptNeeded:\n return SearchResult(0,0)\n \n cost = 0\n lpt = iidx-lidx\n assert(lpt >= 0)\n cost += lpt*ii - (presum[iidx] - presum[lidx])\n if ridx >= iidx:\n rpt = (ridx+1)-iidx\n assert(rpt >= 0)\n cost += (presum[ridx+1] - presum[iidx]) - rpt*ii\n return SearchResult(points,cost)\n\n def cntSet(ii,ptNeeded):\n # calculate number of items set between i-mid to i+mid\n more = ptNeeded-nums[ii]\n mid = (more>>1) + (more&1)\n\n iidx = bisect_memo[ii]\n\n lidx = max(0,iidx-mid)\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\n points = (ridx+1)-lidx\n if points < ptNeeded:\n lidx = max(0,ridx-ptNeeded+1)\n\n ptA,costA = calcCost(lidx,ii,ptNeeded)\n ptB,costB = calcCost(lidx+1,ii,ptNeeded)\n\n\n if ptA != ptNeeded:\n ptA,costA = ptB,costB\n \n if ptB == ptNeeded:\n costA = min(costA,costB)\n\n if ptA < ptNeeded:\n return SearchResult(0,0)\n return SearchResult(ptA,costA)\n \n \n INF = float('Inf')\n result = N*k\n for i in range(1,N-1):\n kk,ct = k,0\n kk -= nums[i]\n if 0 == kk:\n return ct\n kk -= nums[i-1]\n ct += nums[i-1]\n if 0 == kk:\n return ct\n kk -= nums[i+1]\n ct += nums[i+1]\n appl = min(kk,maxChanges)\n kk -= appl\n ct += appl*2\n if 0 == kk:\n assert(ct >= 0)\n result = min(result,ct)\n #print(i,'No need bisect', ct)\n else:\n assert(kk > 0)\n kk,ct = k,0\n kk -= appl\n ct += appl*2\n res = cntSet(i,kk)\n assert(res.cost >= 0)\n assert(ct >= 0)\n #print(i,res,kk)\n if res.points == kk:\n result = min(result,res.cost+ct)\n return result","runtime":"866"},{"code":"def kClosest(nums, x, k):\n l = 0\n r = len(nums) - k\n while l <= r:\n m = (l + r) // 2\n right = nums[m + k] if m + k < len(nums) else float('inf')\n if abs(nums[m] - x) > abs(right - x):\n l = m + 1\n else:\n r = m - 1\n return l\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ones = []\n for i, x in enumerate(nums):\n if x:\n ones.append(i)\n prefix = [0]\n for x in ones:\n prefix.append(prefix[-1] + x)\n ret = float('inf')\n for i in range(n):\n picked = 0\n if nums[i]:\n picked += 1\n if picked == k:\n return 0\n ops = 0\n for ix in i - 1, i + 1:\n if 0 <= ix < n and nums[ix]:\n picked += 1\n ops += 1\n if picked == k:\n break\n if picked == k:\n ret = min(ops, ret)\n continue\n elif maxChanges >= k - picked:\n ops += (k - picked) * 2\n ret = min(ops, ret)\n continue\n else:\n ops += maxChanges * 2\n picked += maxChanges\n size = k - picked\n for ix in range(i - 1, i + 2):\n if 0 <= ix < n and nums[ix]:\n size += 1\n index = kClosest(ones, i, size)\n endIndex = index + size - 1\n l = index\n r = endIndex\n while l <= r:\n m = (l + r) // 2\n if ones[m] <= i:\n l = m + 1\n else:\n r = m - 1\n if l < index:\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\n ops -= 1\n elif l > endIndex:\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\n ops -= 1\n else:\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\n if l - 1 >= index and ones[l - 1] < i:\n ops += (l - index) * i - (prefix[l] - prefix[index])\n elif l - 2 >= index:\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\n for ix in i - 1, i + 1:\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\n ops -= 1\n ret = min(ret, ops)\n return ret\n","runtime":"907"},{"code":"def kClosest(nums, x, k):\n l = 0\n r = len(nums) - k\n while l <= r:\n m = (l + r) // 2\n right = nums[m + k] if m + k < len(nums) else float('inf')\n if abs(nums[m] - x) > abs(right - x):\n l = m + 1\n else:\n r = m - 1\n return l\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ones = []\n for i, x in enumerate(nums):\n if x:\n ones.append(i)\n prefix = [0]\n for x in ones:\n prefix.append(prefix[-1] + x)\n ret = float('inf')\n for i in range(n):\n picked = 0\n if nums[i]:\n picked += 1\n if picked == k:\n return 0\n ops = 0\n for ix in i - 1, i + 1:\n if 0 <= ix < n and nums[ix]:\n picked += 1\n ops += 1\n if picked == k:\n break\n if picked == k:\n ret = min(ops, ret)\n continue\n elif maxChanges >= k - picked:\n ops += (k - picked) * 2\n ret = min(ops, ret)\n continue\n else:\n ops += maxChanges * 2\n picked += maxChanges\n size = k - picked\n for ix in range(i - 1, i + 2):\n if 0 <= ix < n and nums[ix]:\n size += 1\n index = kClosest(ones, i, size)\n endIndex = index + size - 1\n l = index\n r = endIndex\n while l <= r:\n m = (l + r) // 2\n if ones[m] <= i:\n l = m + 1\n else:\n r = m - 1\n if l < index:\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\n ops -= 1\n elif l > endIndex:\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\n ops -= 1\n else:\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\n if l - 1 >= index and ones[l - 1] < i:\n ops += (l - index) * i - (prefix[l] - prefix[index])\n elif l - 2 >= index:\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\n for ix in i - 1, i + 1:\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\n ops -= 1\n ret = min(ret, ops)\n return ret\n","runtime":"948"},{"code":"def kClosest(nums, x, k):\n l = 0\n r = len(nums) - k\n while l <= r:\n m = (l + r) // 2\n right = nums[m + k] if m + k < len(nums) else float('inf')\n if abs(nums[m] - x) > abs(right - x):\n l = m + 1\n else:\n r = m - 1\n return l\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ones = []\n for i, x in enumerate(nums):\n if x:\n ones.append(i)\n prefix = [0]\n for x in ones:\n prefix.append(prefix[-1] + x)\n ret = float('inf')\n for i in range(n):\n picked = 0\n if nums[i]:\n picked += 1\n if picked == k:\n return 0\n ops = 0\n for ix in i - 1, i + 1:\n if 0 <= ix < n and nums[ix]:\n picked += 1\n ops += 1\n if picked == k:\n break\n if picked == k:\n ret = min(ops, ret)\n continue\n elif maxChanges >= k - picked:\n ops += (k - picked) * 2\n ret = min(ops, ret)\n continue\n else:\n ops += maxChanges * 2\n picked += maxChanges\n size = k - picked\n for ix in range(i - 1, i + 2):\n if 0 <= ix < n and nums[ix]:\n size += 1\n index = kClosest(ones, i, size)\n endIndex = index + size - 1\n l = index\n r = endIndex\n while l <= r:\n m = (l + r) // 2\n if ones[m] <= i:\n l = m + 1\n else:\n r = m - 1\n if l < index:\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\n ops -= 1\n elif l > endIndex:\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\n ops -= 1\n else:\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\n if l - 1 >= index and ones[l - 1] < i:\n ops += (l - index) * i - (prefix[l] - prefix[index])\n elif l - 2 >= index:\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\n for ix in i - 1, i + 1:\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\n ops -= 1\n ret = min(ret, ops)\n return ret\n","runtime":"988"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n cnt = [0] * (n + 1)\n s = [0] * (n + 1)\n for i, x in enumerate(nums, 1):\n cnt[i] = cnt[i - 1] + x\n s[i] = s[i - 1] + i * x\n ans = inf\n max = lambda x, y: x if x > y else y\n min = lambda x, y: x if x < y else y\n for i, x in enumerate(nums, 1):\n t = 0\n need = k - x\n for j in (i - 1, i + 1):\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\n need -= 1\n t += 1\n c = min(need, maxChanges)\n need -= c\n t += c * 2\n if need <= 0:\n ans = min(ans, t)\n continue\n l, r = 2, max(i - 1, n - i)\n while l <= r:\n mid = (l + r) >> 1\n l1, r1 = max(1, i - mid), max(0, i - 2)\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\n c1 = cnt[r1] - cnt[l1 - 1]\n c2 = cnt[r2] - cnt[l2 - 1]\n if c1 + c2 >= need:\n t1 = c1 * i - (s[r1] - s[l1 - 1])\n t2 = s[r2] - s[l2 - 1] - c2 * i\n ans = min(ans, t + t1 + t2)\n r = mid - 1\n else:\n l = mid + 1\n return ans","runtime":"1029"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n cnt = [0] * (n + 1)\n s = [0] * (n + 1)\n for i, x in enumerate(nums, 1):\n cnt[i] = cnt[i - 1] + x\n s[i] = s[i - 1] + i * x\n ans = inf\n max = lambda x, y: x if x > y else y\n min = lambda x, y: x if x < y else y\n for i, x in enumerate(nums, 1):\n t = 0\n need = k - x\n for j in (i - 1, i + 1):\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\n need -= 1\n t += 1\n c = min(need, maxChanges)\n need -= c\n t += c * 2\n if need <= 0:\n ans = min(ans, t)\n continue\n l, r = 2, max(i - 1, n - i)\n while l <= r:\n mid = (l + r) >> 1\n l1, r1 = max(1, i - mid), max(0, i - 2)\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\n c1 = cnt[r1] - cnt[l1 - 1]\n c2 = cnt[r2] - cnt[l2 - 1]\n if c1 + c2 >= need:\n t1 = c1 * i - (s[r1] - s[l1 - 1])\n t2 = s[r2] - s[l2 - 1] - c2 * i\n ans = min(ans, t + t1 + t2)\n r = mid - 1\n else:\n l = mid + 1\n return ans","runtime":"1070"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n cnt = [0] * (n + 1)\n s = [0] * (n + 1)\n for i, x in enumerate(nums, 1):\n cnt[i] = cnt[i - 1] + x\n s[i] = s[i - 1] + i * x\n ans = inf\n max = lambda x, y: x if x > y else y\n min = lambda x, y: x if x < y else y\n for i, x in enumerate(nums, 1):\n t = 0\n need = k - x\n for j in (i - 1, i + 1):\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\n need -= 1\n t += 1\n c = min(need, maxChanges)\n need -= c\n t += c * 2\n if need <= 0:\n ans = min(ans, t)\n continue\n l, r = 2, max(i - 1, n - i)\n while l <= r:\n mid = (l + r) >> 1\n l1, r1 = max(1, i - mid), max(0, i - 2)\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\n c1 = cnt[r1] - cnt[l1 - 1]\n c2 = cnt[r2] - cnt[l2 - 1]\n if c1 + c2 >= need:\n t1 = c1 * i - (s[r1] - s[l1 - 1])\n t2 = s[r2] - s[l2 - 1] - c2 * i\n ans = min(ans, t + t1 + t2)\n r = mid - 1\n else:\n l = mid + 1\n return ans","runtime":"1111"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n\\n t = max((len(list(g)) for k, g in groupby(nums) if k == 1), default=0)\\n t = min(t, 3)\\n\\n if k - maxChanges <= t:\\n if k <= t:\\n return k - 1\\n if t > 0:\\n return 2*(k - t) + t-1\\n return 2*k\\n \\n k -= maxChanges\\n res = inf\\n\\n psums = list(accumulate((i for i, x in enumerate(nums) if x==1), initial=0))\\n for i in range(k, len(psums)):\\n j = i-(k+1)//2\\n res = min(res, (psums[i]-psums[i-k//2]) - (psums[j]-psums[j-k//2]))\\n return res + 2*maxChanges\\n\\n\\n\",\n \"runtime\": \"500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n s = \\\"\\\".join(map(str, nums))\\n if \\\"111\\\" in s:\\n maxcon = 3\\n elif \\\"11\\\" in s:\\n maxcon = 2\\n elif \\\"1\\\" in s:\\n maxcon = 1\\n else:\\n maxcon = 0\\n\\n if maxcon > k:\\n maxcon = k\\n if maxChanges >= k - maxcon:\\n return (k - maxcon) * 2 + max(0, maxcon - 1)\\n\\n res = maxChanges * 2\\n k -= maxChanges\\n idxes = [i for i in range(len(nums)) if nums[i] == 1]\\n pmid = k // 2\\n left = 0\\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\\n for right in range(k, len(idxes)):\\n cdiff -= idxes[pmid] - idxes[left]\\n left += 1\\n cdiff += idxes[right] - idxes[pmid + 1]\\n move_d = idxes[pmid + 1] - idxes[pmid]\\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\\n mdiff = min(mdiff, cdiff)\\n pmid += 1\\n res += mdiff\\n return res\\nres=2\\nk=4\\nidxes=0,1,2,3,4\\npmid=3\\nleft=1\\ncdiff=4\\nmdiff=4\\nmove_d=1\\nright=4\",\n \"runtime\": \"500\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nIntuitions\\n1. There are 2 optimal ways of getting a point.\\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\\n This costs 2 operations.\\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\\n This costs dist(alice_index, one_index) many operations. \\n2. There can be at most 3 operations costing < 2 operations for (b) if we have \\n <= 3 consecutive ones.\\n\\nAlgorithm\\n1. Count the number of consecutive ones up to 3.\\n2. If k <= m, we only need k - 1 moves.\\n3. \\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n pos = []\\n \\n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\\n # requiring less than 2 operations).\\n m = 0\\n \\n # compute m (just counting the max consecutive ones up to length 3).\\n for i, num in enumerate(nums):\\n if num == 0:\\n continue \\n pos.append(i)\\n m = max(m, 1)\\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\\n m = 3\\n elif i > 0 and nums[i - 1] == 1:\\n m = max(m, 2)\\n \\n # here, we are greedy and prefer using as little moves as possible\\n # optimally, we want to use operations costing 0 (start at 1), \\n # 1 (move adjacent 1), or 2 (use operation (a)).\\n if m >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n return k - 1\\n elif m + max_changes >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n # for the remaining operations, use the 2 move operations. \\n return max(m - 1, 0) + (k - m) * 2\\n \\n k -= max_changes\\n n = len(pos)\\n prefix = [0] + list(accumulate(pos))\\n res = float(\\\"inf\\\")\\n \\n for i in range(n - k + 1):\\n j = i + k\\n median = i + k // 2\\n idx = pos[median]\\n left = idx * (median - i) - (prefix[median] - prefix[i])\\n right = prefix[j] - prefix[median] - idx * (j - median)\\n res = min(res, left + right)\\n \\n return max_changes * 2 + res\\n \",\n \"runtime\": \"541\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n\\n s = \\\"\\\".join(map(str, nums))\\n if \\\"111\\\" in s:\\n max_cons = 3\\n elif \\\"11\\\" in s:\\n max_cons = 2\\n elif \\\"1\\\" in s:\\n max_cons = 1\\n else:\\n max_cons = 0\\n\\n if max_cons > k:\\n max_cons = k\\n if max_changes >= k - max_cons:\\n return (k - max_cons) * 2 + max(0, max_cons - 1)\\n\\n one_idxs = [idx for idx, num in enumerate(nums) if num == 1]\\n if not one_idxs:\\n return k*2\\n # print('one_idxs',one_idxs)\\n # return \\n prefix_sums = [x for x in one_idxs]\\n prefix_sums[0] = one_idxs[0]\\n for i in range(1, len(one_idxs)):\\n prefix_sums[i] += prefix_sums[i - 1]\\n\\n def get_sum(left, right):\\n if right < left:\\n return 0\\n if left == 0:\\n return prefix_sums[right]\\n return prefix_sums[right] - prefix_sums[left - 1]\\n min_cost = float('inf')\\n for change in range(max_changes,max_changes+1):\\n rem_k = k - change\\n cost_change = change * 2\\n if rem_k > len(one_idxs):\\n continue\\n left = 0\\n right = max(0,rem_k - 1)\\n cost_swap = float('inf')\\n # print(\\\"START\\\", left,right, 'change',change,'rem_k',rem_k),\\n while right < len(one_idxs):\\n mid = (left + right) // 2\\n # print(left,mid,right)\\n cost_left = (mid-left)*one_idxs[mid] - get_sum(left,mid-1)\\n # print('(mid-left)*one_idxs[mid]',(mid-left)*one_idxs[mid])\\n # print('get_sum(left,mid-1)',get_sum(left,mid-1))\\n cost_right = get_sum(mid+1, right) - (right-mid)*one_idxs[mid]\\n # print('rem_k',rem_k, 'left', left,'mid',mid,'right', right,'cost_left',cost_left,'cost_right',cost_right )\\n # print()\\n cost_swap = min(cost_swap, cost_left+cost_right)\\n right +=1\\n left += 1\\n # print('change',change, 'cost_change',cost_change, 'cost_swap',cost_swap)\\n min_cost = min(min_cost, cost_change+cost_swap)\\n return min_cost\\n \\n \\n\\n # 0 3 6 12 15\\n # m\\n # 6\\n # m\\n \\n # sums of \\n return 0\",\n \"runtime\": \"541\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n nums = [i for i, a in enumerate(nums) if a]\\n n = len(nums)\\n nums = [0] + list(accumulate(nums))\\n m = max(0, k - maxChanges)\\n res = inf\\n for j in range(m, min(n, m + 3, k) + 1):\\n for i in range(n - j + 1):\\n cur = nums[i + j] - nums[i + j - j // 2] - (nums[i + j // 2] - nums[i])\\n res = min(res, cur + (k - j) * 2)\\n return res\\n\\n \\\"\\\"\\\"\\n ans = inf\\n prefix = [0]\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n prefix.append(prefix[-1] + i)\\n # case all zero\\n if len(prefix) == 1:\\n return k * 2\\n # numbers that must use op2\\n min_ws = max(k - maxChanges, 0)\\n # if ws > min_ws+3, the cost must be greater than 2 -> some op2 should be replace with op1\\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\\n for ws in range(min_ws, max_ws + 1):\\n for start_idx in range(len(prefix) - ws):\\n end_idx = start_idx + ws\\n mid_left = (start_idx + end_idx) // 2\\n mid_right = (start_idx + end_idx + 1) // 2\\n # cost = min dis sum from start_idx to end_idx\\n cost = prefix[end_idx] - prefix[mid_left] - (prefix[mid_right] - prefix[start_idx])\\n # fill rest with op1\\n cost += (k - ws) * 2\\n ans = min(ans, cost)\\n return ans \\\"\\\"\\\"\",\n \"runtime\": \"581\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n if sum(nums) + maxChanges < k:\\n return 0\\n\\n if k == 1 and sum(nums) >= 1:\\n return 0\\n\\n ans = float('inf')\\n\\n for i in range(len(nums) - 2):\\n if nums[i] == nums[i+1] == nums[i+2] == 1:\\n if k == 2:\\n return 1\\n if k == 3:\\n return 2\\n rem = k-3\\n moves = 2\\n if maxChanges >= rem:\\n moves += 2*rem\\n return moves\\n\\n for i in range(len(nums) - 1):\\n if nums[i] == nums[i+1] == 1:\\n if k == 2:\\n return 1\\n rem = k-2\\n moves = 1\\n if maxChanges >= rem:\\n moves += 2*rem\\n return moves\\n\\n if sum(nums) >= 1:\\n if maxChanges >= k-1:\\n return 2*(k-1)\\n else:\\n if maxChanges >= k:\\n return 2*k\\n\\n # print(\\\"huhee\\\")\\n idx = []\\n running_sum = 0\\n prefix = []\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n running_sum += i\\n idx.append(i)\\n prefix.append(running_sum)\\n\\n\\n # print(idx)\\n \\n moves = 2*maxChanges\\n rem = k - maxChanges\\n\\n # print(rem, moves)\\n\\n l = 0\\n best_possible_of_rest = float('inf')\\n for r in range(rem-1, len(idx)):\\n mid = (r+l)//2\\n if l > 0:\\n diff = abs(prefix[mid] - prefix[l-1] - (idx[mid]*(mid - l + 1))) + abs(prefix[r] - prefix[mid] - idx[mid]*(r-mid))\\n else:\\n diff = abs(prefix[mid] - 0 - (idx[mid]*(mid - l + 1))) + abs(prefix[r] - prefix[mid] - idx[mid]*(r-mid))\\n best_possible_of_rest = min(best_possible_of_rest, diff)\\n l += 1\\n\\n # print(best_possible_of_rest)\\n moves += best_possible_of_rest\\n\\n return moves\\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"581\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ans = float(\\\"inf\\\")\\n\\n for i in range(n):\\n curr = nums[i]\\n move = 0\\n if i > 0 and nums[i - 1] == 1:\\n curr += 1\\n move += 1\\n if i < n - 1 and nums[i + 1] == 1 and curr < k:\\n curr += 1\\n move += 1\\n if curr + maxChanges >= k:\\n ans = min(ans, move + (k - curr) * 2)\\n if curr + maxChanges >= k:\\n return max(0, ans)\\n\\n arr = [i for i, v in enumerate(nums) if v == 1]\\n target = k - maxChanges\\n l, r = 0, target - 1\\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges * 2\\n ans = min(ans, prev)\\n for i in range(1, len(arr)):\\n diff = arr[i] - arr[i - 1]\\n left_count, right_count = i - l, r - i + 1\\n curr = prev + (left_count - right_count) * diff\\n while r + 1 < len(arr) and arr[r + 1] - arr[i] <= arr[i] - arr[l]:\\n curr -= arr[i] - arr[l]\\n curr += arr[r + 1] - arr[i]\\n r += 1\\n l += 1\\n ans = min(ans, curr)\\n prev = curr\\n return max(0, ans)\\n\\n \",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n \\n # SLIDING WINDOW AND PREFIX SUMS ( Note THAT TRICK Below )\\n\\n n = len(nums)\\n\\n max_consecutive = 0\\n for i in range(n):\\n cnt = 0\\n for j in range(3):\\n if i + j < n and nums[i + j] == 1:\\n cnt += 1\\n else:\\n break\\n max_consecutive = max(max_consecutive, cnt)\\n\\n if max_consecutive + max_changes >= k:\\n if k <= max_consecutive:\\n return k - 1\\n\\n req_changes = k - max_consecutive\\n ans = req_changes * 2\\n if max_consecutive > 0:\\n ans += max_consecutive - 1\\n return ans\\n\\n def converge(l, r, pos, ones, prefix):\\n # VERY VERY USEFUL as IT TAKES only O(N)\\n left = (pos - l + 1) * ones[pos] - (prefix[pos] - prefix[l - 1])\\n right = (prefix[r] - prefix[pos]) - (r - pos) * ones[pos]\\n\\n return left + right\\n\\n ones = [-1]\\n prefix = [0]\\n for i in range(n):\\n if nums[i] == 1:\\n ones.append(i)\\n prefix.append(prefix[-1] + i)\\n\\n req_1 = k - max_changes\\n ans = float('inf')\\n\\n for l in range(1, len(ones) - req_1 + 1):\\n r = l + req_1 - 1\\n best_pos = (l + r) // 2\\n ans = min(ans, converge(l, r, best_pos, ones, prefix))\\n\\n return ans + max_changes * 2\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nIntuitions\\n1. There are 2 optimal ways of getting a point.\\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\\n This costs 2 operations.\\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\\n This costs dist(alice_index, one_index) many operations. \\n2. There can be at most 3 operations costing < 2 operations for (b) if we have \\n <= 3 consecutive ones.\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n pos = []\\n \\n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\\n # requiring less than 2 operations).\\n m = 0\\n \\n # compute m (just counting the max consecutive ones up to length 3).\\n for i, num in enumerate(nums):\\n if num == 0:\\n continue \\n pos.append(i)\\n m = max(m, 1)\\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\\n m = 3\\n elif i > 0 and nums[i - 1] == 1:\\n m = max(m, 2)\\n \\n # here, we are greedy and prefer using as little moves as possible\\n # optimally, we want to use operations costing 0 (start at 1), \\n # 1 (move adjacent 1), or 2 (use operation (a)).\\n if m >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n return k - 1\\n elif m + max_changes >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n # for the remaining operations, use the 2 move operations. \\n return max(m - 1, 0) + (k - m) * 2\\n \\n # we can use between [0, max_changes] many operations costing 2 moves.\\n n = len(pos)\\n prefix = [0] + list(accumulate(pos))\\n res = float(\\\"inf\\\")\\n \\n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\\n for x in range(max_changes - m, max_changes + 1):\\n required_window_size = k - x\\n for i in range(max(n - required_window_size + 1, 0)):\\n j = i + required_window_size\\n median = i + required_window_size // 2\\n idx = pos[median]\\n \\n # we are at idx = pos[median].\\n # (1) assume we are at 0 instead. For each median - i points strictly prior \\n # to median (i.e. ignoring median), it takes idx moves to move to idx.\\n # Hence, idx * (median - i).\\n # (2) but we don't start at 0. Instead, we start at pos[i], pos[i + 1], etc.\\n # So, we want to subtract pos[i] + pos[i + 1] + ... + pos[median - 1].\\n # This is prefix[median] - prefix[i].\\n \\n #\\n # For more clarify, for each i <= a < median\\n # idx = pos[median] = (pos[median] - pos[a]) + (pos[a] - 0)\\n # = (pos[median] - pos[a]) + pos[a]\\n # really, we just want is just (pos[median] - pos[a]).\\n # step (1) computes pos[median] * idx = sum(pos[median] - pos[a] + pos[a])\\n # step (2) computes sum(pos[median] - pos[a]) = pos[median] * idx - sum(pos[a]).\\n # \\n left = idx * (median - i) - (prefix[median] - prefix[i])\\n \\n # we are at idx = pos[median]\\n # (1) assume we are at 0 instead. It takes prefix[j] - prefix[median] to traverse\\n # to the point that we should end up at. This accounts for dist(0, median) + \\n # dist(median, point). \\n # (2) but we don't start at 0, and for each point, we've overcounted by idx.\\n # hence, we subtract idx * (j - median) away.\\n right = prefix[j] - prefix[median] - idx * (j - median)\\n res = min(res, left + right + 2 * x)\\n return res \",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nIntuitions\\n1. There are 2 optimal ways of getting a point.\\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\\n This costs 2 operations.\\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\\n This costs dist(alice_index, one_index) many operations. \\n2. There can be at most 3 operations costing < 2 operations for (b) if we have \\n <= 3 consecutive ones.\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n pos = []\\n \\n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\\n # requiring less than 2 operations).\\n m = 0\\n \\n # compute m (just counting the max consecutive ones up to length 3).\\n for i, num in enumerate(nums):\\n if num == 0:\\n continue \\n pos.append(i)\\n m = max(m, 1)\\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\\n m = 3\\n elif i > 0 and nums[i - 1] == 1:\\n m = max(m, 2)\\n \\n # here, we are greedy and prefer using as little moves as possible\\n # optimally, we want to use operations costing 0 (start at 1), \\n # 1 (move adjacent 1), or 2 (use operation (a)).\\n if m >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n return k - 1\\n elif m + max_changes >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n # for the remaining operations, use the 2 move operations. \\n return max(m - 1, 0) + (k - m) * 2\\n \\n # we can use between [0, max_changes] many operations costing 2 moves.\\n n = len(pos)\\n prefix = [0] + list(accumulate(pos))\\n res = float(\\\"inf\\\")\\n \\n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\\n for x in range(max_changes - m, max_changes + 1):\\n required_window_size = k - x\\n for i in range(max(n - required_window_size + 1, 0)):\\n j = i + required_window_size\\n median = i + required_window_size // 2\\n idx = pos[median]\\n \\n # we are at idx = pos[median].\\n # (1) assume we are at 0 instead. For each median - i points strictly prior \\n # to median (i.e. ignoring median), it takes idx moves to move to idx.\\n # Hence, idx * (median - i).\\n # (2) but we don't start at 0. Instead, we start at pos[i], pos[i + 1], etc.\\n # So, we want to subtract pos[i] + pos[i + 1] + ... + pos[median - 1].\\n # This is prefix[median] - prefix[i].\\n \\n #\\n # For more clarify, for each i <= a < median\\n # idx = pos[median] = (pos[median] - pos[a]) + (pos[a] - 0)\\n # = (pos[median] - pos[a]) + pos[a]\\n # really, we just want is just (pos[median] - pos[a]).\\n # step (1) computes pos[median] * idx = sum(pos[median] - pos[a] + pos[a])\\n # step (2) computes sum(pos[median] - pos[a]) = pos[median] * idx - sum(pos[a]).\\n # \\n left = idx * (median - i) - (prefix[median] - prefix[i])\\n \\n\\n right = prefix[j] - prefix[median] - idx * (j - median)\\n res = min(res, left + right + 2 * x)\\n return res \",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.n = 0\\n self.ones = []\\n self.prefix = []\\n\\n def Converge(self, l, r, pos):\\n lft = (pos - l + 1) * self.ones[pos] - (self.prefix[pos] - self.prefix[l - 1])\\n rgt = (self.prefix[r] - self.prefix[pos]) - (r - pos) * self.ones[pos]\\n return lft + rgt\\n\\n def minimumMoves(self, nums, k, maxChanges):\\n self.n = len(nums)\\n max_consecutive = 0\\n\\n # Find maximum number of consecutive ones in any segment of up to 3 elements\\n for i in range(self.n):\\n cnt = 0\\n for j in range(3):\\n if i + j < self.n and nums[i + j] == 1:\\n cnt += 1\\n else:\\n break\\n max_consecutive = max(max_consecutive, cnt)\\n\\n # If max consecutive ones plus max changes is greater than or equal to k\\n if max_consecutive + maxChanges >= k:\\n if k <= max_consecutive:\\n return k - 1\\n \\n req_changes = k - max_consecutive\\n ans = req_changes * 2\\n if max_consecutive > 0:\\n ans += max_consecutive - 1\\n return ans\\n\\n # Populate ones and prefix arrays\\n self.ones = [-1]\\n self.prefix = [0]\\n for i in range(self.n):\\n if nums[i] == 1:\\n self.ones.append(i)\\n self.prefix.append(self.prefix[-1] + i)\\n print(self.ones, self.prefix)\\n req_1 = k - maxChanges\\n ans = float('inf')\\n\\n for l in range(1, len(self.ones) - req_1 + 1):\\n r = l + req_1 - 1\\n best_pos = (l + r) // 2\\n print(json.dumps({\\\"converge\\\": self.Converge(l,r,best_pos)}))\\n ans = min(ans, self.Converge(l, r, best_pos))\\n\\n return ans + maxChanges * 2\\n\\n# Example usage:\\n# sol = Solution()\\n# result = sol.minimumMoves([1, 0, 1, 0, 1], 3, 1)\\n# print(result)\\n\",\n \"runtime\": \"703\"\n },\n {\n \"code\": \"import numpy as np\\nfrom typing import List\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n \\n res = np.inf\\n n = len(nums)\\n ones_index = [i for i in range(n) if nums[i] == 1]\\n\\n def integrateCloseNeighborsAndMaxMoves(ind):\\n score = 0\\n moves = 0\\n if nums[ind] == 1:\\n score += 1\\n\\n if ind - 1 >= 0 and nums[ind-1] == 1 and score <k:\\n moves += 1\\n score += 1\\n if ind + 1 < n and nums[ind+1] == 1 and score <k:\\n moves += 1\\n score +=1\\n \\n if score < k and maxChanges > 0:\\n diff = min(k - score, maxChanges)\\n score += diff \\n moves += 2 * diff\\n\\n return (score, moves)\\n \\n def compute_nearest_neighbors(ind, left, nb_left, right, score):\\n\\n if needed <= 0:\\n return (0,0,0,0)\\n\\n if ind == 0:\\n nb_left = 1 if nums[ind] == 1 else 0\\n left = 0 if nums[ind] == 1 else -1\\n right = needed - 1\\n score = sum(ones_index[:needed])\\n\\n else:\\n score += nb_left\\n score -= needed - nb_left\\n\\n if nums[ind] == 1:\\n nb_left += 1\\n if left == -1:\\n left = 0\\n\\n while nb_left > 0 and right + 1 < len(ones_index) and ind-ones_index[left] >= ones_index[right + 1] - ind:\\n score -= ind-ones_index[left]\\n left += 1\\n nb_left -= 1\\n score += ones_index[right + 1] - ind\\n right += 1\\n\\n return (left, nb_left, right, score)\\n \\n left, nb_left, right, score = None, None, None, None\\n needed = k - maxChanges\\n for i in range(n):\\n \\n #situation everything works with close points\\n s,m = integrateCloseNeighborsAndMaxMoves(i)\\n if s >= k:\\n res = min(res, m)\\n \\n #situation need to fetch closest k - maxMoves neighbors\\n m = 2 * maxChanges\\n left, nb_left, right, score = compute_nearest_neighbors(i, left, nb_left, right, score) \\n m += score\\n\\n res = min(res, m)\\n \\n return res\",\n \"runtime\": \"744\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n index_of_ones = [i for i, num in enumerate(nums) if num == 1]\\n n = len(index_of_ones)\\n print(n)\\n prefix_sum = [0] * (n+1)\\n for i in range(1, n+1):\\n prefix_sum[i] = prefix_sum[i-1] + index_of_ones[i-1]\\n \\n min_step2 = max(0, k-maxChanges)\\n max_step2 = min(k, min_step2+3)\\n\\n res = inf\\n for l in range(min_step2, max_step2+1):\\n for left in range(n-l+1):\\n right = left + l # [ )\\n \\n moves = (k - l) * 2 # step1\\n print(right, left + (l + 1)// 2, left + l//2 , left)\\n moves += prefix_sum[right] - prefix_sum[left + (l+1) // 2] - (prefix_sum[left + l // 2] - prefix_sum[left])\\n res = min(res, moves)\\n return res\",\n \"runtime\": \"785\"\n },\n {\n \"code\": \"\\nSearchResult = namedtuple('SearchResult','points,cost')\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n \\n nums = [0] + nums + [0]\\n N = len(nums)\\n marked = []\\n bisect_memo = [0]*N\\n for i,x in enumerate(nums):\\n bisect_memo[i] = len(marked)\\n if 1 == x:\\n marked.append(i)\\n \\n if 0 == len(marked):\\n return k*2 # we can only apply rule1 for all the points\\n\\n # make the prefix memo\\n presum = [0] + list(accumulate(marked))\\n\\n def calcCost(lidx,ii,ptNeeded):\\n iidx = bisect_memo[ii]\\n if lidx > iidx:\\n lidx = iidx\\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\\n points = (ridx+1)-lidx\\n if points < ptNeeded:\\n return SearchResult(0,0)\\n \\n cost = 0\\n lpt = iidx-lidx\\n assert(lpt >= 0)\\n cost += lpt*ii - (presum[iidx] - presum[lidx])\\n if ridx >= iidx:\\n rpt = (ridx+1)-iidx\\n assert(rpt >= 0)\\n cost += (presum[ridx+1] - presum[iidx]) - rpt*ii\\n return SearchResult(points,cost)\\n\\n def cntSet(ii,ptNeeded):\\n # calculate number of items set between i-mid to i+mid\\n more = ptNeeded-nums[ii]\\n mid = (more>>1) + (more&1)\\n\\n iidx = bisect_memo[ii]\\n\\n lidx = max(0,iidx-mid)\\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\\n points = (ridx+1)-lidx\\n if points < ptNeeded:\\n lidx = max(0,ridx-ptNeeded+1)\\n\\n ptA,costA = calcCost(lidx,ii,ptNeeded)\\n ptB,costB = calcCost(lidx+1,ii,ptNeeded)\\n\\n\\n if ptA != ptNeeded:\\n ptA,costA = ptB,costB\\n \\n if ptB == ptNeeded:\\n costA = min(costA,costB)\\n\\n if ptA < ptNeeded:\\n return SearchResult(0,0)\\n return SearchResult(ptA,costA)\\n \\n \\n INF = float('Inf')\\n result = N*k\\n for i in range(1,N-1):\\n kk,ct = k,0\\n kk -= nums[i]\\n if 0 == kk:\\n return ct\\n kk -= nums[i-1]\\n ct += nums[i-1]\\n if 0 == kk:\\n return ct\\n kk -= nums[i+1]\\n ct += nums[i+1]\\n appl = min(kk,maxChanges)\\n kk -= appl\\n ct += appl*2\\n if 0 == kk:\\n assert(ct >= 0)\\n result = min(result,ct)\\n #print(i,'No need bisect', ct)\\n else:\\n assert(kk > 0)\\n kk,ct = k,0\\n kk -= appl\\n ct += appl*2\\n res = cntSet(i,kk)\\n assert(res.cost >= 0)\\n assert(ct >= 0)\\n #print(i,res,kk)\\n if res.points == kk:\\n result = min(result,res.cost+ct)\\n return result\\n \",\n \"runtime\": \"826\"\n },\n {\n \"code\": \"SearchResult = namedtuple('SearchResult','points,cost')\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n \\n nums = [0] + nums + [0]\\n N = len(nums)\\n marked = []\\n bisect_memo = [0]*N\\n for i,x in enumerate(nums):\\n bisect_memo[i] = len(marked)\\n if 1 == x:\\n marked.append(i)\\n \\n if 0 == len(marked):\\n return k*2 # we can only apply rule1 for all the points\\n\\n # make the prefix memo\\n presum = [0] + list(accumulate(marked))\\n\\n def calcCost(lidx,ii,ptNeeded):\\n iidx = bisect_memo[ii]\\n if lidx > iidx:\\n lidx = iidx\\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\\n points = (ridx+1)-lidx\\n if points < ptNeeded:\\n return SearchResult(0,0)\\n \\n cost = 0\\n lpt = iidx-lidx\\n assert(lpt >= 0)\\n cost += lpt*ii - (presum[iidx] - presum[lidx])\\n if ridx >= iidx:\\n rpt = (ridx+1)-iidx\\n assert(rpt >= 0)\\n cost += (presum[ridx+1] - presum[iidx]) - rpt*ii\\n return SearchResult(points,cost)\\n\\n def cntSet(ii,ptNeeded):\\n # calculate number of items set between i-mid to i+mid\\n more = ptNeeded-nums[ii]\\n mid = (more>>1) + (more&1)\\n\\n iidx = bisect_memo[ii]\\n\\n lidx = max(0,iidx-mid)\\n ridx = min(lidx+ptNeeded-1,len(marked)-1)\\n points = (ridx+1)-lidx\\n if points < ptNeeded:\\n lidx = max(0,ridx-ptNeeded+1)\\n\\n ptA,costA = calcCost(lidx,ii,ptNeeded)\\n ptB,costB = calcCost(lidx+1,ii,ptNeeded)\\n\\n\\n if ptA != ptNeeded:\\n ptA,costA = ptB,costB\\n \\n if ptB == ptNeeded:\\n costA = min(costA,costB)\\n\\n if ptA < ptNeeded:\\n return SearchResult(0,0)\\n return SearchResult(ptA,costA)\\n \\n \\n INF = float('Inf')\\n result = N*k\\n for i in range(1,N-1):\\n kk,ct = k,0\\n kk -= nums[i]\\n if 0 == kk:\\n return ct\\n kk -= nums[i-1]\\n ct += nums[i-1]\\n if 0 == kk:\\n return ct\\n kk -= nums[i+1]\\n ct += nums[i+1]\\n appl = min(kk,maxChanges)\\n kk -= appl\\n ct += appl*2\\n if 0 == kk:\\n assert(ct >= 0)\\n result = min(result,ct)\\n #print(i,'No need bisect', ct)\\n else:\\n assert(kk > 0)\\n kk,ct = k,0\\n kk -= appl\\n ct += appl*2\\n res = cntSet(i,kk)\\n assert(res.cost >= 0)\\n assert(ct >= 0)\\n #print(i,res,kk)\\n if res.points == kk:\\n result = min(result,res.cost+ct)\\n return result\",\n \"runtime\": \"866\"\n },\n {\n \"code\": \"def kClosest(nums, x, k):\\n l = 0\\n r = len(nums) - k\\n while l <= r:\\n m = (l + r) // 2\\n right = nums[m + k] if m + k < len(nums) else float('inf')\\n if abs(nums[m] - x) > abs(right - x):\\n l = m + 1\\n else:\\n r = m - 1\\n return l\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ones = []\\n for i, x in enumerate(nums):\\n if x:\\n ones.append(i)\\n prefix = [0]\\n for x in ones:\\n prefix.append(prefix[-1] + x)\\n ret = float('inf')\\n for i in range(n):\\n picked = 0\\n if nums[i]:\\n picked += 1\\n if picked == k:\\n return 0\\n ops = 0\\n for ix in i - 1, i + 1:\\n if 0 <= ix < n and nums[ix]:\\n picked += 1\\n ops += 1\\n if picked == k:\\n break\\n if picked == k:\\n ret = min(ops, ret)\\n continue\\n elif maxChanges >= k - picked:\\n ops += (k - picked) * 2\\n ret = min(ops, ret)\\n continue\\n else:\\n ops += maxChanges * 2\\n picked += maxChanges\\n size = k - picked\\n for ix in range(i - 1, i + 2):\\n if 0 <= ix < n and nums[ix]:\\n size += 1\\n index = kClosest(ones, i, size)\\n endIndex = index + size - 1\\n l = index\\n r = endIndex\\n while l <= r:\\n m = (l + r) // 2\\n if ones[m] <= i:\\n l = m + 1\\n else:\\n r = m - 1\\n if l < index:\\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\\n ops -= 1\\n elif l > endIndex:\\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\\n ops -= 1\\n else:\\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\\n if l - 1 >= index and ones[l - 1] < i:\\n ops += (l - index) * i - (prefix[l] - prefix[index])\\n elif l - 2 >= index:\\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\\n for ix in i - 1, i + 1:\\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\\n ops -= 1\\n ret = min(ret, ops)\\n return ret\\n\",\n \"runtime\": \"907\"\n },\n {\n \"code\": \"def kClosest(nums, x, k):\\n l = 0\\n r = len(nums) - k\\n while l <= r:\\n m = (l + r) // 2\\n right = nums[m + k] if m + k < len(nums) else float('inf')\\n if abs(nums[m] - x) > abs(right - x):\\n l = m + 1\\n else:\\n r = m - 1\\n return l\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ones = []\\n for i, x in enumerate(nums):\\n if x:\\n ones.append(i)\\n prefix = [0]\\n for x in ones:\\n prefix.append(prefix[-1] + x)\\n ret = float('inf')\\n for i in range(n):\\n picked = 0\\n if nums[i]:\\n picked += 1\\n if picked == k:\\n return 0\\n ops = 0\\n for ix in i - 1, i + 1:\\n if 0 <= ix < n and nums[ix]:\\n picked += 1\\n ops += 1\\n if picked == k:\\n break\\n if picked == k:\\n ret = min(ops, ret)\\n continue\\n elif maxChanges >= k - picked:\\n ops += (k - picked) * 2\\n ret = min(ops, ret)\\n continue\\n else:\\n ops += maxChanges * 2\\n picked += maxChanges\\n size = k - picked\\n for ix in range(i - 1, i + 2):\\n if 0 <= ix < n and nums[ix]:\\n size += 1\\n index = kClosest(ones, i, size)\\n endIndex = index + size - 1\\n l = index\\n r = endIndex\\n while l <= r:\\n m = (l + r) // 2\\n if ones[m] <= i:\\n l = m + 1\\n else:\\n r = m - 1\\n if l < index:\\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\\n ops -= 1\\n elif l > endIndex:\\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\\n ops -= 1\\n else:\\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\\n if l - 1 >= index and ones[l - 1] < i:\\n ops += (l - index) * i - (prefix[l] - prefix[index])\\n elif l - 2 >= index:\\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\\n for ix in i - 1, i + 1:\\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\\n ops -= 1\\n ret = min(ret, ops)\\n return ret\\n\",\n \"runtime\": \"948\"\n },\n {\n \"code\": \"def kClosest(nums, x, k):\\n l = 0\\n r = len(nums) - k\\n while l <= r:\\n m = (l + r) // 2\\n right = nums[m + k] if m + k < len(nums) else float('inf')\\n if abs(nums[m] - x) > abs(right - x):\\n l = m + 1\\n else:\\n r = m - 1\\n return l\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ones = []\\n for i, x in enumerate(nums):\\n if x:\\n ones.append(i)\\n prefix = [0]\\n for x in ones:\\n prefix.append(prefix[-1] + x)\\n ret = float('inf')\\n for i in range(n):\\n picked = 0\\n if nums[i]:\\n picked += 1\\n if picked == k:\\n return 0\\n ops = 0\\n for ix in i - 1, i + 1:\\n if 0 <= ix < n and nums[ix]:\\n picked += 1\\n ops += 1\\n if picked == k:\\n break\\n if picked == k:\\n ret = min(ops, ret)\\n continue\\n elif maxChanges >= k - picked:\\n ops += (k - picked) * 2\\n ret = min(ops, ret)\\n continue\\n else:\\n ops += maxChanges * 2\\n picked += maxChanges\\n size = k - picked\\n for ix in range(i - 1, i + 2):\\n if 0 <= ix < n and nums[ix]:\\n size += 1\\n index = kClosest(ones, i, size)\\n endIndex = index + size - 1\\n l = index\\n r = endIndex\\n while l <= r:\\n m = (l + r) // 2\\n if ones[m] <= i:\\n l = m + 1\\n else:\\n r = m - 1\\n if l < index:\\n ops += prefix[endIndex + 1] - prefix[index] - (endIndex - index) * i\\n if i + 1 < n and nums[i + 1] and index <= i + 1 <= endIndex:\\n ops -= 1\\n elif l > endIndex:\\n ops += (endIndex - index) * i - (prefix[endIndex + 1] - prefix[index])\\n if i - 1 >= 0 and nums[i - 1] and 0 <= i - 1 <= endIndex:\\n ops -= 1\\n else:\\n ops += prefix[endIndex + 1] - prefix[l] - (endIndex - l + 1) * i\\n if l - 1 >= index and ones[l - 1] < i:\\n ops += (l - index) * i - (prefix[l] - prefix[index])\\n elif l - 2 >= index:\\n ops += (l - 1 - index) * i - (prefix[l - 1] - prefix[index])\\n for ix in i - 1, i + 1:\\n if ones[index] <= ix <= ones[endIndex] and nums[ix]:\\n ops -= 1\\n ret = min(ret, ops)\\n return ret\\n\",\n \"runtime\": \"988\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n cnt = [0] * (n + 1)\\n s = [0] * (n + 1)\\n for i, x in enumerate(nums, 1):\\n cnt[i] = cnt[i - 1] + x\\n s[i] = s[i - 1] + i * x\\n ans = inf\\n max = lambda x, y: x if x > y else y\\n min = lambda x, y: x if x < y else y\\n for i, x in enumerate(nums, 1):\\n t = 0\\n need = k - x\\n for j in (i - 1, i + 1):\\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\\n need -= 1\\n t += 1\\n c = min(need, maxChanges)\\n need -= c\\n t += c * 2\\n if need <= 0:\\n ans = min(ans, t)\\n continue\\n l, r = 2, max(i - 1, n - i)\\n while l <= r:\\n mid = (l + r) >> 1\\n l1, r1 = max(1, i - mid), max(0, i - 2)\\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\\n c1 = cnt[r1] - cnt[l1 - 1]\\n c2 = cnt[r2] - cnt[l2 - 1]\\n if c1 + c2 >= need:\\n t1 = c1 * i - (s[r1] - s[l1 - 1])\\n t2 = s[r2] - s[l2 - 1] - c2 * i\\n ans = min(ans, t + t1 + t2)\\n r = mid - 1\\n else:\\n l = mid + 1\\n return ans\",\n \"runtime\": \"1029\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n cnt = [0] * (n + 1)\\n s = [0] * (n + 1)\\n for i, x in enumerate(nums, 1):\\n cnt[i] = cnt[i - 1] + x\\n s[i] = s[i - 1] + i * x\\n ans = inf\\n max = lambda x, y: x if x > y else y\\n min = lambda x, y: x if x < y else y\\n for i, x in enumerate(nums, 1):\\n t = 0\\n need = k - x\\n for j in (i - 1, i + 1):\\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\\n need -= 1\\n t += 1\\n c = min(need, maxChanges)\\n need -= c\\n t += c * 2\\n if need <= 0:\\n ans = min(ans, t)\\n continue\\n l, r = 2, max(i - 1, n - i)\\n while l <= r:\\n mid = (l + r) >> 1\\n l1, r1 = max(1, i - mid), max(0, i - 2)\\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\\n c1 = cnt[r1] - cnt[l1 - 1]\\n c2 = cnt[r2] - cnt[l2 - 1]\\n if c1 + c2 >= need:\\n t1 = c1 * i - (s[r1] - s[l1 - 1])\\n t2 = s[r2] - s[l2 - 1] - c2 * i\\n ans = min(ans, t + t1 + t2)\\n r = mid - 1\\n else:\\n l = mid + 1\\n return ans\",\n \"runtime\": \"1070\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n cnt = [0] * (n + 1)\\n s = [0] * (n + 1)\\n for i, x in enumerate(nums, 1):\\n cnt[i] = cnt[i - 1] + x\\n s[i] = s[i - 1] + i * x\\n ans = inf\\n max = lambda x, y: x if x > y else y\\n min = lambda x, y: x if x < y else y\\n for i, x in enumerate(nums, 1):\\n t = 0\\n need = k - x\\n for j in (i - 1, i + 1):\\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\\n need -= 1\\n t += 1\\n c = min(need, maxChanges)\\n need -= c\\n t += c * 2\\n if need <= 0:\\n ans = min(ans, t)\\n continue\\n l, r = 2, max(i - 1, n - i)\\n while l <= r:\\n mid = (l + r) >> 1\\n l1, r1 = max(1, i - mid), max(0, i - 2)\\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\\n c1 = cnt[r1] - cnt[l1 - 1]\\n c2 = cnt[r2] - cnt[l2 - 1]\\n if c1 + c2 >= need:\\n t1 = c1 * i - (s[r1] - s[l1 - 1])\\n t2 = s[r2] - s[l2 - 1] - c2 * i\\n ans = min(ans, t + t1 + t2)\\n r = mid - 1\\n else:\\n l = mid + 1\\n return ans\",\n \"runtime\": \"1111\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":21,"string":"21"},"mm_list":{"kind":"list like","value":[{"code":"from typing import List\n\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n \n if n == 2:\n ones_in_2_window = nums[0] + nums[1]\n if k == 1:\n return 0 if ones_in_2_window >= 1 else 2\n return 2*(k-ones_in_2_window) + (1 if ones_in_2_window == 2 else 0)\n\n ones_in_2_window = nums[0] + nums[1]\n ones_in_3_window = 0\n for n1, n2, n3 in zip(nums, nums[1:], nums[2:]):\n if ones_in_2_window < n2 + n3:\n ones_in_2_window = n2 + n3\n if ones_in_3_window < n1 + n2 + n3:\n ones_in_3_window = n1 + n2 + n3\n if ones_in_3_window == 3:\n break\n\n # All the edge cases where k <= maxChanges + ones_in_3_window\n\n # --- first the k <= ones_in_3_window cases\n if k == 1:\n return 0 if ones_in_3_window >= 1 else 2\n\n if k == 2:\n if ones_in_2_window >= 2:\n return 1\n if ones_in_3_window >= 2:\n return 2\n\n # is contained in the next case\n # if k == 3:\n # if ones_in_3_window >= 3:\n # return 2\n\n # --- if ones_in_3_window < k <= maxChanges + ones_in_3_window\n if k <= maxChanges + ones_in_3_window:\n if ones_in_3_window == 3:\n return 2+2*(k-3)\n\n if ones_in_2_window == 2:\n # note that ones_in_3_window == 2, and there are adjacent 1's\n return 1+2*(k-2)\n\n if ones_in_3_window == 2:\n # there are no adjacent 1's\n return 2+2*(k-2)\n\n if ones_in_3_window == 1:\n return 2*(k-1)\n\n if ones_in_3_window == 0:\n return 2*k\n\n # --- maxChanges + ones_in_3_window < k\n # We are going to use all the maxChanges\n k -= maxChanges # add later 2*maxChanges to cost\n\n left_count = 0\n left_cost = 0\n left_length = 0\n right_count = 0\n right_cost = 0\n right_length = 0\n if nums[0] == 1:\n k -= 1\n while k > 0:\n right_length += 1\n if nums[right_length] == 1:\n right_cost += right_length\n right_count += 1\n k -= 1\n\n next_1_index = right_length + 1\n while next_1_index < n and nums[next_1_index] == 0:\n next_1_index += 1\n\n min_cost = right_cost\n\n for i in range(1, n):\n if nums[i-1-left_length] == 1:\n left_length += 1\n if nums[i-1] == 1:\n left_count += 1\n left_cost += left_count\n\n right_length -= 1\n right_cost -= right_count\n if nums[i] == 1:\n right_count -= 1\n\n if next_1_index < n and next_1_index - i <= left_length:\n right_length = next_1_index - i\n right_count += 1\n right_cost += right_length\n\n left_count -= 1\n left_cost -= left_length\n\n left_length -= 1\n while left_length > 0 and nums[i-left_length] == 0:\n left_length -= 1\n\n next_1_index += 1\n while next_1_index < n and nums[next_1_index] == 0:\n next_1_index += 1\n\n if left_cost + right_cost < min_cost:\n min_cost = left_cost + right_cost\n\n return min_cost + 2*maxChanges","memory":"19700"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ones = []\n ans = float('inf')\n\n # First sub-problem: Check if maxChanges and adjacent ones are enough\n for i in range(n):\n if nums[i]:\n ones.append(i)\n \n curr = nums[i]\n moves = 0\n \n if i > 0 and nums[i-1] == 1 and curr < k:\n moves += 1\n curr += 1\n \n if i + 1 < n and nums[i+1] == 1 and curr < k:\n moves += 1\n curr += 1\n \n if curr + maxChanges >= k:\n moves += (k - curr) * 2\n ans = min(ans, moves)\n \n if ans != float('inf'):\n return ans\n\n # Second sub-problem: Find optimal window for swapping ones\n rem = k - maxChanges\n no_of_ones = len(ones)\n l, r = 0, rem - 1\n\n curr_moves = 2 * maxChanges\n for i in range(rem):\n curr_moves += abs(ones[r // 2] - ones[i])\n \n ans = min(ans, curr_moves)\n l += 1\n r += 1\n\n while r < no_of_ones:\n mid = (l + r) // 2\n curr = ones[mid]\n prev = ones[mid - 1]\n lc = mid - l\n rc = r - mid\n\n curr_moves = curr_moves - curr * (rc - lc + 1) + prev * (rc - lc - 1) + ones[l - 1] + ones[r]\n ans = min(ans, curr_moves)\n l += 1\n r += 1\n\n return ans","memory":"22400"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ones = []\n ans = float('inf')\n\n # First sub-problem: Check if maxChanges and adjacent ones are enough\n for i in range(n):\n if nums[i]:\n ones.append(i)\n \n numMoves, numOnes = 0, nums[i]\n\n if i - 1 >= 0 and nums[i-1] and numOnes < k:\n numOnes += 1\n numMoves += 1\n if i + 1 < len(nums) and nums[i+1] and numOnes < k:\n numOnes += 1\n numMoves += 1\n \n if numOnes + maxChanges >= k:\n numMoves += (k - numOnes) * 2\n ans = min(ans, numMoves)\n \n if ans != float('inf'):\n return ans\n\n # Second sub-problem: Find optimal window for swapping ones\n remainingOnes = k - maxChanges\n l, r = 0, remainingOnes - 1\n numMoves = 2 * maxChanges # assuming we used our maxChanges, it takes 2 moves to get a 1 in the middle\n for i in range(remainingOnes):\n numMoves += abs(ones[r//2] - ones[i]) # for the initial window, we want to know the cost to push all 1's to the middle\n ans = min(ans, numMoves)\n l += 1\n r += 1\n\n while r < len(ones):\n mid = (l + r) // 2 # middle index of our current window\n cur = ones[mid] # the index of the middle one in the original array.\n prev = ones[mid-1] # the index of the one just before the middle\n leftOnes, rightOnes = mid - l, r - mid\n\n '''\n -curr * (rc - lc + 1): Remove the contribution of the current middle to all elements.\n +prev * (rc - lc - 1): Add the contribution of the new middle to all elements except the extremes.\n +ones[l - 1]: Add the cost of moving the new leftmost element.\n +ones[r]: Add the cost of moving the new rightmost element.\n '''\n numMoves = numMoves - cur * (rightOnes - leftOnes + 1) + prev * (rightOnes - leftOnes - 1) + ones[l - 1] + ones[r]\n ans = min(ans, numMoves)\n l += 1\n r += 1\n\n return ans\n","memory":"22500"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n ans = float(\"inf\")\n for i in range(len(nums)):\n cur = nums[i]\n moves = 0\n if i > 0 and cur < k:\n cur += nums[i - 1]\n moves += nums[i - 1]\n if i < len(nums) - 1 and cur < k:\n cur += nums[i + 1]\n moves += nums[i + 1]\n if cur + maxChanges >= k:\n ans = min(ans, moves + (k - cur) * 2)\n \n if ans != float(\"inf\"):\n return ans\n \n onePositions = []\n for i in range(len(nums)):\n if nums[i] == 1:\n onePositions.append(i)\n \n onesNeeded = k - maxChanges\n prev = maxChanges * 2\n for i in range(onesNeeded):\n prev += onePositions[i] - onePositions[0]\n\n l, r = 0, onesNeeded - 1\n for i in range(1, len(onePositions)):\n diff = onePositions[i] - onePositions[i - 1]\n countToLeft, countToRight = i - l, r - i + 1\n cur = prev + (countToLeft - countToRight) * diff\n while r + 1 < len(onePositions) and onePositions[r + 1] - onePositions[i] <= onePositions[i] - onePositions[l]:\n cur += onePositions[r + 1] - onePositions[i]\n cur -= onePositions[i] - onePositions[l]\n l += 1\n r += 1\n ans = min(ans, cur)\n prev = cur\n return ans","memory":"22600"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n\n one_list = []\n N = len(nums)\n threshold = max(k - maxChanges, 0)\n cnt, max_cnt = 0, 0\n for i in range(N):\n if nums[i]:\n cnt += 1\n max_cnt = max(max_cnt, cnt)\n one_list.append(i)\n else:\n cnt = 0\n\n if not one_list:\n return k * 2\n\n max_cnt = min(max_cnt, 3)\n if max_cnt >= threshold:\n if k == 1:\n return 0\n elif k == 2:\n return 1 if max_cnt >= k else 2\n return max(0, max_cnt - 1) + (k - max_cnt) * 2\n\n M = len(one_list)\n p, q, mid = 0, 0, 0\n step = 0\n while q < M and q < threshold:\n step += one_list[q] - one_list[0]\n q += 1\n\n step += maxChanges * 2\n ans = step\n\n while mid + 1 < M:\n gap = one_list[mid + 1] - one_list[mid]\n step += (mid - p + 1) * gap\n step -= (q - mid - 1) * gap\n mid += 1\n\n while (\n p < mid\n and q < M\n and (one_list[mid] - one_list[p]) > (one_list[q] - one_list[mid])\n ):\n step -= one_list[mid] - one_list[p]\n step += one_list[q] - one_list[mid]\n p += 1\n q += 1\n\n ans = min(ans, step)\n\n return ans\n\n # pre_one_cnt = 0\n # suf_one_cnt = 0\n\n # ans = math.inf\n # step = 0\n # p, q, mid = 0, 0, 0\n # prev_one_l = []\n # N = len(nums)\n # threshold = max(k - maxChanges, 0)\n\n # # pick up start point\n # while mid < N and nums[mid] == 0:\n # mid += 1\n\n # if mid == N:\n # return k * 2\n\n # q = mid\n # while q < N:\n # if nums[q] == 1:\n # suf_one_cnt += 1\n # step += q - mid\n # q += 1\n\n # if suf_one_cnt == k or (suf_one_cnt >= threshold and q - mid > 2):\n # ans = min(ans, step + max((k - suf_one_cnt), 0) * 2)\n # break\n\n # ans = min(ans, step + max((k - suf_one_cnt), 0) * 2)\n # while mid + 1 < N:\n # mid += 1\n # if nums[mid - 1] == 1:\n # suf_one_cnt -= 1\n # pre_one_cnt += 1\n # prev_one_l.append(mid - 1)\n # step += pre_one_cnt\n # step -= suf_one_cnt\n\n # if nums[mid] == 0:\n # continue\n\n # while q < N and p < len(prev_one_l) and (mid - prev_one_l[0]) > (q - mid):\n # if nums[q] == 0:\n # q += 1\n # continue\n\n # pre_one_cnt -= 1\n # suf_one_cnt += 1\n # step += q - mid\n # step -= prev_one_l[0]\n # p += 1\n # q += 1\n\n # ans = min(ans, step + (k - (suf_one_cnt + pre_one_cnt)) * 2)\n\n # return ans\n","memory":"22600"},{"code":"INF = 10 ** 10\n\nclass Solution:\n def getMoves(self, ones: List[int], window: int) -> int:\n n = len(ones)\n \n if window == 0:\n return 0\n \n if n < window:\n return INF \n \n leftSize = window // 2\n rightSize = window - leftSize\n\n leftSum, rightSum = 0, 0\n leftQ, rightQ = deque(), deque()\n \n def insertRight(ind):\n nonlocal rightSum\n rightQ.append(ind)\n rightSum += ind\n \n def insertLeft(ind):\n nonlocal leftSum\n leftQ.append(ind)\n leftSum += ind\n \n def removeRight():\n nonlocal rightSum\n rightSum -= rightQ[0]\n return rightQ.popleft()\n \n def removeLeft():\n nonlocal leftSum\n leftSum -= leftQ[0]\n return leftQ.popleft()\n \n def rebalance():\n if len(leftQ) <= leftSize and len(rightQ) <= rightSize:\n return\n \n if len(rightQ) > rightSize:\n x = removeRight()\n insertLeft(x)\n \n if len(leftQ) > leftSize:\n removeLeft()\n \n minCost = INF\n for ind in ones:\n insertRight(ind)\n rebalance()\n if len(leftQ) + len(rightQ) == window:\n median = rightQ[0]\n leftCost = len(leftQ) * median - leftSum\n rightCost = rightSum - len(rightQ) * median\n minCost = min(minCost, leftCost + rightCost)\n \n return minCost\n \n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n maxChanges = min(k, maxChanges)\n ones = [i for i, x in enumerate(nums) if x == 1]\n \n ans = INF\n for ignore in range(4):\n if maxChanges >= ignore:\n ans = min(ans, self.getMoves(ones, k - maxChanges + ignore) + (maxChanges - ignore) * 2)\n return ans","memory":"22700"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n ans = inf\n prefix = [0]\n for i in range(len(nums)):\n if nums[i] == 1:\n prefix.append(prefix[-1] + i)\n # case all zero\n if len(prefix) == 1:\n return k * 2\n # numbers that must use op2\n min_ws = max(k - maxChanges, 0)\n # if ws > min_ws+3, the cost must be greater than 2 -> some op2 should be replace with op1\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\n for ws in range(min_ws, max_ws + 1):\n for start_idx in range(len(prefix) - ws):\n end_idx = start_idx + ws\n mid_left = (start_idx + end_idx) // 2\n mid_right = (start_idx + end_idx + 1) // 2\n # cost = min dis sum from start_idx to end_idx\n cost = prefix[end_idx] - prefix[mid_left] - (prefix[mid_right] - prefix[start_idx])\n # fill rest with op1\n cost += (k - ws) * 2\n ans = min(ans, cost)\n return ans","memory":"23000"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n # op 1 is the optimal move if | y - x | > 2\n # op 2 is the optimal move if | y - x | <= 1\n # \n # To quickly calculate the sum of distances, \n # we can make a prefix sum array for all indices of 1.\n\n res = inf\n prefix = [0]\n for i in range(len(nums)):\n if nums[i] == 1:\n prefix.append(prefix[-1] + i)\n\n # in case nums is all zero\n if len(prefix) == 1:\n return k * 2\n\n # numbers that must use op2\n min_ws = max(k - maxChanges, 0)\n\n # if ws > min_ws + 3, the cost must be greater than 2,\n # some op 2 should be replaced by op 1\n max_ws = min([k, min_ws + 3])\n for ws in range(min_ws, max_ws + 1):\n for start_idx in range(len(prefix) - ws):\n end_idx = start_idx + ws\n mid_left = (start_idx + end_idx) // 2\n mid_right = (start_idx + end_idx + 1) // 2\n # cost = min distance sum from start_idx to end_idx\n cost = (prefix[end_idx] - prefix[mid_left]) - (prefix[mid_right] - prefix[start_idx])\n cost += (k - ws) * 2\n res = min(res, cost)\n return res\n","memory":"23400"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n t=max((len(list(g))for k,g in groupby(nums)if k==1),default=0)\n t=min(t,3)\n if k<=maxChanges+t:\n if k<=t:return k-1\n\n if t>0:\n return t-1+2*(k-t)\n else:\n return 2*k\n \n k-=maxChanges\n\n psums=list(accumulate((i for i,x in enumerate(nums) if x==1),initial=0))\n res=inf\n for i in range(k,len(psums)):\n j=i-(k+1)//2\n res=min(res,psums[i]-psums[i-k//2]-(psums[j]-psums[j-k//2]))\n return res+maxChanges*2\n ","memory":"23500"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n # operation 1 is the optimal move if | y - x | > 2\n # operation 2 is the optimal move if | y - x | <= 2, since we can use op 2 unlimited number of times\n # The cost of using operation 1 to pick 1, is 2.\n # The cost of using operation 2 to pick 1, is the distance to that 1.\n # i - 1, i, i + 1, at most 3 places have diatance <= 2.\n # We will at most take m + 3 of 1 using operation 2,\n\n # and also,\n # m <= n, where we have n of 1 at the begin.\n # m <= k, where need k of 1.\n\n # Now the question is simple,\n # what's the minimum distance from m points in A?\n\n # We choose the center of m points as initial index,\n # and calculate the total distance with prefix skill.\n\n # Return the minimum result in the end.\n # -----------------------------------------------\n # Intuition\n # Suppose stand index is x\n # If we use step 1 -> we need 2 moves to take 1 point\n # If we use step 2 -> we nedd |y - x| moves to take 1 point (y is one index)\n\n # So step 1 will be optimal if [y - x] > 2.\n # But we just can do the step 1 in max_changes times\n # So we do step 2 in k - max_changes, but if |y - x| <= 1, step 2 will be optimal\n # So we consider do the step 2 from k - max_changes to k - max_changes + 3 times because we just have 3 y satisfy |y - x| <= 1\n # So we can see the problem right now will be count minimum moves to take z points if only using step 2\n # -> using sliding window\n # we use sliding window since everything else outside the windows will be optimal using op 1\n # the cost can be calculated by (k - ws) * 2\n # and then we just need to exam the cost using op1 inside the window, and where to start\n # by going through start index from the beginning to the end - ws\n\n # For example we have array [1, 5, 6, 9, 10, 15]\n # We need to chose one index is stand index and total distanse from this index to other index is minimum\n # -> Chose the middle index (in this example is 9), so total distance is minimum\n # To caculate the total distanse in O(1), we use prefix sum\n # In this example total_distance = sum(10, 15) - 9 * 2 + 9 * 3 - sum(1, 5, 6)\n\n res = inf\n prefix = [0]\n for i in range(len(nums)):\n if nums[i] == 1:\n prefix.append(prefix[-1] + i)\n\n # in case nums is all zero\n if len(prefix) == 1:\n return k * 2\n\n # minimum windos size, numbers that must use op2\n min_ws = max(k - maxChanges, 0)\n\n # if ws > min_ws + 3, the cost must be greater than 2,\n # some op 2 should be replaced by op 1\n\n # for case [1, 1, 1], k = 2, maxChanges = 0\n # we need the max_ws to be k\n\n # when k is a huge number we want the max_ws to be the min_ws + 3\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\n \n for ws in range(min_ws, max_ws + 1):\n for start_idx in range(len(prefix) - ws):\n # Imagine indexes to be [0,1,4,5,7]\n # we are looking at last 4 points and for 4 points (m=4).\n # distance of 4 from every other point: 5-4+7-4+4-1=(7+5)-(1+4)\n # 7+5 is A[i + m]) - A[i + m - m // 2]\n # 1+4 is (A[i + m // 2] - A[i])\n # prefix will be [0,0,1,5,10,17]\n\n end_idx = start_idx + ws\n\n # check LC 1478 for similar prefix_sum technic\n # for odd number of ws, the mid is the same\n # for even number of ws, the mid is either mid_left or mid_right\n mid_left = (start_idx + end_idx) // 2\n mid_right = (start_idx + end_idx + 1) // 2\n # cost = min distance sum from start_idx to end_idx\n cost = (prefix[end_idx] - prefix[mid_right]) - (prefix[mid_left] - prefix[start_idx])\n cost += (k - ws) * 2\n res = min(res, cost)\n return max(res, 0)","memory":"23600"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n s = \"\".join(map(str, nums))\n if \"111\" in s:\n max_cons = 3\n elif \"11\" in s:\n max_cons = 2\n elif \"1\" in s:\n max_cons = 1\n else:\n max_cons = 0\n print(s, max_cons)\n if max_cons > k:\n max_cons = k\n if max_changes >= k - max_cons:\n return (k - max_cons) * 2 + max(0, max_cons - 1)\n \n res = max_changes * 2\n print('res',res)\n k -= max_changes\n print('k', k)\n idxes = [i for i in range(len(nums)) if nums[i]]\n print('idxes',idxes)\n pmid = k // 2\n left = 0\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\n print('pmid',pmid)\n print('left', left)\n print('cdiff',cdiff)\n for right in range(k, len(idxes)):\n cdiff -= idxes[pmid] - idxes[left]\n left += 1\n cdiff += idxes[right] - idxes[pmid + 1]\n move_d = idxes[pmid + 1] - idxes[pmid]\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\n mdiff = min(mdiff, cdiff)\n pmid += 1\n res += mdiff\n return res","memory":"25700"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n s = \"\".join(map(str, nums))\n if \"111\" in s:\n max_cons = 3\n elif \"11\" in s:\n max_cons = 2\n elif \"1\" in s:\n max_cons = 1\n else:\n max_cons = 0\n print(s, max_cons)\n if max_cons > k:\n max_cons = k\n if max_changes >= k - max_cons:\n return (k - max_cons) * 2 + max(0, max_cons - 1)\n \n res = max_changes * 2\n print('res',res)\n k -= max_changes\n print('k', k)\n idxes = [i for i in range(len(nums)) if nums[i]]\n print('idxes',idxes)\n pmid = k // 2\n left = 0\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\n print('pmid',pmid)\n print('left', left)\n print('cdiff',cdiff)\n for right in range(k, len(idxes)):\n cdiff -= idxes[pmid] - idxes[left]\n left += 1\n cdiff += idxes[right] - idxes[pmid + 1]\n move_d = idxes[pmid + 1] - idxes[pmid]\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\n mdiff = min(mdiff, cdiff)\n pmid += 1\n res += mdiff\n return res","memory":"25800"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ans = 1e18\n # finish without step 2\n for i in range(n):\n curr = nums[i]\n move = 0\n if i > 0 and nums[i-1] == 1:\n curr += 1\n move += 1\n if i < n-1 and nums[i+1] == 1 and curr < k:\n move += 1\n curr += 1\n if curr + maxChanges >= k:\n ans = min(ans, move + (k - curr) * 2)\n \n if maxChanges >= k:\n return max(0, ans)\n\n # sliding window for step2\n arr = [i for i, v in enumerate(nums) if v == 1]\n target = k - maxChanges\n l, r = 0, target-1\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges*2\n ans = min(ans, prev)\n for i in range(1, len(arr)):\n diff = arr[i] - arr[i-1]\n left_count, right_count = i - l, r - i + 1\n curr = prev + (left_count - right_count)*diff\n while r + 1 < len(arr) and arr[r+1] - arr[i] <= arr[i] - arr[l]:\n curr -= arr[i] - arr[l]\n curr += arr[r+1] - arr[i]\n r += 1\n l += 1\n ans = min(ans, curr)\n prev = curr\n return max(0, ans)","memory":"25900"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n ans = 1e18\n # finish without step 2\n for i in range(n):\n curr = nums[i]\n move = 0\n if i > 0 and nums[i-1] == 1:\n curr += 1\n move += 1\n if i < n-1 and nums[i+1] == 1 and curr < k:\n move += 1\n curr += 1\n if curr + maxChanges >= k:\n ans = min(ans, move + (k - curr) * 2)\n \n if maxChanges >= k:\n return max(0, ans)\n\n # sliding window for step2\n arr = [i for i, v in enumerate(nums) if v == 1]\n target = k - maxChanges\n l, r = 0, target-1\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges*2\n ans = min(ans, prev)\n for i in range(1, len(arr)):\n diff = arr[i] - arr[i-1]\n left_count, right_count = i - l, r - i + 1\n curr = prev + (left_count - right_count)*diff\n while r + 1 < len(arr) and arr[r+1] - arr[i] <= arr[i] - arr[l]:\n curr -= arr[i] - arr[l]\n curr += arr[r+1] - arr[i]\n r += 1\n l += 1\n ans = min(ans, curr)\n prev = curr\n return max(0, ans)","memory":"26000"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n\n cnt , seq = 0 , 0\n\n pones = []\n\n for i , x in enumerate(nums):\n if x > 0:\n pones.append(i)\n seq = max(seq , cnt:=x and cnt + 1)\n \n seq = min(3 , k , seq)\n\n if seq + maxChanges >=k:\n return max(0 , seq - 1) + 2*(k - seq)\n \n ans = inf\n\n n = k - maxChanges\n prefix = list(accumulate(pones , initial = 0))\n\n for i in range(len(pones) - n + 1):\n wd =prefix[i + n] - prefix[i + (n + 1)//2] - (prefix[i + n//2] - prefix[i])\n ans = min(ans , wd + 2*maxChanges)\n \n return ans\n ","memory":"26400"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n one_indexes = [index for index in range(len(nums)) if nums[index] == 1]\n min_moves = float('inf')\n if max_changes >= k: # with 0 step 2\n min_moves = 2 * k\n\n prefix_sums = one_indexes.copy()\n for i in range(1, len(one_indexes)):\n prefix_sums[i] += prefix_sums[i - 1]\n\n def get_sum(left, right):\n if left > right:\n return 0\n if left == 0:\n return prefix_sums[right]\n return prefix_sums[right] - prefix_sums[left - 1]\n\n min_step_twos = max(1, k - max_changes)\n # step_twos is the number of times using step 2\n for step_twos in range(min_step_twos, min_step_twos + 3):\n if step_twos > k:\n break\n\n for left in range(len(one_indexes)):\n right = left + step_twos - 1\n if right >= len(one_indexes):\n break\n\n stand_index = (right + left) // 2\n # number moves that using step 1\n curr_moves = (k - step_twos) * 2\n # total distance from mid to right\n curr_moves += get_sum(stand_index + 1, right) - (right - stand_index) * one_indexes[stand_index]\n # total distance from left to mid\n curr_moves += (stand_index - left) * one_indexes[stand_index] - get_sum(left, stand_index - 1)\n\n min_moves = min(min_moves, curr_moves)\n\n return min_moves","memory":"26500"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n\n cnt , seq = 0 , 0\n\n pones = []\n\n for i , x in enumerate(nums):\n if x > 0:\n pones.append(i)\n seq = max(seq , cnt:=x and cnt + 1)\n \n seq = min(3 , k , seq)\n\n if seq + maxChanges >=k:\n return max(0 , seq - 1) + 2*(k - seq)\n \n ans = inf\n\n n = k - maxChanges\n prefix = list(accumulate(pones , initial = 0))\n\n for i in range(len(pones) - n + 1):\n wd =prefix[i + n] - prefix[i + (n + 1)//2] - (prefix[i + n//2] - prefix[i])\n ans = min(ans , wd + 2*maxChanges)\n \n return ans\n ","memory":"26600"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n one_indexes = [index for index in range(len(nums)) if nums[index] == 1]\n min_moves = float('inf')\n if max_changes >= k: # with 0 step 2\n min_moves = 2 * k\n\n prefix_sums = one_indexes.copy()\n for i in range(1, len(one_indexes)):\n prefix_sums[i] += prefix_sums[i - 1]\n\n def get_sum(left, right):\n if left > right:\n return 0\n if left == 0:\n return prefix_sums[right]\n return prefix_sums[right] - prefix_sums[left - 1]\n\n min_step_twos = max(1, k - max_changes)\n # step_twos is the number of times using step 2\n for step_twos in range(min_step_twos, min_step_twos + 3):\n if step_twos > k:\n break\n\n for left in range(len(one_indexes)):\n right = left + step_twos - 1\n if right >= len(one_indexes):\n break\n\n stand_index = (right + left) // 2\n # number moves that using step 1\n curr_moves = (k - step_twos) * 2\n # total distance from mid to right\n curr_moves += get_sum(stand_index + 1, right) - (right - stand_index) * one_indexes[stand_index]\n # total distance from left to mid\n curr_moves += (stand_index - left) * one_indexes[stand_index] - get_sum(left, stand_index - 1)\n\n min_moves = min(min_moves, curr_moves)\n\n return min_moves","memory":"26600"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n n = len(nums)\n cnt = [0] * (n + 1)\n s = [0] * (n + 1)\n for i, x in enumerate(nums, 1):\n cnt[i] = cnt[i - 1] + x\n s[i] = s[i - 1] + i * x\n ans = inf\n max = lambda x, y: x if x > y else y\n min = lambda x, y: x if x < y else y\n for i, x in enumerate(nums, 1):\n t = 0\n need = k - x\n for j in (i - 1, i + 1):\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\n need -= 1\n t += 1\n c = min(need, maxChanges)\n need -= c\n t += c * 2\n if need <= 0:\n ans = min(ans, t)\n continue\n l, r = 2, max(i - 1, n - i)\n while l <= r:\n mid = (l + r) >> 1\n l1, r1 = max(1, i - mid), max(0, i - 2)\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\n c1 = cnt[r1] - cnt[l1 - 1]\n c2 = cnt[r2] - cnt[l2 - 1]\n if c1 + c2 >= need:\n t1 = c1 * i - (s[r1] - s[l1 - 1])\n t2 = s[r2] - s[l2 - 1] - c2 * i\n ans = min(ans, t + t1 + t2)\n r = mid - 1\n else:\n l = mid + 1\n return ans","memory":"26700"},{"code":"class Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n N = len(nums)\n INF = 10 ** 20\n pref = [0] + list(accumulate(nums))\n pref_ind = [0] \n for i in range(N):\n pref_ind.append(pref_ind[-1])\n if nums[i] == 1: pref_ind[-1] += i\n \n def go(index):\n k_copy = k\n moves = 0\n\n if nums[index] == 1: k_copy -= 1\n \n if k_copy == 0: return moves\n\n if index > 0 and nums[index - 1]:\n moves += 1\n k_copy -= 1\n\n if k_copy == 0: return moves\n\n if index < N - 1 and nums[index + 1]:\n moves += 1\n k_copy -= 1\n\n if k_copy == 0: return moves\n\n delta = min(maxChanges, k_copy)\n\n k_copy -= delta\n\n moves += 2 * delta\n\n if k_copy == 0: return moves\n\n\n def good(t):\n # count ones not including index, index + 1, index - 1, within a radius t\n left_ones = pref[max(index - 1, 0)] - pref[max(0, index - 1 - t)]\n right_ones = pref[min(N, index + 1 + t + 1)] - pref[min(N, index + 1 + 1)]\n return left_ones + right_ones >= k_copy\n\n \n l, r = 0, N\n\n while l < r:\n mid = (l + r) // 2\n\n if good(mid):\n r = mid\n\n else:\n l = mid + 1\n\n left_close_to_index = max(index - 1, 0)\n left_far_from_index = max(index - 1 - l, 0)\n left_count_ones = pref[left_close_to_index] - pref[left_far_from_index]\n\n right_far_from_index = min(index + l + 2, N)\n right_close_to_index = min(index + 2, N)\n right_count_ones = pref[right_far_from_index] - pref[right_close_to_index]\n\n\n left_index_sum = pref_ind[left_close_to_index] - pref_ind[left_far_from_index]\n right_index_sum = pref_ind[right_far_from_index] - pref_ind[right_close_to_index]\n\n moves += index * left_count_ones - left_index_sum\n moves += right_index_sum - index * right_count_ones\n\n if left_count_ones + right_count_ones > k_copy:\n moves -= (l + 1)\n\n return moves\n \n\n best = INF\n for i in range(N):\n best = min(best, go(i))\n\n return best","memory":"26700"},{"code":"import bisect\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\n if sum(nums) == 0:\n return k * 2\n index1 = list(i for i, num in enumerate(nums) if num)\n sumL = [0]\n for num in index1: sumL.append(sumL[-1] + num)\n def inter_sum(l, r):\n return sumL[r+1] - sumL[l]\n def cost(dylanIndex, k):\n def trial(delta):\n L = bisect.bisect_left(index1, dylanIndex - delta)\n R = bisect.bisect_left(index1, dylanIndex + delta)\n if R == len(index1) or index1[R] != dylanIndex + delta:\n R -= 1\n return R - L + 1, (L, R)\n L, R = -1, 10**5\n while R - L != 1:\n M = (L + R + 1) // 2\n if trial(M)[0] >= k:\n R = M\n else:\n L = M\n delta, chosen = R, trial(R)[1]\n if chosen[1] - chosen[0] + 1 > k:\n chosen = [chosen[0], chosen[1]-1]\n pivot = bisect.bisect_left(index1, dylanIndex)\n Lcost = dylanIndex * (pivot - chosen[0]) - inter_sum(chosen[0], pivot-1)\n Rcost = max(0, inter_sum(pivot, chosen[1]) - dylanIndex * (chosen[1] - pivot + 1))\n return Lcost + Rcost\n\n ans = float('inf')\n for dylanIndex in range(len(nums)):\n near = sum(nums[max(0, dylanIndex-1):dylanIndex+2])\n byChange = 0 if near >= k else min(maxChanges, k - near)\n curCost = cost(dylanIndex, k - byChange)\n ans = min(ans, curCost + byChange * 2)\n return ans","memory":"26800"},{"code":"\"\"\"\nIntuitions\n1. There are 2 optimal ways of getting a point.\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\n This costs 2 operations.\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\n This costs dist(alice_index, one_index) many operations. \n2. There can be at most 3 operations costing < 2 operations for (b) if we have \n <= 3 consecutive ones.\n\"\"\"\n\nclass Solution:\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\n pos = []\n \n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\n # requiring less than 2 operations).\n m = 0\n \n # compute m (just counting the max consecutive ones up to length 3).\n for i, num in enumerate(nums):\n if num == 0:\n continue \n pos.append(i)\n m = max(m, 1)\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\n m = 3\n elif i > 0 and nums[i - 1] == 1:\n m = max(m, 2)\n \n # here, we are greedy and prefer using as little moves as possible\n # optimally, we want to use operations costing 0 (start at 1), \n # 1 (move adjacent 1), or 2 (use operation (a)).\n if m >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n return k - 1\n elif m + max_changes >= k:\n # start at a 1 and use k - 1 operations costing 1 move.\n # for the remaining operations, use the 2 move operations. \n return max(m - 1, 0) + (k - m) * 2\n \n # we can use between [0, max_changes] many operations costing 2 moves.\n n = len(pos)\n prefix = [0] + list(accumulate(pos))\n res = float(\"inf\")\n \n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\n for x in range(max_changes - m, max_changes + 1):\n required_window_size = k - x\n for i in range(max(n - required_window_size + 1, 0)):\n j = i + required_window_size\n median = i + required_window_size // 2\n idx = pos[median]\n \n left = idx * (median - i) - (prefix[median] - prefix[i])\n right = prefix[j] - prefix[median] - idx * (j - median)\n res = min(res, left + right + 2 * x)\n return res ","memory":"27200"}],"string":"[\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n \\n if n == 2:\\n ones_in_2_window = nums[0] + nums[1]\\n if k == 1:\\n return 0 if ones_in_2_window >= 1 else 2\\n return 2*(k-ones_in_2_window) + (1 if ones_in_2_window == 2 else 0)\\n\\n ones_in_2_window = nums[0] + nums[1]\\n ones_in_3_window = 0\\n for n1, n2, n3 in zip(nums, nums[1:], nums[2:]):\\n if ones_in_2_window < n2 + n3:\\n ones_in_2_window = n2 + n3\\n if ones_in_3_window < n1 + n2 + n3:\\n ones_in_3_window = n1 + n2 + n3\\n if ones_in_3_window == 3:\\n break\\n\\n # All the edge cases where k <= maxChanges + ones_in_3_window\\n\\n # --- first the k <= ones_in_3_window cases\\n if k == 1:\\n return 0 if ones_in_3_window >= 1 else 2\\n\\n if k == 2:\\n if ones_in_2_window >= 2:\\n return 1\\n if ones_in_3_window >= 2:\\n return 2\\n\\n # is contained in the next case\\n # if k == 3:\\n # if ones_in_3_window >= 3:\\n # return 2\\n\\n # --- if ones_in_3_window < k <= maxChanges + ones_in_3_window\\n if k <= maxChanges + ones_in_3_window:\\n if ones_in_3_window == 3:\\n return 2+2*(k-3)\\n\\n if ones_in_2_window == 2:\\n # note that ones_in_3_window == 2, and there are adjacent 1's\\n return 1+2*(k-2)\\n\\n if ones_in_3_window == 2:\\n # there are no adjacent 1's\\n return 2+2*(k-2)\\n\\n if ones_in_3_window == 1:\\n return 2*(k-1)\\n\\n if ones_in_3_window == 0:\\n return 2*k\\n\\n # --- maxChanges + ones_in_3_window < k\\n # We are going to use all the maxChanges\\n k -= maxChanges # add later 2*maxChanges to cost\\n\\n left_count = 0\\n left_cost = 0\\n left_length = 0\\n right_count = 0\\n right_cost = 0\\n right_length = 0\\n if nums[0] == 1:\\n k -= 1\\n while k > 0:\\n right_length += 1\\n if nums[right_length] == 1:\\n right_cost += right_length\\n right_count += 1\\n k -= 1\\n\\n next_1_index = right_length + 1\\n while next_1_index < n and nums[next_1_index] == 0:\\n next_1_index += 1\\n\\n min_cost = right_cost\\n\\n for i in range(1, n):\\n if nums[i-1-left_length] == 1:\\n left_length += 1\\n if nums[i-1] == 1:\\n left_count += 1\\n left_cost += left_count\\n\\n right_length -= 1\\n right_cost -= right_count\\n if nums[i] == 1:\\n right_count -= 1\\n\\n if next_1_index < n and next_1_index - i <= left_length:\\n right_length = next_1_index - i\\n right_count += 1\\n right_cost += right_length\\n\\n left_count -= 1\\n left_cost -= left_length\\n\\n left_length -= 1\\n while left_length > 0 and nums[i-left_length] == 0:\\n left_length -= 1\\n\\n next_1_index += 1\\n while next_1_index < n and nums[next_1_index] == 0:\\n next_1_index += 1\\n\\n if left_cost + right_cost < min_cost:\\n min_cost = left_cost + right_cost\\n\\n return min_cost + 2*maxChanges\",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ones = []\\n ans = float('inf')\\n\\n # First sub-problem: Check if maxChanges and adjacent ones are enough\\n for i in range(n):\\n if nums[i]:\\n ones.append(i)\\n \\n curr = nums[i]\\n moves = 0\\n \\n if i > 0 and nums[i-1] == 1 and curr < k:\\n moves += 1\\n curr += 1\\n \\n if i + 1 < n and nums[i+1] == 1 and curr < k:\\n moves += 1\\n curr += 1\\n \\n if curr + maxChanges >= k:\\n moves += (k - curr) * 2\\n ans = min(ans, moves)\\n \\n if ans != float('inf'):\\n return ans\\n\\n # Second sub-problem: Find optimal window for swapping ones\\n rem = k - maxChanges\\n no_of_ones = len(ones)\\n l, r = 0, rem - 1\\n\\n curr_moves = 2 * maxChanges\\n for i in range(rem):\\n curr_moves += abs(ones[r // 2] - ones[i])\\n \\n ans = min(ans, curr_moves)\\n l += 1\\n r += 1\\n\\n while r < no_of_ones:\\n mid = (l + r) // 2\\n curr = ones[mid]\\n prev = ones[mid - 1]\\n lc = mid - l\\n rc = r - mid\\n\\n curr_moves = curr_moves - curr * (rc - lc + 1) + prev * (rc - lc - 1) + ones[l - 1] + ones[r]\\n ans = min(ans, curr_moves)\\n l += 1\\n r += 1\\n\\n return ans\",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ones = []\\n ans = float('inf')\\n\\n # First sub-problem: Check if maxChanges and adjacent ones are enough\\n for i in range(n):\\n if nums[i]:\\n ones.append(i)\\n \\n numMoves, numOnes = 0, nums[i]\\n\\n if i - 1 >= 0 and nums[i-1] and numOnes < k:\\n numOnes += 1\\n numMoves += 1\\n if i + 1 < len(nums) and nums[i+1] and numOnes < k:\\n numOnes += 1\\n numMoves += 1\\n \\n if numOnes + maxChanges >= k:\\n numMoves += (k - numOnes) * 2\\n ans = min(ans, numMoves)\\n \\n if ans != float('inf'):\\n return ans\\n\\n # Second sub-problem: Find optimal window for swapping ones\\n remainingOnes = k - maxChanges\\n l, r = 0, remainingOnes - 1\\n numMoves = 2 * maxChanges # assuming we used our maxChanges, it takes 2 moves to get a 1 in the middle\\n for i in range(remainingOnes):\\n numMoves += abs(ones[r//2] - ones[i]) # for the initial window, we want to know the cost to push all 1's to the middle\\n ans = min(ans, numMoves)\\n l += 1\\n r += 1\\n\\n while r < len(ones):\\n mid = (l + r) // 2 # middle index of our current window\\n cur = ones[mid] # the index of the middle one in the original array.\\n prev = ones[mid-1] # the index of the one just before the middle\\n leftOnes, rightOnes = mid - l, r - mid\\n\\n '''\\n -curr * (rc - lc + 1): Remove the contribution of the current middle to all elements.\\n +prev * (rc - lc - 1): Add the contribution of the new middle to all elements except the extremes.\\n +ones[l - 1]: Add the cost of moving the new leftmost element.\\n +ones[r]: Add the cost of moving the new rightmost element.\\n '''\\n numMoves = numMoves - cur * (rightOnes - leftOnes + 1) + prev * (rightOnes - leftOnes - 1) + ones[l - 1] + ones[r]\\n ans = min(ans, numMoves)\\n l += 1\\n r += 1\\n\\n return ans\\n\",\n \"memory\": \"22500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n ans = float(\\\"inf\\\")\\n for i in range(len(nums)):\\n cur = nums[i]\\n moves = 0\\n if i > 0 and cur < k:\\n cur += nums[i - 1]\\n moves += nums[i - 1]\\n if i < len(nums) - 1 and cur < k:\\n cur += nums[i + 1]\\n moves += nums[i + 1]\\n if cur + maxChanges >= k:\\n ans = min(ans, moves + (k - cur) * 2)\\n \\n if ans != float(\\\"inf\\\"):\\n return ans\\n \\n onePositions = []\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n onePositions.append(i)\\n \\n onesNeeded = k - maxChanges\\n prev = maxChanges * 2\\n for i in range(onesNeeded):\\n prev += onePositions[i] - onePositions[0]\\n\\n l, r = 0, onesNeeded - 1\\n for i in range(1, len(onePositions)):\\n diff = onePositions[i] - onePositions[i - 1]\\n countToLeft, countToRight = i - l, r - i + 1\\n cur = prev + (countToLeft - countToRight) * diff\\n while r + 1 < len(onePositions) and onePositions[r + 1] - onePositions[i] <= onePositions[i] - onePositions[l]:\\n cur += onePositions[r + 1] - onePositions[i]\\n cur -= onePositions[i] - onePositions[l]\\n l += 1\\n r += 1\\n ans = min(ans, cur)\\n prev = cur\\n return ans\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n\\n one_list = []\\n N = len(nums)\\n threshold = max(k - maxChanges, 0)\\n cnt, max_cnt = 0, 0\\n for i in range(N):\\n if nums[i]:\\n cnt += 1\\n max_cnt = max(max_cnt, cnt)\\n one_list.append(i)\\n else:\\n cnt = 0\\n\\n if not one_list:\\n return k * 2\\n\\n max_cnt = min(max_cnt, 3)\\n if max_cnt >= threshold:\\n if k == 1:\\n return 0\\n elif k == 2:\\n return 1 if max_cnt >= k else 2\\n return max(0, max_cnt - 1) + (k - max_cnt) * 2\\n\\n M = len(one_list)\\n p, q, mid = 0, 0, 0\\n step = 0\\n while q < M and q < threshold:\\n step += one_list[q] - one_list[0]\\n q += 1\\n\\n step += maxChanges * 2\\n ans = step\\n\\n while mid + 1 < M:\\n gap = one_list[mid + 1] - one_list[mid]\\n step += (mid - p + 1) * gap\\n step -= (q - mid - 1) * gap\\n mid += 1\\n\\n while (\\n p < mid\\n and q < M\\n and (one_list[mid] - one_list[p]) > (one_list[q] - one_list[mid])\\n ):\\n step -= one_list[mid] - one_list[p]\\n step += one_list[q] - one_list[mid]\\n p += 1\\n q += 1\\n\\n ans = min(ans, step)\\n\\n return ans\\n\\n # pre_one_cnt = 0\\n # suf_one_cnt = 0\\n\\n # ans = math.inf\\n # step = 0\\n # p, q, mid = 0, 0, 0\\n # prev_one_l = []\\n # N = len(nums)\\n # threshold = max(k - maxChanges, 0)\\n\\n # # pick up start point\\n # while mid < N and nums[mid] == 0:\\n # mid += 1\\n\\n # if mid == N:\\n # return k * 2\\n\\n # q = mid\\n # while q < N:\\n # if nums[q] == 1:\\n # suf_one_cnt += 1\\n # step += q - mid\\n # q += 1\\n\\n # if suf_one_cnt == k or (suf_one_cnt >= threshold and q - mid > 2):\\n # ans = min(ans, step + max((k - suf_one_cnt), 0) * 2)\\n # break\\n\\n # ans = min(ans, step + max((k - suf_one_cnt), 0) * 2)\\n # while mid + 1 < N:\\n # mid += 1\\n # if nums[mid - 1] == 1:\\n # suf_one_cnt -= 1\\n # pre_one_cnt += 1\\n # prev_one_l.append(mid - 1)\\n # step += pre_one_cnt\\n # step -= suf_one_cnt\\n\\n # if nums[mid] == 0:\\n # continue\\n\\n # while q < N and p < len(prev_one_l) and (mid - prev_one_l[0]) > (q - mid):\\n # if nums[q] == 0:\\n # q += 1\\n # continue\\n\\n # pre_one_cnt -= 1\\n # suf_one_cnt += 1\\n # step += q - mid\\n # step -= prev_one_l[0]\\n # p += 1\\n # q += 1\\n\\n # ans = min(ans, step + (k - (suf_one_cnt + pre_one_cnt)) * 2)\\n\\n # return ans\\n\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"INF = 10 ** 10\\n\\nclass Solution:\\n def getMoves(self, ones: List[int], window: int) -> int:\\n n = len(ones)\\n \\n if window == 0:\\n return 0\\n \\n if n < window:\\n return INF \\n \\n leftSize = window // 2\\n rightSize = window - leftSize\\n\\n leftSum, rightSum = 0, 0\\n leftQ, rightQ = deque(), deque()\\n \\n def insertRight(ind):\\n nonlocal rightSum\\n rightQ.append(ind)\\n rightSum += ind\\n \\n def insertLeft(ind):\\n nonlocal leftSum\\n leftQ.append(ind)\\n leftSum += ind\\n \\n def removeRight():\\n nonlocal rightSum\\n rightSum -= rightQ[0]\\n return rightQ.popleft()\\n \\n def removeLeft():\\n nonlocal leftSum\\n leftSum -= leftQ[0]\\n return leftQ.popleft()\\n \\n def rebalance():\\n if len(leftQ) <= leftSize and len(rightQ) <= rightSize:\\n return\\n \\n if len(rightQ) > rightSize:\\n x = removeRight()\\n insertLeft(x)\\n \\n if len(leftQ) > leftSize:\\n removeLeft()\\n \\n minCost = INF\\n for ind in ones:\\n insertRight(ind)\\n rebalance()\\n if len(leftQ) + len(rightQ) == window:\\n median = rightQ[0]\\n leftCost = len(leftQ) * median - leftSum\\n rightCost = rightSum - len(rightQ) * median\\n minCost = min(minCost, leftCost + rightCost)\\n \\n return minCost\\n \\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n maxChanges = min(k, maxChanges)\\n ones = [i for i, x in enumerate(nums) if x == 1]\\n \\n ans = INF\\n for ignore in range(4):\\n if maxChanges >= ignore:\\n ans = min(ans, self.getMoves(ones, k - maxChanges + ignore) + (maxChanges - ignore) * 2)\\n return ans\",\n \"memory\": \"22700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n ans = inf\\n prefix = [0]\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n prefix.append(prefix[-1] + i)\\n # case all zero\\n if len(prefix) == 1:\\n return k * 2\\n # numbers that must use op2\\n min_ws = max(k - maxChanges, 0)\\n # if ws > min_ws+3, the cost must be greater than 2 -> some op2 should be replace with op1\\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\\n for ws in range(min_ws, max_ws + 1):\\n for start_idx in range(len(prefix) - ws):\\n end_idx = start_idx + ws\\n mid_left = (start_idx + end_idx) // 2\\n mid_right = (start_idx + end_idx + 1) // 2\\n # cost = min dis sum from start_idx to end_idx\\n cost = prefix[end_idx] - prefix[mid_left] - (prefix[mid_right] - prefix[start_idx])\\n # fill rest with op1\\n cost += (k - ws) * 2\\n ans = min(ans, cost)\\n return ans\",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n # op 1 is the optimal move if | y - x | > 2\\n # op 2 is the optimal move if | y - x | <= 1\\n # \\n # To quickly calculate the sum of distances, \\n # we can make a prefix sum array for all indices of 1.\\n\\n res = inf\\n prefix = [0]\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n prefix.append(prefix[-1] + i)\\n\\n # in case nums is all zero\\n if len(prefix) == 1:\\n return k * 2\\n\\n # numbers that must use op2\\n min_ws = max(k - maxChanges, 0)\\n\\n # if ws > min_ws + 3, the cost must be greater than 2,\\n # some op 2 should be replaced by op 1\\n max_ws = min([k, min_ws + 3])\\n for ws in range(min_ws, max_ws + 1):\\n for start_idx in range(len(prefix) - ws):\\n end_idx = start_idx + ws\\n mid_left = (start_idx + end_idx) // 2\\n mid_right = (start_idx + end_idx + 1) // 2\\n # cost = min distance sum from start_idx to end_idx\\n cost = (prefix[end_idx] - prefix[mid_left]) - (prefix[mid_right] - prefix[start_idx])\\n cost += (k - ws) * 2\\n res = min(res, cost)\\n return res\\n\",\n \"memory\": \"23400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n t=max((len(list(g))for k,g in groupby(nums)if k==1),default=0)\\n t=min(t,3)\\n if k<=maxChanges+t:\\n if k<=t:return k-1\\n\\n if t>0:\\n return t-1+2*(k-t)\\n else:\\n return 2*k\\n \\n k-=maxChanges\\n\\n psums=list(accumulate((i for i,x in enumerate(nums) if x==1),initial=0))\\n res=inf\\n for i in range(k,len(psums)):\\n j=i-(k+1)//2\\n res=min(res,psums[i]-psums[i-k//2]-(psums[j]-psums[j-k//2]))\\n return res+maxChanges*2\\n \",\n \"memory\": \"23500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n # operation 1 is the optimal move if | y - x | > 2\\n # operation 2 is the optimal move if | y - x | <= 2, since we can use op 2 unlimited number of times\\n # The cost of using operation 1 to pick 1, is 2.\\n # The cost of using operation 2 to pick 1, is the distance to that 1.\\n # i - 1, i, i + 1, at most 3 places have diatance <= 2.\\n # We will at most take m + 3 of 1 using operation 2,\\n\\n # and also,\\n # m <= n, where we have n of 1 at the begin.\\n # m <= k, where need k of 1.\\n\\n # Now the question is simple,\\n # what's the minimum distance from m points in A?\\n\\n # We choose the center of m points as initial index,\\n # and calculate the total distance with prefix skill.\\n\\n # Return the minimum result in the end.\\n # -----------------------------------------------\\n # Intuition\\n # Suppose stand index is x\\n # If we use step 1 -> we need 2 moves to take 1 point\\n # If we use step 2 -> we nedd |y - x| moves to take 1 point (y is one index)\\n\\n # So step 1 will be optimal if [y - x] > 2.\\n # But we just can do the step 1 in max_changes times\\n # So we do step 2 in k - max_changes, but if |y - x| <= 1, step 2 will be optimal\\n # So we consider do the step 2 from k - max_changes to k - max_changes + 3 times because we just have 3 y satisfy |y - x| <= 1\\n # So we can see the problem right now will be count minimum moves to take z points if only using step 2\\n # -> using sliding window\\n # we use sliding window since everything else outside the windows will be optimal using op 1\\n # the cost can be calculated by (k - ws) * 2\\n # and then we just need to exam the cost using op1 inside the window, and where to start\\n # by going through start index from the beginning to the end - ws\\n\\n # For example we have array [1, 5, 6, 9, 10, 15]\\n # We need to chose one index is stand index and total distanse from this index to other index is minimum\\n # -> Chose the middle index (in this example is 9), so total distance is minimum\\n # To caculate the total distanse in O(1), we use prefix sum\\n # In this example total_distance = sum(10, 15) - 9 * 2 + 9 * 3 - sum(1, 5, 6)\\n\\n res = inf\\n prefix = [0]\\n for i in range(len(nums)):\\n if nums[i] == 1:\\n prefix.append(prefix[-1] + i)\\n\\n # in case nums is all zero\\n if len(prefix) == 1:\\n return k * 2\\n\\n # minimum windos size, numbers that must use op2\\n min_ws = max(k - maxChanges, 0)\\n\\n # if ws > min_ws + 3, the cost must be greater than 2,\\n # some op 2 should be replaced by op 1\\n\\n # for case [1, 1, 1], k = 2, maxChanges = 0\\n # we need the max_ws to be k\\n\\n # when k is a huge number we want the max_ws to be the min_ws + 3\\n max_ws = min([k, min_ws + 3, len(prefix) - 1])\\n \\n for ws in range(min_ws, max_ws + 1):\\n for start_idx in range(len(prefix) - ws):\\n # Imagine indexes to be [0,1,4,5,7]\\n # we are looking at last 4 points and for 4 points (m=4).\\n # distance of 4 from every other point: 5-4+7-4+4-1=(7+5)-(1+4)\\n # 7+5 is A[i + m]) - A[i + m - m // 2]\\n # 1+4 is (A[i + m // 2] - A[i])\\n # prefix will be [0,0,1,5,10,17]\\n\\n end_idx = start_idx + ws\\n\\n # check LC 1478 for similar prefix_sum technic\\n # for odd number of ws, the mid is the same\\n # for even number of ws, the mid is either mid_left or mid_right\\n mid_left = (start_idx + end_idx) // 2\\n mid_right = (start_idx + end_idx + 1) // 2\\n # cost = min distance sum from start_idx to end_idx\\n cost = (prefix[end_idx] - prefix[mid_right]) - (prefix[mid_left] - prefix[start_idx])\\n cost += (k - ws) * 2\\n res = min(res, cost)\\n return max(res, 0)\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n s = \\\"\\\".join(map(str, nums))\\n if \\\"111\\\" in s:\\n max_cons = 3\\n elif \\\"11\\\" in s:\\n max_cons = 2\\n elif \\\"1\\\" in s:\\n max_cons = 1\\n else:\\n max_cons = 0\\n print(s, max_cons)\\n if max_cons > k:\\n max_cons = k\\n if max_changes >= k - max_cons:\\n return (k - max_cons) * 2 + max(0, max_cons - 1)\\n \\n res = max_changes * 2\\n print('res',res)\\n k -= max_changes\\n print('k', k)\\n idxes = [i for i in range(len(nums)) if nums[i]]\\n print('idxes',idxes)\\n pmid = k // 2\\n left = 0\\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\\n print('pmid',pmid)\\n print('left', left)\\n print('cdiff',cdiff)\\n for right in range(k, len(idxes)):\\n cdiff -= idxes[pmid] - idxes[left]\\n left += 1\\n cdiff += idxes[right] - idxes[pmid + 1]\\n move_d = idxes[pmid + 1] - idxes[pmid]\\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\\n mdiff = min(mdiff, cdiff)\\n pmid += 1\\n res += mdiff\\n return res\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n s = \\\"\\\".join(map(str, nums))\\n if \\\"111\\\" in s:\\n max_cons = 3\\n elif \\\"11\\\" in s:\\n max_cons = 2\\n elif \\\"1\\\" in s:\\n max_cons = 1\\n else:\\n max_cons = 0\\n print(s, max_cons)\\n if max_cons > k:\\n max_cons = k\\n if max_changes >= k - max_cons:\\n return (k - max_cons) * 2 + max(0, max_cons - 1)\\n \\n res = max_changes * 2\\n print('res',res)\\n k -= max_changes\\n print('k', k)\\n idxes = [i for i in range(len(nums)) if nums[i]]\\n print('idxes',idxes)\\n pmid = k // 2\\n left = 0\\n cdiff = mdiff = sum(abs(i - idxes[pmid]) for i in idxes[:k])\\n print('pmid',pmid)\\n print('left', left)\\n print('cdiff',cdiff)\\n for right in range(k, len(idxes)):\\n cdiff -= idxes[pmid] - idxes[left]\\n left += 1\\n cdiff += idxes[right] - idxes[pmid + 1]\\n move_d = idxes[pmid + 1] - idxes[pmid]\\n cdiff += ((pmid + 1 - left) - (right - 1 - pmid)) * move_d\\n mdiff = min(mdiff, cdiff)\\n pmid += 1\\n res += mdiff\\n return res\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ans = 1e18\\n # finish without step 2\\n for i in range(n):\\n curr = nums[i]\\n move = 0\\n if i > 0 and nums[i-1] == 1:\\n curr += 1\\n move += 1\\n if i < n-1 and nums[i+1] == 1 and curr < k:\\n move += 1\\n curr += 1\\n if curr + maxChanges >= k:\\n ans = min(ans, move + (k - curr) * 2)\\n \\n if maxChanges >= k:\\n return max(0, ans)\\n\\n # sliding window for step2\\n arr = [i for i, v in enumerate(nums) if v == 1]\\n target = k - maxChanges\\n l, r = 0, target-1\\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges*2\\n ans = min(ans, prev)\\n for i in range(1, len(arr)):\\n diff = arr[i] - arr[i-1]\\n left_count, right_count = i - l, r - i + 1\\n curr = prev + (left_count - right_count)*diff\\n while r + 1 < len(arr) and arr[r+1] - arr[i] <= arr[i] - arr[l]:\\n curr -= arr[i] - arr[l]\\n curr += arr[r+1] - arr[i]\\n r += 1\\n l += 1\\n ans = min(ans, curr)\\n prev = curr\\n return max(0, ans)\",\n \"memory\": \"25900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n ans = 1e18\\n # finish without step 2\\n for i in range(n):\\n curr = nums[i]\\n move = 0\\n if i > 0 and nums[i-1] == 1:\\n curr += 1\\n move += 1\\n if i < n-1 and nums[i+1] == 1 and curr < k:\\n move += 1\\n curr += 1\\n if curr + maxChanges >= k:\\n ans = min(ans, move + (k - curr) * 2)\\n \\n if maxChanges >= k:\\n return max(0, ans)\\n\\n # sliding window for step2\\n arr = [i for i, v in enumerate(nums) if v == 1]\\n target = k - maxChanges\\n l, r = 0, target-1\\n prev = sum([arr[i] - arr[l] for i in range(target)]) + maxChanges*2\\n ans = min(ans, prev)\\n for i in range(1, len(arr)):\\n diff = arr[i] - arr[i-1]\\n left_count, right_count = i - l, r - i + 1\\n curr = prev + (left_count - right_count)*diff\\n while r + 1 < len(arr) and arr[r+1] - arr[i] <= arr[i] - arr[l]:\\n curr -= arr[i] - arr[l]\\n curr += arr[r+1] - arr[i]\\n r += 1\\n l += 1\\n ans = min(ans, curr)\\n prev = curr\\n return max(0, ans)\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n\\n cnt , seq = 0 , 0\\n\\n pones = []\\n\\n for i , x in enumerate(nums):\\n if x > 0:\\n pones.append(i)\\n seq = max(seq , cnt:=x and cnt + 1)\\n \\n seq = min(3 , k , seq)\\n\\n if seq + maxChanges >=k:\\n return max(0 , seq - 1) + 2*(k - seq)\\n \\n ans = inf\\n\\n n = k - maxChanges\\n prefix = list(accumulate(pones , initial = 0))\\n\\n for i in range(len(pones) - n + 1):\\n wd =prefix[i + n] - prefix[i + (n + 1)//2] - (prefix[i + n//2] - prefix[i])\\n ans = min(ans , wd + 2*maxChanges)\\n \\n return ans\\n \",\n \"memory\": \"26400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n one_indexes = [index for index in range(len(nums)) if nums[index] == 1]\\n min_moves = float('inf')\\n if max_changes >= k: # with 0 step 2\\n min_moves = 2 * k\\n\\n prefix_sums = one_indexes.copy()\\n for i in range(1, len(one_indexes)):\\n prefix_sums[i] += prefix_sums[i - 1]\\n\\n def get_sum(left, right):\\n if left > right:\\n return 0\\n if left == 0:\\n return prefix_sums[right]\\n return prefix_sums[right] - prefix_sums[left - 1]\\n\\n min_step_twos = max(1, k - max_changes)\\n # step_twos is the number of times using step 2\\n for step_twos in range(min_step_twos, min_step_twos + 3):\\n if step_twos > k:\\n break\\n\\n for left in range(len(one_indexes)):\\n right = left + step_twos - 1\\n if right >= len(one_indexes):\\n break\\n\\n stand_index = (right + left) // 2\\n # number moves that using step 1\\n curr_moves = (k - step_twos) * 2\\n # total distance from mid to right\\n curr_moves += get_sum(stand_index + 1, right) - (right - stand_index) * one_indexes[stand_index]\\n # total distance from left to mid\\n curr_moves += (stand_index - left) * one_indexes[stand_index] - get_sum(left, stand_index - 1)\\n\\n min_moves = min(min_moves, curr_moves)\\n\\n return min_moves\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n\\n cnt , seq = 0 , 0\\n\\n pones = []\\n\\n for i , x in enumerate(nums):\\n if x > 0:\\n pones.append(i)\\n seq = max(seq , cnt:=x and cnt + 1)\\n \\n seq = min(3 , k , seq)\\n\\n if seq + maxChanges >=k:\\n return max(0 , seq - 1) + 2*(k - seq)\\n \\n ans = inf\\n\\n n = k - maxChanges\\n prefix = list(accumulate(pones , initial = 0))\\n\\n for i in range(len(pones) - n + 1):\\n wd =prefix[i + n] - prefix[i + (n + 1)//2] - (prefix[i + n//2] - prefix[i])\\n ans = min(ans , wd + 2*maxChanges)\\n \\n return ans\\n \",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n one_indexes = [index for index in range(len(nums)) if nums[index] == 1]\\n min_moves = float('inf')\\n if max_changes >= k: # with 0 step 2\\n min_moves = 2 * k\\n\\n prefix_sums = one_indexes.copy()\\n for i in range(1, len(one_indexes)):\\n prefix_sums[i] += prefix_sums[i - 1]\\n\\n def get_sum(left, right):\\n if left > right:\\n return 0\\n if left == 0:\\n return prefix_sums[right]\\n return prefix_sums[right] - prefix_sums[left - 1]\\n\\n min_step_twos = max(1, k - max_changes)\\n # step_twos is the number of times using step 2\\n for step_twos in range(min_step_twos, min_step_twos + 3):\\n if step_twos > k:\\n break\\n\\n for left in range(len(one_indexes)):\\n right = left + step_twos - 1\\n if right >= len(one_indexes):\\n break\\n\\n stand_index = (right + left) // 2\\n # number moves that using step 1\\n curr_moves = (k - step_twos) * 2\\n # total distance from mid to right\\n curr_moves += get_sum(stand_index + 1, right) - (right - stand_index) * one_indexes[stand_index]\\n # total distance from left to mid\\n curr_moves += (stand_index - left) * one_indexes[stand_index] - get_sum(left, stand_index - 1)\\n\\n min_moves = min(min_moves, curr_moves)\\n\\n return min_moves\",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n n = len(nums)\\n cnt = [0] * (n + 1)\\n s = [0] * (n + 1)\\n for i, x in enumerate(nums, 1):\\n cnt[i] = cnt[i - 1] + x\\n s[i] = s[i - 1] + i * x\\n ans = inf\\n max = lambda x, y: x if x > y else y\\n min = lambda x, y: x if x < y else y\\n for i, x in enumerate(nums, 1):\\n t = 0\\n need = k - x\\n for j in (i - 1, i + 1):\\n if need > 0 and 1 <= j <= n and nums[j - 1] == 1:\\n need -= 1\\n t += 1\\n c = min(need, maxChanges)\\n need -= c\\n t += c * 2\\n if need <= 0:\\n ans = min(ans, t)\\n continue\\n l, r = 2, max(i - 1, n - i)\\n while l <= r:\\n mid = (l + r) >> 1\\n l1, r1 = max(1, i - mid), max(0, i - 2)\\n l2, r2 = min(n + 1, i + 2), min(n, i + mid)\\n c1 = cnt[r1] - cnt[l1 - 1]\\n c2 = cnt[r2] - cnt[l2 - 1]\\n if c1 + c2 >= need:\\n t1 = c1 * i - (s[r1] - s[l1 - 1])\\n t2 = s[r2] - s[l2 - 1] - c2 * i\\n ans = min(ans, t + t1 + t2)\\n r = mid - 1\\n else:\\n l = mid + 1\\n return ans\",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n N = len(nums)\\n INF = 10 ** 20\\n pref = [0] + list(accumulate(nums))\\n pref_ind = [0] \\n for i in range(N):\\n pref_ind.append(pref_ind[-1])\\n if nums[i] == 1: pref_ind[-1] += i\\n \\n def go(index):\\n k_copy = k\\n moves = 0\\n\\n if nums[index] == 1: k_copy -= 1\\n \\n if k_copy == 0: return moves\\n\\n if index > 0 and nums[index - 1]:\\n moves += 1\\n k_copy -= 1\\n\\n if k_copy == 0: return moves\\n\\n if index < N - 1 and nums[index + 1]:\\n moves += 1\\n k_copy -= 1\\n\\n if k_copy == 0: return moves\\n\\n delta = min(maxChanges, k_copy)\\n\\n k_copy -= delta\\n\\n moves += 2 * delta\\n\\n if k_copy == 0: return moves\\n\\n\\n def good(t):\\n # count ones not including index, index + 1, index - 1, within a radius t\\n left_ones = pref[max(index - 1, 0)] - pref[max(0, index - 1 - t)]\\n right_ones = pref[min(N, index + 1 + t + 1)] - pref[min(N, index + 1 + 1)]\\n return left_ones + right_ones >= k_copy\\n\\n \\n l, r = 0, N\\n\\n while l < r:\\n mid = (l + r) // 2\\n\\n if good(mid):\\n r = mid\\n\\n else:\\n l = mid + 1\\n\\n left_close_to_index = max(index - 1, 0)\\n left_far_from_index = max(index - 1 - l, 0)\\n left_count_ones = pref[left_close_to_index] - pref[left_far_from_index]\\n\\n right_far_from_index = min(index + l + 2, N)\\n right_close_to_index = min(index + 2, N)\\n right_count_ones = pref[right_far_from_index] - pref[right_close_to_index]\\n\\n\\n left_index_sum = pref_ind[left_close_to_index] - pref_ind[left_far_from_index]\\n right_index_sum = pref_ind[right_far_from_index] - pref_ind[right_close_to_index]\\n\\n moves += index * left_count_ones - left_index_sum\\n moves += right_index_sum - index * right_count_ones\\n\\n if left_count_ones + right_count_ones > k_copy:\\n moves -= (l + 1)\\n\\n return moves\\n \\n\\n best = INF\\n for i in range(N):\\n best = min(best, go(i))\\n\\n return best\",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"import bisect\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, maxChanges: int) -> int:\\n if sum(nums) == 0:\\n return k * 2\\n index1 = list(i for i, num in enumerate(nums) if num)\\n sumL = [0]\\n for num in index1: sumL.append(sumL[-1] + num)\\n def inter_sum(l, r):\\n return sumL[r+1] - sumL[l]\\n def cost(dylanIndex, k):\\n def trial(delta):\\n L = bisect.bisect_left(index1, dylanIndex - delta)\\n R = bisect.bisect_left(index1, dylanIndex + delta)\\n if R == len(index1) or index1[R] != dylanIndex + delta:\\n R -= 1\\n return R - L + 1, (L, R)\\n L, R = -1, 10**5\\n while R - L != 1:\\n M = (L + R + 1) // 2\\n if trial(M)[0] >= k:\\n R = M\\n else:\\n L = M\\n delta, chosen = R, trial(R)[1]\\n if chosen[1] - chosen[0] + 1 > k:\\n chosen = [chosen[0], chosen[1]-1]\\n pivot = bisect.bisect_left(index1, dylanIndex)\\n Lcost = dylanIndex * (pivot - chosen[0]) - inter_sum(chosen[0], pivot-1)\\n Rcost = max(0, inter_sum(pivot, chosen[1]) - dylanIndex * (chosen[1] - pivot + 1))\\n return Lcost + Rcost\\n\\n ans = float('inf')\\n for dylanIndex in range(len(nums)):\\n near = sum(nums[max(0, dylanIndex-1):dylanIndex+2])\\n byChange = 0 if near >= k else min(maxChanges, k - near)\\n curCost = cost(dylanIndex, k - byChange)\\n ans = min(ans, curCost + byChange * 2)\\n return ans\",\n \"memory\": \"26800\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nIntuitions\\n1. There are 2 optimal ways of getting a point.\\n (a) swap zero neighbor to a 1 (action 1) and perform a swap (option 2).\\n This costs 2 operations.\\n (b) continuously swap a 1 until it becomes a neighbor to obtain a point.\\n This costs dist(alice_index, one_index) many operations. \\n2. There can be at most 3 operations costing < 2 operations for (b) if we have \\n <= 3 consecutive ones.\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minimumMoves(self, nums: List[int], k: int, max_changes: int) -> int:\\n pos = []\\n \\n # let m be the number of moves requiring less than 2 operations (i.e. operation (b)'s\\n # requiring less than 2 operations).\\n m = 0\\n \\n # compute m (just counting the max consecutive ones up to length 3).\\n for i, num in enumerate(nums):\\n if num == 0:\\n continue \\n pos.append(i)\\n m = max(m, 1)\\n if i > 1 and nums[i - 1] == 1 and nums[i - 2] == 1:\\n m = 3\\n elif i > 0 and nums[i - 1] == 1:\\n m = max(m, 2)\\n \\n # here, we are greedy and prefer using as little moves as possible\\n # optimally, we want to use operations costing 0 (start at 1), \\n # 1 (move adjacent 1), or 2 (use operation (a)).\\n if m >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n return k - 1\\n elif m + max_changes >= k:\\n # start at a 1 and use k - 1 operations costing 1 move.\\n # for the remaining operations, use the 2 move operations. \\n return max(m - 1, 0) + (k - m) * 2\\n \\n # we can use between [0, max_changes] many operations costing 2 moves.\\n n = len(pos)\\n prefix = [0] + list(accumulate(pos))\\n res = float(\\\"inf\\\")\\n \\n # greedily use between [max_changes - m - 1, max_changes] 2-move ops.\\n for x in range(max_changes - m, max_changes + 1):\\n required_window_size = k - x\\n for i in range(max(n - required_window_size + 1, 0)):\\n j = i + required_window_size\\n median = i + required_window_size // 2\\n idx = pos[median]\\n \\n left = idx * (median - i) - (prefix[median] - prefix[i])\\n right = prefix[j] - prefix[median] - idx * (j - median)\\n res = min(res, left + right + 2 * x)\\n return res \",\n \"memory\": \"27200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":22,"string":"22"}}},{"rowIdx":2441,"cells":{"question_id":{"kind":"number","value":3278,"string":"3,278"},"name":{"kind":"string","value":"find-the-number-of-ways-to-place-people-i"},"content":{"kind":"string","value":"<p>You are given a 2D array <code>points</code> of size <code>n x 2</code> representing integer coordinates of some points on a 2D plane, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>.</p>\n\n<p>Count the number of pairs of points <code>(A, B)</code>, where</p>\n\n<ul>\n\t<li><code>A</code> is on the <strong>upper left</strong> side of <code>B</code>, and</li>\n\t<li>there are no other points in the rectangle (or line) they make (<strong>including the border</strong>).</li>\n</ul>\n\n<p>Return the count.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[1,1],[2,2],[3,3]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">0</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img src=\"https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png\" style=\"width: 427px; height: 350px;\" /></p>\n\n<p>There is no way to choose <code>A</code> and <code>B</code> so <code>A</code> is on the upper left side of <code>B</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[6,2],[4,4],[2,6]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img height=\"365\" src=\"https://assets.leetcode.com/uploads/2024/06/25/t2.jpg\" width=\"1321\" /></p>\n\n<ul>\n\t<li>The left one is the pair <code>(points[1], points[0])</code>, where <code>points[1]</code> is on the upper left side of <code>points[0]</code> and the rectangle is empty.</li>\n\t<li>The middle one is the pair <code>(points[2], points[1])</code>, same as the left one it is a valid pair.</li>\n\t<li>The right one is the pair <code>(points[2], points[0])</code>, where <code>points[2]</code> is on the upper left side of <code>points[0]</code>, but <code>points[1]</code> is inside the rectangle so it's not a valid pair.</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">points = [[3,1],[1,3],[1,1]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img src=\"https://assets.leetcode.com/uploads/2024/06/25/t3.jpg\" style=\"width: 1269px; height: 350px;\" /></p>\n\n<ul>\n\t<li>The left one is the pair <code>(points[2], points[0])</code>, where <code>points[2]</code> is on the upper left side of <code>points[0]</code> and there are no other points on the line they form. Note that it is a valid state when the two points form a line.</li>\n\t<li>The middle one is the pair <code>(points[1], points[2])</code>, it is a valid pair same as the left one.</li>\n\t<li>The right one is the pair <code>(points[1], points[0])</code>, it is not a valid pair as <code>points[2]</code> is on the border of the rectangle.</li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= n <= 50</code></li>\n\t<li><code>points[i].length == 2</code></li>\n\t<li><code>0 <= points[i][0], points[i][1] <= 50</code></li>\n\t<li>All <code>points[i]</code> are distinct.</li>\n</ul>\n"},"acRate":{"kind":"number","value":41.5325760009345,"string":"41.532576"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","math","geometry","sorting","enumeration"],"string":"[\n \"array\",\n \"math\",\n \"geometry\",\n \"sorting\",\n \"enumeration\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"88\", 3.7266000000000004], [\"93\", 4.3477], [\"98\", 8.6958], [\"104\", 9.3168], [\"109\", 5.5901], [\"114\", 1.8633], [\"119\", 2.4844], [\"124\", 1.2422], [\"130\", 0.6211], [\"135\", 2.4844999999999997], [\"140\", 2.4844], [\"145\", 1.8633], [\"150\", 0.6211], [\"156\", 0.6211], [\"161\", 0.6211], [\"166\", 0.6211], [\"171\", 0.6211], [\"176\", 0.6211], [\"181\", 0.6211], [\"187\", 1.2422], [\"192\", 0.6211], [\"197\", 0.6211], [\"202\", 1.8633], [\"207\", 0.6211], [\"213\", 2.4844], [\"218\", 0.6211], [\"223\", 6.8322], [\"228\", 3.1055], [\"233\", 3.1055], [\"239\", 1.2422], [\"244\", 0.6211], [\"249\", 0.6211], [\"254\", 0.6211], [\"259\", 0.6211], [\"264\", 1.2422], [\"270\", 0.6211], [\"275\", 1.8633], [\"280\", 0.6211], [\"285\", 2.4844], [\"290\", 0.6211], [\"296\", 0.6211], [\"301\", 1.2422], [\"306\", 0.6211], [\"311\", 0.6211], [\"316\", 0.6211], [\"322\", 0.6211], [\"327\", 0.6211], [\"332\", 0.6211], [\"337\", 0.6211], [\"342\", 0.6211], [\"347\", 0.6211], [\"353\", 0.6211], [\"358\", 0.6211], [\"363\", 0.6211], [\"368\", 1.2422], [\"373\", 0.6211], [\"379\", 0.6211], [\"384\", 0.6211], [\"389\", 0.6211]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 0.6211], [\"16400\", 14.2857], [\"16500\", 27.3292], [\"16600\", 45.3416]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n # if two points have the same x-coordinate, they are sorted by their y-coordinate in descending order\n points.sort(key=lambda p: (p[0], -p[1]))\n for i, (x1, y1) in enumerate(points):\n y = -inf # keep track of the valid largest y-coordinate so far\n for x2, y2 in points[i + 1:]:\n # y1 must be upper left, on a horizontal line or on a vertical line with y2\n # y2 must greater than y, otherwise a third person will inside/on the fence\n if y1 >= y2 > y:\n res += 1\n y = y2\n return res","runtime":"88"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda x: (x[0], -x[1]))\n l = len(points)\n\n result = 0\n for i in range(l):\n x, y = points[i]\n b_min = -1\n for j in range(i+1, l):\n b = points[j][1]\n if b_min < b <= y:\n result += 1\n b_min = b\n return result","runtime":"88"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda x: (x[0], -x[1]))\n ans = 0\n for i, (_, y1) in enumerate(points):\n max_y = -inf\n for _, y2 in points[i + 1 :]:\n if max_y < y2 <= y1:\n max_y = y2\n ans += 1\n return ans","runtime":"93"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \"\"\"\n We want to count the number of rectangles that can be defined with\n top left and bottom right corners such that the rectangle contains\n no other points. Degenerate rectangles are permissible.\n\n Observe that, for a given point A (top left candidate), the\n feasible B points will form a sort of pareto frontier, where their\n y coordinates strictly increase as their x coordinates increase.\n Note that we are guaranteed no duplicate coordinate pairs in points.\n\n We can sort the x and y coordinates. For a given point, iterate\n over the points with x coordinates greater than or equal to its own\n by ascending x value. Ties are resolved such that the point with\n the larger y value comes first. Keep track of the largest y value\n seen thusfar. Ignore any points with a smaller y value. Break the\n loop when the y value meets or exceeds our A candidate's y value.\n\n This requires some tangled co-sorting because we want it to be\n possible to locate a given point's x and y coordinate within the\n sorted lists efficiently.\n\n There's probably a way to squeeze out more performance by using\n one point's results to warm start the next.\n \"\"\"\n x_y_cosorted = sorted((points), key=lambda tup_xy: (tup_xy[0], -tup_xy[1]))\n n_pairs = 0\n for a in range(len(x_y_cosorted)):\n max_y_seen = -1\n for b in range(a + 1, len(x_y_cosorted)):\n if (\n x_y_cosorted[b][1] <= x_y_cosorted[a][1] # B cannot be above A\n and x_y_cosorted[b][1] > max_y_seen # AB cannot contain another point\n ):\n n_pairs += 1\n max_y_seen = x_y_cosorted[b][1]\n # If AB is a horizontal line, we are done\n if max_y_seen == x_y_cosorted[a][1]:\n break\n return n_pairs\n","runtime":"93"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda point: (point[0], -point[1]))\n n = len(points)\n total = 0\n\n for l in range(n):\n x = points[l][0]\n y = points[l][1]\n highest = -1\n\n for r in range(l + 1, n):\n if highest < points[r][1] <= y:\n highest = points[r][1]\n total += 1\n \n return total\n ","runtime":"98"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda p: (-p[1], p[0]))\n res, n = 0, len(points)\n for i in range(n - 1):\n min_x = float(\"inf\")\n for j in range(i + 1, n):\n if points[i][0] <= points[j][0] < min_x:\n res += 1\n min_x = min(min_x, points[j][0])\n return res\n # def is_valid(p1, p2, i1, i2):\n # x1, y1 = p1\n # x2, y2 = p2\n # for i, (x, y) in enumerate(points):\n # if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\n # return False\n # return True\n\n # pl = len(points)\n # cnt = 0\n # for i in range(pl):\n # for j in range(pl):\n # if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n # if is_valid(points[i], points[j], i, j):\n # cnt += 1\n # return cnt","runtime":"98"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = [x[1] for x in sorted(points, key=lambda x: (x[0], -x[1]))]\n l = len(points)\n\n result = 0\n for i in range(l):\n y = points[i]\n b_min = -1\n for j in range(i+1, l):\n b = points[j]\n if b_min < b <= y:\n result += 1\n b_min = b\n return result","runtime":"104"},{"code":"# FARHANG\n\nclass Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda x: (x[0], -x[1]))\n counter = 0\n\n for i in range(len(points)):\n highest_y = -1\n for j in range(i + 1, len(points)):\n if points[i][1] >= points[j][1] > highest_y:\n counter += 1\n highest_y = points[j][1]\n \n return counter","runtime":"104"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda point: (point[0], -point[1]))\n n = len(points)\n total = 0\n\n for l in range(n):\n x = points[l][0]\n y = points[l][1]\n highest = -1\n\n for r in range(l + 1, n):\n if highest < points[r][1] <= y:\n highest = points[r][1]\n total += 1\n \n return total\n ","runtime":"109"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda p: (p[0], - p[1]))\n n = len(points)\n result = 0\n for i in range(n):\n x, y = points[i]\n #print(x, y)\n # if i < len(points) -1 and points[i+1][0] == x:\n # #print('skip')\n # continue\n smallest_y = 100\n prev = points[0:i][::-1]\n for xp, yp in prev:\n #print('prev', xp, yp)\n if yp >= y:\n if yp < smallest_y:\n result += 1\n smallest_y = min(smallest_y, yp)\n\n return result\n ","runtime":"109"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda p:(-p[1], p[0]))\n print(points)\n ans = 0\n pl = len(points)\n for i in range(pl-1):\n min_x = float('inf')\n for j in range(i+1, pl):\n if points[i][0] <= points[j][0] < min_x:\n ans += 1\n min_x = min(min_x, points[j][0])\n return ans\n\n # def is_valid(p1, p2, i1, i2):\n # x1, y1 = p1\n # x2, y2 = p2\n # for i, (x, y) in enumerate(points):\n # if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\n # return False\n # return True\n\n # pl = len(points)\n # cnt = 0\n # for i in range(pl):\n # for j in range(pl):\n # if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n # if is_valid(points[i], points[j], i, j):\n # cnt += 1\n # return cnt","runtime":"114"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n cols = defaultdict(list)\n rows = defaultdict(list)\n\n for r, c in points:\n rows[r].append(c) or cols[c].append(r)\n \n p = sorted(rows)\n for v in rows.values():\n v.sort()\n\n ans = 0\n for r in range(len(p)):\n ans += len(rows[p[r]]) - 1\n for c in range(len(rows[p[r]]) - 1, -1, -1):\n b = rows[p[r]][c - 1] if c else -1\n for dr in range(r + 1, len(p)):\n for dc in range(len(rows[p[dr]]) - 1, -1, -1):\n if rows[p[dr]][dc] > rows[p[r]][c]:\n continue\n if rows[p[dr]][dc] > b:\n ans += 1\n b = rows[p[dr]][dc]\n break\n return ans\n","runtime":"114"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n cols = defaultdict(list)\n rows = defaultdict(list)\n\n for c, r in points:\n rows[r].append(c)\n cols[c].append(r)\n\n p = sorted(rows)\n for v in rows.values():\n v.sort()\n\n ans = 0\n for r in range(len(p)):\n #print(777,rows[p[r]])\n ans += len(rows[p[r]]) - 1\n\n for c in range(len(rows[p[r]]) - 1, -1, -1):\n b = rows[p[r]][c - 1] if c else -1\n for dr in range(r + 1, len(p)):\n for dc in range(len(rows[p[dr]]) - 1, -1, -1):\n if rows[p[dr]][dc] > rows[p[r]][c]:\n continue\n if rows[p[dr]][dc] > b:\n ans += 1\n #print(r, c, dr, dc, rows[p[r]][c], rows[p[dr]][dc], b)\n b = rows[p[dr]][dc]\n break\n \n #print(\"r\", r, ans)\n\n\n return ans\n","runtime":"119"},{"code":"\nclass Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n sortedPoints = sorted(points, key=lambda p: (p[0], -p[1]))\n n = len(points)\n cnt = 0\n for i in range(n):\n p1 = sortedPoints[i]\n between = set()\n for j in range(i + 1, n):\n p2 = sortedPoints[j]\n if p1[1] >= p2[1]:\n having_between = False\n if between:\n for num in between:\n if p2[1] <= num <= p1[1]:\n having_between = True\n break\n if having_between:\n continue\n cnt += 1\n between.add(p2[1])\n return cnt\n","runtime":"119"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda point: (point[0], -point[1]))\n n = len(points)\n result = 0\n for i in range(n):\n prev = None\n for j in range(i + 1, n):\n if points[j][1] <= points[i][1] and (prev == None or points[j][1] > points[prev][1]):\n print(points[i], points[j])\n prev = j\n result += 1\n return result\n ","runtime":"124"},{"code":"class Solution:\n def numberOfPairs(self, points):\n n, count = len(points), 0 \n\n points.sort(key = lambda x: (x[0],-x[1]))\n\n for i in range(n):\n for j in range(i+1,n):\n if points[i][1] >= points[j][1]:\n is_valid = True\n for k in range(i+1,j):\n if (points[j][1] <= points[k][1] <= points[i][1]):\n is_valid = False\n break \n\n if is_valid:\n count += 1 \n\n return count","runtime":"124"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n count=0\n points= sorted(points, key=lambda x: (x[0],-x[1]))\n print(points)\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n x1, y1= points[i]\n x2, y2= points[j]\n if y1>=y2:\n Flag=True\n for k in range(i+1,j):\n x3, y3 = points[k]\n if x1<=x3<=x2 and y2<=y3<=y1:\n Flag=False\n break\n\n if Flag==True:\n count+=1\n\n return count","runtime":"130"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda x:(x[0], -x[1]))\n res = 0\n n = len(points)\n\n for i in range(n-1):\n ax, ay = points[i][0], points[i][1]\n for j in range(i+1, n):\n bx, by = points[j][0], points[j][1]\n flag = True\n\n if ax <= bx and ay >= by:\n for k in range(i+1, j):\n cx, cy = points[k][0], points[k][1]\n if ax <= cx <= bx and by <= cy <= ay:\n flag = False\n break\n else: flag = False\n \n if flag:\n res += 1\n\n return res\n\n ","runtime":"135"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = sorted(points, key=lambda point: (point[0], -point[1]))\n n = len(points)\n result = 0\n for i in range(n):\n prev = None\n for j in range(i + 1, n):\n if points[j][1] <= points[i][1] and (prev == None or points[j][1] > points[prev][1]):\n print(points[i], points[j])\n prev = j\n result += 1\n return result\n ","runtime":"135"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n ans = 0 \n for i, (xi, yi) in enumerate(points): \n vals = []\n for j, (xj, yj) in enumerate(points): \n if i != j and xj <= xi and yj >= yi: vals.append([xj, yj])\n small = inf \n for xj, yj in sorted(vals, key = lambda x: (-x[0], x[1])): \n if yj < small: \n ans += 1\n small = yj\n return ans ","runtime":"140"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n points = sorted(points, key=lambda x: (-x[1], x[0]))\n\n ans = 0\n for i in range(n - 1):\n for j in range(i + 1, n):\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\n valid = True\n for k in range(i + 1, j):\n if points[k][0] >= points[i][0] and points[k][1] <= points[i][1] and points[k][0] <= points[j][0] and points[k][1] >= points[j][1]:\n valid = False\n break\n if valid:\n ans += 1\n\n return ans\n","runtime":"140"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n\n points.sort(key=lambda x: (-x[0], x[1]))\n print(points)\n\n for i in range(len(points)):\n p1x, p1y = points[i]\n\n for j in range(i+1, len(points)):\n p2x, p2y = points[j]\n\n if p1x >= p2x and p1y <= p2y:\n found = False\n\n for k in range(i+1, j):\n p3x, p3y = points[k]\n\n if p1x >= p3x >= p2x and p1y <= p3y <= p2y:\n found = True\n break\n\n if not found:\n res += 1\n\n\n return res","runtime":"145"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points=sorted(points,key=lambda x: (x[0],-x[1]))\n cnt=0\n for i in range(len(points)-1):\n for j in range(i+1,len(points)):\n if points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\n flag=True\n for k in range(i+1,j):\n if points[i][0]<=points[k][0]<=points[j][0] and points[j][1]<=points[k][1]<=points[i][1]:\n flag=False\n break\n if flag==True:\n cnt+=1\n return cnt\n\n ","runtime":"145"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n n = len(points)\n sorted_points = sorted(points, key = lambda p: (p[0], -p[1]))\n\n def isValid(i, j):\n ul, br = sorted_points[i], sorted_points[j]\n if ul[1] < br[1]:\n return False\n\n for k in range(i+1, j):\n mid = sorted_points[k]\n if (ul[0] <= mid[0] <= br[0]) and (br[1] <= mid[1] <= ul[1]):\n return False\n return True\n\n count = 0\n for i in range(n):\n for j in range(i+1, n):\n if isValid(i, j):\n count += 1\n\n return count\n","runtime":"150"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points=sorted(points,key=lambda x: (x[0],-x[1]))\n cnt=0\n for i in range(len(points)-1):\n for j in range(i+1,len(points)):\n flag=True\n if points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\n for k in range(i+1,j):\n if points[i][0]<=points[k][0]<=points[j][0] and points[j][1]<=points[k][1]<=points[i][1]:\n flag=False\n break\n if flag==True:\n cnt+=1\n return cnt\n\n ","runtime":"156"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n for x1, y1 in points:\n rectangles = []\n for x2,y2 in points:\n if x1 == x2 and y1 == y2:\n continue\n if x1 <= x2 and y1 >= y2:\n within_rectangle = False\n for x3,y3 in points:\n if (x1 == x3 and y1 == y3) or (x2 == x3 and y2 == y3):\n continue\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\n within_rectangle = True\n break\n if not within_rectangle:\n res += 1\n return res","runtime":"161"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n co = sorted(points, key=lambda x: (-x[1], x[0]))\n l=len(co)\n \n ans=0\n \n for i in range(l-1):\n for j in range(i+1,l):\n x1,x2=co[i][0],co[j][0]\n y1,y2=co[i][1],co[j][1]\n yes=True\n \n if y1>=y2 and x1<=x2:\n for k in range(i+1,j):\n if min(x1,x2)<=co[k][0]<=max(x1,x2) and min(y1,y2)<=co[k][1]<=max(y1,y2):\n yes=False\n break\n if yes:\n ans+=1\n \n \n return ans","runtime":"176"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n for x1, y1 in points:\n rectangles = []\n for x2,y2 in points:\n if x1 == x2 and y1 == y2:\n continue\n if x2 <= x1 and y2 >= y1:\n within_rectangle = False\n for x3,y3 in points:\n if (x1 == x3 and y1 == y3) or (x2 == x3 and y2 == y3):\n continue\n if (x3 <= x1 and y3 >= y1) and (x2 <= x3 and y2 >= y3):\n within_rectangle = True\n break\n if not within_rectangle:\n res += 1\n return res","runtime":"181"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n \n points = sorted(points, key = lambda x: x[1] - x[0])\n\n def is_covering(i, k, j):\n return (\n (points[k][0] <= points[i][0] and points[k][1] >= points[i][1])\n and\n (points[k][0] >= points[j][0] and points[k][1] <= points[j][1])\n )\n\n def is_upperleft(i, j):\n return points[i][0] >= points[j][0] and points[i][1] <= points[j][1]\n\n count = 0\n for j in range(1, n):\n for i in range(j):\n if is_upperleft(i, j):\n flag = True\n for k in range(i + 1, j):\n if is_covering(i, k, j):\n flag = False\n break\n if flag:\n count += 1\n \n return count","runtime":"187"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def validRectangle(ul,i,lr,j):\n x1,y1 = ul\n x2,y2 = lr\n if not (x1<=x2 and y1>=y2):\n return False\n flag = True\n for x in range(x1,x2+1):\n for y,index in self.d[x]:\n if index==i or index==j:\n continue\n if y2<=y<=y1:\n flag = False\n break\n if flag == False:\n break\n return flag\n \n \n N = len(points)\n res = 0\n \n self.d = defaultdict(lambda: [])\n for i,p in enumerate(points):\n x,y = p\n self.d[x].append((y,i))\n \n for i in range(N):\n for j in range(N):\n if i==j:\n continue\n if validRectangle(points[i], i, points[j], j):\n res += 1\n \n return res","runtime":"192"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n N=len(points)\n #points.sort(key=lambda x:(x[0],x[1]))\n def valid(xy,xz,c,t):\n x1,y1=xy\n x2,y2=xz\n for i,(x,y) in enumerate(points):\n if (x1<=x<=x2 and y1>=y>=y2 and i!=c and i!=t):return False\n return True\n res=0\n for r in range(N):\n x1,y1=points[r]\n px,py=None,None\n for c in range(N):\n x2,y2=points[c]\n if r!=c and (x1<=x2 and y1>=y2 ):\n if valid(points[r],points[c],r,c):res+=1\n return res","runtime":"197"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(chisato, takina, c, t):\n x1, y1 = chisato\n x2, y2 = takina\n for i, (x, y) in enumerate(points):\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count","runtime":"202"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n points.sort(key = lambda x: (x[0], -x[1]))\n res = 0\n\n for i in range(n):\n for j in range(i + 1, n):\n if points[i][1] >= points[j][1]:\n flag = True\n for k in range(i + 1, j):\n if points[j][1] <= points[k][1] <= points[i][1]:\n flag = False\n \n if flag:\n res += 1\n \n return res","runtime":"202"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n count=0\n points= sorted(points, key=lambda x: (x[0],-x[1]))\n print(points)\n for i in range(len(points)):\n for j in range(i+1,len(points)):\n x1, y1= points[i]\n x2, y2= points[j]\n if y1>=y2:\n Flag=True\n for k in range(i+1,j):\n x3, y3 = points[k]\n if x1<=x3<=x2 and y2<=y3<=y1:\n Flag=False\n\n if Flag==True:\n count+=1\n\n return count","runtime":"207"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(X, Y, idx_x, idx_y):\n x1, y1 = X\n x2, y2 = Y\n for i, (x, y) in enumerate(points):\n # Check if there are any points inside the triangle of X and Y.\n # Check with idx_x and idx_y makes sure that we are not comapring\n # with the same point.\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != idx_x and i != idx_y:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and\\\n points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count\n\n # time complexity: O(N^3)\n","runtime":"213"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(chisato, takina, c, t):\n x1, y1 = chisato\n x2, y2 = takina\n for i, (x, y) in enumerate(points):\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count\n \n \n \n \n \n \n \n \n ","runtime":"213"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def check_if_inside(x1,y1,x2,y2,i,j):\n for z,point in enumerate(points):\n x3,y3= point \n if z !=i and z !=j and x3 >= x1 and x3 <= x2 and y3 <= y1 and y3 >= y2:\n return True \n return False \n counter = 0\n for i in range(len(points)):\n x1,y1 = points[i]\n for j in range(len(points)):\n x2,y2 = points[j]\n if i != j and x1 <= x2 and y1 >= y2 and not check_if_inside(x1,y1,x2,y2,i,j):\n counter += 1\n return counter ","runtime":"218"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(X, Y, idx_x, idx_y):\n x1, y1 = X\n x2, y2 = Y\n for i, (x, y) in enumerate(points):\n # Check if there are any points inside the triangle of X and Y.\n # Check with idx_x and idx_y makes sure that we are not comapring\n # with the same point.\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != idx_x and i != idx_y:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and\\\n points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count\n\n # time complexity: O(N^3)\n","runtime":"223"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(p1, p2, c, t):\n x1, y1 = p1\n x2, y2 = p2\n for i, (x, y) in enumerate(points):\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count","runtime":"223"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(chisato, takina, c, t):\n x1, y1 = chisato\n x2, y2 = takina\n for i, (x, y) in enumerate(points):\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\n return False\n return True\n\n n = len(points)\n count = 0\n for i in range(n):\n for j in range(n):\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count\n \n \n \n \n \n \n \n \n ","runtime":"228"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n # Helper function to check if the rectangle formed by two points is empty\n def is_valid(chisato, takina, c, t):\n x1, y1 = chisato\n x2, y2 = takina\n # Iterate through all points to check if any point lies within the rectangle\n for i, (x, y) in enumerate(points):\n # Check if the point (x, y) is inside the rectangle formed by (x1, y1) and (x2, y2)\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\n return False\n return True\n\n n = len(points)\n count = 0\n # Iterate over all pairs of points\n for i in range(n):\n for j in range(n):\n # Ensure we are not comparing the same point and check if point[i] is upper-left of point[j]\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n # Check if the rectangle formed by these two points is empty\n if is_valid(points[i], points[j], i, j):\n count += 1\n\n return count","runtime":"228"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/3000-3099/3025.Find%20the%20Number%20of%20Ways%20to%20Place%20People%20I\n def check(x1, x2, y1, y2):\n for x, y in points:\n if x == x1 and y == y1 or x == x2 and y == y2: \n continue\n if x1 <= x <= x2 and y2 <= y <= y1:\n return False\n return True\n\n points.sort(key=lambda x: (x[0], -x[1]))\n n = len(points)\n cnt = 0\n # for (x1, y1), (x2, y2) in pairwise(points): \n for (x1, y1), (x2, y2) in permutations(points, 2): \n if x1 > x2 or y2 > y1: continue\n if check(x1, x2, y1, y2): \n cnt += 1\n return cnt","runtime":"233"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid(p1, p2, i1, i2):\n x1, y1 = p1\n x2, y2 = p2\n for i, (x, y) in enumerate(points):\n if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\n return False\n return True\n\n pl = len(points)\n cnt = 0\n for i in range(pl):\n for j in range(pl):\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\n if is_valid(points[i], points[j], i, j):\n cnt += 1\n return cnt","runtime":"233"},{"code":"class Solution:\n def numberOfPairs(self, P: List[List[int]]) -> int:\n n = len(P)\n P.sort(key=lambda p: (p[0], -p[1]))\n res = 0\n for i in range(n - 1):\n x_i, y_i = P[i]\n for j in range(i + 1, n):\n x_j, y_j = P[j]\n if y_i < y_j or x_i > x_j: continue\n\n contained = False\n for k in range(n):\n if k == i or k == j: continue\n x_k, y_k = P[k]\n if x_i <= x_k <= x_j and y_j <= y_k <= y_i: \n contained = True\n break\n if not contained: res += 1\n return res\n\n ","runtime":"239"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort()\n pairs = 0\n n = len(points)\n\n for i in range(n):\n for j in range(i + 1, n):\n x_a, y_a = points[i]\n x_b, y_b = points[j]\n if y_a < y_b:\n if x_a == x_b:\n x_a, x_b = x_b, x_a\n y_a, y_b = y_b, y_a\n else:\n continue\n good = True\n for k in range(n):\n if k == i or k == j:\n continue\n x, y = points[k]\n if x_a <= x <= x_b and y_b <= y <= y_a:\n good = False\n break\n pairs += good\n \n return pairs\n ","runtime":"239"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n N = len(points)\n points.sort(key=lambda p: (p[0], -p[1]))\n pairs = 0\n for i in range(N):\n for j in range(i + 1, N):\n x1, y1 = points[i]\n x2, y2 = points[j]\n if x1 > x2 or y1 < y2:\n continue\n if N - 2 > 0:\n for k in range(N):\n if k == i or k == j:\n continue\n xk, yk = points[k]\n if x1 <= xk <= x2 and y2 <= yk <= y1:\n break\n else:\n pairs += 1\n else:\n pairs += 1\n return pairs\n ","runtime":"244"},{"code":"class Solution:\n def numberOfPairs(self, v):\n n = len(v)\n ans = 0\n\n for i in range(n):\n x1, y1 = v[i][0], v[i][1]\n\n for j in range(n):\n if i == j:\n continue\n\n x2, y2 = v[j][0], v[j][1]\n f = 0\n\n if y1 >= y2 and x1 <= x2:\n for k in range(n):\n if k == i or k == j:\n continue\n\n x3, y3 = v[k][0], v[k][1]\n\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\n f = 1\n break\n\n if f == 0:\n ans += 1\n\n return ans","runtime":"249"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def checkVertical(i, j):\n for k in range(i+1, j):\n if points[k][0]==points[i][0]:\n return False\n else:\n return True\n def checkHorizontal(i, j):\n for k in range(i+1, j):\n if points[k][1]==points[i][1]:\n return False\n else:\n return True\n def checkSquare(i, j):\n for k in range(n):\n if k==i or k==j:\n pass\n elif points[i][0]<=points[k][0]<=points[j][0] and points[i][1]>=points[k][1]>=points[j][1]:\n return False\n else:\n return True\n\n\n\n count = 0\n n = len(points)\n points.sort(key=lambda x:(x[0], x[1]))\n print(points)\n for i in range(n):\n for j in range(i+1, n):\n if points[i][0]==points[j][0]:\n if checkVertical(i, j):\n count += 1\n else:\n if points[i][1]==points[j][1]:\n if checkHorizontal(i, j):\n count += 1\n elif points[i][1]>points[j][1]:\n if checkSquare(i, j):\n count+=1\n\n return count","runtime":"254"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n ans = 0\n\n n = len(points)\n\n for i in range(n):\n for j in range(i + 1, n):\n A = points[i]\n B = points[j]\n\n if B[0] == A[0] or (B[1] - A[1]) / (B[0] - A[0]) <= 0:\n if A[0] > B[0] or B[1] > A[1]:\n A, B = B, A\n\n for k in range(n):\n if k == i or k == j:\n continue\n \n C = points[k]\n\n if ( A[0] <= C[0] <= B[0] and B[1] <= C[1] <= A[1]):\n ans -= 1\n break\n\n ans += 1\n\n \n return ans\n\n","runtime":"259"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n count = 0\n for i in range(len(points)):\n for j in range(len(points)):\n x1 = points[i][0]\n y1 = points[i][1]\n x2 = points[j][0]\n y2 = points[j][1]\n if x2 <= x1 and y2 >= y1 and (x2 < x1 or y2 > y1):\n canCount = True\n for k in range(len(points)):\n if k != i and k != j:\n X1 = points[k][0]\n Y1 = points[k][1]\n #x1, y1 = [6,2] and x2, y2 = [2,6], X1, Y1 = [4,4]\n if X1 <= x1 and Y1 >= y1 and X1 >= x2 and Y1 <= y2:\n canCount = False\n break\n if canCount:\n count += 1\n return count\n","runtime":"264"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","runtime":"264"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n count = 0\n \n\n for i in range(n):\n for j in range(n):\n if i != j:\n \n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\n t= True\n for k in range(n):\n if k != i and k != j:\n \n if points[i][0] <= points[k][0] <= points[j][0] and points[j][1] <= points[k][1] <= points[i][1]:\n t = False\n break\n if t:\n count += 1\n return count","runtime":"270"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","runtime":"275"},{"code":"from typing import List\n\nclass Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n count = 0\n \n # Helper function to determine if a point is strictly inside the rectangle\n def is_strictly_inside(px, py, x1, y1, x2, y2):\n return x1 < px < x2 and y1 < py < y2\n \n for i in range(n):\n for j in range(n):\n if i != j:\n # Check if point[i] is on upper left of point[j]\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\n # Check that no other points are inside or on the border of the rectangle\n empty_rectangle = True\n for k in range(n):\n if k != i and k != j:\n if (points[i][0] <= points[k][0] <= points[j][0] and\n points[j][1] <= points[k][1] <= points[i][1]):\n empty_rectangle = False\n break\n if empty_rectangle:\n count += 1\n return count","runtime":"275"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort(key=lambda x: (x[0], -x[1]))\n\n n = len(points)\n cnt = 0\n\n for i in range(n):\n for j in range(i+1, n):\n if points[i][1] >= points[j][1]:\n # check that no other point is here\n for k in range(n):\n if k == i or k == j:\n continue\n # print(\"Checking \", points[k], \"vs\", points[i], points[j])\n if (points[i][0] <= points[k][0] <= points[j][0] and points[i][1] >= points[k][1] >= points[j][1]):\n break\n else:\n cnt += 1\n return cnt","runtime":"280"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n n = len(points)\n for i in range(n):\n x1 = points[i][0]\n y1 = points[i][1]\n for j in range(n):\n if i == j:\n continue\n x2 = points[j][0]\n y2 = points[j][1]\n # valid if x1 <= x2, y1 >= y2\n if x1 > x2:\n continue\n if y1 < y2:\n continue\n valid = True\n for k in range(n):\n if i == k or j == k:\n continue\n x3 = points[k][0]\n y3 = points[k][1]\n if x1 <= x3 <= x2 and y1 >= y3 >= y2:\n valid = False\n break\n if valid:\n res += 1\n print('---')\n return res\n","runtime":"285"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n seen = set([tuple(point) for point in points])\n n = len(points)\n points.sort(key=lambda x: (x[0], -x[1]))\n res = 0\n for i, [x1, y1] in enumerate(points):\n for j in range(i+1, n):\n x2, y2 = points[j]\n\n if x1 < x2 and y1 < y2:\n continue\n \n found = False\n for x in range(x1, x2+1):\n for y in range(y2, y1+1):\n if (x, y) in seen and (x, y) not in [(x1, y1), (x2, y2)]:\n found = True\n break\n if found:\n break\n if not found:\n res += 1\n return res","runtime":"285"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n # for every point, pair it with every other point to test if any of those is on the upper left of the other.\n # if yes, iterate over all the points and if there is any other point in the rectangle than break otherwise count it\n n = len(points)\n count = 0\n\n def is_upper_left(point1, point2):\n if point1[0] <= point2[0] and point1[1] >= point2[1]:\n return point1, point2\n if point2[0] <= point1[0] and point2[1] >= point1[1]:\n return point2, point1\n return None\n\n def point_found(upper_left, lower_right):\n for point in points:\n if point == upper_left or point == lower_right:\n continue\n if upper_left[0] <= point[0] <= lower_right[0] and lower_right[1] <= point[1] <= upper_left[1]:\n return True\n return False\n\n for i in range(n):\n for j in range(i+1, n):\n upper_left_exists = is_upper_left(points[i], points[j])\n if upper_left_exists:\n upper_left, lower_right = upper_left_exists\n if point_found(upper_left, lower_right) == False:\n\n count += 1\n \n return count\n ","runtime":"290"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n # for every point, pair it with every other point to test if any of those is on the upper left of the other.\n # if yes, iterate over all the points and if there is any other point in the rectangle than break otherwise count it\n n = len(points)\n count = 0\n\n def is_upper_left(point1, point2):\n if point1[0] <= point2[0] and point1[1] >= point2[1]:\n return point1, point2\n if point2[0] <= point1[0] and point2[1] >= point1[1]:\n return point2, point1\n return None\n\n def point_found(upper_left, lower_right):\n for point in points:\n if point == upper_left or point == lower_right:\n continue\n if upper_left[0] <= point[0] <= lower_right[0] and lower_right[1] <= point[1] <= upper_left[1]:\n return True\n return False\n\n for i in range(n):\n for j in range(i+1, n):\n upper_left_exists = is_upper_left(points[i], points[j])\n if upper_left_exists:\n upper_left, lower_right = upper_left_exists\n if point_found(upper_left, lower_right) == False:\n\n count += 1\n \n return count\n ","runtime":"296"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def isUpperLeft(a, b):\n # returns if a is upper left of b\n return a[0] <= b[0] and a[1] >= b[1]\n def contains(a, b):\n # returns if box of a to b contains any points from point list\n # that are not a or b\n for p in points:\n if p != a and p != b:\n if a[0] <= p[0] <= b[0] and a[1] >= p[1] >= b[1]: return True\n return False\n ret, n = 0, len(points)\n for i in range(n):\n for j in range(n):\n if i == j: continue\n # if i is top left of j\n # check if any point contained\n # if not, ret += 1\n # else move on to next j\n if isUpperLeft(points[i], points[j]) and not contains(points[i], points[j]): ret += 1\n return ret\n ","runtime":"301"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n N = len(points)\n L = sorted([x,-y] for x,y in points)\n ret = 0\n for i in range(N-1):\n for j in range(i+1,N):\n if L[i][0]<=L[j][0] and L[i][1]<=L[j][1]: # upleft\n flag = 1\n for k in range(N):\n if L[k][0] > L[j][0]:\n break\n if k!=i and k!=j:\n if L[i][0]<=L[k][0]<=L[j][0] and L[i][1]<=L[k][1]<=L[j][1]:\n flag = 0\n break\n ret += flag\n return ret","runtime":"301"},{"code":"class Solution:\n def arePoints(self,x,y,points):\n i=0\n while(i<len(points) and points[i][0]<=y[0]):\n if(points[i]!=x and points[i]!=y):\n if(x[0]<=points[i][0]<=y[0] and y[1]<=points[i][1]<=x[1]):\n return False\n i+=1\n\n return True\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort()\n #fixing A\n count=0\n n=len(points)\n for i in range(n):\n hor=False\n ver=False\n for j in range(i+1,n):\n if(points[i][0]==points[j][0]):\n if(not ver):\n count+=1\n ver=True\n elif(points[i][1]==points[j][1]):\n if(not hor):\n count+=1\n hor=True\n else:\n if(points[i][1]>points[j][1]):\n if(self.arePoints(points[i],points[j],points)):\n count+=1\n print(\"**********\",i,j)\n return count","runtime":"306"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points.sort()\n ans = 0\n # print(\"new\")\n # print(points)\n for i in range(len(points)):\n x1, y1 = points[i]\n for j in range(len(points)):\n if i == j:\n continue\n x2, y2 = points[j]\n if not (x1 <= x2 and y1 >= y2):\n continue\n if any(x1 <= points[k][0] <= x2 and y2 <= points[k][1] <= y1 for k in range(len(points)) if k != i and k != j):\n continue\n # print(x1, y1, x2, y2)\n ans += 1\n return ans\n \n ","runtime":"311"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def is_valid_pair(a, b):\n if a[0] <= b[0] and a[1] >= b[1]:\n for c in points:\n if c != a and c != b:\n if (a[0] <= c[0] <= b[0] or a[0] >= c[0] >= b[0]) and \\\n (a[1] >= c[1] >= b[1] or a[1] <= c[1] <= b[1]):\n return False\n return True\n return False\n\n count = 0\n n = len(points)\n \n for i in range(n):\n for j in range(n):\n if i != j and is_valid_pair(points[i], points[j]):\n count += 1\n \n return count","runtime":"316"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n ans = 0\n\n n = len(points)\n\n for i in range(n):\n for j in range(i + 1, n):\n A = points[i]\n B = points[j]\n\n if B[0] == A[0] or (B[1] - A[1]) / (B[0] - A[0]) <= 0:\n print(B, A)\n if A[0] > B[0] or B[1] > A[1]:\n A, B = B, A\n\n for k in range(n):\n if k == i or k == j:\n continue\n \n C = points[k]\n\n if ( A[0] <= C[0] <= B[0] and B[1] <= C[1] <= A[1]):\n ans -= 1\n break\n\n ans += 1\n\n \n return ans\n\n","runtime":"322"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n count =0\n for x in range(len(points)):\n for y in range(x+1, len(points)):\n if (points[y][0]>=points[x][0] and points[y][1]<=points[x][1]) or (points[x][0]>=points[y][0] and points[x][1]<=points[y][1]):\n count +=1\n for z in (points):\n if z == points[x] or z == points[y]:\n continue\n else:\n if ((z[0]<=points[x][0] and z[0]>=points[y][0]) and (z[1]>=points[x][1] and z[1]<=points[y][1])) or ((z[0]>=points[x][0] and z[0]<=points[y][0]) and (z[1]<=points[x][1] and z[1]>=points[y][1])):\n count -=1\n break\n return count\n","runtime":"327"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n # C at upper-left; T at lower-right; nothing in between\n n = len(points)\n points.sort(key=lambda k: (k[0], -k[1])) # left to right, up to down\n print(points)\n result = 0\n for i in range(n):\n for j in range(i + 1, n):\n cx, cy = points[i]\n tx, ty = points[j]\n print((cx, cy), (tx, ty))\n if cy < ty: continue # C below T, not feasible\n print(\"here\")\n between = False\n for k in range(i + 1, j):\n kx, ky = points[k]\n if cx <= kx <= tx and cy >= ky >= ty:\n print(\"inside\")\n between = True\n break\n if not between: \n print((cx, cy), (tx, ty))\n result += 1\n return result","runtime":"332"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n ans = 0\n N = len(points)\n\n for i in range(N):\n x, y = points[i]\n for j in range(N):\n r, c = points[j]\n if r <= x and c >= y:\n if j == i:\n continue\n lies = False\n for k in range(N):\n if k == i or k == j:\n continue\n a, b = points[k]\n if a >= r and b <= c and a <= x and b >= y:\n lies = True\n \n if not lies:\n ans += 1\n return ans","runtime":"337"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n valid = 0\n for i, (x1, y1) in enumerate(points):\n for j, (x2, y2) in enumerate(points):\n if i != j and x1 <= x2 and y1 >= y2:\n not_in_fence = True\n for k, (x, y) in enumerate(points):\n if k != i and k != j and x1 <= x <= x2 and y2 <= y <= y1:\n not_in_fence = False\n if not_in_fence: valid += 1 \n return valid","runtime":"342"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n res = 0\n\n for i, (x1, y1) in enumerate(points):\n for j, (x2, y2) in enumerate(points):\n if i == j: continue\n if x1 > x2 or y1 < y2: continue\n\n valid = True\n for k, (x3, y3) in enumerate(points):\n if k == i or k == j: continue\n if x1 <= x3 <= x2 and y2 <= y3 <= y1:\n valid = False\n if valid:\n res += 1\n return res\n","runtime":"347"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n print(firstCorner)\n print(secondCorner)\n print(intersectingPoint)\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","runtime":"353"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n ans = 0\n N = len(points)\n\n for i in range(N):\n x, y = points[i]\n for j in range(N):\n r, c = points[j]\n if r <= x and c >= y:\n if j == i:\n continue\n lies = False\n for k in range(N):\n if k == i or k == j:\n continue\n a, b = points[k]\n if a >= r and b <= c and a <= x and b >= y:\n lies = True\n \n if not lies:\n ans += 1\n return ans","runtime":"358"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n ans = 0\n N = len(points)\n\n for i in range(N):\n x, y = points[i]\n for j in range(N):\n r, c = points[j]\n if r <= x and c >= y:\n if j == i:\n continue\n lies = False\n for k in range(N):\n if k == i or k == j:\n continue\n a, b = points[k]\n if a >= r and b <= c and a <= x and b >= y:\n lies = True\n # elif a <= x and b >= y:\n # lies = True \n \n if not lies:\n print(x, y, r, c)\n ans += 1\n return ans","runtime":"363"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n print(firstCorner)\n print(secondCorner)\n print(intersectingPoint)\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","runtime":"368"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n print(firstCorner)\n print(secondCorner)\n print(intersectingPoint)\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","runtime":"373"},{"code":"from numpy import matrix,dot\nclass Solution:\n def numberOfPairs(self, pts: List[List[int]]) -> int:\n o=0\n n=len(pts)\n pts=sorted(pts,key=lambda x:(x[0],-x[1]))\n M=[[0 for i in range(n)]for j in range(n)]\n def isbob(e,el):\n xe,ye=e\n xel,yel=el\n return xel>=xe and yel<=ye\n for i,e1 in enumerate(pts):\n for j in range(i+1,n):\n e2=pts[j]\n M[i][j]=isbob(e1,e2)\n M=matrix(M)\n R=M-dot(M,M)\n for i in range(n):\n for j in range(i+1,n):\n o+=(R[i,j]>0)\n return o","runtime":"379"},{"code":"# holy shit! brute?!\nclass Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n = len(points)\n if n == 2:\n if not ((points[0][0] <= points[1][0] and points[0][1] >= points[1][1]) or (points[0][0] >= points[1][0] and points[0][1] <= points[1][1])):\n return 0\n else:\n return 1\n\n def check(a, b, c, d, e, f) -> int: # A, B, C\n if not ((a <= c and b >= d) or (a >= c and b <= d)):\n return 0\n if a <= c and b >= d and a <= e <= c and d <= f <= b:\n return 0\n if a >= c and b <= d and c <= e <= a and b <= f <= d:\n return 0\n return 1 \n \n r = 0\n for i in range(n):\n for j in range(i + 1, n): # risk of over counting if starts from 0\n v = 1\n for k in range(n):\n if k == i or k == j:\n continue\n if not check(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1]):\n v = 0\n break\n if v:\n r += 1\n return r","runtime":"384"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n self.nums = [[0 for _ in range(52)] for _ in range(52)]\n\n for x, y in points:\n self.nums[y+1][x+1] += 1\n\n for i in range(1, 52):\n for j in range(1, 52):\n self.nums[i][j] += self.nums[i-1][j] + self.nums[i][j-1] - self.nums[i-1][j-1]\n\n def check(i, j):\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\n return True\n return False\n\n def find(i, j):\n p = self.nums[points[i][1]+1][points[j][0]+1] - self.nums[points[j][1]][points[j][0]+1] - self.nums[points[i][1] + 1][points[i][0]] + self.nums[points[j][1]][points[i][0]]\n return p\n\n N = len(points)\n pairs = 0\n for i in range(N):\n for j in range(i+1, N):\n if check(i, j):\n if find(i, j) == 2:\n pairs += 1\n elif check(j, i):\n if find(j, i) == 2:\n pairs += 1\n\n return pairs","runtime":"389"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n # if two points have the same x-coordinate, they are sorted by their y-coordinate in descending order\\n points.sort(key=lambda p: (p[0], -p[1]))\\n for i, (x1, y1) in enumerate(points):\\n y = -inf # keep track of the valid largest y-coordinate so far\\n for x2, y2 in points[i + 1:]:\\n # y1 must be upper left, on a horizontal line or on a vertical line with y2\\n # y2 must greater than y, otherwise a third person will inside/on the fence\\n if y1 >= y2 > y:\\n res += 1\\n y = y2\\n return res\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x: (x[0], -x[1]))\\n l = len(points)\\n\\n result = 0\\n for i in range(l):\\n x, y = points[i]\\n b_min = -1\\n for j in range(i+1, l):\\n b = points[j][1]\\n if b_min < b <= y:\\n result += 1\\n b_min = b\\n return result\",\n \"runtime\": \"88\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x: (x[0], -x[1]))\\n ans = 0\\n for i, (_, y1) in enumerate(points):\\n max_y = -inf\\n for _, y2 in points[i + 1 :]:\\n if max_y < y2 <= y1:\\n max_y = y2\\n ans += 1\\n return ans\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n We want to count the number of rectangles that can be defined with\\n top left and bottom right corners such that the rectangle contains\\n no other points. Degenerate rectangles are permissible.\\n\\n Observe that, for a given point A (top left candidate), the\\n feasible B points will form a sort of pareto frontier, where their\\n y coordinates strictly increase as their x coordinates increase.\\n Note that we are guaranteed no duplicate coordinate pairs in points.\\n\\n We can sort the x and y coordinates. For a given point, iterate\\n over the points with x coordinates greater than or equal to its own\\n by ascending x value. Ties are resolved such that the point with\\n the larger y value comes first. Keep track of the largest y value\\n seen thusfar. Ignore any points with a smaller y value. Break the\\n loop when the y value meets or exceeds our A candidate's y value.\\n\\n This requires some tangled co-sorting because we want it to be\\n possible to locate a given point's x and y coordinate within the\\n sorted lists efficiently.\\n\\n There's probably a way to squeeze out more performance by using\\n one point's results to warm start the next.\\n \\\"\\\"\\\"\\n x_y_cosorted = sorted((points), key=lambda tup_xy: (tup_xy[0], -tup_xy[1]))\\n n_pairs = 0\\n for a in range(len(x_y_cosorted)):\\n max_y_seen = -1\\n for b in range(a + 1, len(x_y_cosorted)):\\n if (\\n x_y_cosorted[b][1] <= x_y_cosorted[a][1] # B cannot be above A\\n and x_y_cosorted[b][1] > max_y_seen # AB cannot contain another point\\n ):\\n n_pairs += 1\\n max_y_seen = x_y_cosorted[b][1]\\n # If AB is a horizontal line, we are done\\n if max_y_seen == x_y_cosorted[a][1]:\\n break\\n return n_pairs\\n\",\n \"runtime\": \"93\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda point: (point[0], -point[1]))\\n n = len(points)\\n total = 0\\n\\n for l in range(n):\\n x = points[l][0]\\n y = points[l][1]\\n highest = -1\\n\\n for r in range(l + 1, n):\\n if highest < points[r][1] <= y:\\n highest = points[r][1]\\n total += 1\\n \\n return total\\n \",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda p: (-p[1], p[0]))\\n res, n = 0, len(points)\\n for i in range(n - 1):\\n min_x = float(\\\"inf\\\")\\n for j in range(i + 1, n):\\n if points[i][0] <= points[j][0] < min_x:\\n res += 1\\n min_x = min(min_x, points[j][0])\\n return res\\n # def is_valid(p1, p2, i1, i2):\\n # x1, y1 = p1\\n # x2, y2 = p2\\n # for i, (x, y) in enumerate(points):\\n # if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\\n # return False\\n # return True\\n\\n # pl = len(points)\\n # cnt = 0\\n # for i in range(pl):\\n # for j in range(pl):\\n # if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n # if is_valid(points[i], points[j], i, j):\\n # cnt += 1\\n # return cnt\",\n \"runtime\": \"98\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = [x[1] for x in sorted(points, key=lambda x: (x[0], -x[1]))]\\n l = len(points)\\n\\n result = 0\\n for i in range(l):\\n y = points[i]\\n b_min = -1\\n for j in range(i+1, l):\\n b = points[j]\\n if b_min < b <= y:\\n result += 1\\n b_min = b\\n return result\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"# FARHANG\\n\\nclass Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x: (x[0], -x[1]))\\n counter = 0\\n\\n for i in range(len(points)):\\n highest_y = -1\\n for j in range(i + 1, len(points)):\\n if points[i][1] >= points[j][1] > highest_y:\\n counter += 1\\n highest_y = points[j][1]\\n \\n return counter\",\n \"runtime\": \"104\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda point: (point[0], -point[1]))\\n n = len(points)\\n total = 0\\n\\n for l in range(n):\\n x = points[l][0]\\n y = points[l][1]\\n highest = -1\\n\\n for r in range(l + 1, n):\\n if highest < points[r][1] <= y:\\n highest = points[r][1]\\n total += 1\\n \\n return total\\n \",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda p: (p[0], - p[1]))\\n n = len(points)\\n result = 0\\n for i in range(n):\\n x, y = points[i]\\n #print(x, y)\\n # if i < len(points) -1 and points[i+1][0] == x:\\n # #print('skip')\\n # continue\\n smallest_y = 100\\n prev = points[0:i][::-1]\\n for xp, yp in prev:\\n #print('prev', xp, yp)\\n if yp >= y:\\n if yp < smallest_y:\\n result += 1\\n smallest_y = min(smallest_y, yp)\\n\\n return result\\n \",\n \"runtime\": \"109\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda p:(-p[1], p[0]))\\n print(points)\\n ans = 0\\n pl = len(points)\\n for i in range(pl-1):\\n min_x = float('inf')\\n for j in range(i+1, pl):\\n if points[i][0] <= points[j][0] < min_x:\\n ans += 1\\n min_x = min(min_x, points[j][0])\\n return ans\\n\\n # def is_valid(p1, p2, i1, i2):\\n # x1, y1 = p1\\n # x2, y2 = p2\\n # for i, (x, y) in enumerate(points):\\n # if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\\n # return False\\n # return True\\n\\n # pl = len(points)\\n # cnt = 0\\n # for i in range(pl):\\n # for j in range(pl):\\n # if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n # if is_valid(points[i], points[j], i, j):\\n # cnt += 1\\n # return cnt\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n cols = defaultdict(list)\\n rows = defaultdict(list)\\n\\n for r, c in points:\\n rows[r].append(c) or cols[c].append(r)\\n \\n p = sorted(rows)\\n for v in rows.values():\\n v.sort()\\n\\n ans = 0\\n for r in range(len(p)):\\n ans += len(rows[p[r]]) - 1\\n for c in range(len(rows[p[r]]) - 1, -1, -1):\\n b = rows[p[r]][c - 1] if c else -1\\n for dr in range(r + 1, len(p)):\\n for dc in range(len(rows[p[dr]]) - 1, -1, -1):\\n if rows[p[dr]][dc] > rows[p[r]][c]:\\n continue\\n if rows[p[dr]][dc] > b:\\n ans += 1\\n b = rows[p[dr]][dc]\\n break\\n return ans\\n\",\n \"runtime\": \"114\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n cols = defaultdict(list)\\n rows = defaultdict(list)\\n\\n for c, r in points:\\n rows[r].append(c)\\n cols[c].append(r)\\n\\n p = sorted(rows)\\n for v in rows.values():\\n v.sort()\\n\\n ans = 0\\n for r in range(len(p)):\\n #print(777,rows[p[r]])\\n ans += len(rows[p[r]]) - 1\\n\\n for c in range(len(rows[p[r]]) - 1, -1, -1):\\n b = rows[p[r]][c - 1] if c else -1\\n for dr in range(r + 1, len(p)):\\n for dc in range(len(rows[p[dr]]) - 1, -1, -1):\\n if rows[p[dr]][dc] > rows[p[r]][c]:\\n continue\\n if rows[p[dr]][dc] > b:\\n ans += 1\\n #print(r, c, dr, dc, rows[p[r]][c], rows[p[dr]][dc], b)\\n b = rows[p[dr]][dc]\\n break\\n \\n #print(\\\"r\\\", r, ans)\\n\\n\\n return ans\\n\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n sortedPoints = sorted(points, key=lambda p: (p[0], -p[1]))\\n n = len(points)\\n cnt = 0\\n for i in range(n):\\n p1 = sortedPoints[i]\\n between = set()\\n for j in range(i + 1, n):\\n p2 = sortedPoints[j]\\n if p1[1] >= p2[1]:\\n having_between = False\\n if between:\\n for num in between:\\n if p2[1] <= num <= p1[1]:\\n having_between = True\\n break\\n if having_between:\\n continue\\n cnt += 1\\n between.add(p2[1])\\n return cnt\\n\",\n \"runtime\": \"119\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda point: (point[0], -point[1]))\\n n = len(points)\\n result = 0\\n for i in range(n):\\n prev = None\\n for j in range(i + 1, n):\\n if points[j][1] <= points[i][1] and (prev == None or points[j][1] > points[prev][1]):\\n print(points[i], points[j])\\n prev = j\\n result += 1\\n return result\\n \",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points):\\n n, count = len(points), 0 \\n\\n points.sort(key = lambda x: (x[0],-x[1]))\\n\\n for i in range(n):\\n for j in range(i+1,n):\\n if points[i][1] >= points[j][1]:\\n is_valid = True\\n for k in range(i+1,j):\\n if (points[j][1] <= points[k][1] <= points[i][1]):\\n is_valid = False\\n break \\n\\n if is_valid:\\n count += 1 \\n\\n return count\",\n \"runtime\": \"124\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n count=0\\n points= sorted(points, key=lambda x: (x[0],-x[1]))\\n print(points)\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n x1, y1= points[i]\\n x2, y2= points[j]\\n if y1>=y2:\\n Flag=True\\n for k in range(i+1,j):\\n x3, y3 = points[k]\\n if x1<=x3<=x2 and y2<=y3<=y1:\\n Flag=False\\n break\\n\\n if Flag==True:\\n count+=1\\n\\n return count\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x:(x[0], -x[1]))\\n res = 0\\n n = len(points)\\n\\n for i in range(n-1):\\n ax, ay = points[i][0], points[i][1]\\n for j in range(i+1, n):\\n bx, by = points[j][0], points[j][1]\\n flag = True\\n\\n if ax <= bx and ay >= by:\\n for k in range(i+1, j):\\n cx, cy = points[k][0], points[k][1]\\n if ax <= cx <= bx and by <= cy <= ay:\\n flag = False\\n break\\n else: flag = False\\n \\n if flag:\\n res += 1\\n\\n return res\\n\\n \",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = sorted(points, key=lambda point: (point[0], -point[1]))\\n n = len(points)\\n result = 0\\n for i in range(n):\\n prev = None\\n for j in range(i + 1, n):\\n if points[j][1] <= points[i][1] and (prev == None or points[j][1] > points[prev][1]):\\n print(points[i], points[j])\\n prev = j\\n result += 1\\n return result\\n \",\n \"runtime\": \"135\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n ans = 0 \\n for i, (xi, yi) in enumerate(points): \\n vals = []\\n for j, (xj, yj) in enumerate(points): \\n if i != j and xj <= xi and yj >= yi: vals.append([xj, yj])\\n small = inf \\n for xj, yj in sorted(vals, key = lambda x: (-x[0], x[1])): \\n if yj < small: \\n ans += 1\\n small = yj\\n return ans \",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n points = sorted(points, key=lambda x: (-x[1], x[0]))\\n\\n ans = 0\\n for i in range(n - 1):\\n for j in range(i + 1, n):\\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\\n valid = True\\n for k in range(i + 1, j):\\n if points[k][0] >= points[i][0] and points[k][1] <= points[i][1] and points[k][0] <= points[j][0] and points[k][1] >= points[j][1]:\\n valid = False\\n break\\n if valid:\\n ans += 1\\n\\n return ans\\n\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n\\n points.sort(key=lambda x: (-x[0], x[1]))\\n print(points)\\n\\n for i in range(len(points)):\\n p1x, p1y = points[i]\\n\\n for j in range(i+1, len(points)):\\n p2x, p2y = points[j]\\n\\n if p1x >= p2x and p1y <= p2y:\\n found = False\\n\\n for k in range(i+1, j):\\n p3x, p3y = points[k]\\n\\n if p1x >= p3x >= p2x and p1y <= p3y <= p2y:\\n found = True\\n break\\n\\n if not found:\\n res += 1\\n\\n\\n return res\",\n \"runtime\": \"145\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points=sorted(points,key=lambda x: (x[0],-x[1]))\\n cnt=0\\n for i in range(len(points)-1):\\n for j in range(i+1,len(points)):\\n if points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\\n flag=True\\n for k in range(i+1,j):\\n if points[i][0]<=points[k][0]<=points[j][0] and points[j][1]<=points[k][1]<=points[i][1]:\\n flag=False\\n break\\n if flag==True:\\n cnt+=1\\n return cnt\\n\\n \",\n \"runtime\": \"145\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n n = len(points)\\n sorted_points = sorted(points, key = lambda p: (p[0], -p[1]))\\n\\n def isValid(i, j):\\n ul, br = sorted_points[i], sorted_points[j]\\n if ul[1] < br[1]:\\n return False\\n\\n for k in range(i+1, j):\\n mid = sorted_points[k]\\n if (ul[0] <= mid[0] <= br[0]) and (br[1] <= mid[1] <= ul[1]):\\n return False\\n return True\\n\\n count = 0\\n for i in range(n):\\n for j in range(i+1, n):\\n if isValid(i, j):\\n count += 1\\n\\n return count\\n\",\n \"runtime\": \"150\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points=sorted(points,key=lambda x: (x[0],-x[1]))\\n cnt=0\\n for i in range(len(points)-1):\\n for j in range(i+1,len(points)):\\n flag=True\\n if points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\\n for k in range(i+1,j):\\n if points[i][0]<=points[k][0]<=points[j][0] and points[j][1]<=points[k][1]<=points[i][1]:\\n flag=False\\n break\\n if flag==True:\\n cnt+=1\\n return cnt\\n\\n \",\n \"runtime\": \"156\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n for x1, y1 in points:\\n rectangles = []\\n for x2,y2 in points:\\n if x1 == x2 and y1 == y2:\\n continue\\n if x1 <= x2 and y1 >= y2:\\n within_rectangle = False\\n for x3,y3 in points:\\n if (x1 == x3 and y1 == y3) or (x2 == x3 and y2 == y3):\\n continue\\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\\n within_rectangle = True\\n break\\n if not within_rectangle:\\n res += 1\\n return res\",\n \"runtime\": \"161\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n co = sorted(points, key=lambda x: (-x[1], x[0]))\\n l=len(co)\\n \\n ans=0\\n \\n for i in range(l-1):\\n for j in range(i+1,l):\\n x1,x2=co[i][0],co[j][0]\\n y1,y2=co[i][1],co[j][1]\\n yes=True\\n \\n if y1>=y2 and x1<=x2:\\n for k in range(i+1,j):\\n if min(x1,x2)<=co[k][0]<=max(x1,x2) and min(y1,y2)<=co[k][1]<=max(y1,y2):\\n yes=False\\n break\\n if yes:\\n ans+=1\\n \\n \\n return ans\",\n \"runtime\": \"176\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n for x1, y1 in points:\\n rectangles = []\\n for x2,y2 in points:\\n if x1 == x2 and y1 == y2:\\n continue\\n if x2 <= x1 and y2 >= y1:\\n within_rectangle = False\\n for x3,y3 in points:\\n if (x1 == x3 and y1 == y3) or (x2 == x3 and y2 == y3):\\n continue\\n if (x3 <= x1 and y3 >= y1) and (x2 <= x3 and y2 >= y3):\\n within_rectangle = True\\n break\\n if not within_rectangle:\\n res += 1\\n return res\",\n \"runtime\": \"181\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n \\n points = sorted(points, key = lambda x: x[1] - x[0])\\n\\n def is_covering(i, k, j):\\n return (\\n (points[k][0] <= points[i][0] and points[k][1] >= points[i][1])\\n and\\n (points[k][0] >= points[j][0] and points[k][1] <= points[j][1])\\n )\\n\\n def is_upperleft(i, j):\\n return points[i][0] >= points[j][0] and points[i][1] <= points[j][1]\\n\\n count = 0\\n for j in range(1, n):\\n for i in range(j):\\n if is_upperleft(i, j):\\n flag = True\\n for k in range(i + 1, j):\\n if is_covering(i, k, j):\\n flag = False\\n break\\n if flag:\\n count += 1\\n \\n return count\",\n \"runtime\": \"187\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def validRectangle(ul,i,lr,j):\\n x1,y1 = ul\\n x2,y2 = lr\\n if not (x1<=x2 and y1>=y2):\\n return False\\n flag = True\\n for x in range(x1,x2+1):\\n for y,index in self.d[x]:\\n if index==i or index==j:\\n continue\\n if y2<=y<=y1:\\n flag = False\\n break\\n if flag == False:\\n break\\n return flag\\n \\n \\n N = len(points)\\n res = 0\\n \\n self.d = defaultdict(lambda: [])\\n for i,p in enumerate(points):\\n x,y = p\\n self.d[x].append((y,i))\\n \\n for i in range(N):\\n for j in range(N):\\n if i==j:\\n continue\\n if validRectangle(points[i], i, points[j], j):\\n res += 1\\n \\n return res\",\n \"runtime\": \"192\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n N=len(points)\\n #points.sort(key=lambda x:(x[0],x[1]))\\n def valid(xy,xz,c,t):\\n x1,y1=xy\\n x2,y2=xz\\n for i,(x,y) in enumerate(points):\\n if (x1<=x<=x2 and y1>=y>=y2 and i!=c and i!=t):return False\\n return True\\n res=0\\n for r in range(N):\\n x1,y1=points[r]\\n px,py=None,None\\n for c in range(N):\\n x2,y2=points[c]\\n if r!=c and (x1<=x2 and y1>=y2 ):\\n if valid(points[r],points[c],r,c):res+=1\\n return res\",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(chisato, takina, c, t):\\n x1, y1 = chisato\\n x2, y2 = takina\\n for i, (x, y) in enumerate(points):\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\",\n \"runtime\": \"202\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n points.sort(key = lambda x: (x[0], -x[1]))\\n res = 0\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n if points[i][1] >= points[j][1]:\\n flag = True\\n for k in range(i + 1, j):\\n if points[j][1] <= points[k][1] <= points[i][1]:\\n flag = False\\n \\n if flag:\\n res += 1\\n \\n return res\",\n \"runtime\": \"202\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n count=0\\n points= sorted(points, key=lambda x: (x[0],-x[1]))\\n print(points)\\n for i in range(len(points)):\\n for j in range(i+1,len(points)):\\n x1, y1= points[i]\\n x2, y2= points[j]\\n if y1>=y2:\\n Flag=True\\n for k in range(i+1,j):\\n x3, y3 = points[k]\\n if x1<=x3<=x2 and y2<=y3<=y1:\\n Flag=False\\n\\n if Flag==True:\\n count+=1\\n\\n return count\",\n \"runtime\": \"207\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(X, Y, idx_x, idx_y):\\n x1, y1 = X\\n x2, y2 = Y\\n for i, (x, y) in enumerate(points):\\n # Check if there are any points inside the triangle of X and Y.\\n # Check with idx_x and idx_y makes sure that we are not comapring\\n # with the same point.\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != idx_x and i != idx_y:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and\\\\\\n points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\\n\\n # time complexity: O(N^3)\\n\",\n \"runtime\": \"213\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(chisato, takina, c, t):\\n x1, y1 = chisato\\n x2, y2 = takina\\n for i, (x, y) in enumerate(points):\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"213\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def check_if_inside(x1,y1,x2,y2,i,j):\\n for z,point in enumerate(points):\\n x3,y3= point \\n if z !=i and z !=j and x3 >= x1 and x3 <= x2 and y3 <= y1 and y3 >= y2:\\n return True \\n return False \\n counter = 0\\n for i in range(len(points)):\\n x1,y1 = points[i]\\n for j in range(len(points)):\\n x2,y2 = points[j]\\n if i != j and x1 <= x2 and y1 >= y2 and not check_if_inside(x1,y1,x2,y2,i,j):\\n counter += 1\\n return counter \",\n \"runtime\": \"218\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(X, Y, idx_x, idx_y):\\n x1, y1 = X\\n x2, y2 = Y\\n for i, (x, y) in enumerate(points):\\n # Check if there are any points inside the triangle of X and Y.\\n # Check with idx_x and idx_y makes sure that we are not comapring\\n # with the same point.\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != idx_x and i != idx_y:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and\\\\\\n points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\\n\\n # time complexity: O(N^3)\\n\",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(p1, p2, c, t):\\n x1, y1 = p1\\n x2, y2 = p2\\n for i, (x, y) in enumerate(points):\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(chisato, takina, c, t):\\n x1, y1 = chisato\\n x2, y2 = takina\\n for i, (x, y) in enumerate(points):\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n # Helper function to check if the rectangle formed by two points is empty\\n def is_valid(chisato, takina, c, t):\\n x1, y1 = chisato\\n x2, y2 = takina\\n # Iterate through all points to check if any point lies within the rectangle\\n for i, (x, y) in enumerate(points):\\n # Check if the point (x, y) is inside the rectangle formed by (x1, y1) and (x2, y2)\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i != c and i != t:\\n return False\\n return True\\n\\n n = len(points)\\n count = 0\\n # Iterate over all pairs of points\\n for i in range(n):\\n for j in range(n):\\n # Ensure we are not comparing the same point and check if point[i] is upper-left of point[j]\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n # Check if the rectangle formed by these two points is empty\\n if is_valid(points[i], points[j], i, j):\\n count += 1\\n\\n return count\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/3000-3099/3025.Find%20the%20Number%20of%20Ways%20to%20Place%20People%20I\\n def check(x1, x2, y1, y2):\\n for x, y in points:\\n if x == x1 and y == y1 or x == x2 and y == y2: \\n continue\\n if x1 <= x <= x2 and y2 <= y <= y1:\\n return False\\n return True\\n\\n points.sort(key=lambda x: (x[0], -x[1]))\\n n = len(points)\\n cnt = 0\\n # for (x1, y1), (x2, y2) in pairwise(points): \\n for (x1, y1), (x2, y2) in permutations(points, 2): \\n if x1 > x2 or y2 > y1: continue\\n if check(x1, x2, y1, y2): \\n cnt += 1\\n return cnt\",\n \"runtime\": \"233\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid(p1, p2, i1, i2):\\n x1, y1 = p1\\n x2, y2 = p2\\n for i, (x, y) in enumerate(points):\\n if (x1 <= x <= x2 and y1 >= y >= y2) and i not in {i1, i2}:\\n return False\\n return True\\n\\n pl = len(points)\\n cnt = 0\\n for i in range(pl):\\n for j in range(pl):\\n if i != j and (points[i][0] <= points[j][0] and points[i][1] >= points[j][1]):\\n if is_valid(points[i], points[j], i, j):\\n cnt += 1\\n return cnt\",\n \"runtime\": \"233\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, P: List[List[int]]) -> int:\\n n = len(P)\\n P.sort(key=lambda p: (p[0], -p[1]))\\n res = 0\\n for i in range(n - 1):\\n x_i, y_i = P[i]\\n for j in range(i + 1, n):\\n x_j, y_j = P[j]\\n if y_i < y_j or x_i > x_j: continue\\n\\n contained = False\\n for k in range(n):\\n if k == i or k == j: continue\\n x_k, y_k = P[k]\\n if x_i <= x_k <= x_j and y_j <= y_k <= y_i: \\n contained = True\\n break\\n if not contained: res += 1\\n return res\\n\\n \",\n \"runtime\": \"239\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort()\\n pairs = 0\\n n = len(points)\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n x_a, y_a = points[i]\\n x_b, y_b = points[j]\\n if y_a < y_b:\\n if x_a == x_b:\\n x_a, x_b = x_b, x_a\\n y_a, y_b = y_b, y_a\\n else:\\n continue\\n good = True\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n x, y = points[k]\\n if x_a <= x <= x_b and y_b <= y <= y_a:\\n good = False\\n break\\n pairs += good\\n \\n return pairs\\n \",\n \"runtime\": \"239\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n N = len(points)\\n points.sort(key=lambda p: (p[0], -p[1]))\\n pairs = 0\\n for i in range(N):\\n for j in range(i + 1, N):\\n x1, y1 = points[i]\\n x2, y2 = points[j]\\n if x1 > x2 or y1 < y2:\\n continue\\n if N - 2 > 0:\\n for k in range(N):\\n if k == i or k == j:\\n continue\\n xk, yk = points[k]\\n if x1 <= xk <= x2 and y2 <= yk <= y1:\\n break\\n else:\\n pairs += 1\\n else:\\n pairs += 1\\n return pairs\\n \",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, v):\\n n = len(v)\\n ans = 0\\n\\n for i in range(n):\\n x1, y1 = v[i][0], v[i][1]\\n\\n for j in range(n):\\n if i == j:\\n continue\\n\\n x2, y2 = v[j][0], v[j][1]\\n f = 0\\n\\n if y1 >= y2 and x1 <= x2:\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n\\n x3, y3 = v[k][0], v[k][1]\\n\\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\\n f = 1\\n break\\n\\n if f == 0:\\n ans += 1\\n\\n return ans\",\n \"runtime\": \"249\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def checkVertical(i, j):\\n for k in range(i+1, j):\\n if points[k][0]==points[i][0]:\\n return False\\n else:\\n return True\\n def checkHorizontal(i, j):\\n for k in range(i+1, j):\\n if points[k][1]==points[i][1]:\\n return False\\n else:\\n return True\\n def checkSquare(i, j):\\n for k in range(n):\\n if k==i or k==j:\\n pass\\n elif points[i][0]<=points[k][0]<=points[j][0] and points[i][1]>=points[k][1]>=points[j][1]:\\n return False\\n else:\\n return True\\n\\n\\n\\n count = 0\\n n = len(points)\\n points.sort(key=lambda x:(x[0], x[1]))\\n print(points)\\n for i in range(n):\\n for j in range(i+1, n):\\n if points[i][0]==points[j][0]:\\n if checkVertical(i, j):\\n count += 1\\n else:\\n if points[i][1]==points[j][1]:\\n if checkHorizontal(i, j):\\n count += 1\\n elif points[i][1]>points[j][1]:\\n if checkSquare(i, j):\\n count+=1\\n\\n return count\",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n ans = 0\\n\\n n = len(points)\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n A = points[i]\\n B = points[j]\\n\\n if B[0] == A[0] or (B[1] - A[1]) / (B[0] - A[0]) <= 0:\\n if A[0] > B[0] or B[1] > A[1]:\\n A, B = B, A\\n\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n \\n C = points[k]\\n\\n if ( A[0] <= C[0] <= B[0] and B[1] <= C[1] <= A[1]):\\n ans -= 1\\n break\\n\\n ans += 1\\n\\n \\n return ans\\n\\n\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n count = 0\\n for i in range(len(points)):\\n for j in range(len(points)):\\n x1 = points[i][0]\\n y1 = points[i][1]\\n x2 = points[j][0]\\n y2 = points[j][1]\\n if x2 <= x1 and y2 >= y1 and (x2 < x1 or y2 > y1):\\n canCount = True\\n for k in range(len(points)):\\n if k != i and k != j:\\n X1 = points[k][0]\\n Y1 = points[k][1]\\n #x1, y1 = [6,2] and x2, y2 = [2,6], X1, Y1 = [4,4]\\n if X1 <= x1 and Y1 >= y1 and X1 >= x2 and Y1 <= y2:\\n canCount = False\\n break\\n if canCount:\\n count += 1\\n return count\\n\",\n \"runtime\": \"264\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"runtime\": \"264\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n count = 0\\n \\n\\n for i in range(n):\\n for j in range(n):\\n if i != j:\\n \\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\\n t= True\\n for k in range(n):\\n if k != i and k != j:\\n \\n if points[i][0] <= points[k][0] <= points[j][0] and points[j][1] <= points[k][1] <= points[i][1]:\\n t = False\\n break\\n if t:\\n count += 1\\n return count\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"runtime\": \"275\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n count = 0\\n \\n # Helper function to determine if a point is strictly inside the rectangle\\n def is_strictly_inside(px, py, x1, y1, x2, y2):\\n return x1 < px < x2 and y1 < py < y2\\n \\n for i in range(n):\\n for j in range(n):\\n if i != j:\\n # Check if point[i] is on upper left of point[j]\\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\\n # Check that no other points are inside or on the border of the rectangle\\n empty_rectangle = True\\n for k in range(n):\\n if k != i and k != j:\\n if (points[i][0] <= points[k][0] <= points[j][0] and\\n points[j][1] <= points[k][1] <= points[i][1]):\\n empty_rectangle = False\\n break\\n if empty_rectangle:\\n count += 1\\n return count\",\n \"runtime\": \"275\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort(key=lambda x: (x[0], -x[1]))\\n\\n n = len(points)\\n cnt = 0\\n\\n for i in range(n):\\n for j in range(i+1, n):\\n if points[i][1] >= points[j][1]:\\n # check that no other point is here\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n # print(\\\"Checking \\\", points[k], \\\"vs\\\", points[i], points[j])\\n if (points[i][0] <= points[k][0] <= points[j][0] and points[i][1] >= points[k][1] >= points[j][1]):\\n break\\n else:\\n cnt += 1\\n return cnt\",\n \"runtime\": \"280\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n n = len(points)\\n for i in range(n):\\n x1 = points[i][0]\\n y1 = points[i][1]\\n for j in range(n):\\n if i == j:\\n continue\\n x2 = points[j][0]\\n y2 = points[j][1]\\n # valid if x1 <= x2, y1 >= y2\\n if x1 > x2:\\n continue\\n if y1 < y2:\\n continue\\n valid = True\\n for k in range(n):\\n if i == k or j == k:\\n continue\\n x3 = points[k][0]\\n y3 = points[k][1]\\n if x1 <= x3 <= x2 and y1 >= y3 >= y2:\\n valid = False\\n break\\n if valid:\\n res += 1\\n print('---')\\n return res\\n\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n seen = set([tuple(point) for point in points])\\n n = len(points)\\n points.sort(key=lambda x: (x[0], -x[1]))\\n res = 0\\n for i, [x1, y1] in enumerate(points):\\n for j in range(i+1, n):\\n x2, y2 = points[j]\\n\\n if x1 < x2 and y1 < y2:\\n continue\\n \\n found = False\\n for x in range(x1, x2+1):\\n for y in range(y2, y1+1):\\n if (x, y) in seen and (x, y) not in [(x1, y1), (x2, y2)]:\\n found = True\\n break\\n if found:\\n break\\n if not found:\\n res += 1\\n return res\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n # for every point, pair it with every other point to test if any of those is on the upper left of the other.\\n # if yes, iterate over all the points and if there is any other point in the rectangle than break otherwise count it\\n n = len(points)\\n count = 0\\n\\n def is_upper_left(point1, point2):\\n if point1[0] <= point2[0] and point1[1] >= point2[1]:\\n return point1, point2\\n if point2[0] <= point1[0] and point2[1] >= point1[1]:\\n return point2, point1\\n return None\\n\\n def point_found(upper_left, lower_right):\\n for point in points:\\n if point == upper_left or point == lower_right:\\n continue\\n if upper_left[0] <= point[0] <= lower_right[0] and lower_right[1] <= point[1] <= upper_left[1]:\\n return True\\n return False\\n\\n for i in range(n):\\n for j in range(i+1, n):\\n upper_left_exists = is_upper_left(points[i], points[j])\\n if upper_left_exists:\\n upper_left, lower_right = upper_left_exists\\n if point_found(upper_left, lower_right) == False:\\n\\n count += 1\\n \\n return count\\n \",\n \"runtime\": \"290\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n # for every point, pair it with every other point to test if any of those is on the upper left of the other.\\n # if yes, iterate over all the points and if there is any other point in the rectangle than break otherwise count it\\n n = len(points)\\n count = 0\\n\\n def is_upper_left(point1, point2):\\n if point1[0] <= point2[0] and point1[1] >= point2[1]:\\n return point1, point2\\n if point2[0] <= point1[0] and point2[1] >= point1[1]:\\n return point2, point1\\n return None\\n\\n def point_found(upper_left, lower_right):\\n for point in points:\\n if point == upper_left or point == lower_right:\\n continue\\n if upper_left[0] <= point[0] <= lower_right[0] and lower_right[1] <= point[1] <= upper_left[1]:\\n return True\\n return False\\n\\n for i in range(n):\\n for j in range(i+1, n):\\n upper_left_exists = is_upper_left(points[i], points[j])\\n if upper_left_exists:\\n upper_left, lower_right = upper_left_exists\\n if point_found(upper_left, lower_right) == False:\\n\\n count += 1\\n \\n return count\\n \",\n \"runtime\": \"296\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def isUpperLeft(a, b):\\n # returns if a is upper left of b\\n return a[0] <= b[0] and a[1] >= b[1]\\n def contains(a, b):\\n # returns if box of a to b contains any points from point list\\n # that are not a or b\\n for p in points:\\n if p != a and p != b:\\n if a[0] <= p[0] <= b[0] and a[1] >= p[1] >= b[1]: return True\\n return False\\n ret, n = 0, len(points)\\n for i in range(n):\\n for j in range(n):\\n if i == j: continue\\n # if i is top left of j\\n # check if any point contained\\n # if not, ret += 1\\n # else move on to next j\\n if isUpperLeft(points[i], points[j]) and not contains(points[i], points[j]): ret += 1\\n return ret\\n \",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n N = len(points)\\n L = sorted([x,-y] for x,y in points)\\n ret = 0\\n for i in range(N-1):\\n for j in range(i+1,N):\\n if L[i][0]<=L[j][0] and L[i][1]<=L[j][1]: # upleft\\n flag = 1\\n for k in range(N):\\n if L[k][0] > L[j][0]:\\n break\\n if k!=i and k!=j:\\n if L[i][0]<=L[k][0]<=L[j][0] and L[i][1]<=L[k][1]<=L[j][1]:\\n flag = 0\\n break\\n ret += flag\\n return ret\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def arePoints(self,x,y,points):\\n i=0\\n while(i<len(points) and points[i][0]<=y[0]):\\n if(points[i]!=x and points[i]!=y):\\n if(x[0]<=points[i][0]<=y[0] and y[1]<=points[i][1]<=x[1]):\\n return False\\n i+=1\\n\\n return True\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort()\\n #fixing A\\n count=0\\n n=len(points)\\n for i in range(n):\\n hor=False\\n ver=False\\n for j in range(i+1,n):\\n if(points[i][0]==points[j][0]):\\n if(not ver):\\n count+=1\\n ver=True\\n elif(points[i][1]==points[j][1]):\\n if(not hor):\\n count+=1\\n hor=True\\n else:\\n if(points[i][1]>points[j][1]):\\n if(self.arePoints(points[i],points[j],points)):\\n count+=1\\n print(\\\"**********\\\",i,j)\\n return count\",\n \"runtime\": \"306\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points.sort()\\n ans = 0\\n # print(\\\"new\\\")\\n # print(points)\\n for i in range(len(points)):\\n x1, y1 = points[i]\\n for j in range(len(points)):\\n if i == j:\\n continue\\n x2, y2 = points[j]\\n if not (x1 <= x2 and y1 >= y2):\\n continue\\n if any(x1 <= points[k][0] <= x2 and y2 <= points[k][1] <= y1 for k in range(len(points)) if k != i and k != j):\\n continue\\n # print(x1, y1, x2, y2)\\n ans += 1\\n return ans\\n \\n \",\n \"runtime\": \"311\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def is_valid_pair(a, b):\\n if a[0] <= b[0] and a[1] >= b[1]:\\n for c in points:\\n if c != a and c != b:\\n if (a[0] <= c[0] <= b[0] or a[0] >= c[0] >= b[0]) and \\\\\\n (a[1] >= c[1] >= b[1] or a[1] <= c[1] <= b[1]):\\n return False\\n return True\\n return False\\n\\n count = 0\\n n = len(points)\\n \\n for i in range(n):\\n for j in range(n):\\n if i != j and is_valid_pair(points[i], points[j]):\\n count += 1\\n \\n return count\",\n \"runtime\": \"316\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n ans = 0\\n\\n n = len(points)\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n A = points[i]\\n B = points[j]\\n\\n if B[0] == A[0] or (B[1] - A[1]) / (B[0] - A[0]) <= 0:\\n print(B, A)\\n if A[0] > B[0] or B[1] > A[1]:\\n A, B = B, A\\n\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n \\n C = points[k]\\n\\n if ( A[0] <= C[0] <= B[0] and B[1] <= C[1] <= A[1]):\\n ans -= 1\\n break\\n\\n ans += 1\\n\\n \\n return ans\\n\\n\",\n \"runtime\": \"322\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n count =0\\n for x in range(len(points)):\\n for y in range(x+1, len(points)):\\n if (points[y][0]>=points[x][0] and points[y][1]<=points[x][1]) or (points[x][0]>=points[y][0] and points[x][1]<=points[y][1]):\\n count +=1\\n for z in (points):\\n if z == points[x] or z == points[y]:\\n continue\\n else:\\n if ((z[0]<=points[x][0] and z[0]>=points[y][0]) and (z[1]>=points[x][1] and z[1]<=points[y][1])) or ((z[0]>=points[x][0] and z[0]<=points[y][0]) and (z[1]<=points[x][1] and z[1]>=points[y][1])):\\n count -=1\\n break\\n return count\\n\",\n \"runtime\": \"327\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n # C at upper-left; T at lower-right; nothing in between\\n n = len(points)\\n points.sort(key=lambda k: (k[0], -k[1])) # left to right, up to down\\n print(points)\\n result = 0\\n for i in range(n):\\n for j in range(i + 1, n):\\n cx, cy = points[i]\\n tx, ty = points[j]\\n print((cx, cy), (tx, ty))\\n if cy < ty: continue # C below T, not feasible\\n print(\\\"here\\\")\\n between = False\\n for k in range(i + 1, j):\\n kx, ky = points[k]\\n if cx <= kx <= tx and cy >= ky >= ty:\\n print(\\\"inside\\\")\\n between = True\\n break\\n if not between: \\n print((cx, cy), (tx, ty))\\n result += 1\\n return result\",\n \"runtime\": \"332\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n ans = 0\\n N = len(points)\\n\\n for i in range(N):\\n x, y = points[i]\\n for j in range(N):\\n r, c = points[j]\\n if r <= x and c >= y:\\n if j == i:\\n continue\\n lies = False\\n for k in range(N):\\n if k == i or k == j:\\n continue\\n a, b = points[k]\\n if a >= r and b <= c and a <= x and b >= y:\\n lies = True\\n \\n if not lies:\\n ans += 1\\n return ans\",\n \"runtime\": \"337\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n valid = 0\\n for i, (x1, y1) in enumerate(points):\\n for j, (x2, y2) in enumerate(points):\\n if i != j and x1 <= x2 and y1 >= y2:\\n not_in_fence = True\\n for k, (x, y) in enumerate(points):\\n if k != i and k != j and x1 <= x <= x2 and y2 <= y <= y1:\\n not_in_fence = False\\n if not_in_fence: valid += 1 \\n return valid\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n res = 0\\n\\n for i, (x1, y1) in enumerate(points):\\n for j, (x2, y2) in enumerate(points):\\n if i == j: continue\\n if x1 > x2 or y1 < y2: continue\\n\\n valid = True\\n for k, (x3, y3) in enumerate(points):\\n if k == i or k == j: continue\\n if x1 <= x3 <= x2 and y2 <= y3 <= y1:\\n valid = False\\n if valid:\\n res += 1\\n return res\\n\",\n \"runtime\": \"347\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n print(firstCorner)\\n print(secondCorner)\\n print(intersectingPoint)\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"runtime\": \"353\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n ans = 0\\n N = len(points)\\n\\n for i in range(N):\\n x, y = points[i]\\n for j in range(N):\\n r, c = points[j]\\n if r <= x and c >= y:\\n if j == i:\\n continue\\n lies = False\\n for k in range(N):\\n if k == i or k == j:\\n continue\\n a, b = points[k]\\n if a >= r and b <= c and a <= x and b >= y:\\n lies = True\\n \\n if not lies:\\n ans += 1\\n return ans\",\n \"runtime\": \"358\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n ans = 0\\n N = len(points)\\n\\n for i in range(N):\\n x, y = points[i]\\n for j in range(N):\\n r, c = points[j]\\n if r <= x and c >= y:\\n if j == i:\\n continue\\n lies = False\\n for k in range(N):\\n if k == i or k == j:\\n continue\\n a, b = points[k]\\n if a >= r and b <= c and a <= x and b >= y:\\n lies = True\\n # elif a <= x and b >= y:\\n # lies = True \\n \\n if not lies:\\n print(x, y, r, c)\\n ans += 1\\n return ans\",\n \"runtime\": \"363\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n print(firstCorner)\\n print(secondCorner)\\n print(intersectingPoint)\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"runtime\": \"368\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n print(firstCorner)\\n print(secondCorner)\\n print(intersectingPoint)\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"runtime\": \"373\"\n },\n {\n \"code\": \"from numpy import matrix,dot\\nclass Solution:\\n def numberOfPairs(self, pts: List[List[int]]) -> int:\\n o=0\\n n=len(pts)\\n pts=sorted(pts,key=lambda x:(x[0],-x[1]))\\n M=[[0 for i in range(n)]for j in range(n)]\\n def isbob(e,el):\\n xe,ye=e\\n xel,yel=el\\n return xel>=xe and yel<=ye\\n for i,e1 in enumerate(pts):\\n for j in range(i+1,n):\\n e2=pts[j]\\n M[i][j]=isbob(e1,e2)\\n M=matrix(M)\\n R=M-dot(M,M)\\n for i in range(n):\\n for j in range(i+1,n):\\n o+=(R[i,j]>0)\\n return o\",\n \"runtime\": \"379\"\n },\n {\n \"code\": \"# holy shit! brute?!\\nclass Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n = len(points)\\n if n == 2:\\n if not ((points[0][0] <= points[1][0] and points[0][1] >= points[1][1]) or (points[0][0] >= points[1][0] and points[0][1] <= points[1][1])):\\n return 0\\n else:\\n return 1\\n\\n def check(a, b, c, d, e, f) -> int: # A, B, C\\n if not ((a <= c and b >= d) or (a >= c and b <= d)):\\n return 0\\n if a <= c and b >= d and a <= e <= c and d <= f <= b:\\n return 0\\n if a >= c and b <= d and c <= e <= a and b <= f <= d:\\n return 0\\n return 1 \\n \\n r = 0\\n for i in range(n):\\n for j in range(i + 1, n): # risk of over counting if starts from 0\\n v = 1\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n if not check(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1]):\\n v = 0\\n break\\n if v:\\n r += 1\\n return r\",\n \"runtime\": \"384\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n self.nums = [[0 for _ in range(52)] for _ in range(52)]\\n\\n for x, y in points:\\n self.nums[y+1][x+1] += 1\\n\\n for i in range(1, 52):\\n for j in range(1, 52):\\n self.nums[i][j] += self.nums[i-1][j] + self.nums[i][j-1] - self.nums[i-1][j-1]\\n\\n def check(i, j):\\n if points[i][0] <= points[j][0] and points[i][1] >= points[j][1]:\\n return True\\n return False\\n\\n def find(i, j):\\n p = self.nums[points[i][1]+1][points[j][0]+1] - self.nums[points[j][1]][points[j][0]+1] - self.nums[points[i][1] + 1][points[i][0]] + self.nums[points[j][1]][points[i][0]]\\n return p\\n\\n N = len(points)\\n pairs = 0\\n for i in range(N):\\n for j in range(i+1, N):\\n if check(i, j):\\n if find(i, j) == 2:\\n pairs += 1\\n elif check(j, i):\\n if find(j, i) == 2:\\n pairs += 1\\n\\n return pairs\",\n \"runtime\": \"389\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":78,"string":"78"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPairs(self, v):\n n = len(v)\n ans = 0\n\n for i in range(n):\n x1, y1 = v[i][0], v[i][1]\n\n for j in range(n):\n if i == j:\n continue\n\n x2, y2 = v[j][0], v[j][1]\n f = 0\n\n if y1 >= y2 and x1 <= x2:\n for k in range(n):\n if k == i or k == j:\n continue\n\n x3, y3 = v[k][0], v[k][1]\n\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\n f = 1\n break\n\n if f == 0:\n ans += 1\n\n return ans\n\n ","memory":"16300"},{"code":"from collections import defaultdict\nclass Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n n=len(points)\n ans=0\n sorted_arr=sorted(points,key=lambda x:(x[0],-x[1]))\n # print(sorted_arr)\n \n def is_valid(y1,y2):\n if y1>=y2:\n return True\n return False\n\n for i in range(n):\n highest=-1\n y1=sorted_arr[i][1]\n for j in range(i+1,n):\n \n y2=sorted_arr[j][1]\n if is_valid(y1,y2) and highest==-1:\n highest=y2\n ans+=1\n continue\n if y2>highest and is_valid(y1,y2):\n\n ans+=1\n highest=y2\n continue\n return ans\n \n \n\n\n\n ","memory":"16400"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n \n def existAnyPointInside():\n for intersectingPoint in points:\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\n if (intersectingPoint != firstCorner and\n intersectingPoint != secondCorner and\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\n return True\n return False\n\n count = 0\n # consider each possible pair\n for firstCorner in points:\n x1, y1 = firstCorner[1], firstCorner[0]\n for secondCorner in points:\n x2, y2 = secondCorner[1], secondCorner[0]\n # test if it satisfy the rectangle constraint\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\n # if positive, test if any other point resides inside the rectangle\n if not existAnyPointInside():\n # if not, increment count\n count += 1\n # return count\n return count","memory":"16500"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n def isValid(a,b,i,j):\n x1,y1 = a[0],a[1]\n x2,y2 = b[0],b[1]\n for ind,point in enumerate(points):\n x,y = point[0],point[1]\n if (x>=x1 and x<=x2) and (y<=y1 and y>=y2) and ind!=i and ind!=j:\n return False\n return True\n\n count=0\n for i in range(len(points)):\n for j in range(len(points)):\n if i!=j and points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\n if isValid(points[i],points[j],i,j):\n count+=1\n return count","memory":"16500"},{"code":"class Solution:\n def numberOfPairs(self, points: List[List[int]]) -> int:\n points = [x[1] for x in sorted(points, key=lambda x: (x[0], -x[1]))]\n l = len(points)\n\n result = 0\n for i in range(l):\n y = points[i]\n b_min = -1\n for j in range(i+1, l):\n b = points[j]\n if b_min < b <= y:\n result += 1\n b_min = b\n return result","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, v):\\n n = len(v)\\n ans = 0\\n\\n for i in range(n):\\n x1, y1 = v[i][0], v[i][1]\\n\\n for j in range(n):\\n if i == j:\\n continue\\n\\n x2, y2 = v[j][0], v[j][1]\\n f = 0\\n\\n if y1 >= y2 and x1 <= x2:\\n for k in range(n):\\n if k == i or k == j:\\n continue\\n\\n x3, y3 = v[k][0], v[k][1]\\n\\n if x3 >= x1 and x3 <= x2 and y3 >= y2 and y3 <= y1:\\n f = 1\\n break\\n\\n if f == 0:\\n ans += 1\\n\\n return ans\\n\\n \",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n n=len(points)\\n ans=0\\n sorted_arr=sorted(points,key=lambda x:(x[0],-x[1]))\\n # print(sorted_arr)\\n \\n def is_valid(y1,y2):\\n if y1>=y2:\\n return True\\n return False\\n\\n for i in range(n):\\n highest=-1\\n y1=sorted_arr[i][1]\\n for j in range(i+1,n):\\n \\n y2=sorted_arr[j][1]\\n if is_valid(y1,y2) and highest==-1:\\n highest=y2\\n ans+=1\\n continue\\n if y2>highest and is_valid(y1,y2):\\n\\n ans+=1\\n highest=y2\\n continue\\n return ans\\n \\n \\n\\n\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n \\n def existAnyPointInside():\\n for intersectingPoint in points:\\n x3, y3 = intersectingPoint[1], intersectingPoint[0]\\n if (intersectingPoint != firstCorner and\\n intersectingPoint != secondCorner and\\n ((x3 <= x2 and x3 >= x1) and (y3 <= y1 and y3 >= y2))):\\n return True\\n return False\\n\\n count = 0\\n # consider each possible pair\\n for firstCorner in points:\\n x1, y1 = firstCorner[1], firstCorner[0]\\n for secondCorner in points:\\n x2, y2 = secondCorner[1], secondCorner[0]\\n # test if it satisfy the rectangle constraint\\n if (x1 < x2 and y1 >= y2 or x1 <= x2 and y1 > y2):\\n # if positive, test if any other point resides inside the rectangle\\n if not existAnyPointInside():\\n # if not, increment count\\n count += 1\\n # return count\\n return count\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n def isValid(a,b,i,j):\\n x1,y1 = a[0],a[1]\\n x2,y2 = b[0],b[1]\\n for ind,point in enumerate(points):\\n x,y = point[0],point[1]\\n if (x>=x1 and x<=x2) and (y<=y1 and y>=y2) and ind!=i and ind!=j:\\n return False\\n return True\\n\\n count=0\\n for i in range(len(points)):\\n for j in range(len(points)):\\n if i!=j and points[i][0]<=points[j][0] and points[i][1]>=points[j][1]:\\n if isValid(points[i],points[j],i,j):\\n count+=1\\n return count\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, points: List[List[int]]) -> int:\\n points = [x[1] for x in sorted(points, key=lambda x: (x[0], -x[1]))]\\n l = len(points)\\n\\n result = 0\\n for i in range(l):\\n y = points[i]\\n b_min = -1\\n for j in range(i+1, l):\\n b = points[j]\\n if b_min < b <= y:\\n result += 1\\n b_min = b\\n return result\",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":5,"string":"5"}}},{"rowIdx":2442,"cells":{"question_id":{"kind":"number","value":3265,"string":"3,265"},"name":{"kind":"string","value":"maximum-good-subarray-sum"},"content":{"kind":"string","value":"<p>You are given an array <code>nums</code> of length <code>n</code> and a <strong>positive</strong> integer <code>k</code>.</p>\n\n<p>A <span data-keyword=\"subarray-nonempty\">subarray</span> of <code>nums</code> is called <strong>good</strong> if the <strong>absolute difference</strong> between its first and last element is <strong>exactly</strong> <code>k</code>, in other words, the subarray <code>nums[i..j]</code> is good if <code>|nums[i] - nums[j]| == k</code>.</p>\n\n<p>Return <em>the <strong>maximum</strong> sum of a <strong>good</strong> subarray of </em><code>nums</code>. <em>If there are no good subarrays</em><em>, return </em><code>0</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,2,3,4,5,6], k = 1\n<strong>Output:</strong> 11\n<strong>Explanation:</strong> The absolute difference between the first and last element<!-- notionvc: 2a6d66c9-0149-4294-b267-8be9fe252de9 --> must be 1 for a good subarray. All the good subarrays are: [1,2], [2,3], [3,4], [4,5], and [5,6]. The maximum subarray sum is 11 for the subarray [5,6].\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [-1,3,2,4,5], k = 3\n<strong>Output:</strong> 11\n<strong>Explanation:</strong> The absolute difference between the first and last element<!-- notionvc: 2a6d66c9-0149-4294-b267-8be9fe252de9 --> must be 3 for a good subarray. All the good subarrays are: [-1,3,2], and [2,4,5]. The maximum subarray sum is 11 for the subarray [2,4,5].\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [-1,-2,-3,-4], k = 2\n<strong>Output:</strong> -6\n<strong>Explanation:</strong> The absolute difference between the first and last element<!-- notionvc: 2a6d66c9-0149-4294-b267-8be9fe252de9 --> must be 2 for a good subarray. All the good subarrays are: [-1,-2,-3], and [-2,-3,-4]. The maximum subarray sum is -6 for the subarray [-1,-2,-3].\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>1 <= k <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":19.128320411065744,"string":"19.12832"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table","prefix-sum"],"string":"[\n \"array\",\n \"hash-table\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"795\", 0.1716], [\"799\", 0.0858], [\"803\", 1.0292000000000001], [\"808\", 0.4289], [\"812\", 0.42889999999999995], [\"816\", 0.9435], [\"821\", 0.6003999999999999], [\"825\", 0.8577], [\"829\", 1.1149], [\"834\", 1.4579999999999997], [\"838\", 1.0291000000000001], [\"842\", 1.8010000000000002], [\"847\", 1.1149], [\"851\", 2.144], [\"855\", 1.5437999999999998], [\"860\", 2.0583], [\"864\", 2.5728999999999997], [\"868\", 1.8868], [\"873\", 2.3156], [\"877\", 3.2588999999999997], [\"881\", 3.6877999999999997], [\"886\", 3.0873999999999997], [\"890\", 3.8594], [\"894\", 3.4306], [\"899\", 3.0875], [\"903\", 2.1441], [\"907\", 3.3448000000000007], [\"912\", 2.3156000000000003], [\"916\", 2.916], [\"920\", 2.1441], [\"925\", 1.0292000000000001], [\"929\", 1.6295], [\"933\", 1.8010000000000002], [\"938\", 1.3721999999999999], [\"942\", 1.1149], [\"946\", 0.8576], [\"951\", 0.8578000000000001], [\"955\", 0.5145000000000001], [\"959\", 1.0292000000000001], [\"964\", 0.8575999999999999], [\"968\", 1.2865], [\"973\", 0.8575999999999999], [\"977\", 0.42880000000000007], [\"981\", 0.6861999999999999], [\"986\", 0.6004999999999999], [\"990\", 0.6860999999999999], [\"994\", 0.8575999999999999], [\"999\", 1.3721999999999999], [\"1003\", 0.6003], [\"1007\", 1.115], [\"1012\", 1.2865], [\"1016\", 1.1149999999999998], [\"1020\", 0.6861], [\"1025\", 1.458], [\"1029\", 1.4581], [\"1033\", 0.7718999999999999], [\"1038\", 1.458], [\"1042\", 0.7719], [\"1046\", 0.5147], [\"1051\", 0.3432], [\"1055\", 1.2006999999999999], [\"1059\", 0.6005], [\"1064\", 0.6003999999999999], [\"1068\", 0.42880000000000007], [\"1072\", 0.9433], [\"1077\", 0.2574], [\"1081\", 0.3431], [\"1085\", 0.5147], [\"1090\", 0.5146999999999999], [\"1094\", 0.42880000000000007], [\"1098\", 0.1716], [\"1103\", 0.6004], [\"1107\", 0.1716], [\"1111\", 0.3431], [\"1116\", 0.1716], [\"1120\", 0.0858], [\"1124\", 0.25730000000000003], [\"1129\", 0.4288], [\"1133\", 0.3432], [\"1137\", 0.0858]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"29100\", 0.0858], [\"29400\", 0.1715], [\"29700\", 0.3431], [\"29800\", 0.0858], [\"30000\", 0.1715], [\"30200\", 0.4288], [\"30300\", 0.9434], [\"30400\", 17.4957], [\"30500\", 20.5832], [\"30600\", 16.4666], [\"30700\", 6.0034], [\"30800\", 3.9451], [\"30900\", 0.8576], [\"31000\", 1.0292], [\"31100\", 1.3722], [\"31200\", 0.2573], [\"31300\", 0.1715], [\"31400\", 0.5146], [\"31500\", 0.1715], [\"31700\", 0.2573], [\"31800\", 0.1715], [\"31900\", 0.0858], [\"32299\", 0.1715], [\"32500\", 0.0858], [\"32600\", 0.0858], [\"32900\", 0.0858], [\"33000\", 0.0858], [\"33800\", 0.1715], [\"34000\", 0.0858], [\"34700\", 0.2573], [\"35000\", 0.0858], [\"35100\", 0.0858], [\"35300\", 0.2573], [\"35400\", 0.0858], [\"35500\", 0.1715], [\"35600\", 3.1732], [\"35700\", 9.5197], [\"35800\", 4.5455], [\"36100\", 0.2573], [\"36200\", 0.2573], [\"36700\", 0.0858], [\"36800\", 0.0858], [\"37000\", 0.5146], [\"37100\", 0.0858], [\"37200\", 0.0858], [\"37300\", 0.0858], [\"37400\", 0.1715], [\"37500\", 0.6003], [\"37600\", 1.2864], [\"37700\", 0.7719], [\"38300\", 0.0858]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n result = -math.inf\n prefix = 0\n numToPrefix = {}\n for num in nums:\n if num not in numToPrefix or numToPrefix[num] > prefix:\n numToPrefix[num] = prefix\n prefix += num\n if num + k in numToPrefix:\n result = max(result, prefix - numToPrefix[num + k])\n if num - k in numToPrefix:\n result = max(result, prefix - numToPrefix[num - k])\n return 0 if result == -math.inf else result\n","runtime":"795"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n isum = 0\n psum = {} # v: min prefix sum with end=v\n imax = -10**15\n for v in nums:\n isum += v\n if v-k in psum:\n imax = max(imax,isum-psum[v-k]+v-k)\n if v+k in psum:\n imax = max(imax,isum-psum[v+k]+v+k)\n if v not in psum or psum[v]>isum:\n psum[v] = isum\n #\n if imax==-10**15: return 0\n return imax","runtime":"795"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n allSum = 0\n prefixSums = {}\n highestSum = float('-inf')\n\n for i in range(len(nums)):\n allSum += nums[i]\n\n first_num = k + nums[i]\n if first_num in prefixSums:\n subarray_sum = allSum - prefixSums[first_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n\n second_num = -k + nums[i]\n if second_num in prefixSums:\n subarray_sum = allSum - prefixSums[second_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n if nums[i] in prefixSums:\n if allSum - nums[i] < prefixSums[nums[i]]:\n prefixSums[nums[i]] = allSum - nums[i]\n else:\n prefixSums[nums[i]] = allSum - nums[i]\n \n return highestSum if highestSum != float('-inf') else 0\n","runtime":"812"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n d_cum = dict()\n \n res = -float('inf')\n prefix_sum = 0\n for num in nums:\n if num in d_cum:\n d_cum[num] = min(d_cum[num],prefix_sum)\n else:\n d_cum[num] = prefix_sum\n prefix_sum +=num\n\n dif1 = num+k\n dif2 = num-k\n if dif1 in d_cum:\n res = max(res,prefix_sum-d_cum[dif1])\n\n if dif2 in d_cum:\n res = max(res,prefix_sum-d_cum[dif2])\n \n\n return res if res!= -float('inf') else 0\n \n ","runtime":"812"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -math.inf\n prefix = 0\n numToMinPrefix = {}\n\n for num in nums:\n if num not in numToMinPrefix or numToMinPrefix[num] > prefix:\n numToMinPrefix[num] = prefix\n prefix += num\n if num + k in numToMinPrefix:\n ans = max(ans, prefix - numToMinPrefix[num + k])\n if num - k in numToMinPrefix:\n ans = max(ans, prefix - numToMinPrefix[num - k])\n\n return 0 if ans == -math.inf else ans","runtime":"816"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n res = float('-inf')\n currSum = 0\n prefixMap = dict()\n\n for i, num in enumerate(nums):\n\n if num not in prefixMap or currSum < prefixMap[num]:\n prefixMap[num] = currSum\n \n currSum += num\n\n if num + k in prefixMap:\n res = max (res, currSum - prefixMap[num+k])\n if num - k in prefixMap:\n res = max(res, currSum - prefixMap[num-k])\n \n\n return 0 if res == float('-inf') else res\n","runtime":"816"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n# mp = {}\n# res, sumVal = 0, 0 \n \n# for idx, num in enumerate(nums):\n \n# if num not in mp or mp[num] > sumVal:\n# mp[num] = sumVal\n \n# sumVal += num\n \n# if num - k in mp:\n# res = max(res, abs(sumVal - mp[num-k]))\n \n# if num + k in mp:\n# res = max(res, sumVal - mp[num+k])\n# return res\n\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\n sumVal, res = 0, -math.inf\n \n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\n mp = {}\n \n # Iterate through each number num in nums\n for idx, num in enumerate(nums):\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\n if num not in mp or mp[num] > sumVal:\n mp[num] = sumVal\n \n # Update sumVal by adding num to it, representing the running sum up to the current number\n sumVal += num\n \n # Check if num - k exists in mp\n if num - k in mp:\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\n res = max(sumVal - mp[num - k], res)\n \n # Check if num + k exists in mp\n if num + k in mp:\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\n res = max(sumVal - mp[num + k], res)\n \n # Return res if it is not equal to negative infinity, otherwise return 0\n return res if res != -math.inf else 0","runtime":"821"},{"code":"\ndef mgs(nums, k):\n n = len(nums)\n\n \n hsh = {}\n rsum = 0\n maxi = None\n update_max = lambda val: max(val, maxi) if maxi is not None else val\n\n for i in range(n):\n el = nums[i]\n\n if el - k in hsh:\n val = rsum + el - hsh[el - k]\n maxi = update_max(val)\n if el + k in hsh:\n val = rsum + el - hsh[el + k]\n maxi = update_max(val)\n \n # store the prefix sum till el before\n if el not in hsh or hsh[el] > rsum:\n hsh[el] = rsum\n rsum += el\n\n return maxi if maxi is not None else 0\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n return mgs(nums, k)","runtime":"821"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n curSum, res = 0, -math.inf\n mp = {}\n\n for idx, num in enumerate(nums):\n if num not in mp or curSum < mp[num]:\n mp[num] = curSum\n\n curSum += num\n\n if num - k in mp:\n res = max(curSum - mp[num - k], res)\n\n if num + k in mp:\n res = max(curSum - mp[num + k], res)\n\n return res if res != -math.inf else 0\n","runtime":"825"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n minPrefSum = dict()\n currentSum = 0\n \n bestSum = -math.inf \n \n for val in nums:\n if val in minPrefSum:\n minPrefSum[val] = min(minPrefSum[val], currentSum)\n else:\n minPrefSum[val] = currentSum\n currentSum += val\n \n if val + k in minPrefSum:\n bestSum = max(bestSum, currentSum - minPrefSum[val + k])\n \n if val - k in minPrefSum:\n bestSum = max(bestSum, currentSum - minPrefSum[val - k]) \n \n \n \n \n return bestSum if bestSum > -math.inf else 0 ","runtime":"825"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n s = 0\n psum = [0]\n idxDict = {}\n ans = -float('inf')\n\n for idx, n in enumerate(nums):\n s += n\n psum.append(s)\n\n if n - k in idxDict:\n ans = max(s - psum[idxDict[n - k]], ans)\n if n + k in idxDict:\n ans = max(s - psum[idxDict[n + k]], ans)\n if n not in idxDict or psum[idxDict[n]] > psum[-2]:\n idxDict[n] = idx\n\n return ans if ans != -float('inf') else 0","runtime":"829"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = float('-inf')\n \n preSum = defaultdict(int) # stores {num: max agg values ending at num}\n agg = 0\n\n for num in nums:\n agg += num\n\n # if num + k seen before in preSum, then num + k - num = k\n # so the total sum between them is agg - preSum[num + k]\n if num + k in preSum:\n head = num + k\n res = max(res, agg - preSum[num + k] + head)\n\n # if num - k seen before in preSum, then num - (num - k) = k\n # so the total sum between them is agg - preSum[num - k]\n if num - k in preSum:\n head = num - k\n res = max(res, agg - preSum[num - k] + head)\n\n # map current num to agg value \n if num not in preSum:\n preSum[num] = agg\n else:\n preSum[num] = min(preSum[num], agg)\n\n return res if res != float('-inf') else 0","runtime":"829"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # prefix sum\n prefix_dt = {}\n cur_sum = 0\n ans = float(\"-inf\")\n for n in nums:\n cur_sum += n\n if n+k in prefix_dt:\n ans = max(ans, cur_sum + n + k - prefix_dt[n+k])\n if n-k in prefix_dt:\n ans = max(ans, cur_sum + n - k - prefix_dt[n-k])\n if n not in prefix_dt:\n prefix_dt[n] = cur_sum\n else:\n prefix_dt[n] = min(prefix_dt[n], cur_sum)\n #print(prefix_dt)\n return ans if ans != float(\"-inf\") else 0\n\n # two pointers\n max_sum = 0\n ans = float(\"-inf\")\n for i in range(len(nums)):\n prefix = nums[i]\n for j in range(i+1, len(nums)):\n prefix += nums[j]\n if abs(nums[i] - nums[j]) == k:\n ans = max(ans, prefix)\n return ans if ans != float(\"-inf\") else 0\n","runtime":"834"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixes = {}\n currSum = 0\n ans = -inf\n\n for num in nums:\n if num in prefixes:\n prefixes[num] = min(prefixes[num],currSum)\n else:\n prefixes[num] = currSum\n currSum+=num\n if num-k in prefixes:\n ans = max(ans,currSum - prefixes[num-k])\n if num+k in prefixes:\n ans = max(ans,currSum - prefixes[num+k])\n\n return ans if ans > -inf else 0","runtime":"834"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [0] + list(accumulate(nums))\n ans = -float('inf')\n m = {}\n for i, x in enumerate(nums):\n if x - k in m:\n ans = max(ans, prefix[i+1] - prefix[m[x-k]])\n if k + x in m:\n ans = max(ans, prefix[i+1] - prefix[m[k+x]])\n if x not in m or prefix[m[x]] > prefix[i]:\n m[x] = i\n return ans if ans != -float('inf') else 0\n ","runtime":"838"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n '''\n 1. Calculate the sum of the array\n '''\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\n sumVal, res = 0, -math.inf\n \n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\n mp = {}\n \n # Iterate through each number num in nums\n for idx, num in enumerate(nums):\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\n if num not in mp or mp[num] > sumVal:\n mp[num] = sumVal\n \n # Update sumVal by adding num to it, representing the running sum up to the current number\n sumVal += num\n \n # Check if num - k exists in mp\n if num - k in mp:\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\n res = max(sumVal - mp[num - k], res)\n \n # Check if num + k exists in mp\n if num + k in mp:\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\n res = max(sumVal - mp[num + k], res)\n \n # Return res if it is not equal to negative infinity, otherwise return 0\n return res if res != -math.inf else 0","runtime":"838"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n #currsum - prefix_sum is the sum of the curr subarray\n curr_sum = 0 \n # max_sum tracks the best sum\n max_sum = float('-inf')\n # use hashmap (number, prefix sum) to keep track of the array we saw\n hashmap = dict()\n # loop through the array to add to hashmap\n\n for num in nums:\n prefix_sum = curr_sum\n curr_sum += num\n if k+num in hashmap:\n max_sum = max(max_sum,curr_sum-hashmap[k+num])\n if num-k in hashmap:\n max_sum = max(max_sum,curr_sum-hashmap[num-k])\n \n if num in hashmap:\n hashmap[num]=min(hashmap[num],prefix_sum)\n else:\n hashmap[num] = prefix_sum\n \n return max_sum if max_sum>float('-inf') else 0\n\n ","runtime":"842"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n allSum = 0\n prefixSums = {}\n highestSum = float('-inf')\n\n for i in range(len(nums)):\n allSum += nums[i]\n\n first_num = k + nums[i]\n if first_num in prefixSums:\n subarray_sum = allSum - prefixSums[first_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n\n second_num = -k + nums[i]\n if second_num in prefixSums:\n subarray_sum = allSum - prefixSums[second_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n if nums[i] in prefixSums:\n if allSum - nums[i] < prefixSums[nums[i]]:\n prefixSums[nums[i]] = allSum - nums[i]\n else:\n prefixSums[nums[i]] = allSum - nums[i]\n \n return highestSum if highestSum != float('-inf') else 0\n","runtime":"842"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n allSum = 0\n prefixSums = {}\n highestSum = float('-inf')\n\n for i in range(len(nums)):\n allSum += nums[i]\n\n first_num = k + nums[i]\n # if highestSum > 155:\n # print(f' nums[i {nums[i]}')\n # print(f'allSum {allSum}')\n # print(prefixSums)\n # print(f'first_num {first_num}')\n if first_num in prefixSums:\n # print('first num in')\n subarray_sum = allSum - prefixSums[first_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n \n \n second_num = -k + nums[i]\n # print(f'second_num {second_num}')\n if second_num in prefixSums:\n # print('second num in')\n subarray_sum = allSum - prefixSums[second_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n # print(f'highestSum {highestSum}')\n if nums[i] in prefixSums:\n if allSum - nums[i] < prefixSums[nums[i]]:\n prefixSums[nums[i]] = allSum - nums[i]\n else:\n prefixSums[nums[i]] = allSum - nums[i]\n \n return highestSum if highestSum != float('-inf') else 0\n\n \n \n\n","runtime":"847"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n curr = 0\n n = len(nums)\n # maybe store minimum presum value?\n dic = {}\n maxim = float('-inf')\n for idx, i in enumerate(nums):\n dic[i] = min(dic[i], curr) if i in dic else curr\n curr += i\n if i+k in dic:\n maxim = max(maxim, curr - dic[i+k])\n if i-k in dic:\n maxim = max(maxim, curr - dic[i-k])\n\n \n \n return maxim if maxim != float('-inf') else 0\n \n\n \n","runtime":"847"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n s = 0\n psum = [0]\n idxDict = {} # keeps track of the idx in which a certain prefix sum was found\n ans = -float('inf')\n\n for idx, n in enumerate(nums):\n prevSum = s\n s += n\n psum.append(s)\n smallerDiff = n - k\n biggerDiff = n + k\n\n if smallerDiff in idxDict:\n smallDiffIdx = idxDict[smallerDiff]\n ans = max(s - psum[smallDiffIdx], ans)\n if n + k in idxDict:\n bigDiffIdx = idxDict[biggerDiff]\n ans = max(s - psum[bigDiffIdx], ans)\n if n not in idxDict or psum[idxDict[n]] > prevSum:\n idxDict[n] = idx\n\n return ans if ans != -float('inf') else 0","runtime":"851"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n allSum = 0\n prefixSums = {}\n highestSum = float('-inf')\n\n for i in range(len(nums)):\n allSum += nums[i]\n\n first_num = k + nums[i]\n if first_num in prefixSums:\n subarray_sum = allSum - prefixSums[first_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n \n \n second_num = -k + nums[i]\n if second_num in prefixSums:\n subarray_sum = allSum - prefixSums[second_num]\n if subarray_sum > highestSum:\n highestSum = subarray_sum\n if nums[i] in prefixSums:\n if allSum - nums[i] < prefixSums[nums[i]]:\n prefixSums[nums[i]] = allSum - nums[i]\n else:\n prefixSums[nums[i]] = allSum - nums[i]\n \n return highestSum if highestSum != float('-inf') else 0\n","runtime":"851"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # Forming the prefix sum\n temp_sum = 0 # Initialize a running sum variable\n prefix_sum = [0] # Prefix sum array, starting with 0 for easier calculations\n for num in nums:\n temp_sum += num\n prefix_sum.append(temp_sum)\n \n \n seen = {} # Dictionary to store the latest index of each number\n res = -float('inf') # Initialize result to negative infinity to track the maximum\n for right, num in enumerate(nums):\n \n if (num - k) in seen:\n left = seen[num - k]\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\n res = max(res, subarray_sum)\n \n if (num + k) in seen:\n left = seen[num + k]\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\n res = max(res, subarray_sum)\n \n # Update the dictionary with the current number and its index\n # If this number hasn't been seen before, or the current prefix sum is larger than\n # the one at the stored index, update the dictionary\n if num not in seen or prefix_sum[seen[num]] >= prefix_sum[right]:\n seen[num] = right\n \n # Return the result, if it hasn't changed return 0 (indicating no subarray found)\n return res if res != -float('inf') else 0","runtime":"855"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # from collections import defaultdict\n # maxsum = float('-inf')\n # hashmap = defaultdict(list)\n # prefixsum = defaultdict(int)\n # presum = 0\n # # for i in range(len(nums)):\n \n # for i in range(len(nums)):\n # hashmap[nums[i]].append(i)\n # presum += nums[i]\n # prefixsum[i] = presum\n # if k + nums[i] in hashmap:\n # for index in hashmap[k + nums[i]]:\n # m, n = min(index, i), max(index, i)\n # maxsum = max(maxsum, prefixsum[n] - (prefixsum[m - 1] if m > 0 else 0))\n # if - k + nums[i] in hashmap:\n # for index in hashmap[- k + nums[i]]:\n # m, n = min(index, i), max(index, i)\n # maxsum = max(maxsum, prefixsum[n] - (prefixsum[m - 1] if m > 0 else 0)) \n # return maxsum if maxsum != float('-inf') else 0\n\n n = len(nums)\n prefix_sum = [0] * (n + 1)\n for i, num in enumerate(nums):\n prefix_sum[i + 1] = prefix_sum[i] + num\n seen = {}\n ans = float('-inf')\n for i, num in enumerate(nums):\n if num - k in seen:\n j = seen[num - k]\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\n if num + k in seen:\n j = seen[num + k]\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\n if num in seen:\n j = seen[num]\n if prefix_sum[i] - prefix_sum[j] < 0:\n seen[num] = i\n else:\n seen[num] = i\n return ans if ans > float('-inf') else 0\n\n ","runtime":"855"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # Forming the prefix sum\n temp_sum = 0 # Initialize a running sum variable\n prefix_sum = [0] # Prefix sum array, starting with 0 for easier calculations\n for num in nums:\n temp_sum += num\n prefix_sum.append(temp_sum)\n \n \n seen = {} # Dictionary to store the latest index of each number\n res = -float('inf') # Initialize result to negative infinity to track the maximum\n for right, num in enumerate(nums):\n \n if (num - k) in seen:\n left = seen[num - k]\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\n res = max(res, subarray_sum)\n \n if (num + k) in seen:\n left = seen[num + k]\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\n res = max(res, subarray_sum)\n \n # Update the dictionary with the current number and its index\n # If this number hasn't been seen before, or the current prefix sum is larger than\n # the one at the stored index, update the dictionary\n if num not in seen or prefix_sum[seen[num]] >= prefix_sum[right]:\n seen[num] = right\n \n # Return the result, if it hasn't changed return 0 (indicating no subarray found)\n return res if res != -float('inf') else 0","runtime":"860"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # questions: duplicate values? --> YES THERE ARE\n # edge cases: 0, 1, or 2 elements --> looks like min length will be 2 elems\n # brute force: look through each pair of values and check if their abs difference is k\n # - keep track of those indices\n # - get everything in between and sum it up\n # - nested loops needed -> O(n^2)\n # another idea:\n # - hash table where key is the integer and value is the index in the original nums array\n # - loop through the nums array once\n # - find what number is necessary for the difference to be k\n # - if that number exists in the dictionary, keep track of the index pair (i, j)\n # - loop through index pairs and find the max sum of the sub array\n # - time: O(n), space: O(n)\n # ^^^^ DIDNT WORK BC DOESNT DEAL WITH DUPLICATES\n # solution:\n # - hash table where key is the integer num and value is the current minimum prefix sum\n # - update current good subarray max sum for every num we traverse through\n\n n = len(nums)\n prefix_sum = [0] * (n + 1)\n for i, num in enumerate(nums):\n prefix_sum[i + 1] = prefix_sum[i] + num\n\n seen = {}\n ans = float('-inf')\n\n for i, num in enumerate(nums):\n if num - k in seen:\n j = seen[num - k]\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j]) # prefix sum is [i + 1] bc we have an extra 0 at the beginning of our prefix sum list\n if num + k in seen:\n j = seen[num + k]\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\n if num in seen:\n j = seen[num]\n # only update the index of the number if it will contribute to max sum\n if prefix_sum[i] < prefix_sum[j]:\n seen[num] = i\n else:\n seen[num] = i\n return ans if ans > float('-inf') else 0\n","runtime":"860"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pre_sum = []\n cur_sum = 0\n for num in nums:\n cur_sum += num\n pre_sum.append(cur_sum)\n\n num_index = {}\n result = float('-inf')\n for i, num in enumerate(nums):\n small = num - k\n large = num + k\n if small in num_index:\n prev = num_index[small] - 1\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\n result = max(result, ps)\n if large in num_index:\n prev = num_index[large] - 1\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\n result = max(result, ps)\n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\n continue\n else:\n num_index[num] = i\n \n return result if result != float('-inf') else 0\n","runtime":"864"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # prefix sum\n prefix = {}\n res = -float('inf')\n curr = 0\n for num in nums:\n for t in (num+k, num-k):\n if t in prefix:\n res = max(res, curr+num-prefix[t])\n if num not in prefix or prefix[num] >= curr:\n prefix[num] = curr\n curr += num\n return res if res != -float('inf') else 0\n\n ","runtime":"864"},{"code":"# import math\n\n# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# max_sum = -math.inf\n# hashmap = {}\n\n# n = len(nums)\n# prefix_sum = [nums[0]] * n\n# for i in range(1, n):\n# prefix_sum[i] = prefix_sum[i-1] + nums[i]\n \n# for i in range(n):\n# if nums[i] not in hashmap:\n# hashmap[nums[i]] = i\n# target_list = [nums[i] + k, nums[i] - k]\n# for target in target_list:\n# if target in hashmap:\n# y = hashmap[target]\n# s = i if i < y else y\n# t = y if i < y else i\n# max_sum = max(max_sum, prefix_sum[t] - prefix_sum[s] + nums[s])\n\n# return max_sum\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n indexMap = {}\n prefixSum = [0]\n ans = float('-inf')\n\n for i,num in enumerate(nums):\n if num not in indexMap or prefixSum[indexMap[num]]>prefixSum[-1]:\n indexMap[num] = i\n currSum = prefixSum[-1]+num\n prefixSum.append(currSum)\n\n if k+num in indexMap:\n index = indexMap[k+num]\n ans = max(ans,currSum-prefixSum[index])\n\n if -k+num in indexMap:\n index = indexMap[-k+num]\n ans = max(ans,currSum-prefixSum[index])\n\n return 0 if ans==float('-inf') else ans\n\n\n ","runtime":"868"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n sums = []\n s = 0\n for i in nums:\n s += i\n sums.append(s)\n # print(sums)\n d = dict()\n ret = -9999999999999999999999999999999999999999\n for i in range(0, len(nums)):\n if nums[i]+k in d:\n p = d.get(nums[i]+k)\n # print(i, p)\n ret = max(ret, sums[i] - sums[p] + nums[p])\n if nums[i]-k in d:\n p = d.get(nums[i]-k)\n # print(i, p)\n ret = max(ret, sums[i] - sums[p] + nums[p])\n if nums[i] in d:\n p = d.get(nums[i])\n d[nums[i]] = i if sums[i] < sums[p] else p\n else:\n d[nums[i]] = i\n\n return 0 if ret == -9999999999999999999999999999999999999999 else ret\n \n","runtime":"868"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -float('inf')\n prefix_sums = {nums[0]: 0}\n current_sum = 0\n for i, num in enumerate(nums):\n current_sum += num\n if num - k in prefix_sums:\n ans = max(ans, current_sum - prefix_sums[num - k])\n if num + k in prefix_sums:\n ans = max(ans, current_sum - prefix_sums[num + k])\n if i + 1 < len(nums) and (nums[i + 1] not in prefix_sums or prefix_sums[nums[i + 1]] > current_sum):\n prefix_sums[nums[i + 1]] = current_sum\n return 0 if ans == -inf else ans\n \n \n \n\n\n ","runtime":"873"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = {}\n current_sum = 0\n result = -math.inf\n\n for num in nums:\n if num in prefix_sum:\n prefix_sum[num] = min(prefix_sum[num], current_sum)\n else:\n prefix_sum[num] = current_sum\n \n current_sum += num\n\n for y in [num + k, num - k]:\n if y in prefix_sum:\n result = max(result, current_sum - prefix_sum[y])\n \n return result if result != -math.inf else 0\n\n\n\n\n \n\n\n\n\n \n\n \n\n ","runtime":"873"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = float('-inf')\n psum = [0]\n m = defaultdict(int)\n \n for i in range(len(nums)):\n psum.append(psum[-1] + nums[i]) # Prefix Sum\n \n if nums[i] - k in m:\n res = max(res, psum[i + 1] - psum[m[nums[i] - k]]) # nums[i] - k\n if nums[i] + k in m:\n res = max(res, psum[i + 1] - psum[m[nums[i] + k]]) # nums[i] + k\n \n if nums[i] not in m or psum[i] - psum[m[nums[i]]] <= 0:\n m[nums[i]] = i # Kadane-like logic\n \n return 0 if res == float('-inf') else res\n","runtime":"877"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n preSum = [0 for _ in range(len(nums))]\n preSum[0] = nums[0]\n for i in range(1, len(nums)):\n preSum[i] = preSum[i-1]+nums[i]\n \n store = {}\n\n ans = float(\"-inf\")\n\n for i in range(len(nums)):\n curNum = nums[i]\n complement1 = k + curNum\n complement2 = curNum - k\n\n if complement1 in store:\n sum = preSum[i] - preSum[store[complement1]] + complement1\n ans = max(ans, sum)\n\n if complement2 in store:\n sum = preSum[i] - preSum[store[complement2]] + complement2\n ans = max(ans, sum)\n\n if nums[i] not in store:\n store[nums[i]] = i\n else:\n if preSum[i] < preSum[store[nums[i]]]:\n store[nums[i]] = i\n return 0 if ans == float(\"-inf\") else ans\n ","runtime":"877"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = float('-inf') # Initialize the result with negative infinity\n psum = [0] # Prefix sum list, initialized with 0\n m = {} # Dictionary to store the index of certain values of nums\n\n for i in range(len(nums)):\n psum.append(psum[-1] + nums[i]) # Update prefix sum\n\n # Check if nums[i] - k exists in the map\n if nums[i] - k in m:\n res = max(res, psum[i + 1] - psum[m[nums[i] - k]])\n\n # Check if nums[i] + k exists in the map\n if nums[i] + k in m:\n res = max(res, psum[i + 1] - psum[m[nums[i] + k]])\n\n # Only update the map if either the value doesn't exist or the current subarray is \"better\"\n if nums[i] not in m or psum[i] - psum[m[nums[i]]] <= 0:\n m[nums[i]] = i # Store the index of the current number\n \n # Return the result, if no valid subarray was found, return 0\n return 0 if res == float('-inf') else res\n","runtime":"881"},{"code":"import math\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n \n di = {}\n \n ans = -math.inf\n \n pre = [0 for i in range(n)]\n \n pre[0] = nums[0]\n \n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n \n # print(pre)\n \n i = 0\n f = -1\n for x in nums:\n \n if(x-k in di):\n f = 1\n y = di[x-k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n if(x+k in di):\n f = 1\n y = di[x+k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n \n if(x in di):\n curr = 0\n if(di[x] == 0):\n curr = 0\n else:\n curr = di[x]-1\n \n if(pre[curr] > pre[i-1]):\n di[x] = i\n else:\n di[x] = i\n \n i += 1\n \n if(f == -1):\n ans = 0\n \n return ans","runtime":"881"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n runSum=0\n preSum=[0]\n keyDic = {}\n result = -math.inf\n for i, val in enumerate(nums):\n runSum+=val\n preSum.append(runSum)\n if keyDic.get(val-k)!=None: result = max(result, runSum-preSum[keyDic[val-k]])\n if keyDic.get(val+k)!=None: result = max(result, runSum-preSum[keyDic[val+k]])\n if keyDic.get(val)==None or preSum[keyDic[val]]>preSum[-2]: \n keyDic[val]=i\n # print(keyDic)\n return result if result != -math.inf else 0\n\n\n\n\n","runtime":"886"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n min_prefix_sum = {}\n ans= -float('inf')\n running_sum = 0 \n \n for num in nums:\n\n if num in min_prefix_sum:\n min_prefix_sum[num] = min(min_prefix_sum[num],running_sum)\n else:\n min_prefix_sum[num]= running_sum\n \n running_sum += num\n\n for target_sum in [num+k,num-k]:\n if target_sum in min_prefix_sum:\n ans = max(ans, running_sum - min_prefix_sum[target_sum])\n return ans if ans != -float('inf') else 0\n \n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # approach 1 : Brute force \n # ans = -float(\"inf\") \n # for st in range(len(nums)):\n # for end in range(st+1,len(nums)):\n # if abs(nums[st]-nums[end])==k:\n # ans = max(ans,sum(nums[st:end+1]))\n # return ans if ans != -float('inf') else 0\n\n # approach 2:\n\n ans = -float('inf')\n ps_map = {} # minimum prefix sum map for number \"num\"\n running_sum = 0\n \n for num in nums:\n\n if num in ps_map:\n ps_map[num] = min(ps_map[num],running_sum)\n else:\n ps_map[num] = running_sum\n\n running_sum += num\n\n for y in [num-k,num+k]:\n if y in ps_map:\n ans = max(ans,running_sum - ps_map[y])\n \n return ans if ans!= -float('inf') else 0\n\n \n \n\n ","runtime":"886"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n di = {}\n ans = float('-inf')\n pre = [0 for i in range(n)]\n pre[0] = nums[0]\n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n \n i = 0\n f = -1\n for x in nums:\n if(x-k in di):\n f = 1\n y = di[x-k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n if(x+k in di):\n f = 1\n y = di[x+k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n\n if(x in di):\n curr = 0\n if(di[x] == 0):\n curr = 0\n else:\n curr = di[x]-1 \n if(pre[curr] > pre[i-1]):\n di[x] = i\n else:\n di[x] = i\n \n i += 1\n \n if(f == -1):\n ans = 0\n \n return ans\n\n\n","runtime":"890"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n sums, currentSum = [0], 0\n for num in nums:\n currentSum += num\n sums.append(currentSum)\n \n ind, maxSum = dict(), -float('inf')\n for i, num in enumerate(nums):\n for diff in [k, -k]:\n if num+diff in ind:\n maxSum = max(maxSum, sums[i+1]-sums[ind[num+diff]])\n \n if num not in ind or sums[ind[num]] > sums[i]:\n ind[num] = i\n \n return maxSum if maxSum != -float('inf') else 0","runtime":"890"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n\n min_prefix_sum = {}\n ans= -float('inf')\n running_sum = 0 \n \n for num in nums:\n\n if num in min_prefix_sum:\n min_prefix_sum[num] = min(min_prefix_sum[num],running_sum)\n else:\n min_prefix_sum[num]= running_sum\n \n running_sum += num\n\n for target_sum in [num+k,num-k]:\n if target_sum in min_prefix_sum:\n ans = max(ans, running_sum - min_prefix_sum[target_sum])\n return ans if ans != -float('inf') else 0\n \n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # approach 1 : Brute force \n # ans = -float(\"inf\") \n # for st in range(len(nums)):\n # for end in range(st+1,len(nums)):\n # if abs(nums[st]-nums[end])==k:\n # ans = max(ans,sum(nums[st:end+1]))\n # return ans if ans != -float('inf') else 0\n\n # approach 2:\n\n ans = -float('inf')\n ps_map = {} # minimum prefix sum map for number \"num\"\n running_sum = 0\n \n for num in nums:\n\n if num in ps_map:\n ps_map[num] = min(ps_map[num],running_sum)\n else:\n ps_map[num] = running_sum\n\n running_sum += num\n\n for y in [num-k,num+k]:\n if y in ps_map:\n ans = max(ans,running_sum - ps_map[y])\n \n return ans if ans!= -float('inf') else 0\n\n \n \n\n ","runtime":"894"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n prefixSumDict = defaultdict(lambda : inf)\n result = -inf\n curr = 0\n\n for num in nums:\n prefixSumDict[num] = min(prefixSumDict[num], curr)\n curr += num\n\n if num - k in prefixSumDict:\n result = max(result, curr - prefixSumDict[num - k])\n if num + k in prefixSumDict:\n result = max(result, curr - prefixSumDict[num + k])\n \n return result if result!= -inf else 0\n ","runtime":"894"},{"code":"'''\n\nnums = [-1, 3, -2, 4, 5]\npref = [ 0, -1, 2, 0, 4, 9]\n\n> x = nums[i] - k or\n x = nums[i] + k\n\n\nd = { // nums[i] --> min(pref_sum_until_nums_i)\n -1: -1,\n 3: 2\n}\n\n'''\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pref = [0]\n for i in range(1, len(nums) + 1):\n pref.append(nums[i - 1] + pref[i - 1])\n\n res = -inf\n d = {} # value -> min_pref_sum_indx\n \n for i, n in enumerate(nums):\n x = n - k\n if x in d:\n _sum = pref[i + 1] - pref[d[x]]\n res = max(res, _sum)\n \n x = n + k\n if x in d:\n _sum = pref[i + 1] - pref[d[x]]\n res = max(res, _sum)\n\n if n not in d or pref[d[n] + 1] > pref[i + 1]:\n d[n] = i\n\n return 0 if res == -inf else res\n\n'''\n\ndef maximumSubarraySum(self, nums: List[int], k: int) -> int:\n for i, n in enumerate(nums):\n x = n - k\n if x in met:\n value = pref[i + 1] - pref[met[x][0]]\n res = value if res == 0 else max(res, value)\n x = n + k\n if x in met:\n value = pref[i + 1] - pref[met[x][0]]\n res = value if res == 0 else max(res, value)\n\n if n not in met:\n met[n] = (i, pref[i + 1])\n elif met[n][1] > pref[i + 1]:\n met[n] = (i, pref[i + 1])\n\n return res\n\n\n'''","runtime":"899"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n result=-pow(10,15)\n prefix_sum=[0]*len(nums)\n prefix_sum[0]=nums[0]\n for i in range(1,len(nums)):\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\n map={}\n for i in range(len(nums)):\n if nums[i]-k in map:\n idx=map[nums[i]-k]\n sum= prefix_sum[i]-prefix_sum[idx-1] if idx>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i]+k in map:\n idx=map[nums[i]+k]\n sum= prefix_sum[i]-prefix_sum[idx-1] if map[nums[i]+k]>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i] not in map:\n map[nums[i]]=i\n else:\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\n if prefix_sum[i-1]<pref_sum:\n map[nums[i]]=i\n if result== -pow(10,15):\n return 0\n else:\n return result\n \n\n\n ","runtime":"899"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n prefix_left=defaultdict(lambda: inf)\n result=-inf\n cur=0\n\n for x in nums:\n prefix_left[x]=min(prefix_left[x], cur)\n cur+=x\n\n if(x-k in prefix_left):\n result=max(result, cur-prefix_left[x-k])\n if(x+k in prefix_left):\n result=max(result, cur-prefix_left[x+k])\n\n return result if result!=-inf else 0","runtime":"903"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n map = {} # prefix sums\n map[-1] = 0\n\n indices = {} # value to index with the lowest prefix sum, in order to maximize a potential result sum\n currSum = 0\n maxSum = None\n\n for i in range(len(nums)):\n currSum += nums[i]\n map[i] = currSum\n if (nums[i] not in indices) or (nums[i] in indices and currSum < map[indices[nums[i]]]):\n indices[nums[i]] = i\n\n if (nums[i] - k) in indices:\n index = indices[nums[i] - k]\n if maxSum is None:\n maxSum = map[i] - map[index - 1]\n else:\n maxSum = max(maxSum, map[i] - map[index - 1])\n\n if (nums[i] + k) in indices:\n index = indices[nums[i] + k]\n if maxSum is None:\n maxSum = map[i] - map[index - 1]\n else:\n maxSum = max(maxSum, map[i] - map[index - 1])\n\n return 0 if maxSum is None else maxSum","runtime":"903"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n di = {}\n \n ans = -math.inf\n \n pre = [0 for i in range(n)]\n \n pre[0] = nums[0]\n \n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n \n # print(pre)\n \n i = 0\n f = -1\n for x in nums:\n \n if(x-k in di):\n f = 1\n y = di[x-k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n if(x+k in di):\n f = 1\n y = di[x+k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n \n if(x in di):\n curr = 0\n if(di[x] == 0):\n curr = 0\n else:\n curr = di[x]-1\n \n if(pre[curr] > pre[i-1]):\n di[x] = i\n else:\n di[x] = i\n \n i += 1\n \n if(f == -1):\n ans = 0\n \n return ans","runtime":"907"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n pre = [nums[0]]\n s = set()\n idx = defaultdict(int)\n for i in range(1,n):\n pre.append(pre[i-1] + nums[i])\n\n res = float('-inf')\n for i in range(n):\n l = nums[i]\n if nums[i] not in s:\n idx[nums[i]] = i\n s.add(nums[i])\n else:\n if pre[idx[nums[i]]] > pre[i]:\n idx[nums[i]] = i\n \n if k+l in s:\n \n # for j in range(len(idx[k+l])):\n t = pre[i]\n if idx[k+l] >0:\n t -= pre[idx[k+l]-1] \n if t> res:\n res = t\n \n if l-k in s:\n # for j in range(len(idx[l-k])):\n t = pre[i]\n if idx[l-k] >0:\n t -= pre[idx[l-k]-1]\n if t> res:\n res = t\n return res if res != float('-inf') else 0\n \n \n\n\n ","runtime":"907"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n result=-pow(10,15)\n prefix_sum=[0]*len(nums)\n prefix_sum[0]=nums[0]\n for i in range(1,len(nums)):\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\n map={}\n for i in range(len(nums)):\n if nums[i]-k in map:\n sum= prefix_sum[i]-prefix_sum[map[nums[i]-k]-1] if map[nums[i]-k]>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i]+k in map:\n sum= prefix_sum[i]-prefix_sum[map[nums[i]+k]-1] if map[nums[i]+k]>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i] not in map:\n map[nums[i]]=i\n else:\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\n if prefix_sum[i-1]<pref_sum:\n map[nums[i]]=i\n if result== -pow(10,15):\n return 0\n else:\n return result\n \n\n\n ","runtime":"912"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# maxSum = -float('inf')\n# table = {}\n# for i,v in enumerate(nums):\n# if v in table:\n# table[v] = min(table[v],i)\n# else:\n# table[v] = i\n# v1 = v + k\n# v2 = v - k\n# if v1 in table:\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\n# maxSum = max(maxSum,subSum1)\n# if v2 in table:\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\n# maxSum = max(maxSum,subSum2)\n# else:\n# continue\n# if maxSum > -float('inf'):\n# return maxSum\n# else:\n# return 0\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n l, max_sum, hash_map = len(nums), -inf, {}\n pre_sum = [0] * (l+1)\n pre_sum[0] = 0\n\n for i,n in enumerate(nums):\n pre_sum[i+1] = pre_sum[i] + n\n if n-k in hash_map:\n max_sum = max(max_sum, pre_sum[i+1]-pre_sum[hash_map[n-k]])\n \n if k+n in hash_map:\n max_sum = max(max_sum, pre_sum[i+1]-pre_sum[hash_map[n+k]])\n\n if n not in hash_map:\n hash_map[n] = i\n \n if n in hash_map:\n if pre_sum[hash_map[n]]>= pre_sum[i]:\n hash_map[n] = i\n\n \n if max_sum> -inf: return max_sum\n else: return 0\n","runtime":"912"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n prefix = defaultdict(lambda: inf)\n total = 0\n res = -inf\n for num in nums:\n\n prefix[num] = min(total, prefix[num] )\n total += num\n if num-k in prefix:\n res = max(res, total- prefix[ num-k ])\n if num+k in prefix:\n res = max(res, total- prefix[ num+k ])\n return res if res != -inf else 0\n\n# //////////////////////////////////////////////\n\n # [-1, 3, 2, 4, 5]\n # -1 2 4 8 13\n # 2 4 5\n\n \n","runtime":"916"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n prefixSumDict = defaultdict(lambda : inf)\n maxSum = -inf\n currSum = 0\n\n for num in nums:\n prefixSumDict[num] = min(prefixSumDict[num], currSum)\n\n currSum += num\n\n if num - k in prefixSumDict:\n maxSum = max(maxSum, currSum - prefixSumDict[num - k])\n \n if num + k in prefixSumDict:\n maxSum = max(maxSum, currSum - prefixSumDict[num + k])\n \n return maxSum if maxSum!= -inf else 0\n ","runtime":"916"},{"code":"'''\nprefix sum for O(1) subarray sums\nlook up table for previous occurances of n - k or n + k\n\nif we have access to previous indexes of n - k and n + k\n\n'''\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [0] * (len(nums) + 1)\n total = 0\n for i in range(len(nums)):\n total += nums[i]\n prefix[i + 1] = total\n # we want to look up best occurance of n - k and n + k\n # n -> index of best n\n # either n itself is the best start or a previous n is good\n\n lookup = {}\n res = -inf\n for i in range(len(nums)):\n # if we haven't seen before or the array between the occurance is not worth reset to new i\n n = nums[i]\n if n not in lookup or n > prefix[i + 1] - prefix[lookup[n]]:\n lookup[n] = i\n\n if n - k in lookup:\n res = max(res, prefix[i + 1] - prefix[lookup[n-k]])\n if n + k in lookup:\n res = max(res, prefix[i + 1] - prefix[lookup[n+k]])\n if res == -inf:\n return 0\n return res\n","runtime":"920"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_left = defaultdict(lambda: inf)\n res = -inf\n curr = 0\n \n for n in nums:\n prefix_left[n] = min(prefix_left[n], curr)\n curr += n\n if n-k in prefix_left:\n res = max(res, curr - prefix_left[n-k])\n if n+k in prefix_left:\n res = max(res, curr - prefix_left[n+k])\n return res if res != -inf else 0","runtime":"920"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res, preSum, mp = -sys.float_info.max, 0, {}\n for r in nums:\n for l in [r + k, r - k]:\n if l in mp:\n res = max(res, preSum + r - mp[l])\n if r not in mp:\n mp[r] = preSum\n mp[r] = min(mp[r], preSum)\n preSum += r\n return res if res != -sys.float_info.max else 0","runtime":"925"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# map = collections.defaultdict(list)\n# n = len(nums)\n\n# prefixSum = [0]*n\n# for idx in range(n):\n# prefixSum[idx] = nums[idx] + (prefixSum[idx-1] if idx else 0)\n\n# # print(prefixSum)\n# def query(left, right):\n# return prefixSum[right] - (prefixSum[left-1] if left else 0)\n\n# for idx in range(n):\n# map[nums[idx]].append(idx)\n\n# ans = float(\"-inf\")\n# for idx, num in enumerate(nums):\n# if num + k in map:\n# for val in map[num+k]:\n# left = min(idx, val)\n# right = max(idx, val)\n# # print(left, right)\n# ans = max(ans , query(left, right))\n\n# return 0 if ans == float(\"-inf\") else ans\n\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n idx_map = collections.defaultdict(list)\n n = len(nums)\n\n prefixSum = [0]*n\n for idx in range(n):\n prefixSum[idx] = nums[idx] + (prefixSum[idx-1] if idx else 0)\n\n # print(prefixSum)\n def query(left, right):\n return prefixSum[right] - (prefixSum[left-1] if left else 0)\n\n ans = float(\"-inf\")\n for i, num in enumerate(nums):\n target1 = num + k\n target2 = num - k\n\n if target1 in idx_map:\n left = idx_map[target1]\n right = i\n ans = max(ans, query(left, right))\n\n if target2 in idx_map:\n left = idx_map[target2]\n right = i\n ans = max(ans, query(left, right))\n\n\n if (num not in idx_map) or (query(idx_map[num], i-1) < 0):\n idx_map[num] = i\n\n return 0 if ans == float(\"-inf\") else ans\n\n\n\n\n\n\n\n","runtime":"925"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n s = 0\n psum = [0]\n h = {}\n res = -math.inf\n for i, n in enumerate(nums):\n s += n\n psum.append(s)\n if h.get(n - k) != None:\n res = max(s - psum[h[n - k]], res)\n if h.get(n + k) != None:\n res = max(s - psum[h[n + k]], res)\n if h.get(n) == None or psum[h[n]] > psum[-2]:\n h[n] = i\n return res if res != -math.inf else 0","runtime":"929"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n prefix_sum = defaultdict(lambda: float(\"inf\"))\n curr_sum = 0\n res = float(\"-inf\")\n for n in nums:\n prefix_sum[n] = min(prefix_sum[n], curr_sum)\n curr_sum += n\n if n - k in prefix_sum:\n res = max(res, curr_sum - prefix_sum[n-k])\n if n + k in prefix_sum:\n res = max(res, curr_sum - prefix_sum[n+k])\n return res if res != float(\"-inf\") else 0","runtime":"929"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n v2i = {}\n pref = [0]\n ans = -1e18\n \n for i, v in enumerate(nums):\n v2i[v] = min(pref[-1], v2i.get(v, 1e18))\n pref.append(pref[-1] + v)\n ps = pref[-1]\n\n # need to look in v2i for v-k or v+k\n if v-k in v2i:\n ans = max(ans, ps - v2i[v-k])\n if v+k in v2i:\n ans = max(ans, ps - v2i[v+k])\n \n return ans if ans != -1e18 else 0\n","runtime":"933"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n maxSum = float(\"-inf\")\n prefixSum = defaultdict(lambda: float(\"inf\"))\n runningSum = 0\n\n for n in nums:\n prefixSum[n] = min(prefixSum[n], runningSum)\n runningSum += n\n\n if n-k in prefixSum:\n maxSum = max(maxSum, runningSum - prefixSum[n-k])\n if n+k in prefixSum:\n maxSum = max(maxSum, runningSum - prefixSum[n+k])\n\n return maxSum if maxSum != float(\"-inf\") else 0","runtime":"933"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: list[int], k: int) -> int:\n if len(nums)<2:\n return 0\n # Блок объявления\n nums.insert(0, 0)\n dict_indexes ={} # Ключ - интересное число, значение - индекс\n nums_sum=[0]\n max_sum=float('-inf')\n\n for i in range(1,len(nums)):\n nums_sum.append(nums[i]+nums_sum[i-1]) #Кадане - считаем суммы\n #Если такого числа нет в словаре\n if dict_indexes.get(nums[i],None) == None:\n dict_indexes[nums[i]] = i\n else: #Если есть\n if nums_sum[dict_indexes.get(nums[i])] >nums_sum[i]:\n dict_indexes[nums[i]] = i\n #Если есть подходящее\n dict_posK_ind = dict_indexes.get(nums[i]+k,None)\n dict_negK_ind = dict_indexes.get(nums[i]-k,None)\n if (dict_posK_ind!=None and dict_posK_ind<i) and (dict_negK_ind!=None and dict_negK_ind<i):\n if max_sum < max(nums_sum[i]-nums_sum[dict_posK_ind-1], nums_sum[i]-nums_sum[dict_negK_ind-1]):\n max_sum = max(nums_sum[i]-nums_sum[dict_posK_ind-1], nums_sum[i]-nums_sum[dict_negK_ind-1])\n elif dict_posK_ind!=None and dict_posK_ind<i:\n if max_sum < nums_sum[i]-nums_sum[dict_posK_ind-1]:\n max_sum = nums_sum[i]-nums_sum[dict_posK_ind-1]\n elif dict_negK_ind!=None and dict_negK_ind<i:\n if max_sum < nums_sum[i]-nums_sum[dict_negK_ind-1]:\n max_sum = nums_sum[i]-nums_sum[dict_negK_ind-1]\n\n\n return max_sum if max_sum!=float('-inf') else 0","runtime":"938"},{"code":"import math\nclass Solution:\n \n def __init__(self):\n self.ans = -math.inf\n self.dic = {}\n \n\n def get_max_subarray(self, index, pre, i):\n res = self.dic[index]\n if res != 0:\n self.ans = max(self.ans, pre[i] - pre[res-1])\n else:\n self.ans = max(self.ans, pre[i])\n\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n\n pre = [ 0 for _ in range(n)]\n pre[0] = nums[0]\n\n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n\n found_good_subarray = False\n i = 0\n\n for num in nums:\n if num - k in self.dic:\n found_good_subarray = True\n self.get_max_subarray(num - k, pre, i)\n \n if num + k in self.dic:\n found_good_subarray = True\n self.get_max_subarray(num + k, pre,i)\n\n if num in self.dic:\n curr = 0\n if self.dic[num] != 0:\n curr = self.dic[num] - 1\n \n if pre[curr] > pre[i - 1]:\n self.dic[num] = i\n else:\n self.dic[num] = i\n i += 1\n\n return self.ans if found_good_subarray else 0\n \n\n\n ","runtime":"938"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # p_i = sum [0, i)\n prefix_sum = [0] * (len(nums) + 1)\n\n for idx, num in enumerate(nums):\n prefix_sum[idx+1] = prefix_sum[idx] + num\n\n val_to_idx = {}\n max_total = None\n for idx, num in enumerate(nums):\n # abs(num - x) == k\n # x == num - k or x == num + k\n prev_idx_neg = val_to_idx.get(num-k, None) \n prev_idx_pos = val_to_idx.get(num+k, None)\n\n for prev_idx in [prev_idx_neg, prev_idx_pos]:\n if prev_idx is not None:\n total = prefix_sum[idx+1] - prefix_sum[prev_idx]\n if max_total is None:\n max_total = total\n else:\n max_total = max(total, max_total)\n\n if num not in val_to_idx:\n val_to_idx[num] = idx\n else:\n prev_idx = val_to_idx[num]\n if prefix_sum[idx] - prefix_sum[prev_idx] <= 0:\n val_to_idx[num] = idx\n\n return max_total or 0\n ","runtime":"955"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n from collections import defaultdict\n prefix_left = defaultdict(lambda: float('inf'))\n res = -float('inf')\n cur = 0\n for x in nums:\n prefix_left[x]=min(prefix_left[x], cur)\n cur += x\n\n if x-k in prefix_left:\n res = max(res, cur-prefix_left[x-k])\n if x+k in prefix_left:\n res = max(res, cur-prefix_left[x+k])\n return res if res != -float('inf') else 0","runtime":"955"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n '''\n iterate through array, maintain running sum\n store running sum of element in hashmap at index + 1's value\n at each element, check if val - k or val + k is in hashmap\n if yes, calculate sum of that subarray using prefix sum hashmap\n otherwise continue\n '''\n prefix_sum = {}\n cur_sum = 0\n max_sum = float(\"-inf\")\n\n for i, n in enumerate(nums):\n if n not in prefix_sum:\n prefix_sum[n] = cur_sum\n prefix_sum[n] = min(prefix_sum[n], cur_sum)\n if n - k in prefix_sum:\n max_sum = max(max_sum, cur_sum + n - prefix_sum[n - k])\n if n + k in prefix_sum:\n max_sum = max(max_sum, cur_sum + n - prefix_sum[n + k])\n cur_sum += n\n print(prefix_sum)\n return max_sum if max_sum != float(\"-inf\") else 0\n\n\n","runtime":"959"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n cumulativeSums = {}\n currentSum = 0\n maxSum = float('-inf') # This is the Python equivalent of Long.MIN_VALUE\n\n for value in nums:\n # Check if value - k exists in the map\n if (value - k) in cumulativeSums:\n minValue = cumulativeSums[value - k]\n maxSum = max(maxSum, currentSum + value - minValue)\n\n # Check if value + k exists in the map\n if (value + k) in cumulativeSums:\n minValue = cumulativeSums[value + k]\n maxSum = max(maxSum, currentSum + value - minValue)\n\n # Update the map with the minimum currentSum for the current value\n cumulativeSums[value] = min(cumulativeSums.get(value, float('inf')), currentSum)\n \n # Update currentSum with the current value\n currentSum += value\n\n # If maxSum is still -inf, it means no valid subarray was found\n return 0 if maxSum == float('-inf') else maxSum\n ","runtime":"959"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n opt = -math.inf\n curr_acc = 0\n acc = defaultdict(lambda: math.inf)\n\n for j, y in enumerate(nums):\n acc[y] = min(acc[y], curr_acc)\n curr_acc += y\n\n for x in [y - k, y + k]:\n if x in acc:\n opt = max(opt, curr_acc - acc[x])\n \n return opt if opt != -math.inf else 0","runtime":"964"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n seen = {}\n prefix = []\n ssum = 0\n self.max_sum = float('-inf')\n\n def update_max_sum(key, i):\n if key in seen:\n index = seen[key]\n total = prefix[i] - prefix[index] + nums[i]\n self.max_sum = max(self.max_sum, total)\n\n for i, n in enumerate(nums):\n prefix.append(ssum)\n ssum = ssum + n\n if n in seen:\n idx = seen[n]\n prev_sum = prefix[idx]\n #from line 11 to maximize total prefix[index] should have the smallest value\n seen[n] = idx if prev_sum < prefix[i] else i \n else:\n seen[n] = i\n\n update_max_sum(n - k, i)\n update_max_sum(n + k, i)\n\n return self.max_sum if self.max_sum != float('-inf') else 0","runtime":"964"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n output = float('-inf')\n prefix = {}\n curSum = 0\n for i in range(len(nums)):\n curSum += nums[i]\n prefix[i] = curSum \n idx = {}\n print(prefix)\n for i in range(len(nums)): \n if nums[i] in idx: \n if prefix[idx[nums[i]]] > prefix[i]:\n idx[nums[i]] = i \n else:\n idx[nums[i]] = i \n if nums[i] - k in idx: \n other_i = idx[nums[i] - k]\n output = max(output, prefix[i] - prefix[other_i] + nums[i] - k)\n if nums[i] + k in idx: \n other_i = idx[nums[i] + k]\n output = max(output, prefix[i] - prefix[other_i] + nums[i] + k)\n if output == float(\"-inf\"):\n return 0\n return output\n ","runtime":"968"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n d = dict()\n res = -float('inf')\n curr = 0\n for r in range(len(nums)):\n curr += nums[r]\n\n if nums[r] - k in d:\n c = d[nums[r] - k]\n res = max(res, curr - c)\n \n if nums[r] + k in d:\n c = d[nums[r] + k]\n res = max(res, curr - c)\n \n d[nums[r]] = min(d.get(nums[r], float('inf')), curr - nums[r])\n # print(d)\n \n return res if res != -float('inf') else 0\n","runtime":"968"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pre = 0\n mapping = defaultdict(lambda: math.inf)\n res = -math.inf\n for n in nums:\n if mapping[n] > pre:\n mapping[n] = pre\n pre += n\n \n res = max(res, pre - mapping[n-k], pre - mapping[n+k])\n \n\n if res == -math.inf:\n return 0\n return res\n\n","runtime":"973"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = -math.inf\n prefix_sum = 0\n num_to_min_prefix_sum = defaultdict(lambda: math.inf)\n for num in nums:\n num_to_min_prefix_sum[num] = min(num_to_min_prefix_sum[num], prefix_sum)\n\n prefix_sum += num\n\n if num + k in num_to_min_prefix_sum.keys():\n max_sum = max(max_sum, prefix_sum - num_to_min_prefix_sum[num + k])\n if num - k in num_to_min_prefix_sum.keys():\n max_sum = max(max_sum, prefix_sum - num_to_min_prefix_sum[num - k])\n\n return max_sum if max_sum != -math.inf else 0\n\n# Observation\n# sum(nums[i..j]) = prefix_sum[j] - prefix_sum[i - 1]\n\n# nums = [5,-3,6,1]\n# prefix_sum = [5,2,4,5]","runtime":"973"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n \n indexDict = defaultdict(list)\n minDict = defaultdict(int)\n prefixSum = [0]*len(nums)\n maxValue = -inf\n \n for i in range(len(nums)):\n if i == 0:\n prefixSum[i] = 0\n else: \n prefixSum[i] = prefixSum[i-1] + nums[i-1]\n \n for i, num in enumerate(nums):\n if num - k in indexDict:\n maxValue = max(maxValue, prefixSum[i] - minDict[num-k] + num)\n if num + k in indexDict:\n maxValue = max(maxValue, prefixSum[i] - minDict[num+k] + num)\n \n indexDict[num].append(i) \n # print(\"minDict_num :\", minDict[num])\n minDict[num] = min(minDict[num], prefixSum[i]) if num in minDict else prefixSum[i]\n \n \n \n \n return maxValue if maxValue != -inf else 0\n \n \n \n ","runtime":"977"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = -math.inf\n num_to_prefix = defaultdict(lambda: math.inf)\n prefix_sum = 0\n for num in nums:\n num_to_prefix[num] = min(num_to_prefix[num], prefix_sum)\n\n prefix_sum += num\n\n candidate = num + k\n if candidate in num_to_prefix.keys():\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\n\n candidate = num - k\n if candidate in num_to_prefix.keys():\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\n return max_sum if max_sum != -math.inf else 0","runtime":"977"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n seen = {}\n prefix = []\n ssum = 0\n self.max_sum = float('-inf')\n\n def update_max_sum(key, i):\n if key in seen:\n index = seen[key][0]\n # if i != index:\n # return\n total = prefix[i] - prefix[index] + nums[i]\n self.max_sum = max(self.max_sum, total)\n \n for i, n in enumerate(nums):\n prefix.append(ssum)\n ssum = ssum + n\n if n in seen:\n idx = seen[n][-1]\n prev_sum = prefix[idx]\n seen[n][-1] = idx if prev_sum < prefix[i] else i\n else:\n seen[n] = [i]\n\n update_max_sum(n - k, i)\n update_max_sum(n + k, i)\n\n return self.max_sum if self.max_sum != float('-inf') else 0","runtime":"981"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # hashmap에는 해당 num의 prefix(즉, 자신 빼고 이전까지 더한 합)을 저장\n # update hashmap. 후에는 자신을 더하고 \n # 자신을 더한 합 - hashmap[자신 +- k] \n # ex) (1+2+3+4+5+6) - (1+2+3+4) = 5+6\n \n result = float(\"-inf\")\n hashmap = defaultdict(lambda: inf)\n prefix_sum = 0\n\n for num in nums:\n if hashmap[num] > prefix_sum:\n hashmap[num] = prefix_sum\n prefix_sum += num\n result = max(result, prefix_sum - hashmap[num + k], prefix_sum - hashmap[num - k])\n return result if result != float(\"-inf\") else 0","runtime":"981"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, prefix_dict = -inf, 0, defaultdict(lambda: inf)\n for num in nums:\n if prefix_dict[num] > prefix_sum:\n prefix_dict[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - prefix_dict[num-k], prefix_sum - prefix_dict[num+k])\n return max_sum if max_sum > -inf else 0","runtime":"986"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n max_sum = -inf\n prefix_sum = 0\n num_to_min_prefix_sum = defaultdict(lambda: inf)\n for num in nums:\n if num_to_min_prefix_sum[num] > prefix_sum:\n num_to_min_prefix_sum[num] = prefix_sum\n \n prefix_sum += num\n max_sum = max(max_sum, \n prefix_sum - num_to_min_prefix_sum[num + k], \n prefix_sum - num_to_min_prefix_sum[num - k])\n \n return max_sum if max_sum > -inf else 0\n","runtime":"986"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, min_prefix_sum_dict = -inf, 0, defaultdict(lambda: inf)\n for n in nums:\n if min_prefix_sum_dict[n] > prefix_sum:\n min_prefix_sum_dict[n] = prefix_sum\n prefix_sum += n\n max_sum = max(max_sum, prefix_sum - min_prefix_sum_dict[n - k], prefix_sum - min_prefix_sum_dict[n + k])\n\n return max_sum if max_sum > -inf else 0","runtime":"990"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"990"},{"code":"class Solution: \n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n #kandane algo\n ans = -inf\n prefix_sum = 0\n minPrefixSum = defaultdict(lambda: inf)\n\n # keep track of minimum prefix sum (up to & exclu num) for each number\n for i, num in enumerate(nums):\n if minPrefixSum[num] > prefix_sum:\n minPrefixSum[num] = prefix_sum\n prefix_sum += num\n ans = max(ans, prefix_sum - minPrefixSum[num + k], prefix_sum - minPrefixSum[num - k])\n return ans if ans > -inf else 0 ","runtime":"994"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n h = {}\n maxi = -1e15\n prefix_sum = nums[:]\n for i in range(1,len(nums)):\n prefix_sum[i] = prefix_sum[i-1] + nums[i]\n prefix_sum = [0] + prefix_sum\n find = False\n for i,num in enumerate(nums):\n if num not in h.keys():\n h[num] = i\n else:\n h[num] = h[num] if (prefix_sum[i+1] - prefix_sum[h[num]+1]) > 0 else i\n nums_to_check = []\n nums_to_check.append(num - k) \n nums_to_check.append(num+k)\n for checknum in nums_to_check:\n if checknum in h.keys():\n find = True\n current_sum = prefix_sum[i+1] - prefix_sum[h[checknum]]\n if prefix_sum[i+1] - prefix_sum[h[checknum]] > maxi:\n maxi = current_sum\n else:\n continue\n\n return maxi if find else 0\n\n \n ","runtime":"994"},{"code":"from collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0","runtime":"999"},{"code":"from math import inf\nfrom collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = -inf\n prefix_sum = 0\n min_prefixsum_dict = defaultdict(lambda: inf)\n\n for num in nums:\n if min_prefixsum_dict[num] > prefix_sum:\n min_prefixsum_dict[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - min_prefixsum_dict[num-k], prefix_sum - min_prefixsum_dict[num+k])\n return max_sum if max_sum > -inf else 0\n","runtime":"999"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1003"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -inf\n\n prefix_sum = 0\n seen = defaultdict(lambda: inf)\n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n \n prefix_sum += n\n\n ans = max(ans, prefix_sum - seen[k + n], \\\n prefix_sum - seen[n - k])\n \n return ans if ans != -inf else 0","runtime":"1003"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# maxSum = -float('inf')\n# table = {}\n# for i,v in enumerate(nums):\n# if v in table:\n# table[v] = min(table[v],i)\n# else:\n# table[v] = i\n# v1 = v + k\n# v2 = v - k\n# if v1 in table:\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\n# maxSum = max(maxSum,subSum1)\n# if v2 in table:\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\n# maxSum = max(maxSum,subSum2)\n# else:\n# continue\n# if maxSum > -float('inf'):\n# return maxSum\n# else:\n# return 0\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1007"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = -math.inf \n prefix_sum = 0\n val_to_min_prefix_sum = defaultdict(lambda: math.inf)\n\n for i, num in enumerate(nums):\n if prefix_sum < val_to_min_prefix_sum[num]:\n val_to_min_prefix_sum[num] = prefix_sum \n prefix_sum += num \n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num-k], prefix_sum - val_to_min_prefix_sum[num+k])\n\n if max_sum != -math.inf:\n return max_sum \n return 0\n","runtime":"1007"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1012"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# maxSum = -float('inf')\n# table = {}\n# for i,v in enumerate(nums):\n# if v in table:\n# table[v] = min(table[v],i)\n# else:\n# table[v] = i\n# v1 = v + k\n# v2 = v - k\n# if v1 in table:\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\n# maxSum = max(maxSum,subSum1)\n# if v2 in table:\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\n# maxSum = max(maxSum,subSum2)\n# else:\n# continue\n# if maxSum > -float('inf'):\n# return maxSum\n# else:\n# return 0\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1012"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n max_sum = -math.inf\n num_to_prefix = defaultdict(lambda: math.inf)\n prefix_sum = 0\n for i in range(n):\n num_to_prefix[nums[i]] = min(num_to_prefix[nums[i]], prefix_sum)\n\n prefix_sum += nums[i]\n\n candidate = nums[i] + k\n if candidate in num_to_prefix.keys():\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\n\n candidate = nums[i] - k\n if candidate in num_to_prefix.keys():\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\n return max_sum if max_sum != -math.inf else 0","runtime":"1016"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # Get grefix sum\n pref = [0] * (len(nums) + 1)\n for i in range(0, len(nums)):\n pref[i + 1] = nums[i] + pref[i]\n invIdx = defaultdict(list)\n maxSum = None\n\n for i in range(0, len(nums)):\n key1 = nums[i] + k\n key2 = nums[i] - k\n\n prevPrefs = []\n if key1 in invIdx:\n prevPrefs.append(invIdx.get(key1)[0]) \n if key2 in invIdx:\n prevPrefs.append(invIdx.get(key2)[0])\n\n for prevPref in prevPrefs:\n currSum = pref[i + 1] - prevPref\n maxSum = currSum if maxSum is None else max(currSum, maxSum)\n heappush(invIdx[nums[i]], pref[i])\n \n return maxSum if maxSum is not None else 0\n\n\n# nums = [-1, 3, 2, 4, 5], k = 3\n\n# pref = [0 -1 2 4 8 13]\n\n# invIdx = {-1: [0], 3: [1], 2: [2], 4: [3]}\n# maxSum = 11\n\n# i = 4,\n# nums[i] = 5\n# idxs = [2]\n# idx = 2\n\n\n# idxs = \n\n\n# Input:\n# nums: List[int]\n# k: int\n\n\n# Output:\n# maximumSum: int # maximum good subarray sum\n\n# Example\n# nums = [-1, 3, 2, 4, 5], k = 3\n\n# pref = [-1, 2, 4, 8, 13]\n\n\n# prefSum = []\n# mapp: {val -> [idx]}\n\n# for i,\n# for j\n# pref[j] - pref[i - 1]\n\n\n\n# |a - b| >= |a| - |b|\n# |a - b| = a - b if a > b else b - a\n\n# a - b = k or b - a = k\n# b + k or b - k","runtime":"1016"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_subarray_sum = -inf # Initialize the maximum subarray sum to negative infinity\n current_prefix_sum = 0 # Initialize the prefix sum to 0\n min_prefix_sum_for_value = defaultdict(lambda: inf) # Dictionary to track the minimum prefix sum for each value\n\n for index, num in enumerate(nums):\n # Update the minimum prefix sum for the current number if the current prefix sum is smaller\n if min_prefix_sum_for_value[num] > current_prefix_sum:\n min_prefix_sum_for_value[num] = current_prefix_sum\n\n # ----num-----num+k\n # --k--\n\n # abs(k) = num+k - num\n # abs(k) = num-k - num \n\n current_prefix_sum += num\n # Calculate candidate subarray sums using the values num + k and num - k\n subarray_sum_with_plus_k = current_prefix_sum - min_prefix_sum_for_value[num + k]\n subarray_sum_with_minus_k = current_prefix_sum - min_prefix_sum_for_value[num - k]\n\n # Update the maximum subarray sum with the best candidate\n max_subarray_sum = max(max_subarray_sum, subarray_sum_with_plus_k, subarray_sum_with_minus_k)\n\n # Return the maximum subarray sum, or 0 if it was never updated\n return max_subarray_sum if max_subarray_sum != -inf else 0\n","runtime":"1020"},{"code":"\"\"\"\nCan't sort it\nCan't slide a window\nWhat about two pointers?\n|a - b| = k\na - b = k\na - b = -k\n\na = b - k\na = k - b\nlookup a in hashmap and get it's index to compute a sum\n\na = 0\na = 1 or -1 -> yes at index 0 sum(0, 1) to update max\n{1: 0, 2: 1}\ntotalSum at index i; sum(0, b) = sum(0, a) + sum(a, b)\ntotalSum - prefixSum\n[-1,3,2,4,5]\n\"\"\"\nfrom collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n total_sum = 0\n max_sum = float('-inf')\n complement_map = {}\n\n for index in range(len(nums)): # 4\n num = nums[index] # 5\n complements = [num - k, num + k] # -12, 12\n for complement in complements:\n if complement in complement_map:\n curr_sum = total_sum - complement_map[complement] # 8 - 4 = 4\n max_sum = max(max_sum, curr_sum + num) # 4\n\n complement_map[num] = min(total_sum, complement_map.get(num, float('inf'))) # {-1: 0, 3: 1, 2: 2, 4: 3, 5: 4}\n \n total_sum += num # 8 + 5 = 13\n\n return max_sum if max_sum != float('-inf') else 0\n \n","runtime":"1020"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixSum = {} # key: k-n, value_list: (idx, prefixSum)\n curSum, maxSum = 0, float('-inf')\n for j, nj in enumerate(nums):\n if nj in prefixSum: # handle repeat n, keep smaller prefixSum\n prefixSum[nj] = min(prefixSum[nj], curSum) \n else:\n prefixSum[nj] = curSum\n\n need = [ni for ni in [nj - k, nj + k] if ni in prefixSum]\n for ni in need:\n maxSum = max(maxSum, curSum - prefixSum[ni] + nj)\n\n curSum += nj\n return maxSum if maxSum > float('-inf') else 0\n\n# 1 2 3 4 5 6 , k = 1\n# 1:0 2:1 3:3 4:6 5:9 6:14\n \n\n \n\n\n\n# \n \n\n# 1. brute force: two pointers, two for loops -> O(n^2) check all start, end pair\n\n# 2. dict -> key: k-n value: idx, prefixSum (sum of ends with idx i)\n# go through nums, if k-n in dict -> then update maxSum with prefixSum[cur] - prefixSum[dict[k-n]] + nums[idx]\n# O(n)","runtime":"1025"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1025"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n nums_len = len(nums)\n prefix_sum = [0] * (nums_len + 1)\n for i, num in enumerate(nums):\n prefix_sum[i + 1] = prefix_sum[i] + num\n\n cache = {}\n maximum = float(\"-inf\")\n for i, num in enumerate(nums):\n for diff in [num - k, num + k]:\n if cache.get(diff) is not None:\n maximum = max(\n prefix_sum[i + 1] - prefix_sum[cache.get(diff)], maximum\n )\n if cache.get(num) is None:\n cache[num] = i\n elif (cache.get(num) is not None) and (\n (prefix_sum[i + 1] - prefix_sum[cache.get(num)]) < num\n ):\n cache[num] = i\n\n return maximum if maximum != float(\"-inf\") else 0\n","runtime":"1029"},{"code":"class Solution:\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n for a in A:\n pre[a] = min(pre[a], cur)\n cur += a\n res = max(res, cur - pre[a - k], cur - pre[a + k])\n return res if res > -inf else 0","runtime":"1029"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n nums_len = len(nums)\n prefix_sum = [0] * (nums_len + 1)\n for i, num in enumerate(nums):\n prefix_sum[i + 1] = prefix_sum[i] + num\n\n cache = {}\n maximum = float(\"-inf\")\n for i, num in enumerate(nums):\n for diff in [num - k, num + k]:\n if cache.get(diff) is not None:\n maximum = max(\n prefix_sum[i + 1] - prefix_sum[cache.get(diff)], maximum\n )\n if cache.get(num) is None:\n cache[num] = i\n elif (cache.get(num) is not None) and (\n (prefix_sum[i] - prefix_sum[cache.get(num)]) < 0\n ):\n cache[num] = i\n\n return maximum if maximum != float(\"-inf\") else 0\n","runtime":"1033"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n suffix_sum = [0 for i in range(len(nums) + 1)]\n for i in range(len(nums) - 1, -1, -1):\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\n\n prefix_sum = [0 for i in range(len(nums) + 1)]\n prev = {}\n prev_max_sums = {}\n\n ans = -inf\n for i in range(1, len(nums) + 1):\n low, high = nums[i-1] - k, nums[i-1] + k\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\n if low in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\n if high in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\n\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\n prev[nums[i-1]] = i - 1\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\n \n if ans == -inf:\n return 0\n\n return ans\n","runtime":"1033"},{"code":"class Solution:\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\n \n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n for a in A:\n pre[a] = min(pre[a], cur)\n cur += a\n res = max(res, cur - pre[a - k], cur - pre[a + k])\n return res if res > -inf else 0 \n","runtime":"1038"},{"code":"class Solution:\n # This solves the problem, but too slow.\n def maximumSubarraySum_slow(self, nums: List[int], k: int) -> int:\n # Find all subarrays [start idx, end idx] that is good.\n sub_arrs = []\n for i in range(0, len(nums)):\n for j in range(i, len(nums)):\n if abs(nums[i] - nums[j]) == k:\n sub_arrs.append([i, j])\n # Calc sum of all possible subarrays.\n sums = []\n for idx in sub_arrs:\n sums.append(sum(nums[idx[0]:idx[1]+1]))\n return max(sums) if sums else 0\n\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","runtime":"1038"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = defaultdict(lambda: inf)\n current_sum = 0\n max_good_subrray_sum = -inf\n for number in nums:\n prefix_sum[number] = min(prefix_sum[number], current_sum)\n current_sum += number\n max_good_subrray_sum = max(max_good_subrray_sum, current_sum - prefix_sum[number-k], current_sum - prefix_sum[number+k])\n \n return max_good_subrray_sum if max_good_subrray_sum != -inf else 0","runtime":"1042"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixs = defaultdict(lambda: inf)\n currsum = 0\n ans = -inf\n for num in nums:\n prefixs[num] = min(prefixs[num],currsum)\n currsum += num\n ans = max(ans,currsum-prefixs[num-k],currsum-prefixs[k+num])\n return ans if ans > -inf else 0","runtime":"1042"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixSum = {}\n cur = 0\n best = float('-inf')\n for num in nums:\n if cur < prefixSum.get(num, float('inf')):\n prefixSum[num] = cur\n cur += num\n down = prefixSum.get(num - k, float('inf'))\n up = prefixSum.get(num + k, float('inf'))\n best = max(best, cur - down, cur - up)\n\n if best == float('-inf'):\n return 0\n else:\n return best\n","runtime":"1046"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -inf\n min_s = defaultdict(lambda: inf)\n s = 0\n for x in nums:\n ans = max(ans, s + x - min(min_s[x - k], min_s[x + k]))\n min_s[x] = min(min_s[x], s)\n s += x\n return ans if ans > -inf else 0","runtime":"1046"},{"code":"class Solution:\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n for a in A:\n pre[a] = min(pre[a], cur)\n cur += a\n res = max(res, cur - pre[a - k], cur - pre[a + k])\n return res if res > -inf else 0","runtime":"1051"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -inf\n\n prefix_sum = 0\n seen = defaultdict(lambda: inf)\n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n\n prefix_sum += n\n\n ans = max(ans, prefix_sum - seen[k + n], prefix_sum - seen[n - k])\n\n return ans if ans != -inf else 0\n","runtime":"1051"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -inf\n\n prefix_sum = 0\n seen = defaultdict(lambda: inf)\n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n \n prefix_sum += n\n\n ans = max(ans, prefix_sum - seen[k + n], \\\n prefix_sum - seen[n - k])\n \n return ans if ans != -inf else 0\n\n","runtime":"1055"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n for a in nums:\n pre[a] = min(pre[a], cur)\n cur += a\n res = max(res, cur - pre[a - k], cur - pre[a + k])\n # print(a, pre, cur, res)\n return res if res > -inf else 0","runtime":"1055"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -math.inf\n min_s = defaultdict(lambda: math.inf)\n s = 0\n for x in nums:\n ans = max(ans, s + x - min(min_s[x-k], min_s[x+k]))\n min_s[x] = min(min_s[x], s)\n s += x\n return ans if ans > - math.inf else 0\n ","runtime":"1059"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = -inf\n pre_sum = 0\n seen = defaultdict(lambda:inf)\n for num in nums:\n seen[num] = min(seen[num], pre_sum)\n pre_sum +=num\n res = max(res, pre_sum-seen[num+k], pre_sum-seen[num-k])\n return res if res != -inf else 0","runtime":"1059"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n output = -inf\n prefix_sum = 0\n min_prefix_sum = defaultdict(lambda: inf)\n\n for num in nums:\n min_prefix_sum[num] = min(min_prefix_sum[num], prefix_sum)\n prefix_sum += num\n # check prefix sum at both complements of num\n output = max(\n output,\n prefix_sum-min_prefix_sum[num+k],\n prefix_sum-min_prefix_sum[num-k]\n )\n\n return output if output>-inf else 0","runtime":"1064"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = -inf\n\n prefix_sum = 0\n seen = defaultdict(lambda: inf)\n \n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n prefix_sum += n\n max_sum = max(max_sum, prefix_sum - seen[k+n], prefix_sum - seen[n-k])\n \n return max_sum if max_sum != -inf else 0\n","runtime":"1064"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixes = defaultdict(lambda: inf)\n ans = -inf\n currSum = 0\n for num in nums:\n prefixes[num] = min(prefixes[num],currSum)\n currSum += num\n ans = max(ans,currSum - prefixes[num-k],currSum - prefixes[num+k])\n return ans if ans > -inf else 0\n","runtime":"1068"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n maxs = float('-inf')\n prefix = 0\n maps = defaultdict(lambda: float('inf'))\n\n for num in nums:\n if maps[num] > prefix:\n maps[num] = prefix\n prefix += num\n\n maxs = max(maxs, prefix - maps[num + k], prefix - maps[num - k])\n return maxs if maxs>float('-inf') else 0\n\n\n","runtime":"1068"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = defaultdict(lambda: inf)\n curr = 0\n res = -inf\n for num in nums:\n prefix_sum[num] = min(prefix_sum[num], curr)\n curr += num\n res = max(res, curr - prefix_sum[num - k], curr - prefix_sum[num + k])\n return res if res != -inf else 0\n","runtime":"1072"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefsum_map = collections.defaultdict(lambda: math.inf)\n prefix_sum, result = 0, -math.inf\n\n for n in nums:\n prefsum_map[n] = min(prefsum_map[n], prefix_sum)\n prefix_sum += n\n result = max(\n result,\n prefix_sum - prefsum_map[n - k],\n prefix_sum - prefsum_map[n + k],\n )\n \n return result if result > -math.inf else 0","runtime":"1072"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n d = defaultdict(lambda: inf)\n ps = 0\n ans = -inf\n for n in nums:\n d[n] = min(d[n],ps)\n ps += n\n ans = max(ans, ps - d[n-k], ps - d[n+k])\n return ans if ans != -inf else 0","runtime":"1077"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum = float('-inf')\n prefix_sum = 0\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\n \n for num in nums:\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n \n prefix_sum += num\n \n # Check and update maximum subarray sum of length k\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n \n return max_sum if max_sum > float('-inf') else 0\n","runtime":"1077"},{"code":"\"\"\"\nCan't sort it\nCan't slide a window\nWhat about two pointers?\n|a - b| = k\na - b = k\na - b = -k\n\na = b - k\na = k - b\nlookup a in hashmap and get it's index to compute a sum\n\na = 0\na = 1 or -1 -> yes at index 0 sum(0, 1) to update max\n{1: 0, 2: 1}\ntotalSum at index i; sum(0, b) = sum(0, a) + sum(a, b)\ntotalSum - prefixSum\n[-1,3,2,4,5]\n\"\"\"\nfrom collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n total_sum = 0\n max_sum = float('-inf')\n complement_map = {}\n\n for index in range(len(nums)): # 4\n num = nums[index] # 5\n complements = [num - k, num + k] # -12, 12\n for complement in complements:\n if complement in complement_map:\n curr_sum = total_sum - complement_map[complement] # 8 - 4 = 4\n max_sum = max(max_sum, curr_sum + num) # 4\n\n complement_map[num] = min(total_sum, complement_map.get(num, float('inf'))) # {-1: 0, 3: 1, 2: 2, 4: 3, 5: 4}\n \n total_sum += num # 8 + 5 = 13\n\n return max_sum if max_sum != float('-inf') else 0\n \n","runtime":"1081"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixes = defaultdict(lambda: inf)\n ans = -inf\n currSum = 0\n for i in range(len(nums)):\n prefixes[nums[i]] = min(prefixes[nums[i]],currSum)\n currSum += nums[i]\n ans = max(ans,currSum-prefixes[nums[i]-k],currSum-prefixes[nums[i]+k])\n if ans == -inf:\n return 0\n else:\n return ans\n\n","runtime":"1081"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n seen = defaultdict(lambda: inf)\n prefix_sum = 0\n res = -inf\n\n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n prefix_sum += n\n x = prefix_sum - seen[n + k]\n y = prefix_sum - seen[n - k]\n res = max(res, x, y)\n \n if res == -inf:\n return 0\n return res\n","runtime":"1094"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# m = len(nums)\n# accu = list(accumulate(nums))\n# # print(accu)\n# ref=defaultdict(list)\n# for i in range(m):\n# v = nums[i]\n# ref[v].append(i)\n# res = -math.inf\n# for i in range(m):\n# accu1 = accu[i-1] if i>0 else 0\n# v = nums[i]\n# tar1 = v+k\n# tar2 = v-k\n# idx = bisect_left(ref[tar1],i+1)\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\n# if idx<len(ref[tar1]):\n# # print('1')\n# for j in range(idx,len(ref[tar1])):\n# idx2 = ref[tar1][j]\n# accu2 = accu[idx2]\n# res = max(res,accu2-accu1)\n# idx = bisect_left(ref[tar2],i+1)\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\n# if idx<len(ref[tar2]):\n# # print('1')\n# for j in range(idx,len(ref[tar2])):\n# idx2 = ref[tar2][j]\n# accu2 = accu[idx2]\n# res = max(res,accu2-accu1)\n \n\n# return res if res!=-math.inf else 0\n\n\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_left = defaultdict(lambda: inf)\n res = -inf\n cur = 0 \n\n for x in nums:\n prefix_left[x] = min(prefix_left[x], cur)\n cur += x\n\n if x-k in prefix_left:\n res = max(res, cur - prefix_left[x-k])\n if x+k in prefix_left:\n res = max(res, cur - prefix_left[x+k])\n\n return res if res!=-inf else 0\n \nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = defaultdict(int)\n res = -math.inf\n cur=0\n for num in nums:\n prefix[num] = min(prefix[num] if num in prefix else math.inf,cur)\n cur+=num\n if num+k not in prefix:\n prefix[num+k]=math.inf\n if num-k not in prefix:\n prefix[num-k]=math.inf\n res = max(res, cur-prefix[num+k])\n res = max(res, cur-prefix[num-k])\n # print(f'res:{res} num:{num} num+k:{prefix[num+k]} num-k:{prefix[num-k]} prefix:{prefix}')\n return res if res!=-math.inf else 0","runtime":"1094"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n prefix_sum = 0\n lookup = collections.defaultdict(lambda: math.inf)\n n = len(nums)\n res = -math.inf\n for i in range(n):\n if lookup[nums[i]] > prefix_sum:\n lookup[nums[i]] = prefix_sum\n prefix_sum += nums[i]\n res= max(prefix_sum - lookup[nums[i] - k], res)\n res= max(prefix_sum - lookup[nums[i] + k], res)\n return res if res != -math.inf else 0\n \n\n ","runtime":"1098"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pre = [nums[0]]\n for num in nums[1:]: pre.append(pre[-1] + num)\n loc = defaultdict(list)\n ret = -inf\n for i, num in enumerate(nums):\n if loc[num+k]:\n ret = max(ret, pre[i] - loc[num+k][0])\n if loc[num-k]:\n ret = max(ret, pre[i] - loc[num-k][0])\n heapq.heappush(loc[num], pre[i-1] if i > 0 else 0)\n heapq.heappush(loc[num], pre[i-1] if i > 0 else 0)\n return ret if ret != -inf else 0","runtime":"1098"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = []\n \n good_sum = {} # key - nums[i] = k or key - nums[i] = -k\n ans = -float('inf')\n\n max_sum = {}\n\n for i in range(len(nums)):\n if (i == 0):\n prefix_sum.append(nums[0])\n else:\n prefix_sum.append(prefix_sum[i - 1] + nums[i])\n\n if nums[i] in good_sum:\n\n ans = max(ans, prefix_sum[i] - good_sum[nums[i]]) \n\n difference = nums[i] - k\n total = k + nums[i]\n\n if difference not in good_sum:\n good_sum[difference] = prefix_sum[i] - nums[i]\n \n if total not in good_sum:\n good_sum[total] = prefix_sum[i] - nums[i]\n\n good_sum[difference] = min(good_sum[difference], prefix_sum[i] - nums[i])\n good_sum[total] = min(good_sum[total], prefix_sum[i] - nums[i])\n\n return ans if ans != -float('inf') else 0\n ","runtime":"1103"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = defaultdict(lambda: float('inf'))\n curr = 0\n res = float('-inf')\n for num in nums:\n prefix[num] = min(prefix[num], curr)\n curr += num\n res = max(res, curr - prefix[num - k], curr - prefix[num + k])\n return res if res != float('-inf') else 0","runtime":"1103"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # 1.2: Prefix Sum + Dict + min Heap(optimize)\n # think: don't want to loop through all start indexes, because number of valid start could be large\n # idea: only want to know the start index with the smallest prefix sum\n # => store indexes for each num sorted by prefix sum\n # O(nlogn): push n nums to heap\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\n for num in nums:\n prefix_sum.append(prefix_sum[-1] + num)\n # Optimize: store idx of prev nums in minHeap, sorted by prefixsum[i]\n prev_indexes = collections.defaultdict(list) \n res = None\n\n for i, num in enumerate(nums):\n if prev_indexes[num + k]:\n start_i = prev_indexes[num + k][0][1]\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n if prev_indexes[num - k]:\n start_i = prev_indexes[num - k][0][1]\n\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n # Add cur index to min heap, sorted by prefix_sum[i]\n heapq.heappush(prev_indexes[num], (prefix_sum[i], i))\n return 0 if res is None else res\n\n\n # 1. [!TLE 780/782] My Approach: Dict + Prefix Sum\n # Challenge 1: how to find good subarray(similar to Two Sum)\n # sol: record indexes of previous seen num, so at each num, can use any of the prev indexes of target num as start of subarray\n # note: k>=1 so a single value is not valid subarray\n # Challenge 2: don't want to sum subarray repeatedly\n # sol: use prefix sum to allow O(1) calculate of subarray sum\n # O(n^2): for each num, loop through all possible starts\n\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\n for num in nums:\n prefix_sum.append(prefix_sum[-1] + num)\n prev_indexes = collections.defaultdict(list) # store idx of prev nums\n res = None\n for i, num in enumerate(nums):\n # check if target(num +/- k) start exists\n for prev_i in prev_indexes[num - k]:\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n for prev_i in prev_indexes[num + k]:\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n # add to prev_indexes\n prev_indexes[num].append(i)\n\n return 0 if res is None else res","runtime":"1107"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = 0\n\n # brute force solution\n # for i in range(len(nums)):\n # for j in range(i + 1, len(nums)):\n # if abs(nums[j] - nums[i]) == k:\n # res = max(res, sum(nums[i:j + 1]))\n \n # return res\n\n # keep track of sum so far\n prefix_left = defaultdict(lambda: float('inf'))\n res = float('-inf')\n prefix_sum = 0 # sum so far\n\n for num in nums:\n # the prefix_left map keeps track of last occuring val of num such that \n # is has the LOWEST corresponding prefix_sum\n # because we need to maximize subarray sum\n # and subarray sum is sum at curr index - sum at last index\n # == prefix_sum - prefix_left(abs(k - i))\n prefix_left[num] = min(prefix_left[num], prefix_sum)\n prefix_sum += num\n \n res = max(res, \n prefix_sum - prefix_left[num + k], \n prefix_sum - prefix_left[num - k])\n \n return res if res > float('-inf') else 0\n\n\n\n ","runtime":"1107"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixSum = [0]\n mp = dict()\n goodSum = -float(\"inf\")\n for i in range(len(nums)):\n prefixSum.append(nums[i]+prefixSum[i])\n mp[nums[i]] = min(mp.get(nums[i], float(\"inf\")), prefixSum[i])\n prefixI = float(\"inf\")\n if (nums[i] +k) in mp:\n prefixI = min(mp[nums[i]+k], prefixI)\n if (nums[i] -k) in mp:\n prefixI = min(mp[nums[i]-k], prefixI)\n if prefixI != float(\"inf\"):\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\n return goodSum if goodSum != -float(\"inf\") else 0\n \n ","runtime":"1111"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n rightNumPrefix = 0\n smallestPrefixMap = {} #map a num to smallest prefix\n result = -float('inf')\n for rightNum in nums:\n rightNumPrefix += rightNum\n leftNum1 = rightNum - k\n leftNum2 = rightNum + k\n smallestPrefixMap[rightNum] = min(rightNumPrefix, smallestPrefixMap.get(rightNum,float('inf')))\n result = max(result, rightNumPrefix - smallestPrefixMap.get(leftNum1,float('inf')) + leftNum1,\n rightNumPrefix - smallestPrefixMap.get(leftNum2,float('inf')) + leftNum2)\n if result == -float('inf'): return 0\n return result\n","runtime":"1111"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n def solve(arr):\n n = len(arr)\n pre = [arr[i] for i in range(n)]\n for i in range(1 , n):\n pre[i] += pre[i-1]\n \n def get(i , j):\n if not i:\n return pre[j]\n return pre[j] - pre[i-1]\n\n mp = {}\n ans = float(\"-inf\")\n j = 0\n while j < n:\n vali = arr[j] - k\n if vali in mp:\n ix = mp[vali]\n ans = max(ans , get(ix , j))\n \n if arr[j] in mp:\n if get(mp[arr[j]] , j - 1) < 0:\n mp[arr[j]] = j\n else:\n mp[arr[j]] = j\n \n j += 1\n \n return ans\n\n v = max(solve(nums) , solve(nums[::-1]))\n return 0 if v == float(\"-inf\") else v\n ","runtime":"1116"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = [0] * (len(nums) + 1)\n INF = float('inf')\n\n for idx, num in enumerate(nums, 1):\n prefix_sum[idx] = prefix_sum[idx - 1] + num\n\n prev_sum = defaultdict(lambda: INF)\n ans = -INF\n\n for idx, num in enumerate(nums):\n ans = max(ans, prefix_sum[idx + 1] - prev_sum[num - k], prefix_sum[idx + 1] - prev_sum[num + k])\n\n if num not in prev_sum:\n prev_sum[num] = INF\n\n prev_sum[num] = min(prev_sum[num], prefix_sum[idx])\n\n return ans if ans != -INF else 0","runtime":"1116"},{"code":"# class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# m = len(nums)\n# accu = list(accumulate(nums))\n# # print(accu)\n# ref=defaultdict(list)\n# for i in range(m):\n# v = nums[i]\n# ref[v].append(i)\n# res = -math.inf\n# for i in range(m):\n# accu1 = accu[i-1] if i>0 else 0\n# v = nums[i]\n# tar1 = v+k\n# tar2 = v-k\n# idx = bisect_left(ref[tar1],i+1)\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\n# if idx<len(ref[tar1]):\n# # print('1')\n# for j in range(idx,len(ref[tar1])):\n# idx2 = ref[tar1][j]\n# accu2 = accu[idx2]\n# res = max(res,accu2-accu1)\n# idx = bisect_left(ref[tar2],i+1)\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\n# if idx<len(ref[tar2]):\n# # print('1')\n# for j in range(idx,len(ref[tar2])):\n# idx2 = ref[tar2][j]\n# accu2 = accu[idx2]\n# res = max(res,accu2-accu1)\n \n\n# return res if res!=-math.inf else 0\n\n\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_left = defaultdict(lambda: inf)\n res = -inf\n cur = 0 \n\n for x in nums:\n prefix_left[x] = min(prefix_left[x], cur)\n cur += x\n\n if x-k in prefix_left:\n res = max(res, cur - prefix_left[x-k])\n if x+k in prefix_left:\n res = max(res, cur - prefix_left[x+k])\n\n return res if res!=-inf else 0\n \nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = defaultdict(lambda:math.inf)\n res = -math.inf\n cur=0\n for num in nums:\n prefix[num] = min(prefix[num],cur)\n cur+=num\n if num+k not in prefix:\n prefix[num+k]=math.inf\n if num-k not in prefix:\n prefix[num-k]=math.inf\n res = max(res, cur-prefix[num+k])\n res = max(res, cur-prefix[num-k])\n # print(f'res:{res} num:{num} num+k:{prefix[num+k]} num-k:{prefix[num-k]} prefix:{prefix}')\n return res if res!=-math.inf else 0","runtime":"1120"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n counter = {}\n ans = float(\"-inf\")\n prefix_sum = 0\n for val in nums:\n prefix_sum += val\n for prev in [val - k, val + k]:\n if prev not in counter:\n continue\n print(ans, prefix_sum - counter[prev])\n ans = max(ans, prefix_sum - counter[prev])\n counter[val] = min(counter.get(val, prefix_sum - val), prefix_sum - val)\n #print(\"ans is \", ans)\n return ans if ans > float(\"-inf\") else 0","runtime":"1124"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # |a - b| = k => a - b = k or a - b = -k\n # a is cur\n # b is prev\n # cur - prev = k => prev = cur - k\n # or \n # cur - prev = -k => prev = cur + k\n\n value_maps = defaultdict(list)\n \n # get prefix sum\n prefix_sum = [0]*len(nums)\n cur_sum = 0\n\n max_diff = -math.inf\n prev = -math.inf\n # calculate\n for i, cur in enumerate(nums):\n prefix_sum[i] = cur_sum\n heapq.heappush(value_maps[cur], (cur_sum, i))\n cur_sum += cur\n\n if len(value_maps[cur - k]) > 0:\n idx = value_maps[cur - k][0][1]\n max_diff = max(max_diff, prefix_sum[i] - prefix_sum[idx] + cur)\n \n if len(value_maps[cur + k]) > 0:\n idx = value_maps[cur + k][0][1]\n max_diff = max(max_diff, prefix_sum[i] - prefix_sum[idx] + cur)\n \n if max_diff == -math.inf:\n return 0\n\n return max_diff\n ","runtime":"1124"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = -inf\n n = len(nums)\n minS = defaultdict(lambda: inf)\n prefix = [0] * (n+1)\n for i in range(1,n+1):\n prefix[i] = prefix[i-1] + nums[i-1]\n\n for i, x in enumerate(nums):\n ans = max(ans, prefix[i+1] - minS[k+x], prefix[i+1] - minS[x-k])\n minS[x] = min(minS[x], prefix[i])\n\n return ans if ans != -inf else 0","runtime":"1129"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixLeft = defaultdict(lambda: float('inf'))\n res = float('-inf')\n \n \n prefixLeftSoFar = 0\n for num in nums:\n prefixLeft[num] = min(prefixLeft[num], prefixLeftSoFar)\n\n prefixLeftSoFar += num\n\n res = max(\n res, \n prefixLeftSoFar - prefixLeft[num - k],\n prefixLeftSoFar - prefixLeft[num + k]\n )\n \n return res if res > float('-inf') else 0","runtime":"1129"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n max_sum = float('-inf')\n prefix_sum = 0\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\n\n # Iterate through every value in the array\n for i, num in enumerate(nums):\n # Update the minimum prefix sum for the current number\n val_to_min_prefix_sum[num] = min(val_to_min_prefix_sum[num], prefix_sum)\n\n # Update the current prefix sum\n prefix_sum += num\n\n # Calculate max_sum considering subarrays that satisfy the condition with k\n max_sum = max(max_sum, \n prefix_sum - val_to_min_prefix_sum[num + k], \n prefix_sum - val_to_min_prefix_sum[num - k])\n\n return max_sum if max_sum != float('-inf') else 0","runtime":"1133"},{"code":"from collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n history = defaultdict(lambda: float('inf'))\n current_sum = 0\n best = float('-inf')\n\n for n in nums:\n history[n] = min(history[n], current_sum)\n current_sum += n\n best = max(best, current_sum - history[n - k], current_sum - history[n + k])\n \n return best if best > float('-inf') else 0\n\n\n ","runtime":"1133"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ans = float(\"-inf\")\n prefix_sum = 0\n seen = defaultdict(lambda: float(\"inf\"))\n\n for n in nums:\n seen[n] = min(seen[n], prefix_sum)\n prefix_sum += n\n\n ans = max(ans, prefix_sum - seen[n + k], prefix_sum - seen[n - k])\n \n return ans if ans != float(\"-inf\") else 0","runtime":"1137"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n result = -math.inf\\n prefix = 0\\n numToPrefix = {}\\n for num in nums:\\n if num not in numToPrefix or numToPrefix[num] > prefix:\\n numToPrefix[num] = prefix\\n prefix += num\\n if num + k in numToPrefix:\\n result = max(result, prefix - numToPrefix[num + k])\\n if num - k in numToPrefix:\\n result = max(result, prefix - numToPrefix[num - k])\\n return 0 if result == -math.inf else result\\n\",\n \"runtime\": \"795\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n isum = 0\\n psum = {} # v: min prefix sum with end=v\\n imax = -10**15\\n for v in nums:\\n isum += v\\n if v-k in psum:\\n imax = max(imax,isum-psum[v-k]+v-k)\\n if v+k in psum:\\n imax = max(imax,isum-psum[v+k]+v+k)\\n if v not in psum or psum[v]>isum:\\n psum[v] = isum\\n #\\n if imax==-10**15: return 0\\n return imax\",\n \"runtime\": \"795\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n allSum = 0\\n prefixSums = {}\\n highestSum = float('-inf')\\n\\n for i in range(len(nums)):\\n allSum += nums[i]\\n\\n first_num = k + nums[i]\\n if first_num in prefixSums:\\n subarray_sum = allSum - prefixSums[first_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n\\n second_num = -k + nums[i]\\n if second_num in prefixSums:\\n subarray_sum = allSum - prefixSums[second_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n if nums[i] in prefixSums:\\n if allSum - nums[i] < prefixSums[nums[i]]:\\n prefixSums[nums[i]] = allSum - nums[i]\\n else:\\n prefixSums[nums[i]] = allSum - nums[i]\\n \\n return highestSum if highestSum != float('-inf') else 0\\n\",\n \"runtime\": \"812\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n d_cum = dict()\\n \\n res = -float('inf')\\n prefix_sum = 0\\n for num in nums:\\n if num in d_cum:\\n d_cum[num] = min(d_cum[num],prefix_sum)\\n else:\\n d_cum[num] = prefix_sum\\n prefix_sum +=num\\n\\n dif1 = num+k\\n dif2 = num-k\\n if dif1 in d_cum:\\n res = max(res,prefix_sum-d_cum[dif1])\\n\\n if dif2 in d_cum:\\n res = max(res,prefix_sum-d_cum[dif2])\\n \\n\\n return res if res!= -float('inf') else 0\\n \\n \",\n \"runtime\": \"812\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -math.inf\\n prefix = 0\\n numToMinPrefix = {}\\n\\n for num in nums:\\n if num not in numToMinPrefix or numToMinPrefix[num] > prefix:\\n numToMinPrefix[num] = prefix\\n prefix += num\\n if num + k in numToMinPrefix:\\n ans = max(ans, prefix - numToMinPrefix[num + k])\\n if num - k in numToMinPrefix:\\n ans = max(ans, prefix - numToMinPrefix[num - k])\\n\\n return 0 if ans == -math.inf else ans\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n res = float('-inf')\\n currSum = 0\\n prefixMap = dict()\\n\\n for i, num in enumerate(nums):\\n\\n if num not in prefixMap or currSum < prefixMap[num]:\\n prefixMap[num] = currSum\\n \\n currSum += num\\n\\n if num + k in prefixMap:\\n res = max (res, currSum - prefixMap[num+k])\\n if num - k in prefixMap:\\n res = max(res, currSum - prefixMap[num-k])\\n \\n\\n return 0 if res == float('-inf') else res\\n\",\n \"runtime\": \"816\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n# mp = {}\\n# res, sumVal = 0, 0 \\n \\n# for idx, num in enumerate(nums):\\n \\n# if num not in mp or mp[num] > sumVal:\\n# mp[num] = sumVal\\n \\n# sumVal += num\\n \\n# if num - k in mp:\\n# res = max(res, abs(sumVal - mp[num-k]))\\n \\n# if num + k in mp:\\n# res = max(res, sumVal - mp[num+k])\\n# return res\\n\\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\\n sumVal, res = 0, -math.inf\\n \\n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\\n mp = {}\\n \\n # Iterate through each number num in nums\\n for idx, num in enumerate(nums):\\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\\n if num not in mp or mp[num] > sumVal:\\n mp[num] = sumVal\\n \\n # Update sumVal by adding num to it, representing the running sum up to the current number\\n sumVal += num\\n \\n # Check if num - k exists in mp\\n if num - k in mp:\\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\\n res = max(sumVal - mp[num - k], res)\\n \\n # Check if num + k exists in mp\\n if num + k in mp:\\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\\n res = max(sumVal - mp[num + k], res)\\n \\n # Return res if it is not equal to negative infinity, otherwise return 0\\n return res if res != -math.inf else 0\",\n \"runtime\": \"821\"\n },\n {\n \"code\": \"\\ndef mgs(nums, k):\\n n = len(nums)\\n\\n \\n hsh = {}\\n rsum = 0\\n maxi = None\\n update_max = lambda val: max(val, maxi) if maxi is not None else val\\n\\n for i in range(n):\\n el = nums[i]\\n\\n if el - k in hsh:\\n val = rsum + el - hsh[el - k]\\n maxi = update_max(val)\\n if el + k in hsh:\\n val = rsum + el - hsh[el + k]\\n maxi = update_max(val)\\n \\n # store the prefix sum till el before\\n if el not in hsh or hsh[el] > rsum:\\n hsh[el] = rsum\\n rsum += el\\n\\n return maxi if maxi is not None else 0\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n return mgs(nums, k)\",\n \"runtime\": \"821\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n curSum, res = 0, -math.inf\\n mp = {}\\n\\n for idx, num in enumerate(nums):\\n if num not in mp or curSum < mp[num]:\\n mp[num] = curSum\\n\\n curSum += num\\n\\n if num - k in mp:\\n res = max(curSum - mp[num - k], res)\\n\\n if num + k in mp:\\n res = max(curSum - mp[num + k], res)\\n\\n return res if res != -math.inf else 0\\n\",\n \"runtime\": \"825\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n minPrefSum = dict()\\n currentSum = 0\\n \\n bestSum = -math.inf \\n \\n for val in nums:\\n if val in minPrefSum:\\n minPrefSum[val] = min(minPrefSum[val], currentSum)\\n else:\\n minPrefSum[val] = currentSum\\n currentSum += val\\n \\n if val + k in minPrefSum:\\n bestSum = max(bestSum, currentSum - minPrefSum[val + k])\\n \\n if val - k in minPrefSum:\\n bestSum = max(bestSum, currentSum - minPrefSum[val - k]) \\n \\n \\n \\n \\n return bestSum if bestSum > -math.inf else 0 \",\n \"runtime\": \"825\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n s = 0\\n psum = [0]\\n idxDict = {}\\n ans = -float('inf')\\n\\n for idx, n in enumerate(nums):\\n s += n\\n psum.append(s)\\n\\n if n - k in idxDict:\\n ans = max(s - psum[idxDict[n - k]], ans)\\n if n + k in idxDict:\\n ans = max(s - psum[idxDict[n + k]], ans)\\n if n not in idxDict or psum[idxDict[n]] > psum[-2]:\\n idxDict[n] = idx\\n\\n return ans if ans != -float('inf') else 0\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = float('-inf')\\n \\n preSum = defaultdict(int) # stores {num: max agg values ending at num}\\n agg = 0\\n\\n for num in nums:\\n agg += num\\n\\n # if num + k seen before in preSum, then num + k - num = k\\n # so the total sum between them is agg - preSum[num + k]\\n if num + k in preSum:\\n head = num + k\\n res = max(res, agg - preSum[num + k] + head)\\n\\n # if num - k seen before in preSum, then num - (num - k) = k\\n # so the total sum between them is agg - preSum[num - k]\\n if num - k in preSum:\\n head = num - k\\n res = max(res, agg - preSum[num - k] + head)\\n\\n # map current num to agg value \\n if num not in preSum:\\n preSum[num] = agg\\n else:\\n preSum[num] = min(preSum[num], agg)\\n\\n return res if res != float('-inf') else 0\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # prefix sum\\n prefix_dt = {}\\n cur_sum = 0\\n ans = float(\\\"-inf\\\")\\n for n in nums:\\n cur_sum += n\\n if n+k in prefix_dt:\\n ans = max(ans, cur_sum + n + k - prefix_dt[n+k])\\n if n-k in prefix_dt:\\n ans = max(ans, cur_sum + n - k - prefix_dt[n-k])\\n if n not in prefix_dt:\\n prefix_dt[n] = cur_sum\\n else:\\n prefix_dt[n] = min(prefix_dt[n], cur_sum)\\n #print(prefix_dt)\\n return ans if ans != float(\\\"-inf\\\") else 0\\n\\n # two pointers\\n max_sum = 0\\n ans = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n prefix = nums[i]\\n for j in range(i+1, len(nums)):\\n prefix += nums[j]\\n if abs(nums[i] - nums[j]) == k:\\n ans = max(ans, prefix)\\n return ans if ans != float(\\\"-inf\\\") else 0\\n\",\n \"runtime\": \"834\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixes = {}\\n currSum = 0\\n ans = -inf\\n\\n for num in nums:\\n if num in prefixes:\\n prefixes[num] = min(prefixes[num],currSum)\\n else:\\n prefixes[num] = currSum\\n currSum+=num\\n if num-k in prefixes:\\n ans = max(ans,currSum - prefixes[num-k])\\n if num+k in prefixes:\\n ans = max(ans,currSum - prefixes[num+k])\\n\\n return ans if ans > -inf else 0\",\n \"runtime\": \"834\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [0] + list(accumulate(nums))\\n ans = -float('inf')\\n m = {}\\n for i, x in enumerate(nums):\\n if x - k in m:\\n ans = max(ans, prefix[i+1] - prefix[m[x-k]])\\n if k + x in m:\\n ans = max(ans, prefix[i+1] - prefix[m[k+x]])\\n if x not in m or prefix[m[x]] > prefix[i]:\\n m[x] = i\\n return ans if ans != -float('inf') else 0\\n \",\n \"runtime\": \"838\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n '''\\n 1. Calculate the sum of the array\\n '''\\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\\n sumVal, res = 0, -math.inf\\n \\n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\\n mp = {}\\n \\n # Iterate through each number num in nums\\n for idx, num in enumerate(nums):\\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\\n if num not in mp or mp[num] > sumVal:\\n mp[num] = sumVal\\n \\n # Update sumVal by adding num to it, representing the running sum up to the current number\\n sumVal += num\\n \\n # Check if num - k exists in mp\\n if num - k in mp:\\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\\n res = max(sumVal - mp[num - k], res)\\n \\n # Check if num + k exists in mp\\n if num + k in mp:\\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\\n res = max(sumVal - mp[num + k], res)\\n \\n # Return res if it is not equal to negative infinity, otherwise return 0\\n return res if res != -math.inf else 0\",\n \"runtime\": \"838\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n #currsum - prefix_sum is the sum of the curr subarray\\n curr_sum = 0 \\n # max_sum tracks the best sum\\n max_sum = float('-inf')\\n # use hashmap (number, prefix sum) to keep track of the array we saw\\n hashmap = dict()\\n # loop through the array to add to hashmap\\n\\n for num in nums:\\n prefix_sum = curr_sum\\n curr_sum += num\\n if k+num in hashmap:\\n max_sum = max(max_sum,curr_sum-hashmap[k+num])\\n if num-k in hashmap:\\n max_sum = max(max_sum,curr_sum-hashmap[num-k])\\n \\n if num in hashmap:\\n hashmap[num]=min(hashmap[num],prefix_sum)\\n else:\\n hashmap[num] = prefix_sum\\n \\n return max_sum if max_sum>float('-inf') else 0\\n\\n \",\n \"runtime\": \"842\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n allSum = 0\\n prefixSums = {}\\n highestSum = float('-inf')\\n\\n for i in range(len(nums)):\\n allSum += nums[i]\\n\\n first_num = k + nums[i]\\n if first_num in prefixSums:\\n subarray_sum = allSum - prefixSums[first_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n\\n second_num = -k + nums[i]\\n if second_num in prefixSums:\\n subarray_sum = allSum - prefixSums[second_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n if nums[i] in prefixSums:\\n if allSum - nums[i] < prefixSums[nums[i]]:\\n prefixSums[nums[i]] = allSum - nums[i]\\n else:\\n prefixSums[nums[i]] = allSum - nums[i]\\n \\n return highestSum if highestSum != float('-inf') else 0\\n\",\n \"runtime\": \"842\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n allSum = 0\\n prefixSums = {}\\n highestSum = float('-inf')\\n\\n for i in range(len(nums)):\\n allSum += nums[i]\\n\\n first_num = k + nums[i]\\n # if highestSum > 155:\\n # print(f' nums[i {nums[i]}')\\n # print(f'allSum {allSum}')\\n # print(prefixSums)\\n # print(f'first_num {first_num}')\\n if first_num in prefixSums:\\n # print('first num in')\\n subarray_sum = allSum - prefixSums[first_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n \\n \\n second_num = -k + nums[i]\\n # print(f'second_num {second_num}')\\n if second_num in prefixSums:\\n # print('second num in')\\n subarray_sum = allSum - prefixSums[second_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n # print(f'highestSum {highestSum}')\\n if nums[i] in prefixSums:\\n if allSum - nums[i] < prefixSums[nums[i]]:\\n prefixSums[nums[i]] = allSum - nums[i]\\n else:\\n prefixSums[nums[i]] = allSum - nums[i]\\n \\n return highestSum if highestSum != float('-inf') else 0\\n\\n \\n \\n\\n\",\n \"runtime\": \"847\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n curr = 0\\n n = len(nums)\\n # maybe store minimum presum value?\\n dic = {}\\n maxim = float('-inf')\\n for idx, i in enumerate(nums):\\n dic[i] = min(dic[i], curr) if i in dic else curr\\n curr += i\\n if i+k in dic:\\n maxim = max(maxim, curr - dic[i+k])\\n if i-k in dic:\\n maxim = max(maxim, curr - dic[i-k])\\n\\n \\n \\n return maxim if maxim != float('-inf') else 0\\n \\n\\n \\n\",\n \"runtime\": \"847\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n s = 0\\n psum = [0]\\n idxDict = {} # keeps track of the idx in which a certain prefix sum was found\\n ans = -float('inf')\\n\\n for idx, n in enumerate(nums):\\n prevSum = s\\n s += n\\n psum.append(s)\\n smallerDiff = n - k\\n biggerDiff = n + k\\n\\n if smallerDiff in idxDict:\\n smallDiffIdx = idxDict[smallerDiff]\\n ans = max(s - psum[smallDiffIdx], ans)\\n if n + k in idxDict:\\n bigDiffIdx = idxDict[biggerDiff]\\n ans = max(s - psum[bigDiffIdx], ans)\\n if n not in idxDict or psum[idxDict[n]] > prevSum:\\n idxDict[n] = idx\\n\\n return ans if ans != -float('inf') else 0\",\n \"runtime\": \"851\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n allSum = 0\\n prefixSums = {}\\n highestSum = float('-inf')\\n\\n for i in range(len(nums)):\\n allSum += nums[i]\\n\\n first_num = k + nums[i]\\n if first_num in prefixSums:\\n subarray_sum = allSum - prefixSums[first_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n \\n \\n second_num = -k + nums[i]\\n if second_num in prefixSums:\\n subarray_sum = allSum - prefixSums[second_num]\\n if subarray_sum > highestSum:\\n highestSum = subarray_sum\\n if nums[i] in prefixSums:\\n if allSum - nums[i] < prefixSums[nums[i]]:\\n prefixSums[nums[i]] = allSum - nums[i]\\n else:\\n prefixSums[nums[i]] = allSum - nums[i]\\n \\n return highestSum if highestSum != float('-inf') else 0\\n\",\n \"runtime\": \"851\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # Forming the prefix sum\\n temp_sum = 0 # Initialize a running sum variable\\n prefix_sum = [0] # Prefix sum array, starting with 0 for easier calculations\\n for num in nums:\\n temp_sum += num\\n prefix_sum.append(temp_sum)\\n \\n \\n seen = {} # Dictionary to store the latest index of each number\\n res = -float('inf') # Initialize result to negative infinity to track the maximum\\n for right, num in enumerate(nums):\\n \\n if (num - k) in seen:\\n left = seen[num - k]\\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\\n res = max(res, subarray_sum)\\n \\n if (num + k) in seen:\\n left = seen[num + k]\\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\\n res = max(res, subarray_sum)\\n \\n # Update the dictionary with the current number and its index\\n # If this number hasn't been seen before, or the current prefix sum is larger than\\n # the one at the stored index, update the dictionary\\n if num not in seen or prefix_sum[seen[num]] >= prefix_sum[right]:\\n seen[num] = right\\n \\n # Return the result, if it hasn't changed return 0 (indicating no subarray found)\\n return res if res != -float('inf') else 0\",\n \"runtime\": \"855\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # from collections import defaultdict\\n # maxsum = float('-inf')\\n # hashmap = defaultdict(list)\\n # prefixsum = defaultdict(int)\\n # presum = 0\\n # # for i in range(len(nums)):\\n \\n # for i in range(len(nums)):\\n # hashmap[nums[i]].append(i)\\n # presum += nums[i]\\n # prefixsum[i] = presum\\n # if k + nums[i] in hashmap:\\n # for index in hashmap[k + nums[i]]:\\n # m, n = min(index, i), max(index, i)\\n # maxsum = max(maxsum, prefixsum[n] - (prefixsum[m - 1] if m > 0 else 0))\\n # if - k + nums[i] in hashmap:\\n # for index in hashmap[- k + nums[i]]:\\n # m, n = min(index, i), max(index, i)\\n # maxsum = max(maxsum, prefixsum[n] - (prefixsum[m - 1] if m > 0 else 0)) \\n # return maxsum if maxsum != float('-inf') else 0\\n\\n n = len(nums)\\n prefix_sum = [0] * (n + 1)\\n for i, num in enumerate(nums):\\n prefix_sum[i + 1] = prefix_sum[i] + num\\n seen = {}\\n ans = float('-inf')\\n for i, num in enumerate(nums):\\n if num - k in seen:\\n j = seen[num - k]\\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\\n if num + k in seen:\\n j = seen[num + k]\\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\\n if num in seen:\\n j = seen[num]\\n if prefix_sum[i] - prefix_sum[j] < 0:\\n seen[num] = i\\n else:\\n seen[num] = i\\n return ans if ans > float('-inf') else 0\\n\\n \",\n \"runtime\": \"855\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # Forming the prefix sum\\n temp_sum = 0 # Initialize a running sum variable\\n prefix_sum = [0] # Prefix sum array, starting with 0 for easier calculations\\n for num in nums:\\n temp_sum += num\\n prefix_sum.append(temp_sum)\\n \\n \\n seen = {} # Dictionary to store the latest index of each number\\n res = -float('inf') # Initialize result to negative infinity to track the maximum\\n for right, num in enumerate(nums):\\n \\n if (num - k) in seen:\\n left = seen[num - k]\\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\\n res = max(res, subarray_sum)\\n \\n if (num + k) in seen:\\n left = seen[num + k]\\n subarray_sum = prefix_sum[right + 1] - prefix_sum[left]\\n res = max(res, subarray_sum)\\n \\n # Update the dictionary with the current number and its index\\n # If this number hasn't been seen before, or the current prefix sum is larger than\\n # the one at the stored index, update the dictionary\\n if num not in seen or prefix_sum[seen[num]] >= prefix_sum[right]:\\n seen[num] = right\\n \\n # Return the result, if it hasn't changed return 0 (indicating no subarray found)\\n return res if res != -float('inf') else 0\",\n \"runtime\": \"860\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # questions: duplicate values? --> YES THERE ARE\\n # edge cases: 0, 1, or 2 elements --> looks like min length will be 2 elems\\n # brute force: look through each pair of values and check if their abs difference is k\\n # - keep track of those indices\\n # - get everything in between and sum it up\\n # - nested loops needed -> O(n^2)\\n # another idea:\\n # - hash table where key is the integer and value is the index in the original nums array\\n # - loop through the nums array once\\n # - find what number is necessary for the difference to be k\\n # - if that number exists in the dictionary, keep track of the index pair (i, j)\\n # - loop through index pairs and find the max sum of the sub array\\n # - time: O(n), space: O(n)\\n # ^^^^ DIDNT WORK BC DOESNT DEAL WITH DUPLICATES\\n # solution:\\n # - hash table where key is the integer num and value is the current minimum prefix sum\\n # - update current good subarray max sum for every num we traverse through\\n\\n n = len(nums)\\n prefix_sum = [0] * (n + 1)\\n for i, num in enumerate(nums):\\n prefix_sum[i + 1] = prefix_sum[i] + num\\n\\n seen = {}\\n ans = float('-inf')\\n\\n for i, num in enumerate(nums):\\n if num - k in seen:\\n j = seen[num - k]\\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j]) # prefix sum is [i + 1] bc we have an extra 0 at the beginning of our prefix sum list\\n if num + k in seen:\\n j = seen[num + k]\\n ans = max(ans, prefix_sum[i + 1] - prefix_sum[j])\\n if num in seen:\\n j = seen[num]\\n # only update the index of the number if it will contribute to max sum\\n if prefix_sum[i] < prefix_sum[j]:\\n seen[num] = i\\n else:\\n seen[num] = i\\n return ans if ans > float('-inf') else 0\\n\",\n \"runtime\": \"860\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pre_sum = []\\n cur_sum = 0\\n for num in nums:\\n cur_sum += num\\n pre_sum.append(cur_sum)\\n\\n num_index = {}\\n result = float('-inf')\\n for i, num in enumerate(nums):\\n small = num - k\\n large = num + k\\n if small in num_index:\\n prev = num_index[small] - 1\\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\\n result = max(result, ps)\\n if large in num_index:\\n prev = num_index[large] - 1\\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\\n result = max(result, ps)\\n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\\n continue\\n else:\\n num_index[num] = i\\n \\n return result if result != float('-inf') else 0\\n\",\n \"runtime\": \"864\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # prefix sum\\n prefix = {}\\n res = -float('inf')\\n curr = 0\\n for num in nums:\\n for t in (num+k, num-k):\\n if t in prefix:\\n res = max(res, curr+num-prefix[t])\\n if num not in prefix or prefix[num] >= curr:\\n prefix[num] = curr\\n curr += num\\n return res if res != -float('inf') else 0\\n\\n \",\n \"runtime\": \"864\"\n },\n {\n \"code\": \"# import math\\n\\n# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# max_sum = -math.inf\\n# hashmap = {}\\n\\n# n = len(nums)\\n# prefix_sum = [nums[0]] * n\\n# for i in range(1, n):\\n# prefix_sum[i] = prefix_sum[i-1] + nums[i]\\n \\n# for i in range(n):\\n# if nums[i] not in hashmap:\\n# hashmap[nums[i]] = i\\n# target_list = [nums[i] + k, nums[i] - k]\\n# for target in target_list:\\n# if target in hashmap:\\n# y = hashmap[target]\\n# s = i if i < y else y\\n# t = y if i < y else i\\n# max_sum = max(max_sum, prefix_sum[t] - prefix_sum[s] + nums[s])\\n\\n# return max_sum\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n indexMap = {}\\n prefixSum = [0]\\n ans = float('-inf')\\n\\n for i,num in enumerate(nums):\\n if num not in indexMap or prefixSum[indexMap[num]]>prefixSum[-1]:\\n indexMap[num] = i\\n currSum = prefixSum[-1]+num\\n prefixSum.append(currSum)\\n\\n if k+num in indexMap:\\n index = indexMap[k+num]\\n ans = max(ans,currSum-prefixSum[index])\\n\\n if -k+num in indexMap:\\n index = indexMap[-k+num]\\n ans = max(ans,currSum-prefixSum[index])\\n\\n return 0 if ans==float('-inf') else ans\\n\\n\\n \",\n \"runtime\": \"868\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n sums = []\\n s = 0\\n for i in nums:\\n s += i\\n sums.append(s)\\n # print(sums)\\n d = dict()\\n ret = -9999999999999999999999999999999999999999\\n for i in range(0, len(nums)):\\n if nums[i]+k in d:\\n p = d.get(nums[i]+k)\\n # print(i, p)\\n ret = max(ret, sums[i] - sums[p] + nums[p])\\n if nums[i]-k in d:\\n p = d.get(nums[i]-k)\\n # print(i, p)\\n ret = max(ret, sums[i] - sums[p] + nums[p])\\n if nums[i] in d:\\n p = d.get(nums[i])\\n d[nums[i]] = i if sums[i] < sums[p] else p\\n else:\\n d[nums[i]] = i\\n\\n return 0 if ret == -9999999999999999999999999999999999999999 else ret\\n \\n\",\n \"runtime\": \"868\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -float('inf')\\n prefix_sums = {nums[0]: 0}\\n current_sum = 0\\n for i, num in enumerate(nums):\\n current_sum += num\\n if num - k in prefix_sums:\\n ans = max(ans, current_sum - prefix_sums[num - k])\\n if num + k in prefix_sums:\\n ans = max(ans, current_sum - prefix_sums[num + k])\\n if i + 1 < len(nums) and (nums[i + 1] not in prefix_sums or prefix_sums[nums[i + 1]] > current_sum):\\n prefix_sums[nums[i + 1]] = current_sum\\n return 0 if ans == -inf else ans\\n \\n \\n \\n\\n\\n \",\n \"runtime\": \"873\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = {}\\n current_sum = 0\\n result = -math.inf\\n\\n for num in nums:\\n if num in prefix_sum:\\n prefix_sum[num] = min(prefix_sum[num], current_sum)\\n else:\\n prefix_sum[num] = current_sum\\n \\n current_sum += num\\n\\n for y in [num + k, num - k]:\\n if y in prefix_sum:\\n result = max(result, current_sum - prefix_sum[y])\\n \\n return result if result != -math.inf else 0\\n\\n\\n\\n\\n \\n\\n\\n\\n\\n \\n\\n \\n\\n \",\n \"runtime\": \"873\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = float('-inf')\\n psum = [0]\\n m = defaultdict(int)\\n \\n for i in range(len(nums)):\\n psum.append(psum[-1] + nums[i]) # Prefix Sum\\n \\n if nums[i] - k in m:\\n res = max(res, psum[i + 1] - psum[m[nums[i] - k]]) # nums[i] - k\\n if nums[i] + k in m:\\n res = max(res, psum[i + 1] - psum[m[nums[i] + k]]) # nums[i] + k\\n \\n if nums[i] not in m or psum[i] - psum[m[nums[i]]] <= 0:\\n m[nums[i]] = i # Kadane-like logic\\n \\n return 0 if res == float('-inf') else res\\n\",\n \"runtime\": \"877\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n preSum = [0 for _ in range(len(nums))]\\n preSum[0] = nums[0]\\n for i in range(1, len(nums)):\\n preSum[i] = preSum[i-1]+nums[i]\\n \\n store = {}\\n\\n ans = float(\\\"-inf\\\")\\n\\n for i in range(len(nums)):\\n curNum = nums[i]\\n complement1 = k + curNum\\n complement2 = curNum - k\\n\\n if complement1 in store:\\n sum = preSum[i] - preSum[store[complement1]] + complement1\\n ans = max(ans, sum)\\n\\n if complement2 in store:\\n sum = preSum[i] - preSum[store[complement2]] + complement2\\n ans = max(ans, sum)\\n\\n if nums[i] not in store:\\n store[nums[i]] = i\\n else:\\n if preSum[i] < preSum[store[nums[i]]]:\\n store[nums[i]] = i\\n return 0 if ans == float(\\\"-inf\\\") else ans\\n \",\n \"runtime\": \"877\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = float('-inf') # Initialize the result with negative infinity\\n psum = [0] # Prefix sum list, initialized with 0\\n m = {} # Dictionary to store the index of certain values of nums\\n\\n for i in range(len(nums)):\\n psum.append(psum[-1] + nums[i]) # Update prefix sum\\n\\n # Check if nums[i] - k exists in the map\\n if nums[i] - k in m:\\n res = max(res, psum[i + 1] - psum[m[nums[i] - k]])\\n\\n # Check if nums[i] + k exists in the map\\n if nums[i] + k in m:\\n res = max(res, psum[i + 1] - psum[m[nums[i] + k]])\\n\\n # Only update the map if either the value doesn't exist or the current subarray is \\\"better\\\"\\n if nums[i] not in m or psum[i] - psum[m[nums[i]]] <= 0:\\n m[nums[i]] = i # Store the index of the current number\\n \\n # Return the result, if no valid subarray was found, return 0\\n return 0 if res == float('-inf') else res\\n\",\n \"runtime\": \"881\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n \\n di = {}\\n \\n ans = -math.inf\\n \\n pre = [0 for i in range(n)]\\n \\n pre[0] = nums[0]\\n \\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n \\n # print(pre)\\n \\n i = 0\\n f = -1\\n for x in nums:\\n \\n if(x-k in di):\\n f = 1\\n y = di[x-k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n if(x+k in di):\\n f = 1\\n y = di[x+k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n \\n if(x in di):\\n curr = 0\\n if(di[x] == 0):\\n curr = 0\\n else:\\n curr = di[x]-1\\n \\n if(pre[curr] > pre[i-1]):\\n di[x] = i\\n else:\\n di[x] = i\\n \\n i += 1\\n \\n if(f == -1):\\n ans = 0\\n \\n return ans\",\n \"runtime\": \"881\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n runSum=0\\n preSum=[0]\\n keyDic = {}\\n result = -math.inf\\n for i, val in enumerate(nums):\\n runSum+=val\\n preSum.append(runSum)\\n if keyDic.get(val-k)!=None: result = max(result, runSum-preSum[keyDic[val-k]])\\n if keyDic.get(val+k)!=None: result = max(result, runSum-preSum[keyDic[val+k]])\\n if keyDic.get(val)==None or preSum[keyDic[val]]>preSum[-2]: \\n keyDic[val]=i\\n # print(keyDic)\\n return result if result != -math.inf else 0\\n\\n\\n\\n\\n\",\n \"runtime\": \"886\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n min_prefix_sum = {}\\n ans= -float('inf')\\n running_sum = 0 \\n \\n for num in nums:\\n\\n if num in min_prefix_sum:\\n min_prefix_sum[num] = min(min_prefix_sum[num],running_sum)\\n else:\\n min_prefix_sum[num]= running_sum\\n \\n running_sum += num\\n\\n for target_sum in [num+k,num-k]:\\n if target_sum in min_prefix_sum:\\n ans = max(ans, running_sum - min_prefix_sum[target_sum])\\n return ans if ans != -float('inf') else 0\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # approach 1 : Brute force \\n # ans = -float(\\\"inf\\\") \\n # for st in range(len(nums)):\\n # for end in range(st+1,len(nums)):\\n # if abs(nums[st]-nums[end])==k:\\n # ans = max(ans,sum(nums[st:end+1]))\\n # return ans if ans != -float('inf') else 0\\n\\n # approach 2:\\n\\n ans = -float('inf')\\n ps_map = {} # minimum prefix sum map for number \\\"num\\\"\\n running_sum = 0\\n \\n for num in nums:\\n\\n if num in ps_map:\\n ps_map[num] = min(ps_map[num],running_sum)\\n else:\\n ps_map[num] = running_sum\\n\\n running_sum += num\\n\\n for y in [num-k,num+k]:\\n if y in ps_map:\\n ans = max(ans,running_sum - ps_map[y])\\n \\n return ans if ans!= -float('inf') else 0\\n\\n \\n \\n\\n \",\n \"runtime\": \"886\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n di = {}\\n ans = float('-inf')\\n pre = [0 for i in range(n)]\\n pre[0] = nums[0]\\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n \\n i = 0\\n f = -1\\n for x in nums:\\n if(x-k in di):\\n f = 1\\n y = di[x-k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n if(x+k in di):\\n f = 1\\n y = di[x+k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n\\n if(x in di):\\n curr = 0\\n if(di[x] == 0):\\n curr = 0\\n else:\\n curr = di[x]-1 \\n if(pre[curr] > pre[i-1]):\\n di[x] = i\\n else:\\n di[x] = i\\n \\n i += 1\\n \\n if(f == -1):\\n ans = 0\\n \\n return ans\\n\\n\\n\",\n \"runtime\": \"890\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n sums, currentSum = [0], 0\\n for num in nums:\\n currentSum += num\\n sums.append(currentSum)\\n \\n ind, maxSum = dict(), -float('inf')\\n for i, num in enumerate(nums):\\n for diff in [k, -k]:\\n if num+diff in ind:\\n maxSum = max(maxSum, sums[i+1]-sums[ind[num+diff]])\\n \\n if num not in ind or sums[ind[num]] > sums[i]:\\n ind[num] = i\\n \\n return maxSum if maxSum != -float('inf') else 0\",\n \"runtime\": \"890\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n\\n min_prefix_sum = {}\\n ans= -float('inf')\\n running_sum = 0 \\n \\n for num in nums:\\n\\n if num in min_prefix_sum:\\n min_prefix_sum[num] = min(min_prefix_sum[num],running_sum)\\n else:\\n min_prefix_sum[num]= running_sum\\n \\n running_sum += num\\n\\n for target_sum in [num+k,num-k]:\\n if target_sum in min_prefix_sum:\\n ans = max(ans, running_sum - min_prefix_sum[target_sum])\\n return ans if ans != -float('inf') else 0\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # approach 1 : Brute force \\n # ans = -float(\\\"inf\\\") \\n # for st in range(len(nums)):\\n # for end in range(st+1,len(nums)):\\n # if abs(nums[st]-nums[end])==k:\\n # ans = max(ans,sum(nums[st:end+1]))\\n # return ans if ans != -float('inf') else 0\\n\\n # approach 2:\\n\\n ans = -float('inf')\\n ps_map = {} # minimum prefix sum map for number \\\"num\\\"\\n running_sum = 0\\n \\n for num in nums:\\n\\n if num in ps_map:\\n ps_map[num] = min(ps_map[num],running_sum)\\n else:\\n ps_map[num] = running_sum\\n\\n running_sum += num\\n\\n for y in [num-k,num+k]:\\n if y in ps_map:\\n ans = max(ans,running_sum - ps_map[y])\\n \\n return ans if ans!= -float('inf') else 0\\n\\n \\n \\n\\n \",\n \"runtime\": \"894\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n prefixSumDict = defaultdict(lambda : inf)\\n result = -inf\\n curr = 0\\n\\n for num in nums:\\n prefixSumDict[num] = min(prefixSumDict[num], curr)\\n curr += num\\n\\n if num - k in prefixSumDict:\\n result = max(result, curr - prefixSumDict[num - k])\\n if num + k in prefixSumDict:\\n result = max(result, curr - prefixSumDict[num + k])\\n \\n return result if result!= -inf else 0\\n \",\n \"runtime\": \"894\"\n },\n {\n \"code\": \"'''\\n\\nnums = [-1, 3, -2, 4, 5]\\npref = [ 0, -1, 2, 0, 4, 9]\\n\\n> x = nums[i] - k or\\n x = nums[i] + k\\n\\n\\nd = { // nums[i] --> min(pref_sum_until_nums_i)\\n -1: -1,\\n 3: 2\\n}\\n\\n'''\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pref = [0]\\n for i in range(1, len(nums) + 1):\\n pref.append(nums[i - 1] + pref[i - 1])\\n\\n res = -inf\\n d = {} # value -> min_pref_sum_indx\\n \\n for i, n in enumerate(nums):\\n x = n - k\\n if x in d:\\n _sum = pref[i + 1] - pref[d[x]]\\n res = max(res, _sum)\\n \\n x = n + k\\n if x in d:\\n _sum = pref[i + 1] - pref[d[x]]\\n res = max(res, _sum)\\n\\n if n not in d or pref[d[n] + 1] > pref[i + 1]:\\n d[n] = i\\n\\n return 0 if res == -inf else res\\n\\n'''\\n\\ndef maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n for i, n in enumerate(nums):\\n x = n - k\\n if x in met:\\n value = pref[i + 1] - pref[met[x][0]]\\n res = value if res == 0 else max(res, value)\\n x = n + k\\n if x in met:\\n value = pref[i + 1] - pref[met[x][0]]\\n res = value if res == 0 else max(res, value)\\n\\n if n not in met:\\n met[n] = (i, pref[i + 1])\\n elif met[n][1] > pref[i + 1]:\\n met[n] = (i, pref[i + 1])\\n\\n return res\\n\\n\\n'''\",\n \"runtime\": \"899\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n result=-pow(10,15)\\n prefix_sum=[0]*len(nums)\\n prefix_sum[0]=nums[0]\\n for i in range(1,len(nums)):\\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\\n map={}\\n for i in range(len(nums)):\\n if nums[i]-k in map:\\n idx=map[nums[i]-k]\\n sum= prefix_sum[i]-prefix_sum[idx-1] if idx>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i]+k in map:\\n idx=map[nums[i]+k]\\n sum= prefix_sum[i]-prefix_sum[idx-1] if map[nums[i]+k]>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i] not in map:\\n map[nums[i]]=i\\n else:\\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\\n if prefix_sum[i-1]<pref_sum:\\n map[nums[i]]=i\\n if result== -pow(10,15):\\n return 0\\n else:\\n return result\\n \\n\\n\\n \",\n \"runtime\": \"899\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n prefix_left=defaultdict(lambda: inf)\\n result=-inf\\n cur=0\\n\\n for x in nums:\\n prefix_left[x]=min(prefix_left[x], cur)\\n cur+=x\\n\\n if(x-k in prefix_left):\\n result=max(result, cur-prefix_left[x-k])\\n if(x+k in prefix_left):\\n result=max(result, cur-prefix_left[x+k])\\n\\n return result if result!=-inf else 0\",\n \"runtime\": \"903\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n map = {} # prefix sums\\n map[-1] = 0\\n\\n indices = {} # value to index with the lowest prefix sum, in order to maximize a potential result sum\\n currSum = 0\\n maxSum = None\\n\\n for i in range(len(nums)):\\n currSum += nums[i]\\n map[i] = currSum\\n if (nums[i] not in indices) or (nums[i] in indices and currSum < map[indices[nums[i]]]):\\n indices[nums[i]] = i\\n\\n if (nums[i] - k) in indices:\\n index = indices[nums[i] - k]\\n if maxSum is None:\\n maxSum = map[i] - map[index - 1]\\n else:\\n maxSum = max(maxSum, map[i] - map[index - 1])\\n\\n if (nums[i] + k) in indices:\\n index = indices[nums[i] + k]\\n if maxSum is None:\\n maxSum = map[i] - map[index - 1]\\n else:\\n maxSum = max(maxSum, map[i] - map[index - 1])\\n\\n return 0 if maxSum is None else maxSum\",\n \"runtime\": \"903\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n di = {}\\n \\n ans = -math.inf\\n \\n pre = [0 for i in range(n)]\\n \\n pre[0] = nums[0]\\n \\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n \\n # print(pre)\\n \\n i = 0\\n f = -1\\n for x in nums:\\n \\n if(x-k in di):\\n f = 1\\n y = di[x-k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n if(x+k in di):\\n f = 1\\n y = di[x+k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n \\n if(x in di):\\n curr = 0\\n if(di[x] == 0):\\n curr = 0\\n else:\\n curr = di[x]-1\\n \\n if(pre[curr] > pre[i-1]):\\n di[x] = i\\n else:\\n di[x] = i\\n \\n i += 1\\n \\n if(f == -1):\\n ans = 0\\n \\n return ans\",\n \"runtime\": \"907\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n pre = [nums[0]]\\n s = set()\\n idx = defaultdict(int)\\n for i in range(1,n):\\n pre.append(pre[i-1] + nums[i])\\n\\n res = float('-inf')\\n for i in range(n):\\n l = nums[i]\\n if nums[i] not in s:\\n idx[nums[i]] = i\\n s.add(nums[i])\\n else:\\n if pre[idx[nums[i]]] > pre[i]:\\n idx[nums[i]] = i\\n \\n if k+l in s:\\n \\n # for j in range(len(idx[k+l])):\\n t = pre[i]\\n if idx[k+l] >0:\\n t -= pre[idx[k+l]-1] \\n if t> res:\\n res = t\\n \\n if l-k in s:\\n # for j in range(len(idx[l-k])):\\n t = pre[i]\\n if idx[l-k] >0:\\n t -= pre[idx[l-k]-1]\\n if t> res:\\n res = t\\n return res if res != float('-inf') else 0\\n \\n \\n\\n\\n \",\n \"runtime\": \"907\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n result=-pow(10,15)\\n prefix_sum=[0]*len(nums)\\n prefix_sum[0]=nums[0]\\n for i in range(1,len(nums)):\\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\\n map={}\\n for i in range(len(nums)):\\n if nums[i]-k in map:\\n sum= prefix_sum[i]-prefix_sum[map[nums[i]-k]-1] if map[nums[i]-k]>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i]+k in map:\\n sum= prefix_sum[i]-prefix_sum[map[nums[i]+k]-1] if map[nums[i]+k]>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i] not in map:\\n map[nums[i]]=i\\n else:\\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\\n if prefix_sum[i-1]<pref_sum:\\n map[nums[i]]=i\\n if result== -pow(10,15):\\n return 0\\n else:\\n return result\\n \\n\\n\\n \",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# maxSum = -float('inf')\\n# table = {}\\n# for i,v in enumerate(nums):\\n# if v in table:\\n# table[v] = min(table[v],i)\\n# else:\\n# table[v] = i\\n# v1 = v + k\\n# v2 = v - k\\n# if v1 in table:\\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\\n# maxSum = max(maxSum,subSum1)\\n# if v2 in table:\\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\\n# maxSum = max(maxSum,subSum2)\\n# else:\\n# continue\\n# if maxSum > -float('inf'):\\n# return maxSum\\n# else:\\n# return 0\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n l, max_sum, hash_map = len(nums), -inf, {}\\n pre_sum = [0] * (l+1)\\n pre_sum[0] = 0\\n\\n for i,n in enumerate(nums):\\n pre_sum[i+1] = pre_sum[i] + n\\n if n-k in hash_map:\\n max_sum = max(max_sum, pre_sum[i+1]-pre_sum[hash_map[n-k]])\\n \\n if k+n in hash_map:\\n max_sum = max(max_sum, pre_sum[i+1]-pre_sum[hash_map[n+k]])\\n\\n if n not in hash_map:\\n hash_map[n] = i\\n \\n if n in hash_map:\\n if pre_sum[hash_map[n]]>= pre_sum[i]:\\n hash_map[n] = i\\n\\n \\n if max_sum> -inf: return max_sum\\n else: return 0\\n\",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n prefix = defaultdict(lambda: inf)\\n total = 0\\n res = -inf\\n for num in nums:\\n\\n prefix[num] = min(total, prefix[num] )\\n total += num\\n if num-k in prefix:\\n res = max(res, total- prefix[ num-k ])\\n if num+k in prefix:\\n res = max(res, total- prefix[ num+k ])\\n return res if res != -inf else 0\\n\\n# //////////////////////////////////////////////\\n\\n # [-1, 3, 2, 4, 5]\\n # -1 2 4 8 13\\n # 2 4 5\\n\\n \\n\",\n \"runtime\": \"916\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n prefixSumDict = defaultdict(lambda : inf)\\n maxSum = -inf\\n currSum = 0\\n\\n for num in nums:\\n prefixSumDict[num] = min(prefixSumDict[num], currSum)\\n\\n currSum += num\\n\\n if num - k in prefixSumDict:\\n maxSum = max(maxSum, currSum - prefixSumDict[num - k])\\n \\n if num + k in prefixSumDict:\\n maxSum = max(maxSum, currSum - prefixSumDict[num + k])\\n \\n return maxSum if maxSum!= -inf else 0\\n \",\n \"runtime\": \"916\"\n },\n {\n \"code\": \"'''\\nprefix sum for O(1) subarray sums\\nlook up table for previous occurances of n - k or n + k\\n\\nif we have access to previous indexes of n - k and n + k\\n\\n'''\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [0] * (len(nums) + 1)\\n total = 0\\n for i in range(len(nums)):\\n total += nums[i]\\n prefix[i + 1] = total\\n # we want to look up best occurance of n - k and n + k\\n # n -> index of best n\\n # either n itself is the best start or a previous n is good\\n\\n lookup = {}\\n res = -inf\\n for i in range(len(nums)):\\n # if we haven't seen before or the array between the occurance is not worth reset to new i\\n n = nums[i]\\n if n not in lookup or n > prefix[i + 1] - prefix[lookup[n]]:\\n lookup[n] = i\\n\\n if n - k in lookup:\\n res = max(res, prefix[i + 1] - prefix[lookup[n-k]])\\n if n + k in lookup:\\n res = max(res, prefix[i + 1] - prefix[lookup[n+k]])\\n if res == -inf:\\n return 0\\n return res\\n\",\n \"runtime\": \"920\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_left = defaultdict(lambda: inf)\\n res = -inf\\n curr = 0\\n \\n for n in nums:\\n prefix_left[n] = min(prefix_left[n], curr)\\n curr += n\\n if n-k in prefix_left:\\n res = max(res, curr - prefix_left[n-k])\\n if n+k in prefix_left:\\n res = max(res, curr - prefix_left[n+k])\\n return res if res != -inf else 0\",\n \"runtime\": \"920\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res, preSum, mp = -sys.float_info.max, 0, {}\\n for r in nums:\\n for l in [r + k, r - k]:\\n if l in mp:\\n res = max(res, preSum + r - mp[l])\\n if r not in mp:\\n mp[r] = preSum\\n mp[r] = min(mp[r], preSum)\\n preSum += r\\n return res if res != -sys.float_info.max else 0\",\n \"runtime\": \"925\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# map = collections.defaultdict(list)\\n# n = len(nums)\\n\\n# prefixSum = [0]*n\\n# for idx in range(n):\\n# prefixSum[idx] = nums[idx] + (prefixSum[idx-1] if idx else 0)\\n\\n# # print(prefixSum)\\n# def query(left, right):\\n# return prefixSum[right] - (prefixSum[left-1] if left else 0)\\n\\n# for idx in range(n):\\n# map[nums[idx]].append(idx)\\n\\n# ans = float(\\\"-inf\\\")\\n# for idx, num in enumerate(nums):\\n# if num + k in map:\\n# for val in map[num+k]:\\n# left = min(idx, val)\\n# right = max(idx, val)\\n# # print(left, right)\\n# ans = max(ans , query(left, right))\\n\\n# return 0 if ans == float(\\\"-inf\\\") else ans\\n\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n idx_map = collections.defaultdict(list)\\n n = len(nums)\\n\\n prefixSum = [0]*n\\n for idx in range(n):\\n prefixSum[idx] = nums[idx] + (prefixSum[idx-1] if idx else 0)\\n\\n # print(prefixSum)\\n def query(left, right):\\n return prefixSum[right] - (prefixSum[left-1] if left else 0)\\n\\n ans = float(\\\"-inf\\\")\\n for i, num in enumerate(nums):\\n target1 = num + k\\n target2 = num - k\\n\\n if target1 in idx_map:\\n left = idx_map[target1]\\n right = i\\n ans = max(ans, query(left, right))\\n\\n if target2 in idx_map:\\n left = idx_map[target2]\\n right = i\\n ans = max(ans, query(left, right))\\n\\n\\n if (num not in idx_map) or (query(idx_map[num], i-1) < 0):\\n idx_map[num] = i\\n\\n return 0 if ans == float(\\\"-inf\\\") else ans\\n\\n\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"925\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n s = 0\\n psum = [0]\\n h = {}\\n res = -math.inf\\n for i, n in enumerate(nums):\\n s += n\\n psum.append(s)\\n if h.get(n - k) != None:\\n res = max(s - psum[h[n - k]], res)\\n if h.get(n + k) != None:\\n res = max(s - psum[h[n + k]], res)\\n if h.get(n) == None or psum[h[n]] > psum[-2]:\\n h[n] = i\\n return res if res != -math.inf else 0\",\n \"runtime\": \"929\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n prefix_sum = defaultdict(lambda: float(\\\"inf\\\"))\\n curr_sum = 0\\n res = float(\\\"-inf\\\")\\n for n in nums:\\n prefix_sum[n] = min(prefix_sum[n], curr_sum)\\n curr_sum += n\\n if n - k in prefix_sum:\\n res = max(res, curr_sum - prefix_sum[n-k])\\n if n + k in prefix_sum:\\n res = max(res, curr_sum - prefix_sum[n+k])\\n return res if res != float(\\\"-inf\\\") else 0\",\n \"runtime\": \"929\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n v2i = {}\\n pref = [0]\\n ans = -1e18\\n \\n for i, v in enumerate(nums):\\n v2i[v] = min(pref[-1], v2i.get(v, 1e18))\\n pref.append(pref[-1] + v)\\n ps = pref[-1]\\n\\n # need to look in v2i for v-k or v+k\\n if v-k in v2i:\\n ans = max(ans, ps - v2i[v-k])\\n if v+k in v2i:\\n ans = max(ans, ps - v2i[v+k])\\n \\n return ans if ans != -1e18 else 0\\n\",\n \"runtime\": \"933\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n maxSum = float(\\\"-inf\\\")\\n prefixSum = defaultdict(lambda: float(\\\"inf\\\"))\\n runningSum = 0\\n\\n for n in nums:\\n prefixSum[n] = min(prefixSum[n], runningSum)\\n runningSum += n\\n\\n if n-k in prefixSum:\\n maxSum = max(maxSum, runningSum - prefixSum[n-k])\\n if n+k in prefixSum:\\n maxSum = max(maxSum, runningSum - prefixSum[n+k])\\n\\n return maxSum if maxSum != float(\\\"-inf\\\") else 0\",\n \"runtime\": \"933\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: list[int], k: int) -> int:\\n if len(nums)<2:\\n return 0\\n # Блок объявления\\n nums.insert(0, 0)\\n dict_indexes ={} # Ключ - интересное число, значение - индекс\\n nums_sum=[0]\\n max_sum=float('-inf')\\n\\n for i in range(1,len(nums)):\\n nums_sum.append(nums[i]+nums_sum[i-1]) #Кадане - считаем суммы\\n #Если такого числа нет в словаре\\n if dict_indexes.get(nums[i],None) == None:\\n dict_indexes[nums[i]] = i\\n else: #Если есть\\n if nums_sum[dict_indexes.get(nums[i])] >nums_sum[i]:\\n dict_indexes[nums[i]] = i\\n #Если есть подходящее\\n dict_posK_ind = dict_indexes.get(nums[i]+k,None)\\n dict_negK_ind = dict_indexes.get(nums[i]-k,None)\\n if (dict_posK_ind!=None and dict_posK_ind<i) and (dict_negK_ind!=None and dict_negK_ind<i):\\n if max_sum < max(nums_sum[i]-nums_sum[dict_posK_ind-1], nums_sum[i]-nums_sum[dict_negK_ind-1]):\\n max_sum = max(nums_sum[i]-nums_sum[dict_posK_ind-1], nums_sum[i]-nums_sum[dict_negK_ind-1])\\n elif dict_posK_ind!=None and dict_posK_ind<i:\\n if max_sum < nums_sum[i]-nums_sum[dict_posK_ind-1]:\\n max_sum = nums_sum[i]-nums_sum[dict_posK_ind-1]\\n elif dict_negK_ind!=None and dict_negK_ind<i:\\n if max_sum < nums_sum[i]-nums_sum[dict_negK_ind-1]:\\n max_sum = nums_sum[i]-nums_sum[dict_negK_ind-1]\\n\\n\\n return max_sum if max_sum!=float('-inf') else 0\",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n \\n def __init__(self):\\n self.ans = -math.inf\\n self.dic = {}\\n \\n\\n def get_max_subarray(self, index, pre, i):\\n res = self.dic[index]\\n if res != 0:\\n self.ans = max(self.ans, pre[i] - pre[res-1])\\n else:\\n self.ans = max(self.ans, pre[i])\\n\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n\\n pre = [ 0 for _ in range(n)]\\n pre[0] = nums[0]\\n\\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n\\n found_good_subarray = False\\n i = 0\\n\\n for num in nums:\\n if num - k in self.dic:\\n found_good_subarray = True\\n self.get_max_subarray(num - k, pre, i)\\n \\n if num + k in self.dic:\\n found_good_subarray = True\\n self.get_max_subarray(num + k, pre,i)\\n\\n if num in self.dic:\\n curr = 0\\n if self.dic[num] != 0:\\n curr = self.dic[num] - 1\\n \\n if pre[curr] > pre[i - 1]:\\n self.dic[num] = i\\n else:\\n self.dic[num] = i\\n i += 1\\n\\n return self.ans if found_good_subarray else 0\\n \\n\\n\\n \",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # p_i = sum [0, i)\\n prefix_sum = [0] * (len(nums) + 1)\\n\\n for idx, num in enumerate(nums):\\n prefix_sum[idx+1] = prefix_sum[idx] + num\\n\\n val_to_idx = {}\\n max_total = None\\n for idx, num in enumerate(nums):\\n # abs(num - x) == k\\n # x == num - k or x == num + k\\n prev_idx_neg = val_to_idx.get(num-k, None) \\n prev_idx_pos = val_to_idx.get(num+k, None)\\n\\n for prev_idx in [prev_idx_neg, prev_idx_pos]:\\n if prev_idx is not None:\\n total = prefix_sum[idx+1] - prefix_sum[prev_idx]\\n if max_total is None:\\n max_total = total\\n else:\\n max_total = max(total, max_total)\\n\\n if num not in val_to_idx:\\n val_to_idx[num] = idx\\n else:\\n prev_idx = val_to_idx[num]\\n if prefix_sum[idx] - prefix_sum[prev_idx] <= 0:\\n val_to_idx[num] = idx\\n\\n return max_total or 0\\n \",\n \"runtime\": \"955\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n from collections import defaultdict\\n prefix_left = defaultdict(lambda: float('inf'))\\n res = -float('inf')\\n cur = 0\\n for x in nums:\\n prefix_left[x]=min(prefix_left[x], cur)\\n cur += x\\n\\n if x-k in prefix_left:\\n res = max(res, cur-prefix_left[x-k])\\n if x+k in prefix_left:\\n res = max(res, cur-prefix_left[x+k])\\n return res if res != -float('inf') else 0\",\n \"runtime\": \"955\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n '''\\n iterate through array, maintain running sum\\n store running sum of element in hashmap at index + 1's value\\n at each element, check if val - k or val + k is in hashmap\\n if yes, calculate sum of that subarray using prefix sum hashmap\\n otherwise continue\\n '''\\n prefix_sum = {}\\n cur_sum = 0\\n max_sum = float(\\\"-inf\\\")\\n\\n for i, n in enumerate(nums):\\n if n not in prefix_sum:\\n prefix_sum[n] = cur_sum\\n prefix_sum[n] = min(prefix_sum[n], cur_sum)\\n if n - k in prefix_sum:\\n max_sum = max(max_sum, cur_sum + n - prefix_sum[n - k])\\n if n + k in prefix_sum:\\n max_sum = max(max_sum, cur_sum + n - prefix_sum[n + k])\\n cur_sum += n\\n print(prefix_sum)\\n return max_sum if max_sum != float(\\\"-inf\\\") else 0\\n\\n\\n\",\n \"runtime\": \"959\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n cumulativeSums = {}\\n currentSum = 0\\n maxSum = float('-inf') # This is the Python equivalent of Long.MIN_VALUE\\n\\n for value in nums:\\n # Check if value - k exists in the map\\n if (value - k) in cumulativeSums:\\n minValue = cumulativeSums[value - k]\\n maxSum = max(maxSum, currentSum + value - minValue)\\n\\n # Check if value + k exists in the map\\n if (value + k) in cumulativeSums:\\n minValue = cumulativeSums[value + k]\\n maxSum = max(maxSum, currentSum + value - minValue)\\n\\n # Update the map with the minimum currentSum for the current value\\n cumulativeSums[value] = min(cumulativeSums.get(value, float('inf')), currentSum)\\n \\n # Update currentSum with the current value\\n currentSum += value\\n\\n # If maxSum is still -inf, it means no valid subarray was found\\n return 0 if maxSum == float('-inf') else maxSum\\n \",\n \"runtime\": \"959\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n opt = -math.inf\\n curr_acc = 0\\n acc = defaultdict(lambda: math.inf)\\n\\n for j, y in enumerate(nums):\\n acc[y] = min(acc[y], curr_acc)\\n curr_acc += y\\n\\n for x in [y - k, y + k]:\\n if x in acc:\\n opt = max(opt, curr_acc - acc[x])\\n \\n return opt if opt != -math.inf else 0\",\n \"runtime\": \"964\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n seen = {}\\n prefix = []\\n ssum = 0\\n self.max_sum = float('-inf')\\n\\n def update_max_sum(key, i):\\n if key in seen:\\n index = seen[key]\\n total = prefix[i] - prefix[index] + nums[i]\\n self.max_sum = max(self.max_sum, total)\\n\\n for i, n in enumerate(nums):\\n prefix.append(ssum)\\n ssum = ssum + n\\n if n in seen:\\n idx = seen[n]\\n prev_sum = prefix[idx]\\n #from line 11 to maximize total prefix[index] should have the smallest value\\n seen[n] = idx if prev_sum < prefix[i] else i \\n else:\\n seen[n] = i\\n\\n update_max_sum(n - k, i)\\n update_max_sum(n + k, i)\\n\\n return self.max_sum if self.max_sum != float('-inf') else 0\",\n \"runtime\": \"964\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n output = float('-inf')\\n prefix = {}\\n curSum = 0\\n for i in range(len(nums)):\\n curSum += nums[i]\\n prefix[i] = curSum \\n idx = {}\\n print(prefix)\\n for i in range(len(nums)): \\n if nums[i] in idx: \\n if prefix[idx[nums[i]]] > prefix[i]:\\n idx[nums[i]] = i \\n else:\\n idx[nums[i]] = i \\n if nums[i] - k in idx: \\n other_i = idx[nums[i] - k]\\n output = max(output, prefix[i] - prefix[other_i] + nums[i] - k)\\n if nums[i] + k in idx: \\n other_i = idx[nums[i] + k]\\n output = max(output, prefix[i] - prefix[other_i] + nums[i] + k)\\n if output == float(\\\"-inf\\\"):\\n return 0\\n return output\\n \",\n \"runtime\": \"968\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n d = dict()\\n res = -float('inf')\\n curr = 0\\n for r in range(len(nums)):\\n curr += nums[r]\\n\\n if nums[r] - k in d:\\n c = d[nums[r] - k]\\n res = max(res, curr - c)\\n \\n if nums[r] + k in d:\\n c = d[nums[r] + k]\\n res = max(res, curr - c)\\n \\n d[nums[r]] = min(d.get(nums[r], float('inf')), curr - nums[r])\\n # print(d)\\n \\n return res if res != -float('inf') else 0\\n\",\n \"runtime\": \"968\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pre = 0\\n mapping = defaultdict(lambda: math.inf)\\n res = -math.inf\\n for n in nums:\\n if mapping[n] > pre:\\n mapping[n] = pre\\n pre += n\\n \\n res = max(res, pre - mapping[n-k], pre - mapping[n+k])\\n \\n\\n if res == -math.inf:\\n return 0\\n return res\\n\\n\",\n \"runtime\": \"973\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = -math.inf\\n prefix_sum = 0\\n num_to_min_prefix_sum = defaultdict(lambda: math.inf)\\n for num in nums:\\n num_to_min_prefix_sum[num] = min(num_to_min_prefix_sum[num], prefix_sum)\\n\\n prefix_sum += num\\n\\n if num + k in num_to_min_prefix_sum.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_min_prefix_sum[num + k])\\n if num - k in num_to_min_prefix_sum.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_min_prefix_sum[num - k])\\n\\n return max_sum if max_sum != -math.inf else 0\\n\\n# Observation\\n# sum(nums[i..j]) = prefix_sum[j] - prefix_sum[i - 1]\\n\\n# nums = [5,-3,6,1]\\n# prefix_sum = [5,2,4,5]\",\n \"runtime\": \"973\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n \\n indexDict = defaultdict(list)\\n minDict = defaultdict(int)\\n prefixSum = [0]*len(nums)\\n maxValue = -inf\\n \\n for i in range(len(nums)):\\n if i == 0:\\n prefixSum[i] = 0\\n else: \\n prefixSum[i] = prefixSum[i-1] + nums[i-1]\\n \\n for i, num in enumerate(nums):\\n if num - k in indexDict:\\n maxValue = max(maxValue, prefixSum[i] - minDict[num-k] + num)\\n if num + k in indexDict:\\n maxValue = max(maxValue, prefixSum[i] - minDict[num+k] + num)\\n \\n indexDict[num].append(i) \\n # print(\\\"minDict_num :\\\", minDict[num])\\n minDict[num] = min(minDict[num], prefixSum[i]) if num in minDict else prefixSum[i]\\n \\n \\n \\n \\n return maxValue if maxValue != -inf else 0\\n \\n \\n \\n \",\n \"runtime\": \"977\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = -math.inf\\n num_to_prefix = defaultdict(lambda: math.inf)\\n prefix_sum = 0\\n for num in nums:\\n num_to_prefix[num] = min(num_to_prefix[num], prefix_sum)\\n\\n prefix_sum += num\\n\\n candidate = num + k\\n if candidate in num_to_prefix.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\\n\\n candidate = num - k\\n if candidate in num_to_prefix.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\\n return max_sum if max_sum != -math.inf else 0\",\n \"runtime\": \"977\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n seen = {}\\n prefix = []\\n ssum = 0\\n self.max_sum = float('-inf')\\n\\n def update_max_sum(key, i):\\n if key in seen:\\n index = seen[key][0]\\n # if i != index:\\n # return\\n total = prefix[i] - prefix[index] + nums[i]\\n self.max_sum = max(self.max_sum, total)\\n \\n for i, n in enumerate(nums):\\n prefix.append(ssum)\\n ssum = ssum + n\\n if n in seen:\\n idx = seen[n][-1]\\n prev_sum = prefix[idx]\\n seen[n][-1] = idx if prev_sum < prefix[i] else i\\n else:\\n seen[n] = [i]\\n\\n update_max_sum(n - k, i)\\n update_max_sum(n + k, i)\\n\\n return self.max_sum if self.max_sum != float('-inf') else 0\",\n \"runtime\": \"981\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # hashmap에는 해당 num의 prefix(즉, 자신 빼고 이전까지 더한 합)을 저장\\n # update hashmap. 후에는 자신을 더하고 \\n # 자신을 더한 합 - hashmap[자신 +- k] \\n # ex) (1+2+3+4+5+6) - (1+2+3+4) = 5+6\\n \\n result = float(\\\"-inf\\\")\\n hashmap = defaultdict(lambda: inf)\\n prefix_sum = 0\\n\\n for num in nums:\\n if hashmap[num] > prefix_sum:\\n hashmap[num] = prefix_sum\\n prefix_sum += num\\n result = max(result, prefix_sum - hashmap[num + k], prefix_sum - hashmap[num - k])\\n return result if result != float(\\\"-inf\\\") else 0\",\n \"runtime\": \"981\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, prefix_dict = -inf, 0, defaultdict(lambda: inf)\\n for num in nums:\\n if prefix_dict[num] > prefix_sum:\\n prefix_dict[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - prefix_dict[num-k], prefix_sum - prefix_dict[num+k])\\n return max_sum if max_sum > -inf else 0\",\n \"runtime\": \"986\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n max_sum = -inf\\n prefix_sum = 0\\n num_to_min_prefix_sum = defaultdict(lambda: inf)\\n for num in nums:\\n if num_to_min_prefix_sum[num] > prefix_sum:\\n num_to_min_prefix_sum[num] = prefix_sum\\n \\n prefix_sum += num\\n max_sum = max(max_sum, \\n prefix_sum - num_to_min_prefix_sum[num + k], \\n prefix_sum - num_to_min_prefix_sum[num - k])\\n \\n return max_sum if max_sum > -inf else 0\\n\",\n \"runtime\": \"986\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, min_prefix_sum_dict = -inf, 0, defaultdict(lambda: inf)\\n for n in nums:\\n if min_prefix_sum_dict[n] > prefix_sum:\\n min_prefix_sum_dict[n] = prefix_sum\\n prefix_sum += n\\n max_sum = max(max_sum, prefix_sum - min_prefix_sum_dict[n - k], prefix_sum - min_prefix_sum_dict[n + k])\\n\\n return max_sum if max_sum > -inf else 0\",\n \"runtime\": \"990\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"990\"\n },\n {\n \"code\": \"class Solution: \\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n #kandane algo\\n ans = -inf\\n prefix_sum = 0\\n minPrefixSum = defaultdict(lambda: inf)\\n\\n # keep track of minimum prefix sum (up to & exclu num) for each number\\n for i, num in enumerate(nums):\\n if minPrefixSum[num] > prefix_sum:\\n minPrefixSum[num] = prefix_sum\\n prefix_sum += num\\n ans = max(ans, prefix_sum - minPrefixSum[num + k], prefix_sum - minPrefixSum[num - k])\\n return ans if ans > -inf else 0 \",\n \"runtime\": \"994\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n h = {}\\n maxi = -1e15\\n prefix_sum = nums[:]\\n for i in range(1,len(nums)):\\n prefix_sum[i] = prefix_sum[i-1] + nums[i]\\n prefix_sum = [0] + prefix_sum\\n find = False\\n for i,num in enumerate(nums):\\n if num not in h.keys():\\n h[num] = i\\n else:\\n h[num] = h[num] if (prefix_sum[i+1] - prefix_sum[h[num]+1]) > 0 else i\\n nums_to_check = []\\n nums_to_check.append(num - k) \\n nums_to_check.append(num+k)\\n for checknum in nums_to_check:\\n if checknum in h.keys():\\n find = True\\n current_sum = prefix_sum[i+1] - prefix_sum[h[checknum]]\\n if prefix_sum[i+1] - prefix_sum[h[checknum]] > maxi:\\n maxi = current_sum\\n else:\\n continue\\n\\n return maxi if find else 0\\n\\n \\n \",\n \"runtime\": \"994\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0\",\n \"runtime\": \"999\"\n },\n {\n \"code\": \"from math import inf\\nfrom collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = -inf\\n prefix_sum = 0\\n min_prefixsum_dict = defaultdict(lambda: inf)\\n\\n for num in nums:\\n if min_prefixsum_dict[num] > prefix_sum:\\n min_prefixsum_dict[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - min_prefixsum_dict[num-k], prefix_sum - min_prefixsum_dict[num+k])\\n return max_sum if max_sum > -inf else 0\\n\",\n \"runtime\": \"999\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1003\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -inf\\n\\n prefix_sum = 0\\n seen = defaultdict(lambda: inf)\\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n \\n prefix_sum += n\\n\\n ans = max(ans, prefix_sum - seen[k + n], \\\\\\n prefix_sum - seen[n - k])\\n \\n return ans if ans != -inf else 0\",\n \"runtime\": \"1003\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# maxSum = -float('inf')\\n# table = {}\\n# for i,v in enumerate(nums):\\n# if v in table:\\n# table[v] = min(table[v],i)\\n# else:\\n# table[v] = i\\n# v1 = v + k\\n# v2 = v - k\\n# if v1 in table:\\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\\n# maxSum = max(maxSum,subSum1)\\n# if v2 in table:\\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\\n# maxSum = max(maxSum,subSum2)\\n# else:\\n# continue\\n# if maxSum > -float('inf'):\\n# return maxSum\\n# else:\\n# return 0\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1007\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = -math.inf \\n prefix_sum = 0\\n val_to_min_prefix_sum = defaultdict(lambda: math.inf)\\n\\n for i, num in enumerate(nums):\\n if prefix_sum < val_to_min_prefix_sum[num]:\\n val_to_min_prefix_sum[num] = prefix_sum \\n prefix_sum += num \\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num-k], prefix_sum - val_to_min_prefix_sum[num+k])\\n\\n if max_sum != -math.inf:\\n return max_sum \\n return 0\\n\",\n \"runtime\": \"1007\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1012\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# maxSum = -float('inf')\\n# table = {}\\n# for i,v in enumerate(nums):\\n# if v in table:\\n# table[v] = min(table[v],i)\\n# else:\\n# table[v] = i\\n# v1 = v + k\\n# v2 = v - k\\n# if v1 in table:\\n# subSum1 = sum(nums[min(i,table[v1]):max(i,table[v1])+1])\\n# maxSum = max(maxSum,subSum1)\\n# if v2 in table:\\n# subSum2 = sum(nums[min(i,table[v2]):max(i,table[v2])+1])\\n# maxSum = max(maxSum,subSum2)\\n# else:\\n# continue\\n# if maxSum > -float('inf'):\\n# return maxSum\\n# else:\\n# return 0\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1012\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n max_sum = -math.inf\\n num_to_prefix = defaultdict(lambda: math.inf)\\n prefix_sum = 0\\n for i in range(n):\\n num_to_prefix[nums[i]] = min(num_to_prefix[nums[i]], prefix_sum)\\n\\n prefix_sum += nums[i]\\n\\n candidate = nums[i] + k\\n if candidate in num_to_prefix.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\\n\\n candidate = nums[i] - k\\n if candidate in num_to_prefix.keys():\\n max_sum = max(max_sum, prefix_sum - num_to_prefix[candidate])\\n return max_sum if max_sum != -math.inf else 0\",\n \"runtime\": \"1016\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # Get grefix sum\\n pref = [0] * (len(nums) + 1)\\n for i in range(0, len(nums)):\\n pref[i + 1] = nums[i] + pref[i]\\n invIdx = defaultdict(list)\\n maxSum = None\\n\\n for i in range(0, len(nums)):\\n key1 = nums[i] + k\\n key2 = nums[i] - k\\n\\n prevPrefs = []\\n if key1 in invIdx:\\n prevPrefs.append(invIdx.get(key1)[0]) \\n if key2 in invIdx:\\n prevPrefs.append(invIdx.get(key2)[0])\\n\\n for prevPref in prevPrefs:\\n currSum = pref[i + 1] - prevPref\\n maxSum = currSum if maxSum is None else max(currSum, maxSum)\\n heappush(invIdx[nums[i]], pref[i])\\n \\n return maxSum if maxSum is not None else 0\\n\\n\\n# nums = [-1, 3, 2, 4, 5], k = 3\\n\\n# pref = [0 -1 2 4 8 13]\\n\\n# invIdx = {-1: [0], 3: [1], 2: [2], 4: [3]}\\n# maxSum = 11\\n\\n# i = 4,\\n# nums[i] = 5\\n# idxs = [2]\\n# idx = 2\\n\\n\\n# idxs = \\n\\n\\n# Input:\\n# nums: List[int]\\n# k: int\\n\\n\\n# Output:\\n# maximumSum: int # maximum good subarray sum\\n\\n# Example\\n# nums = [-1, 3, 2, 4, 5], k = 3\\n\\n# pref = [-1, 2, 4, 8, 13]\\n\\n\\n# prefSum = []\\n# mapp: {val -> [idx]}\\n\\n# for i,\\n# for j\\n# pref[j] - pref[i - 1]\\n\\n\\n\\n# |a - b| >= |a| - |b|\\n# |a - b| = a - b if a > b else b - a\\n\\n# a - b = k or b - a = k\\n# b + k or b - k\",\n \"runtime\": \"1016\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_subarray_sum = -inf # Initialize the maximum subarray sum to negative infinity\\n current_prefix_sum = 0 # Initialize the prefix sum to 0\\n min_prefix_sum_for_value = defaultdict(lambda: inf) # Dictionary to track the minimum prefix sum for each value\\n\\n for index, num in enumerate(nums):\\n # Update the minimum prefix sum for the current number if the current prefix sum is smaller\\n if min_prefix_sum_for_value[num] > current_prefix_sum:\\n min_prefix_sum_for_value[num] = current_prefix_sum\\n\\n # ----num-----num+k\\n # --k--\\n\\n # abs(k) = num+k - num\\n # abs(k) = num-k - num \\n\\n current_prefix_sum += num\\n # Calculate candidate subarray sums using the values num + k and num - k\\n subarray_sum_with_plus_k = current_prefix_sum - min_prefix_sum_for_value[num + k]\\n subarray_sum_with_minus_k = current_prefix_sum - min_prefix_sum_for_value[num - k]\\n\\n # Update the maximum subarray sum with the best candidate\\n max_subarray_sum = max(max_subarray_sum, subarray_sum_with_plus_k, subarray_sum_with_minus_k)\\n\\n # Return the maximum subarray sum, or 0 if it was never updated\\n return max_subarray_sum if max_subarray_sum != -inf else 0\\n\",\n \"runtime\": \"1020\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nCan't sort it\\nCan't slide a window\\nWhat about two pointers?\\n|a - b| = k\\na - b = k\\na - b = -k\\n\\na = b - k\\na = k - b\\nlookup a in hashmap and get it's index to compute a sum\\n\\na = 0\\na = 1 or -1 -> yes at index 0 sum(0, 1) to update max\\n{1: 0, 2: 1}\\ntotalSum at index i; sum(0, b) = sum(0, a) + sum(a, b)\\ntotalSum - prefixSum\\n[-1,3,2,4,5]\\n\\\"\\\"\\\"\\nfrom collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n total_sum = 0\\n max_sum = float('-inf')\\n complement_map = {}\\n\\n for index in range(len(nums)): # 4\\n num = nums[index] # 5\\n complements = [num - k, num + k] # -12, 12\\n for complement in complements:\\n if complement in complement_map:\\n curr_sum = total_sum - complement_map[complement] # 8 - 4 = 4\\n max_sum = max(max_sum, curr_sum + num) # 4\\n\\n complement_map[num] = min(total_sum, complement_map.get(num, float('inf'))) # {-1: 0, 3: 1, 2: 2, 4: 3, 5: 4}\\n \\n total_sum += num # 8 + 5 = 13\\n\\n return max_sum if max_sum != float('-inf') else 0\\n \\n\",\n \"runtime\": \"1020\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixSum = {} # key: k-n, value_list: (idx, prefixSum)\\n curSum, maxSum = 0, float('-inf')\\n for j, nj in enumerate(nums):\\n if nj in prefixSum: # handle repeat n, keep smaller prefixSum\\n prefixSum[nj] = min(prefixSum[nj], curSum) \\n else:\\n prefixSum[nj] = curSum\\n\\n need = [ni for ni in [nj - k, nj + k] if ni in prefixSum]\\n for ni in need:\\n maxSum = max(maxSum, curSum - prefixSum[ni] + nj)\\n\\n curSum += nj\\n return maxSum if maxSum > float('-inf') else 0\\n\\n# 1 2 3 4 5 6 , k = 1\\n# 1:0 2:1 3:3 4:6 5:9 6:14\\n \\n\\n \\n\\n\\n\\n# \\n \\n\\n# 1. brute force: two pointers, two for loops -> O(n^2) check all start, end pair\\n\\n# 2. dict -> key: k-n value: idx, prefixSum (sum of ends with idx i)\\n# go through nums, if k-n in dict -> then update maxSum with prefixSum[cur] - prefixSum[dict[k-n]] + nums[idx]\\n# O(n)\",\n \"runtime\": \"1025\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1025\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n nums_len = len(nums)\\n prefix_sum = [0] * (nums_len + 1)\\n for i, num in enumerate(nums):\\n prefix_sum[i + 1] = prefix_sum[i] + num\\n\\n cache = {}\\n maximum = float(\\\"-inf\\\")\\n for i, num in enumerate(nums):\\n for diff in [num - k, num + k]:\\n if cache.get(diff) is not None:\\n maximum = max(\\n prefix_sum[i + 1] - prefix_sum[cache.get(diff)], maximum\\n )\\n if cache.get(num) is None:\\n cache[num] = i\\n elif (cache.get(num) is not None) and (\\n (prefix_sum[i + 1] - prefix_sum[cache.get(num)]) < num\\n ):\\n cache[num] = i\\n\\n return maximum if maximum != float(\\\"-inf\\\") else 0\\n\",\n \"runtime\": \"1029\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n for a in A:\\n pre[a] = min(pre[a], cur)\\n cur += a\\n res = max(res, cur - pre[a - k], cur - pre[a + k])\\n return res if res > -inf else 0\",\n \"runtime\": \"1029\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n nums_len = len(nums)\\n prefix_sum = [0] * (nums_len + 1)\\n for i, num in enumerate(nums):\\n prefix_sum[i + 1] = prefix_sum[i] + num\\n\\n cache = {}\\n maximum = float(\\\"-inf\\\")\\n for i, num in enumerate(nums):\\n for diff in [num - k, num + k]:\\n if cache.get(diff) is not None:\\n maximum = max(\\n prefix_sum[i + 1] - prefix_sum[cache.get(diff)], maximum\\n )\\n if cache.get(num) is None:\\n cache[num] = i\\n elif (cache.get(num) is not None) and (\\n (prefix_sum[i] - prefix_sum[cache.get(num)]) < 0\\n ):\\n cache[num] = i\\n\\n return maximum if maximum != float(\\\"-inf\\\") else 0\\n\",\n \"runtime\": \"1033\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n suffix_sum = [0 for i in range(len(nums) + 1)]\\n for i in range(len(nums) - 1, -1, -1):\\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\\n\\n prefix_sum = [0 for i in range(len(nums) + 1)]\\n prev = {}\\n prev_max_sums = {}\\n\\n ans = -inf\\n for i in range(1, len(nums) + 1):\\n low, high = nums[i-1] - k, nums[i-1] + k\\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\\n if low in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\\n if high in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\\n\\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\\n prev[nums[i-1]] = i - 1\\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\\n \\n if ans == -inf:\\n return 0\\n\\n return ans\\n\",\n \"runtime\": \"1033\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\\n \\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n for a in A:\\n pre[a] = min(pre[a], cur)\\n cur += a\\n res = max(res, cur - pre[a - k], cur - pre[a + k])\\n return res if res > -inf else 0 \\n\",\n \"runtime\": \"1038\"\n },\n {\n \"code\": \"class Solution:\\n # This solves the problem, but too slow.\\n def maximumSubarraySum_slow(self, nums: List[int], k: int) -> int:\\n # Find all subarrays [start idx, end idx] that is good.\\n sub_arrs = []\\n for i in range(0, len(nums)):\\n for j in range(i, len(nums)):\\n if abs(nums[i] - nums[j]) == k:\\n sub_arrs.append([i, j])\\n # Calc sum of all possible subarrays.\\n sums = []\\n for idx in sub_arrs:\\n sums.append(sum(nums[idx[0]:idx[1]+1]))\\n return max(sums) if sums else 0\\n\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"runtime\": \"1038\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = defaultdict(lambda: inf)\\n current_sum = 0\\n max_good_subrray_sum = -inf\\n for number in nums:\\n prefix_sum[number] = min(prefix_sum[number], current_sum)\\n current_sum += number\\n max_good_subrray_sum = max(max_good_subrray_sum, current_sum - prefix_sum[number-k], current_sum - prefix_sum[number+k])\\n \\n return max_good_subrray_sum if max_good_subrray_sum != -inf else 0\",\n \"runtime\": \"1042\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixs = defaultdict(lambda: inf)\\n currsum = 0\\n ans = -inf\\n for num in nums:\\n prefixs[num] = min(prefixs[num],currsum)\\n currsum += num\\n ans = max(ans,currsum-prefixs[num-k],currsum-prefixs[k+num])\\n return ans if ans > -inf else 0\",\n \"runtime\": \"1042\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixSum = {}\\n cur = 0\\n best = float('-inf')\\n for num in nums:\\n if cur < prefixSum.get(num, float('inf')):\\n prefixSum[num] = cur\\n cur += num\\n down = prefixSum.get(num - k, float('inf'))\\n up = prefixSum.get(num + k, float('inf'))\\n best = max(best, cur - down, cur - up)\\n\\n if best == float('-inf'):\\n return 0\\n else:\\n return best\\n\",\n \"runtime\": \"1046\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -inf\\n min_s = defaultdict(lambda: inf)\\n s = 0\\n for x in nums:\\n ans = max(ans, s + x - min(min_s[x - k], min_s[x + k]))\\n min_s[x] = min(min_s[x], s)\\n s += x\\n return ans if ans > -inf else 0\",\n \"runtime\": \"1046\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, A: List[int], k: int) -> int:\\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n for a in A:\\n pre[a] = min(pre[a], cur)\\n cur += a\\n res = max(res, cur - pre[a - k], cur - pre[a + k])\\n return res if res > -inf else 0\",\n \"runtime\": \"1051\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -inf\\n\\n prefix_sum = 0\\n seen = defaultdict(lambda: inf)\\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n\\n prefix_sum += n\\n\\n ans = max(ans, prefix_sum - seen[k + n], prefix_sum - seen[n - k])\\n\\n return ans if ans != -inf else 0\\n\",\n \"runtime\": \"1051\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -inf\\n\\n prefix_sum = 0\\n seen = defaultdict(lambda: inf)\\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n \\n prefix_sum += n\\n\\n ans = max(ans, prefix_sum - seen[k + n], \\\\\\n prefix_sum - seen[n - k])\\n \\n return ans if ans != -inf else 0\\n\\n\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n for a in nums:\\n pre[a] = min(pre[a], cur)\\n cur += a\\n res = max(res, cur - pre[a - k], cur - pre[a + k])\\n # print(a, pre, cur, res)\\n return res if res > -inf else 0\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -math.inf\\n min_s = defaultdict(lambda: math.inf)\\n s = 0\\n for x in nums:\\n ans = max(ans, s + x - min(min_s[x-k], min_s[x+k]))\\n min_s[x] = min(min_s[x], s)\\n s += x\\n return ans if ans > - math.inf else 0\\n \",\n \"runtime\": \"1059\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = -inf\\n pre_sum = 0\\n seen = defaultdict(lambda:inf)\\n for num in nums:\\n seen[num] = min(seen[num], pre_sum)\\n pre_sum +=num\\n res = max(res, pre_sum-seen[num+k], pre_sum-seen[num-k])\\n return res if res != -inf else 0\",\n \"runtime\": \"1059\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n output = -inf\\n prefix_sum = 0\\n min_prefix_sum = defaultdict(lambda: inf)\\n\\n for num in nums:\\n min_prefix_sum[num] = min(min_prefix_sum[num], prefix_sum)\\n prefix_sum += num\\n # check prefix sum at both complements of num\\n output = max(\\n output,\\n prefix_sum-min_prefix_sum[num+k],\\n prefix_sum-min_prefix_sum[num-k]\\n )\\n\\n return output if output>-inf else 0\",\n \"runtime\": \"1064\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = -inf\\n\\n prefix_sum = 0\\n seen = defaultdict(lambda: inf)\\n \\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n prefix_sum += n\\n max_sum = max(max_sum, prefix_sum - seen[k+n], prefix_sum - seen[n-k])\\n \\n return max_sum if max_sum != -inf else 0\\n\",\n \"runtime\": \"1064\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixes = defaultdict(lambda: inf)\\n ans = -inf\\n currSum = 0\\n for num in nums:\\n prefixes[num] = min(prefixes[num],currSum)\\n currSum += num\\n ans = max(ans,currSum - prefixes[num-k],currSum - prefixes[num+k])\\n return ans if ans > -inf else 0\\n\",\n \"runtime\": \"1068\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n maxs = float('-inf')\\n prefix = 0\\n maps = defaultdict(lambda: float('inf'))\\n\\n for num in nums:\\n if maps[num] > prefix:\\n maps[num] = prefix\\n prefix += num\\n\\n maxs = max(maxs, prefix - maps[num + k], prefix - maps[num - k])\\n return maxs if maxs>float('-inf') else 0\\n\\n\\n\",\n \"runtime\": \"1068\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = defaultdict(lambda: inf)\\n curr = 0\\n res = -inf\\n for num in nums:\\n prefix_sum[num] = min(prefix_sum[num], curr)\\n curr += num\\n res = max(res, curr - prefix_sum[num - k], curr - prefix_sum[num + k])\\n return res if res != -inf else 0\\n\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefsum_map = collections.defaultdict(lambda: math.inf)\\n prefix_sum, result = 0, -math.inf\\n\\n for n in nums:\\n prefsum_map[n] = min(prefsum_map[n], prefix_sum)\\n prefix_sum += n\\n result = max(\\n result,\\n prefix_sum - prefsum_map[n - k],\\n prefix_sum - prefsum_map[n + k],\\n )\\n \\n return result if result > -math.inf else 0\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n d = defaultdict(lambda: inf)\\n ps = 0\\n ans = -inf\\n for n in nums:\\n d[n] = min(d[n],ps)\\n ps += n\\n ans = max(ans, ps - d[n-k], ps - d[n+k])\\n return ans if ans != -inf else 0\",\n \"runtime\": \"1077\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum = float('-inf')\\n prefix_sum = 0\\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\\n \\n for num in nums:\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n \\n prefix_sum += num\\n \\n # Check and update maximum subarray sum of length k\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n \\n return max_sum if max_sum > float('-inf') else 0\\n\",\n \"runtime\": \"1077\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nCan't sort it\\nCan't slide a window\\nWhat about two pointers?\\n|a - b| = k\\na - b = k\\na - b = -k\\n\\na = b - k\\na = k - b\\nlookup a in hashmap and get it's index to compute a sum\\n\\na = 0\\na = 1 or -1 -> yes at index 0 sum(0, 1) to update max\\n{1: 0, 2: 1}\\ntotalSum at index i; sum(0, b) = sum(0, a) + sum(a, b)\\ntotalSum - prefixSum\\n[-1,3,2,4,5]\\n\\\"\\\"\\\"\\nfrom collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n total_sum = 0\\n max_sum = float('-inf')\\n complement_map = {}\\n\\n for index in range(len(nums)): # 4\\n num = nums[index] # 5\\n complements = [num - k, num + k] # -12, 12\\n for complement in complements:\\n if complement in complement_map:\\n curr_sum = total_sum - complement_map[complement] # 8 - 4 = 4\\n max_sum = max(max_sum, curr_sum + num) # 4\\n\\n complement_map[num] = min(total_sum, complement_map.get(num, float('inf'))) # {-1: 0, 3: 1, 2: 2, 4: 3, 5: 4}\\n \\n total_sum += num # 8 + 5 = 13\\n\\n return max_sum if max_sum != float('-inf') else 0\\n \\n\",\n \"runtime\": \"1081\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixes = defaultdict(lambda: inf)\\n ans = -inf\\n currSum = 0\\n for i in range(len(nums)):\\n prefixes[nums[i]] = min(prefixes[nums[i]],currSum)\\n currSum += nums[i]\\n ans = max(ans,currSum-prefixes[nums[i]-k],currSum-prefixes[nums[i]+k])\\n if ans == -inf:\\n return 0\\n else:\\n return ans\\n\\n\",\n \"runtime\": \"1081\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n seen = defaultdict(lambda: inf)\\n prefix_sum = 0\\n res = -inf\\n\\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n prefix_sum += n\\n x = prefix_sum - seen[n + k]\\n y = prefix_sum - seen[n - k]\\n res = max(res, x, y)\\n \\n if res == -inf:\\n return 0\\n return res\\n\",\n \"runtime\": \"1094\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# m = len(nums)\\n# accu = list(accumulate(nums))\\n# # print(accu)\\n# ref=defaultdict(list)\\n# for i in range(m):\\n# v = nums[i]\\n# ref[v].append(i)\\n# res = -math.inf\\n# for i in range(m):\\n# accu1 = accu[i-1] if i>0 else 0\\n# v = nums[i]\\n# tar1 = v+k\\n# tar2 = v-k\\n# idx = bisect_left(ref[tar1],i+1)\\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\\n# if idx<len(ref[tar1]):\\n# # print('1')\\n# for j in range(idx,len(ref[tar1])):\\n# idx2 = ref[tar1][j]\\n# accu2 = accu[idx2]\\n# res = max(res,accu2-accu1)\\n# idx = bisect_left(ref[tar2],i+1)\\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\\n# if idx<len(ref[tar2]):\\n# # print('1')\\n# for j in range(idx,len(ref[tar2])):\\n# idx2 = ref[tar2][j]\\n# accu2 = accu[idx2]\\n# res = max(res,accu2-accu1)\\n \\n\\n# return res if res!=-math.inf else 0\\n\\n\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_left = defaultdict(lambda: inf)\\n res = -inf\\n cur = 0 \\n\\n for x in nums:\\n prefix_left[x] = min(prefix_left[x], cur)\\n cur += x\\n\\n if x-k in prefix_left:\\n res = max(res, cur - prefix_left[x-k])\\n if x+k in prefix_left:\\n res = max(res, cur - prefix_left[x+k])\\n\\n return res if res!=-inf else 0\\n \\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = defaultdict(int)\\n res = -math.inf\\n cur=0\\n for num in nums:\\n prefix[num] = min(prefix[num] if num in prefix else math.inf,cur)\\n cur+=num\\n if num+k not in prefix:\\n prefix[num+k]=math.inf\\n if num-k not in prefix:\\n prefix[num-k]=math.inf\\n res = max(res, cur-prefix[num+k])\\n res = max(res, cur-prefix[num-k])\\n # print(f'res:{res} num:{num} num+k:{prefix[num+k]} num-k:{prefix[num-k]} prefix:{prefix}')\\n return res if res!=-math.inf else 0\",\n \"runtime\": \"1094\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n prefix_sum = 0\\n lookup = collections.defaultdict(lambda: math.inf)\\n n = len(nums)\\n res = -math.inf\\n for i in range(n):\\n if lookup[nums[i]] > prefix_sum:\\n lookup[nums[i]] = prefix_sum\\n prefix_sum += nums[i]\\n res= max(prefix_sum - lookup[nums[i] - k], res)\\n res= max(prefix_sum - lookup[nums[i] + k], res)\\n return res if res != -math.inf else 0\\n \\n\\n \",\n \"runtime\": \"1098\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pre = [nums[0]]\\n for num in nums[1:]: pre.append(pre[-1] + num)\\n loc = defaultdict(list)\\n ret = -inf\\n for i, num in enumerate(nums):\\n if loc[num+k]:\\n ret = max(ret, pre[i] - loc[num+k][0])\\n if loc[num-k]:\\n ret = max(ret, pre[i] - loc[num-k][0])\\n heapq.heappush(loc[num], pre[i-1] if i > 0 else 0)\\n heapq.heappush(loc[num], pre[i-1] if i > 0 else 0)\\n return ret if ret != -inf else 0\",\n \"runtime\": \"1098\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = []\\n \\n good_sum = {} # key - nums[i] = k or key - nums[i] = -k\\n ans = -float('inf')\\n\\n max_sum = {}\\n\\n for i in range(len(nums)):\\n if (i == 0):\\n prefix_sum.append(nums[0])\\n else:\\n prefix_sum.append(prefix_sum[i - 1] + nums[i])\\n\\n if nums[i] in good_sum:\\n\\n ans = max(ans, prefix_sum[i] - good_sum[nums[i]]) \\n\\n difference = nums[i] - k\\n total = k + nums[i]\\n\\n if difference not in good_sum:\\n good_sum[difference] = prefix_sum[i] - nums[i]\\n \\n if total not in good_sum:\\n good_sum[total] = prefix_sum[i] - nums[i]\\n\\n good_sum[difference] = min(good_sum[difference], prefix_sum[i] - nums[i])\\n good_sum[total] = min(good_sum[total], prefix_sum[i] - nums[i])\\n\\n return ans if ans != -float('inf') else 0\\n \",\n \"runtime\": \"1103\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = defaultdict(lambda: float('inf'))\\n curr = 0\\n res = float('-inf')\\n for num in nums:\\n prefix[num] = min(prefix[num], curr)\\n curr += num\\n res = max(res, curr - prefix[num - k], curr - prefix[num + k])\\n return res if res != float('-inf') else 0\",\n \"runtime\": \"1103\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # 1.2: Prefix Sum + Dict + min Heap(optimize)\\n # think: don't want to loop through all start indexes, because number of valid start could be large\\n # idea: only want to know the start index with the smallest prefix sum\\n # => store indexes for each num sorted by prefix sum\\n # O(nlogn): push n nums to heap\\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\\n for num in nums:\\n prefix_sum.append(prefix_sum[-1] + num)\\n # Optimize: store idx of prev nums in minHeap, sorted by prefixsum[i]\\n prev_indexes = collections.defaultdict(list) \\n res = None\\n\\n for i, num in enumerate(nums):\\n if prev_indexes[num + k]:\\n start_i = prev_indexes[num + k][0][1]\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n if prev_indexes[num - k]:\\n start_i = prev_indexes[num - k][0][1]\\n\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n # Add cur index to min heap, sorted by prefix_sum[i]\\n heapq.heappush(prev_indexes[num], (prefix_sum[i], i))\\n return 0 if res is None else res\\n\\n\\n # 1. [!TLE 780/782] My Approach: Dict + Prefix Sum\\n # Challenge 1: how to find good subarray(similar to Two Sum)\\n # sol: record indexes of previous seen num, so at each num, can use any of the prev indexes of target num as start of subarray\\n # note: k>=1 so a single value is not valid subarray\\n # Challenge 2: don't want to sum subarray repeatedly\\n # sol: use prefix sum to allow O(1) calculate of subarray sum\\n # O(n^2): for each num, loop through all possible starts\\n\\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\\n for num in nums:\\n prefix_sum.append(prefix_sum[-1] + num)\\n prev_indexes = collections.defaultdict(list) # store idx of prev nums\\n res = None\\n for i, num in enumerate(nums):\\n # check if target(num +/- k) start exists\\n for prev_i in prev_indexes[num - k]:\\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n for prev_i in prev_indexes[num + k]:\\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n # add to prev_indexes\\n prev_indexes[num].append(i)\\n\\n return 0 if res is None else res\",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = 0\\n\\n # brute force solution\\n # for i in range(len(nums)):\\n # for j in range(i + 1, len(nums)):\\n # if abs(nums[j] - nums[i]) == k:\\n # res = max(res, sum(nums[i:j + 1]))\\n \\n # return res\\n\\n # keep track of sum so far\\n prefix_left = defaultdict(lambda: float('inf'))\\n res = float('-inf')\\n prefix_sum = 0 # sum so far\\n\\n for num in nums:\\n # the prefix_left map keeps track of last occuring val of num such that \\n # is has the LOWEST corresponding prefix_sum\\n # because we need to maximize subarray sum\\n # and subarray sum is sum at curr index - sum at last index\\n # == prefix_sum - prefix_left(abs(k - i))\\n prefix_left[num] = min(prefix_left[num], prefix_sum)\\n prefix_sum += num\\n \\n res = max(res, \\n prefix_sum - prefix_left[num + k], \\n prefix_sum - prefix_left[num - k])\\n \\n return res if res > float('-inf') else 0\\n\\n\\n\\n \",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixSum = [0]\\n mp = dict()\\n goodSum = -float(\\\"inf\\\")\\n for i in range(len(nums)):\\n prefixSum.append(nums[i]+prefixSum[i])\\n mp[nums[i]] = min(mp.get(nums[i], float(\\\"inf\\\")), prefixSum[i])\\n prefixI = float(\\\"inf\\\")\\n if (nums[i] +k) in mp:\\n prefixI = min(mp[nums[i]+k], prefixI)\\n if (nums[i] -k) in mp:\\n prefixI = min(mp[nums[i]-k], prefixI)\\n if prefixI != float(\\\"inf\\\"):\\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\\n return goodSum if goodSum != -float(\\\"inf\\\") else 0\\n \\n \",\n \"runtime\": \"1111\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n rightNumPrefix = 0\\n smallestPrefixMap = {} #map a num to smallest prefix\\n result = -float('inf')\\n for rightNum in nums:\\n rightNumPrefix += rightNum\\n leftNum1 = rightNum - k\\n leftNum2 = rightNum + k\\n smallestPrefixMap[rightNum] = min(rightNumPrefix, smallestPrefixMap.get(rightNum,float('inf')))\\n result = max(result, rightNumPrefix - smallestPrefixMap.get(leftNum1,float('inf')) + leftNum1,\\n rightNumPrefix - smallestPrefixMap.get(leftNum2,float('inf')) + leftNum2)\\n if result == -float('inf'): return 0\\n return result\\n\",\n \"runtime\": \"1111\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n def solve(arr):\\n n = len(arr)\\n pre = [arr[i] for i in range(n)]\\n for i in range(1 , n):\\n pre[i] += pre[i-1]\\n \\n def get(i , j):\\n if not i:\\n return pre[j]\\n return pre[j] - pre[i-1]\\n\\n mp = {}\\n ans = float(\\\"-inf\\\")\\n j = 0\\n while j < n:\\n vali = arr[j] - k\\n if vali in mp:\\n ix = mp[vali]\\n ans = max(ans , get(ix , j))\\n \\n if arr[j] in mp:\\n if get(mp[arr[j]] , j - 1) < 0:\\n mp[arr[j]] = j\\n else:\\n mp[arr[j]] = j\\n \\n j += 1\\n \\n return ans\\n\\n v = max(solve(nums) , solve(nums[::-1]))\\n return 0 if v == float(\\\"-inf\\\") else v\\n \",\n \"runtime\": \"1116\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = [0] * (len(nums) + 1)\\n INF = float('inf')\\n\\n for idx, num in enumerate(nums, 1):\\n prefix_sum[idx] = prefix_sum[idx - 1] + num\\n\\n prev_sum = defaultdict(lambda: INF)\\n ans = -INF\\n\\n for idx, num in enumerate(nums):\\n ans = max(ans, prefix_sum[idx + 1] - prev_sum[num - k], prefix_sum[idx + 1] - prev_sum[num + k])\\n\\n if num not in prev_sum:\\n prev_sum[num] = INF\\n\\n prev_sum[num] = min(prev_sum[num], prefix_sum[idx])\\n\\n return ans if ans != -INF else 0\",\n \"runtime\": \"1116\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# m = len(nums)\\n# accu = list(accumulate(nums))\\n# # print(accu)\\n# ref=defaultdict(list)\\n# for i in range(m):\\n# v = nums[i]\\n# ref[v].append(i)\\n# res = -math.inf\\n# for i in range(m):\\n# accu1 = accu[i-1] if i>0 else 0\\n# v = nums[i]\\n# tar1 = v+k\\n# tar2 = v-k\\n# idx = bisect_left(ref[tar1],i+1)\\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\\n# if idx<len(ref[tar1]):\\n# # print('1')\\n# for j in range(idx,len(ref[tar1])):\\n# idx2 = ref[tar1][j]\\n# accu2 = accu[idx2]\\n# res = max(res,accu2-accu1)\\n# idx = bisect_left(ref[tar2],i+1)\\n# # print(f'idx:{idx} i:{i} v:{v} len(ref[v+1]):{len(ref[v+1])}')\\n# if idx<len(ref[tar2]):\\n# # print('1')\\n# for j in range(idx,len(ref[tar2])):\\n# idx2 = ref[tar2][j]\\n# accu2 = accu[idx2]\\n# res = max(res,accu2-accu1)\\n \\n\\n# return res if res!=-math.inf else 0\\n\\n\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_left = defaultdict(lambda: inf)\\n res = -inf\\n cur = 0 \\n\\n for x in nums:\\n prefix_left[x] = min(prefix_left[x], cur)\\n cur += x\\n\\n if x-k in prefix_left:\\n res = max(res, cur - prefix_left[x-k])\\n if x+k in prefix_left:\\n res = max(res, cur - prefix_left[x+k])\\n\\n return res if res!=-inf else 0\\n \\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = defaultdict(lambda:math.inf)\\n res = -math.inf\\n cur=0\\n for num in nums:\\n prefix[num] = min(prefix[num],cur)\\n cur+=num\\n if num+k not in prefix:\\n prefix[num+k]=math.inf\\n if num-k not in prefix:\\n prefix[num-k]=math.inf\\n res = max(res, cur-prefix[num+k])\\n res = max(res, cur-prefix[num-k])\\n # print(f'res:{res} num:{num} num+k:{prefix[num+k]} num-k:{prefix[num-k]} prefix:{prefix}')\\n return res if res!=-math.inf else 0\",\n \"runtime\": \"1120\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n counter = {}\\n ans = float(\\\"-inf\\\")\\n prefix_sum = 0\\n for val in nums:\\n prefix_sum += val\\n for prev in [val - k, val + k]:\\n if prev not in counter:\\n continue\\n print(ans, prefix_sum - counter[prev])\\n ans = max(ans, prefix_sum - counter[prev])\\n counter[val] = min(counter.get(val, prefix_sum - val), prefix_sum - val)\\n #print(\\\"ans is \\\", ans)\\n return ans if ans > float(\\\"-inf\\\") else 0\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # |a - b| = k => a - b = k or a - b = -k\\n # a is cur\\n # b is prev\\n # cur - prev = k => prev = cur - k\\n # or \\n # cur - prev = -k => prev = cur + k\\n\\n value_maps = defaultdict(list)\\n \\n # get prefix sum\\n prefix_sum = [0]*len(nums)\\n cur_sum = 0\\n\\n max_diff = -math.inf\\n prev = -math.inf\\n # calculate\\n for i, cur in enumerate(nums):\\n prefix_sum[i] = cur_sum\\n heapq.heappush(value_maps[cur], (cur_sum, i))\\n cur_sum += cur\\n\\n if len(value_maps[cur - k]) > 0:\\n idx = value_maps[cur - k][0][1]\\n max_diff = max(max_diff, prefix_sum[i] - prefix_sum[idx] + cur)\\n \\n if len(value_maps[cur + k]) > 0:\\n idx = value_maps[cur + k][0][1]\\n max_diff = max(max_diff, prefix_sum[i] - prefix_sum[idx] + cur)\\n \\n if max_diff == -math.inf:\\n return 0\\n\\n return max_diff\\n \",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = -inf\\n n = len(nums)\\n minS = defaultdict(lambda: inf)\\n prefix = [0] * (n+1)\\n for i in range(1,n+1):\\n prefix[i] = prefix[i-1] + nums[i-1]\\n\\n for i, x in enumerate(nums):\\n ans = max(ans, prefix[i+1] - minS[k+x], prefix[i+1] - minS[x-k])\\n minS[x] = min(minS[x], prefix[i])\\n\\n return ans if ans != -inf else 0\",\n \"runtime\": \"1129\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixLeft = defaultdict(lambda: float('inf'))\\n res = float('-inf')\\n \\n \\n prefixLeftSoFar = 0\\n for num in nums:\\n prefixLeft[num] = min(prefixLeft[num], prefixLeftSoFar)\\n\\n prefixLeftSoFar += num\\n\\n res = max(\\n res, \\n prefixLeftSoFar - prefixLeft[num - k],\\n prefixLeftSoFar - prefixLeft[num + k]\\n )\\n \\n return res if res > float('-inf') else 0\",\n \"runtime\": \"1129\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n max_sum = float('-inf')\\n prefix_sum = 0\\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\\n\\n # Iterate through every value in the array\\n for i, num in enumerate(nums):\\n # Update the minimum prefix sum for the current number\\n val_to_min_prefix_sum[num] = min(val_to_min_prefix_sum[num], prefix_sum)\\n\\n # Update the current prefix sum\\n prefix_sum += num\\n\\n # Calculate max_sum considering subarrays that satisfy the condition with k\\n max_sum = max(max_sum, \\n prefix_sum - val_to_min_prefix_sum[num + k], \\n prefix_sum - val_to_min_prefix_sum[num - k])\\n\\n return max_sum if max_sum != float('-inf') else 0\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n history = defaultdict(lambda: float('inf'))\\n current_sum = 0\\n best = float('-inf')\\n\\n for n in nums:\\n history[n] = min(history[n], current_sum)\\n current_sum += n\\n best = max(best, current_sum - history[n - k], current_sum - history[n + k])\\n \\n return best if best > float('-inf') else 0\\n\\n\\n \",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ans = float(\\\"-inf\\\")\\n prefix_sum = 0\\n seen = defaultdict(lambda: float(\\\"inf\\\"))\\n\\n for n in nums:\\n seen[n] = min(seen[n], prefix_sum)\\n prefix_sum += n\\n\\n ans = max(ans, prefix_sum - seen[n + k], prefix_sum - seen[n - k])\\n \\n return ans if ans != float(\\\"-inf\\\") else 0\",\n \"runtime\": \"1137\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":142,"string":"142"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # [-1,3,2,4,5]\n # [0,-1,2,4,8,13]\n\n # [-1] = 0...........-1--------->\n # [-1,3] = -4.........2--------->\n # [-1,3,2] = -3.......4--------->\n # [-1,3,2,4] = -5.....8--------->\n # [-1,3,2,4,5] = -6...13-------->\n\n # [3] = 0\n # [3,2] = -1\n # [3,2,4] = -1\n # [3,2,4,5] = -2\n \n # [2] = 0\n # [2,4] = -2\n # [2,4,5] = -3\n\n # [4] = 0\n # [4,5] = -1\n\n # [5] = 0\n\n # seen = {\n # -1:0 j=0 ans = p[3]-p[0] = 4\n # 3:1\n # 2:2 j=2 ans = p[5]-p[2] = 13-2=11\n # 4:3\n # 5:4\n # }\n\n\n # Variables\n n = len(nums)\n maximum = float('-inf')\n seen = {}\n\n # Create prefix array and store the sum up from idx 0 to idx i\n prefix = [0] * (n+1)\n for i,num in enumerate(nums):\n prefix[i+1] = prefix[i] + num\n\n for i,num in enumerate(nums):\n if num - k in seen:\n print(\"once\", num)\n j = seen[num-k]\n maximum = max(maximum, prefix[i+1]-prefix[j])\n\n if num + k in seen:\n print(\"twice\", num)\n j = seen[num+k]\n maximum = max(maximum, prefix[i+1]-prefix[j])\n\n if num in seen:\n print(\"thrice\")\n j = seen[num]\n if prefix[i] - prefix[j] < 0:\n print(\"when?\")\n seen[num] = i\n else:\n seen[num] = i\n print(seen)\n return maximum if maximum > float('-inf') else 0\n\n\n # # i and j are not inclusive\n # for i in range(n):\n # for j in range(i+1,n):\n # # Generate all possible combinations of |nums[i]-nums[j]|\n # combo = nums[i]-nums[j]\n\n # # If the value is equal to K, \n # if abs(combo) == k:\n # # Use prefix sums to calc the sum\n # total = prefix[j+1]-prefix[i]\n\n # # Store the maximum as global max\n # maximum = max(maximum, total)\n\n # # Return global maximum\n # return maximum if maximum != float('-inf') else 0\n\n\n\n\n\n\n\n\n\n\n","memory":"29100"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # prefix sum\n prefix_dt = {}\n cur_sum = 0\n ans = float(\"-inf\")\n for n in nums:\n cur_sum += n\n if n+k in prefix_dt:\n ans = max(ans, cur_sum + n + k - prefix_dt[n+k])\n if n-k in prefix_dt:\n ans = max(ans, cur_sum + n - k - prefix_dt[n-k])\n if n not in prefix_dt:\n prefix_dt[n] = cur_sum\n else:\n prefix_dt[n] = min(prefix_dt[n], cur_sum)\n #print(prefix_dt)\n return ans if ans != float(\"-inf\") else 0\n\n # two pointers\n max_sum = 0\n ans = float(\"-inf\")\n for i in range(len(nums)):\n prefix = nums[i]\n for j in range(i+1, len(nums)):\n prefix += nums[j]\n if abs(nums[i] - nums[j]) == k:\n ans = max(ans, prefix)\n return ans if ans != float(\"-inf\") else 0\n","memory":"29400"},{"code":"\"\"\"\ngiven\n[1,2,3,4,5,6]\n\nmapping\n{\n 1: 0,\n 2: 1,\n 3: 2,\n 4: 3,\n 5: 4,\n 6: 5\n}\n\niterate i from 0 to n\n\nif given[i] - k is in the array and the index of given[i] - k is before index i\n\nstart = mapping[value - k]\n\ncalculate sum(given[start:i+1])\n\n\"\"\"\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n best = float('-inf')\n\n # map value to not index but instead minimum prefix sum\n # if 5 is twice in the array, 5 should map to the smallest prefix sum\n # so if k = 3, when we come accross 8, the array has the largest possible sum\n mapping = {}\n prefix_sum = 0\n\n for i in range(len(nums)):\n if nums[i] not in mapping or mapping[nums[i]] > prefix_sum:\n mapping[nums[i]] = prefix_sum\n \n prefix_sum += nums[i]\n for value in [nums[i] - k, nums[i] + k]:\n if value not in mapping:\n continue\n best = max(best, prefix_sum - mapping[value])\n\n return best if best != float('-inf') else 0\n","memory":"29700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n preFixSum = {}\n pre_sum = 0\n res = float(\"-inf\")\n \n for num in nums:\n preFixSum[num] = min(preFixSum.get(num, pre_sum), pre_sum)\n pre_sum += num\n \n if (num - k) in preFixSum: \n res = max(res, pre_sum - preFixSum[num - k])\n if (num + k) in preFixSum:\n res = max(res, pre_sum - preFixSum[num + k])\n \n return res if res != float(\"-inf\") else 0\n ","memory":"29800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n record = {}\n curr_sum = 0\n max_sum = -float('inf')\n for num in nums:\n if (num not in record) or (curr_sum < record[num]):\n record[num] = curr_sum\n curr_sum += num\n\n if num+k in record:\n max_sum = max(max_sum, curr_sum - record[num+k])\n\n if num-k in record:\n max_sum = max(max_sum, curr_sum - record[num-k])\n return 0 if max_sum == -float('inf') else max_sum\n ","memory":"30000"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n pre = [nums[0]]\n s = set()\n idx = defaultdict(int)\n for i in range(1,n):\n pre.append(pre[i-1] + nums[i])\n\n res = float('-inf')\n for i in range(n):\n l = nums[i]\n if nums[i] not in s:\n idx[nums[i]] = i\n s.add(nums[i])\n else:\n if pre[idx[nums[i]]] > pre[i]:\n idx[nums[i]] = i\n \n if k+l in s:\n \n # for j in range(len(idx[k+l])):\n t = pre[i]\n if idx[k+l] >0:\n t -= pre[idx[k+l]-1] \n if t> res:\n res = t\n \n if l-k in s:\n # for j in range(len(idx[l-k])):\n t = pre[i]\n if idx[l-k] >0:\n t -= pre[idx[l-k]-1]\n if t> res:\n res = t\n return res if res != float('-inf') else 0\n \n \n\n\n ","memory":"30200"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n '''\n 1. Calculate the sum of the array\n '''\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\n sumVal, res = 0, -math.inf\n \n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\n mp = {}\n \n # Iterate through each number num in nums\n for idx, num in enumerate(nums):\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\n if num not in mp or mp[num] > sumVal:\n mp[num] = sumVal\n \n # Update sumVal by adding num to it, representing the running sum up to the current number\n sumVal += num\n \n # Check if num - k exists in mp\n if num - k in mp:\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\n res = max(sumVal - mp[num - k], res)\n \n # Check if num + k exists in mp\n if num + k in mp:\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\n res = max(sumVal - mp[num + k], res)\n \n # Return res if it is not equal to negative infinity, otherwise return 0\n return res if res != -math.inf else 0","memory":"30300"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n sumVal, res = 0, -math.inf\n \n mp = {} \n for idx, num in enumerate(nums):\n if num not in mp or mp[num] > sumVal:\n mp[num] = sumVal\n sumVal += num \n if num - k in mp:\n res = max(sumVal - mp[num - k], res)\n if num + k in mp:\n res = max(sumVal - mp[num + k], res)\n return res if res != -math.inf else 0\n ","memory":"30400"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n ret_dict = defaultdict(lambda :inf)\n cur = 0\n result = -inf\n for x in nums:\n ret_dict[x] = min(cur,ret_dict[x])\n cur +=x\n\n if x-k in ret_dict:\n result = max(result,cur - ret_dict[x-k])\n if x+k in ret_dict:\n result = max(result,cur - ret_dict[x+k])\n return result if result != -inf else 0","memory":"30400"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = {}\n currentSum = 0\n res = -inf\n\n for i in range(len(nums)): \n if nums[i] not in prefix or prefix[nums[i]] > currentSum:\n prefix[nums[i]] = currentSum\n\n currentSum += nums[i]\n\n for n in [nums[i] - k, nums[i] + k]:\n if n in prefix:\n res = max(res, currentSum - prefix[n])\n\n if res == -inf:\n return 0\n \n return res\n \n ","memory":"30500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = float('-inf')\n\n cur_sum = 0\n min_presum = {}\n for n in nums:\n \n if n not in min_presum or min_presum[n] > cur_sum:\n min_presum[n] = cur_sum\n cur_sum += n\n if n + k in min_presum:\n res = max(res, cur_sum - min_presum[n+k])\n if n - k in min_presum:\n res = max(res, cur_sum - min_presum[n-k])\n return res if res != float('-inf') else 0\n","memory":"30500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n\n # inputs: -inf < nums[i] < inf, 1 <= k < inf, k > any good subarray? no good subarray, return 0 \n # outputs: max sum else 0 with |nums[i]-nums[j]| == k\n # special conditions: \n # examples: [3,4,-2,3,8] k=6\n # ideas: Two sum, sliding window/two pointers, hashmap, prefix sum\n\n # Brute force O(N^2) \n # Global variable to track max\n # nums[j] + k = nums[i] and nums[j] - k = nums[i]\n # if not found in hashmap, save both\n # Prefix sum to calc sum\n n = len(nums)\n prefix = [0] * (n+1)\n\n for i,num in enumerate(nums):\n prefix[i+1] = prefix[i] + num\n\n # Store index of num\n seen = {}\n ans = -float('inf')\n for i,num in enumerate(nums):\n if num-k in seen:\n j = seen[num-k]\n ans = max(ans, prefix[i+1] - prefix[j])\n\n if num+k in seen:\n j = seen[num+k]\n ans = max(ans, prefix[i+1] - prefix[j])\n\n if num in seen:\n j = seen[num]\n if prefix[i] - prefix[j] < 0:\n seen[num] = i\n else:\n seen[num] = i\n\n return ans if ans != -float('inf') else 0\n\n\n\n\n\n\n\n\n\n","memory":"30600"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixSum = [0]\n mp = dict()\n goodSum = -float(\"inf\")\n for i in range(len(nums)):\n prefixSum.append(nums[i]+prefixSum[i])\n mp[nums[i]] = min(mp.get(nums[i], float(\"inf\")), prefixSum[i])\n prefixI = float(\"inf\")\n if (nums[i] +k) in mp:\n prefixI = min(mp[nums[i]+k], prefixI)\n if (nums[i] -k) in mp:\n prefixI = min(mp[nums[i]-k], prefixI)\n if prefixI != float(\"inf\"):\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\n return goodSum if goodSum != -float(\"inf\") else 0\n \n ","memory":"30600"},{"code":"from typing import List\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n # Create prefix sum array\n pre = [0] * n\n pre[0] = nums[0]\n for i in range(1, n):\n pre[i] = pre[i - 1] + nums[i]\n \n # Dictionary to store the last occurrence of each element\n mp = {}\n\n # Initialize the max sum to a very low number\n maxi = float('-inf')\n\n # Traverse through the nums array\n for i in range(n):\n # Update map with last occurrence of nums[i]\n if nums[i] in mp:\n if mp[nums[i]] > 0:\n if pre[i-1] - pre[mp[nums[i]] - 1] >= 0:\n pass # No action needed if prefix sum difference is non-negative\n else:\n mp[nums[i]] = i # Update map to the current index\n else:\n if pre[i - 1] >= 0:\n pass # No action needed if prefix sum difference is non-negative\n else:\n mp[nums[i]] = i\n else:\n mp[nums[i]] = i\n \n # Check for nums[i] - k\n if (nums[i] - k) in mp:\n if mp[nums[i] - k] > 0:\n maxi = max(maxi, pre[i] - pre[mp[nums[i] - k] - 1])\n else:\n maxi = max(maxi, pre[i])\n \n # Check for nums[i] + k\n if (nums[i] + k) in mp:\n if mp[nums[i] + k] > 0:\n maxi = max(maxi, pre[i] - pre[mp[nums[i] + k] - 1])\n else:\n maxi = max(maxi, pre[i])\n\n # Return the maximum sum, or 0 if no valid subarray is found\n if maxi == float('-inf'):\n return 0\n return maxi\n","memory":"30700"},{"code":"import math\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n \n di = {}\n \n ans = -math.inf\n \n pre = [0 for i in range(n)]\n \n pre[0] = nums[0]\n \n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n \n # print(pre)\n \n i = 0\n f = -1\n for x in nums:\n \n if(x-k in di):\n f = 1\n y = di[x-k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n if(x+k in di):\n f = 1\n y = di[x+k]\n if(y != 0):\n ans = max(ans,pre[i]-pre[y-1])\n else:\n ans = max(ans,pre[i])\n \n if(x in di):\n curr = 0\n if(di[x] == 0):\n curr = 0\n else:\n curr = di[x]-1\n \n if(pre[curr] > pre[i-1]):\n di[x] = i\n else:\n di[x] = i\n \n i += 1\n \n if(f == -1):\n ans = 0\n \n return ans\n \n \n \n \n ","memory":"30700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n result=-pow(10,15)\n prefix_sum=[0]*len(nums)\n prefix_sum[0]=nums[0]\n for i in range(1,len(nums)):\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\n map={}\n for i in range(len(nums)):\n if nums[i]-k in map:\n idx=map[nums[i]-k]\n sum= prefix_sum[i]-prefix_sum[idx-1] if idx>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i]+k in map:\n idx=map[nums[i]+k]\n sum= prefix_sum[i]-prefix_sum[idx-1] if map[nums[i]+k]>0 else prefix_sum[i]\n result=max(result,sum)\n if nums[i] not in map:\n map[nums[i]]=i\n else:\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\n if prefix_sum[i-1]<pref_sum:\n map[nums[i]]=i\n if result== -pow(10,15):\n return 0\n else:\n return result\n \n\n\n ","memory":"30800"},{"code":"import math\nclass Solution:\n \n def __init__(self):\n self.ans = -math.inf\n self.dic = {}\n \n\n def get_max_subarray(self, index, pre, i):\n res = self.dic[index]\n if res != 0:\n self.ans = max(self.ans, pre[i] - pre[res-1])\n else:\n self.ans = max(self.ans, pre[i])\n\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n\n pre = [ 0 for _ in range(n)]\n pre[0] = nums[0]\n\n for i in range(1,n):\n pre[i] = pre[i-1] + nums[i]\n\n found_good_subarray = False\n i = 0\n\n for num in nums:\n if num - k in self.dic:\n found_good_subarray = True\n self.get_max_subarray(num - k, pre, i)\n \n if num + k in self.dic:\n found_good_subarray = True\n self.get_max_subarray(num + k, pre,i)\n\n if num in self.dic:\n curr = 0\n if self.dic[num] != 0:\n curr = self.dic[num] - 1\n \n if pre[curr] > pre[i - 1]:\n self.dic[num] = i\n else:\n self.dic[num] = i\n i += 1\n\n return self.ans if found_good_subarray else 0\n \n\n\n ","memory":"30900"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n def find(num):\n ps = float('-inf')\n if num in num_index:\n prev = num_index[num] - 1\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\n return ps\n \n pre_sum = []\n cur_sum = 0\n for num in nums:\n cur_sum += num\n pre_sum.append(cur_sum)\n\n num_index = {}\n result = float('-inf')\n for i, num in enumerate(nums):\n small = num - k\n large = num + k\n result = max(result, find(small))\n result = max(result, find(large))\n \n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\n continue\n else:\n num_index[num] = i\n \n return result if result != float('-inf') else 0\n","memory":"31000"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n def find(num):\n ps = float('-inf')\n if num in num_index:\n prev = num_index[num] - 1\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\n return ps\n \n pre_sum = []\n cur_sum = 0\n for num in nums:\n cur_sum += num\n pre_sum.append(cur_sum)\n\n num_index = {}\n result = float('-inf')\n for i, num in enumerate(nums):\n small = num - k\n large = num + k\n result = max(result, find(small))\n result = max(result, find(large))\n \n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\n continue\n else:\n num_index[num] = i\n \n return result if result != float('-inf') else 0\n","memory":"31000"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix = [0] * n\n prefix[0] = nums[0]\n res = float('-inf')\n\n for i in range(1,n):\n prefix[i] = prefix[i-1] + nums[i]\n\n idx_map = defaultdict(list)\n\n for i,num in enumerate(nums):\n if num + k in idx_map:\n res = max(res, prefix[i] - idx_map[num+k][0])\n if num - k in idx_map:\n res = max(res, prefix[i] - idx_map[num-k][0])\n \n if i == 0:\n heappush(idx_map[num],0)\n else:\n heappush(idx_map[num],prefix[i-1])\n \n return res if res != float('-inf') else 0\n ","memory":"31100"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pref = [0]\n s = 0\n dic = {} #value:index\n ret = float('-inf')\n for i in range(len(nums)):\n s += nums[i]\n pref.append(s)\n if nums[i] - k in dic:\n ret = max(ret, pref[i + 1] - pref[dic[nums[i] - k]])\n if nums[i] + k in dic:\n ret = max(ret, pref[i + 1] - pref[dic[nums[i] + k]]) \n if nums[i] not in dic:\n dic[nums[i]] = i\n if pref[i + 1] < pref[dic[nums[i]] + 1]:\n dic[nums[i]] = i\n\n print(dic, pref)\n\n if ret == float('-inf'):\n return 0\n\n return ret\n\n \n ","memory":"31100"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [0]\n for n in nums:\n prefix.append(prefix[-1] + n)\n print(prefix)\n \n res = -float('inf')\n d = collections.defaultdict(int)\n for i,n in enumerate(nums):\n if n+k in d:\n res = max(res,prefix[i]-prefix[d[n+k]]+n)\n if n-k in d:\n res = max(res,prefix[i]-prefix[d[n-k]]+n)\n \n \n d[n] = i if n not in d or prefix[i] < prefix[d[n]] else d[n]\n return 0 if res == -float('inf') else res\n \n ","memory":"31200"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefixSum = [0]\n mp = dict()\n goodSum = -float(\"inf\")\n for i in range(len(nums)):\n prefixSum.append(nums[i]+prefixSum[i])\n mp[nums[i]] = min(mp.get(nums[i], float(\"inf\")), prefixSum[i])\n prefixI = float(\"inf\")\n if (nums[i] +k) in mp:\n print(nums[i], i)\n prefixI = min(mp[nums[i]+k], prefixI)\n if (nums[i] -k) in mp:\n prefixI = min(mp[nums[i]-k], prefixI)\n if prefixI != float(\"inf\"):\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\n return goodSum if goodSum != -float(\"inf\") else 0\n \n ","memory":"31300"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n res = float('-inf')\n good_sub_found = False\n\n\n prefix = [0] * len(nums)\n prefix[0] = nums[0]\n for i in range(1, len(nums)):\n prefix[i] = prefix[i - 1] + nums[i]\n\n print(prefix)\n print(nums)\n hash_map = {}\n for i in range(len(nums)):\n diffSub = nums[i]-k\n diffAdd = nums[i]+k\n\n if diffSub in hash_map:\n j = hash_map[diffSub]\n if j == 0:\n res = max(res,prefix[i])\n else:\n res = max(res, prefix[i]-prefix[j-1])\n if diffAdd in hash_map:\n j = hash_map[diffAdd]\n if j == 0:\n res = max(res,prefix[i])\n else:\n res = max(res, prefix[i]-prefix[j-1])\n if nums[i] in hash_map:\n j = hash_map[nums[i]]\n if prefix[i] - prefix[j] < 0:\n hash_map[nums[i]] = i\n else:\n hash_map[nums[i]] = i\n\n\n return res if res>float('-inf') else 0\n \n # for i in range(len(nums)):\n # for j in range(i,len(nums)):\n # diff = abs(nums[i]-nums[j])\n # if diff == k:\n # good_sub = True\n # res = max(res,sum(nums[i:j+1]))\n # return res if good_sub else 0\n ","memory":"31400"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # result=float(\"-inf\")\n # for i in range(len(nums)):\n # first=nums[i]\n # sum=first\n # for j in range(i+1,len(nums)):\n # sum+=nums[j]\n # if abs(first-nums[j])==k:\n # result=max(result,sum)\n # return result if result!=float(\"-inf\") else 0\n\n\n #Using prefix sum\n prefix=[0]*(len(nums)+1)\n for i in range(len(nums)):\n prefix[i+1]=nums[i]+prefix[i]\n print(prefix)\n\n mp={}\n result=float(\"-inf\")\n for i in range(len(nums)):\n if nums[i]-k in mp:\n min_sum=mp[nums[i]-k]\n result=max(result,prefix[i+1]-min_sum)\n if nums[i]+k in mp:\n min_sum=mp[nums[i]+k]\n result=max(result,prefix[i+1]-min_sum)\n mp[nums[i]]=min(mp.get(nums[i],float(\"inf\")),prefix[i])\n return result if result!=float(\"-inf\") else 0","memory":"31500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # result=float(\"-inf\")\n # for i in range(len(nums)):\n # first=nums[i]\n # sum=first\n # for j in range(i+1,len(nums)):\n # sum+=nums[j]\n # if abs(first-nums[j])==k:\n # result=max(result,sum)\n # return result if result!=float(\"-inf\") else 0\n\n\n #Using prefix sum\n prefix=[0]*(len(nums)+1)\n for i in range(len(nums)):\n prefix[i+1]=nums[i]+prefix[i]\n print(prefix)\n\n mp={}\n result=float(\"-inf\")\n for i in range(len(nums)):\n if nums[i]-k in mp:\n min_sum=mp[nums[i]-k]\n result=max(result,prefix[i+1]-min_sum)\n if nums[i]+k in mp:\n min_sum=mp[nums[i]+k]\n result=max(result,prefix[i+1]-min_sum)\n mp[nums[i]]=min(mp.get(nums[i],float(\"inf\")),prefix[i])\n return result if result!=float(\"-inf\") else 0","memory":"31500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n dic = {}\n totalDic = {}\n totalSum = 0\n mx = -math.inf\n for i in range(len(nums)):\n totalSum += nums[i]\n if dic.__contains__(nums[i]+k):\n index = dic[nums[i]+k]\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\n \n if dic.__contains__(nums[i]-k):\n index = dic[nums[i]-k]\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\n \n if not dic.__contains__(nums[i]):\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n else:\n if totalSum - totalDic[nums[i]]<0:\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n return mx if mx != -math.inf else 0","memory":"31700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n dic = {}\n totalDic = {}\n totalSum = 0\n mx = -math.inf\n for i in range(len(nums)):\n if dic.__contains__(nums[i]+k):\n mx = max(mx, totalSum - totalDic[nums[i]+k]+nums[i])\n \n if dic.__contains__(nums[i]-k):\n mx = max(mx, totalSum - totalDic[nums[i]-k]+nums[i])\n \n if not dic.__contains__(nums[i]):\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n else:\n if totalSum - totalDic[nums[i]]<0:\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n totalSum += nums[i]\n \n return mx if mx != -math.inf else 0","memory":"31700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n seen = {}\n prefix = []\n ssum = 0\n self.max_sum = float('-inf')\n\n def update_max_sum(key, i):\n if key in seen:\n index = seen[key][0]\n # if i != index:\n # return\n total = prefix[i] - prefix[index] + nums[i]\n self.max_sum = max(self.max_sum, total)\n \n for i, n in enumerate(nums):\n prefix.append(ssum)\n ssum = ssum + n\n if n in seen:\n idx = seen[n][-1]\n prev_sum = prefix[idx]\n seen[n][-1] = idx if prev_sum < prefix[i] else i\n else:\n seen[n] = [i]\n\n update_max_sum(n - k, i)\n update_max_sum(n + k, i)\n\n return self.max_sum if self.max_sum != float('-inf') else 0","memory":"31800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # 1.3: Prefix Sum + Dict + only store idx with min prefix sum\n # idea: for each num, when use it as start index, we only need the index with the smallest prefix sum\n # => only store the index with the smallest prefix sum for each num\n # O(n)\n # O(n)\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\n for num in nums:\n prefix_sum.append(prefix_sum[-1] + num)\n # Optimize: store (idx, pref_sum[idx]) with smallest pref_sum for each num\n prev_index = dict() \n res = None\n\n for i, num in enumerate(nums):\n if num + k in prev_index:\n start_i = prev_index[num + k][0]\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n if num - k in prev_index:\n start_i = prev_index[num - k][0]\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n # update prev_index if cur idx has smaller prefix sum\n if num not in prev_index:\n prev_index[num] = [i, prefix_sum[i]]\n else:\n if prefix_sum[i] < prev_index[num][1]:\n prev_index[num] = [i, prefix_sum[i]]\n \n return 0 if res is None else res\n\n # 1.2: Prefix Sum + Dict + min Heap(optimize)\n # think: don't want to loop through all start indexes, because number of valid start could be large\n # idea: only want to know the start index with the smallest prefix sum\n # => store indexes for each num sorted by prefix sum\n # O(nlogn): push n nums to heap\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\n for num in nums:\n prefix_sum.append(prefix_sum[-1] + num)\n # Optimize: store idx of prev nums in minHeap, sorted by prefixsum[i]\n prev_indexes = collections.defaultdict(list) \n res = None\n\n for i, num in enumerate(nums):\n if prev_indexes[num + k]:\n start_i = prev_indexes[num + k][0][1]\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n if prev_indexes[num - k]:\n start_i = prev_indexes[num - k][0][1]\n\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n # Add cur index to min heap, sorted by prefix_sum[i]\n heapq.heappush(prev_indexes[num], (prefix_sum[i], i))\n return 0 if res is None else res\n\n\n # 1. [!TLE 780/782] My Approach: Dict + Prefix Sum\n # Challenge 1: how to find good subarray(similar to Two Sum)\n # sol: record indexes of previous seen num, so at each num, can use any of the prev indexes of target num as start of subarray\n # note: k>=1 so a single value is not valid subarray\n # Challenge 2: don't want to sum subarray repeatedly\n # sol: use prefix sum to allow O(1) calculate of subarray sum\n # O(n^2): for each num, loop through all possible starts\n\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\n for num in nums:\n prefix_sum.append(prefix_sum[-1] + num)\n prev_indexes = collections.defaultdict(list) # store idx of prev nums\n res = None\n for i, num in enumerate(nums):\n # check if target(num +/- k) start exists\n for prev_i in prev_indexes[num - k]:\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n for prev_i in prev_indexes[num + k]:\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\n if res is None:\n res = cur_sum\n else:\n res = max(res, cur_sum)\n # add to prev_indexes\n prev_indexes[num].append(i)\n\n return 0 if res is None else res","memory":"31900"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n dic = {}\n totalDic = {}\n totalSum = 0\n mx = -math.inf\n for i in range(len(nums)):\n totalSum += nums[i]\n if dic.__contains__(nums[i]+k):\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\n \n if dic.__contains__(nums[i]-k):\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\n \n if not dic.__contains__(nums[i]):\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n else:\n if totalSum - totalDic[nums[i]]<0:\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n return mx if mx != -math.inf else 0","memory":"32299"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n dic = {}\n totalDic = {}\n totalSum = 0\n mx = -math.inf\n for i in range(len(nums)):\n totalSum += nums[i]\n if dic.__contains__(nums[i]+k):\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\n \n if dic.__contains__(nums[i]-k):\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\n \n if not dic.__contains__(nums[i]):\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n else:\n if totalSum - totalDic[nums[i]]<0:\n dic[nums[i]] = i\n totalDic[nums[i]] = totalSum\n return mx if mx != -math.inf else 0","memory":"32299"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n presum = []\n total = 0\n for num in nums:\n total += num\n presum.append(total)\n\n ndict = defaultdict(list)\n ans = - math.inf\n for i, num in enumerate(nums):\n if num + k in ndict or num - k in ndict:\n idx = ndict[num + k] + ndict[num - k]\n for j in idx:\n subsum = presum[i] - presum[j - 1] if j != 0 else presum[i]\n ans = max(ans, subsum)\n if num not in ndict or len(ndict[num]) == 0:\n ndict[num].append(i)\n else:\n j = ndict[num][-1]\n subsum = presum[i - 1] - presum[j - 1] if j != 0 else presum[i - 1]\n if subsum < 0:\n ndict[num][-1] = i\n \n return ans if ans != -math.inf else 0\n\n ","memory":"32500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # brute force approach n^2 to find good subarrays\n\n prefixes = [0]\n for num in nums:\n prefixes.append(prefixes[-1] + num)\n \n max_good_sum = float('-inf')\n counts = defaultdict(list)\n\n for j, num in enumerate(nums):\n plus_k = num + k\n minus_k = num - k\n if num not in counts:\n counts[num].append(j)\n elif prefixes[j] - prefixes[counts[num][0]] < 0:\n counts[num][0] = j\n\n if plus_k in counts:\n for i in counts[plus_k]:\n max_good_sum = max(max_good_sum, prefixes[j+1] - prefixes[i])\n\n if minus_k in counts:\n for i in counts[minus_k]:\n max_good_sum = max(max_good_sum, prefixes[j+1] - prefixes[i])\n\n \n return max_good_sum if max_good_sum != float('-inf') else 0","memory":"32600"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [nums[0]]\n for n in nums[1:]:\n prefix.append(prefix[-1]+n)\n print(prefix)\n \n # 2. dict with\n # key as a [number] in the list (from right side for list)\n # value as prefix sum until that [nunber]\n d = {}\n \n # 3. result\n res = float('-inf')\n for n,ps in zip(nums, prefix):\n # 4. find the maximum prefix sum from the right side of array\n # with n+k, n-k as key\n\n if n-k in d:\n res = max(res, ps-d[n-k])\n if n+k in d:\n res = max(res, ps-d[n+k])\n\n # 5. add the current prefix sum with key n to the dictionary \n d[n] = min(d[n], ps - n) if n in d else ps - n\n return res if res != float('-inf') else 0\n\n \n\n\n ","memory":"32900"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix = [0] * (n+1)\n indices = {}\n curr_sum = 0\n result = float('-inf')\n\n for i in range(1, len(prefix)):\n prefix[i] = prefix[i-1] + nums[i-1]\n \n for i, val in enumerate(nums):\n curr_sum += val\n if val in indices:\n if curr_sum < indices[val][1]:\n indices[val] = (i, curr_sum)\n else:\n indices[val] = (i, curr_sum)\n if val + k in indices:\n index = indices[val+k][0]\n result = max(result, prefix[i+1] - prefix[index])\n if val - k in indices:\n index = indices[val-k][0]\n result = max(result, prefix[i+1] - prefix[index])\n\n return result if result != float('-inf') else 0\n \n ","memory":"33000"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # res, cur, acc = -inf, 0, defaultdict(lambda: inf)\n # for num in nums:\n # acc[num] = min(acc[num], cur)\n # cur += num\n # res = max(res, cur-acc[num-k], cur-acc[num+k])\n # return res if res > -inf else 0\n\n inds, acc, res = defaultdict(list), list(accumulate(nums,initial=0)), -inf\n for i,num in enumerate(nums): inds[num].append(i)\n\n for num in inds:\n if num+k in inds:\n lList, rList = inds[num], inds[num+k]\n ptr, cur, prev, l, r = 0, 0, rList[0], len(lList), len(rList)\n while ptr < l and lList[ptr] < rList[0]: ptr += 1\n for rInd in rList[1:]+[inf]:\n while ptr < l and lList[ptr] < rInd:\n cur += acc[lList[ptr]+1] - acc[prev]\n if res < cur: res = cur\n prev = lList[ptr]+1\n ptr += 1\n if ptr == l: break\n cur += acc[rInd]-acc[prev]\n if cur < 0: cur = 0\n prev = rInd\n ptr, cur, prev = 0, 0, lList[0]\n while ptr < r and rList[ptr] < lList[0]: ptr += 1\n for lInd in lList[1:]+[inf]:\n while ptr < r and rList[ptr] < lInd:\n cur += acc[rList[ptr]+1] - acc[prev]\n if res < cur: res = cur\n prev = rList[ptr]+1\n ptr += 1\n if ptr == r: break\n cur += acc[lInd]-acc[prev]\n if cur < 0: cur = 0\n prev = lInd\n \n return res if res > -inf else 0","memory":"33800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \"\"\"\n \n Sliding Window O(N)\n - sort first so O(NlogN)\n \n \n - Brute Force O(N^2)\n - for a given number, if n[i] is negative, then abs sum will be be maximied\n - if n[i] is pos but n[j] is neg, then maximized,\n - if both pos, then minimized\n - \n \"\"\"\n # nums.sort()\n prefix_sum = list(accumulate([0] + nums))\n # print(nums)\n \n \n cnt = 0\n \n max_val = float('-inf')\n \n visited = defaultdict(list)\n \n for j in range(len(nums)):\n val = nums[j]\n comp1 = val + k\n comp2 = val - k\n \n if comp1 in visited:\n visited[comp1].sort(key = lambda x: prefix_sum[j+1]-prefix_sum[x], reverse=True)\n # for i in visited[comp1]:\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\n visited[comp1] = visited[comp1][:1]\n max_val = max(max_val, prefix_sum[j+1]-prefix_sum[visited[comp1][0]])\n if comp2 in visited:\n # for i in visited[comp2]:\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\n visited[comp2].sort(key = lambda x: prefix_sum[j+1]-prefix_sum[x], reverse=True)\n # for i in visited[comp1]:\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\n visited[comp2] = visited[comp2][:1]\n max_val = max(max_val, prefix_sum[j+1]-prefix_sum[visited[comp2][0]])\n \n visited[val].append(j)\n if max_val == float('-inf'):\n return 0\n return max_val\n \n \n \n \n # for i in range(len(nums)):\n # for j in range(i, len(nums)):\n # if abs(nums[j]-nums[i]) == k:\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\n # if max_val == float('-inf'):\n # return 0\n # return max_val","memory":"34000"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n suffix_sum = [0 for i in range(len(nums) + 1)]\n for i in range(len(nums) - 1, -1, -1):\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\n\n prefix_sum = [0 for i in range(len(nums) + 1)]\n prev = {}\n prev_max_sums = {}\n\n ans = -inf\n for i in range(1, len(nums) + 1):\n low, high = nums[i-1] - k, nums[i-1] + k\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\n if low in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\n if high in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\n\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\n prev[nums[i-1]] = i - 1\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\n \n if ans == -inf:\n return 0\n\n return ans\n","memory":"34700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n suffix_sum = [0 for i in range(len(nums) + 1)]\n for i in range(len(nums) - 1, -1, -1):\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\n\n prefix_sum = [0 for i in range(len(nums) + 1)]\n prev = {}\n prev_max_sums = {}\n\n ans = -inf\n for i in range(1, len(nums) + 1):\n low, high = nums[i-1] - k, nums[i-1] + k\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\n if low in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\n if high in prev:\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\n\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\n prev[nums[i-1]] = i - 1\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\n \n if ans == -inf:\n return 0\n\n return ans\n","memory":"34700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n total = 0\n res = -inf\n prefix_v = defaultdict(lambda: inf)\n\n for v in nums:\n res = max(res, total + v - min(prefix_v[v-k], prefix_v[v+k]))\n prefix_v[v] = min(prefix_v[v], total)\n total += v\n\n return res if res != -inf else 0\n","memory":"35300"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n suffix_sum = [0 for i in range(len(nums) + 1)]\n for i in range(len(nums) - 1, -1, -1):\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\n\n prefix_sum = [0]\n prev = {}\n\n ans = -inf\n for i in range(1, len(nums) + 1):\n low, high = nums[i-1] - k, nums[i-1] + k\n prefix_sum.append(prefix_sum[-1] + nums[i-1])\n\n if low in prev:\n ans = max(ans, prefix_sum[-1] - prefix_sum[prev[low][0]])\n if high in prev:\n ans = max(ans, prefix_sum[-1] - prefix_sum[prev[high][0]])\n\n if prev.get(nums[i-1], (-1, -inf))[1] < suffix_sum[i-1]:\n prev[nums[i-1]] = (i - 1, suffix_sum[i-1])\n \n if ans == -inf:\n return 0\n\n return ans\n","memory":"35400"},{"code":"\"\"\"\n9/8/24\n\npatterns \n\nlearnigns\n\n\"\"\"\nclass Solution:\n def maximumSubarraySum(self, nums, k):\n max_sum = -inf\n prefix_sum = 0\n val_to_min_prefix_sum = defaultdict(lambda: inf)\n\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n \n prefix_sum += num\n\n max_sum = max(\n max_sum, \n prefix_sum - val_to_min_prefix_sum[num + k],\n prefix_sum - val_to_min_prefix_sum[num - k],\n )\n \n return max_sum if max_sum > -inf else 0\n\n\n # def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\n # for i, num in enumerate(nums):\n # if val_to_min_prefix_sum[num] > prefix_sum:\n # val_to_min_prefix_sum[num] = prefix_sum\n # prefix_sum += num\n # max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n # return max_sum if max_sum > -inf else 0 \n ","memory":"35500"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = nums.copy()\n for i in range(1, len(prefix)):\n prefix[i] = prefix[i] + prefix[i-1]\n \n res = float(\"-inf\")\n need = {}\n for i, n in enumerate(nums):\n if n in need:\n res = max(res, prefix[i] - need[n])\n\n summ = 0\n if i > 0:\n summ = prefix[i - 1]\n \n need[n - k] = min(need.get(n - k, float(\"inf\")), summ)\n need[n + k] = min(need.get(n + k, float(\"inf\")), summ)\n\n return res if res != float('-inf') else 0","memory":"35600"},{"code":"class Solution:\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n# max_sum = 0\n\n\n# return max_sum\n\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda:inf)\n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","memory":"35700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n for a in nums:\n pre[a] = min(pre[a], cur)\n cur += a\n res = max(res, cur - pre[a - k], cur - pre[a + k])\n # print(a, pre, cur, res)\n return res if res > -inf else 0","memory":"35700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n # find all of the intervals and then check the sums. N^3 brute force?\n # prefix sum and Kadane's\n \n max_sum= -inf \n prefix_sum = 0 \n # min prefix sum for that number, dict key is the number\n val_to_min_prefix_sum = defaultdict(lambda: inf)\n \n for i, num in enumerate(nums):\n if val_to_min_prefix_sum[num] > prefix_sum:\n val_to_min_prefix_sum[num] = prefix_sum\n prefix_sum += num\n # need to check + or - k\n # since we are traversing nums in one direction, we won't be checking for portion of nums that haven't been traversed\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -inf else 0 ","memory":"35800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # Q: What's the length of nums? (10**5) 100k\n # \n # So there are two problems:\n # 1. Find whether at any given j, there's a i where i < j where nums[i] - nums[j] == k\n # k is basically the difference we need\n # 2. Find the sum of the array from i to j.\n # We can do this using a prefix sum. We make a prefix sum array, and the sum from\n # i to j is equal to sum[j] - sum[i]\n # [1,2,3,4,5,6]\n # [1,3,6,10,15,21]\n\n pre = defaultdict(lambda: inf)\n cur = 0\n res = -inf\n\n for num in nums:\n pre[num] = min(pre[num], cur)\n cur += num\n res = max(res, cur - pre[num - k], cur - pre[num + k])\n\n \n\n\n\n \n\n\n return res if res != -inf else 0","memory":"35800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = [0]\n interval_dict = {}\n sum_tmp = 0\n max_sum = -float(inf)\n found = False\n for curr_index, num in enumerate(nums):\n sum_tmp += num\n prefix_sum.append(sum_tmp)\n\n if num in interval_dict:\n found = True\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\n\n if num+k in interval_dict:\n prev_index = interval_dict[num+k]\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num+k] = curr_index\n \n if num-k in interval_dict:\n prev_index = interval_dict[num-k]\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num-k] = curr_index\n \n if not found:\n return 0\n else:\n return max_sum\n\n \n","memory":"36100"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = [0]\n interval_dict = {}\n sum_tmp = 0\n max_sum = -float(inf)\n found = False\n for curr_index, num in enumerate(nums):\n sum_tmp += num\n prefix_sum.append(sum_tmp)\n\n if num in interval_dict:\n found = True\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\n\n if num+k in interval_dict:\n prev_index = interval_dict[num+k]\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num+k] = curr_index\n \n if num-k in interval_dict:\n prev_index = interval_dict[num-k]\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num-k] = curr_index\n \n if not found:\n return 0\n else:\n return max_sum\n\n \n","memory":"36200"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = [0]\n interval_dict = {}\n sum_tmp = 0\n max_sum = -float(inf)\n found = False\n for curr_index, num in enumerate(nums):\n sum_tmp += num\n prefix_sum.append(sum_tmp)\n\n if num in interval_dict:\n found = True\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\n\n if num+k in interval_dict:\n prev_index = interval_dict[num+k]\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num+k] = curr_index\n \n if num-k in interval_dict:\n prev_index = interval_dict[num-k]\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\n else:\n interval_dict[num-k] = curr_index\n \n if not found:\n return 0\n else:\n return max_sum\n\n \n","memory":"36200"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = [nums[0]]\n s = 0\n for n in nums[1:]:\n prefix_sum.append(n + prefix_sum[-1])\n n_to_maxPs = collections.Counter()\n\n maxSum = float('-inf')\n for ni, ps in reversed(list(zip(nums, prefix_sum))):\n # |nj - ni| = k => nj = ni + k or nj = ni - k \n if ni + k in n_to_maxPs:\n # subarray_sum(ni, nj) = prefix_sum(nj) - prefix_sum(ni) + ni\n maxSum = max(maxSum, n_to_maxPs[ni + k] - ps + ni)\n if ni - k in n_to_maxPs:\n maxSum = max(maxSum, n_to_maxPs[ni - k] - ps + ni)\n \n n_to_maxPs[ni] = max(n_to_maxPs[ni], ps) if ni in n_to_maxPs else ps\n return maxSum if maxSum != float('-inf') else 0\n\n","memory":"36700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \"\"\"\n TC: O(n)\n SC: O(n)\n \"\"\"\n\n prefix_sum = [nums[0]]\n for elem in nums[1:]:\n prefix_sum.append(prefix_sum[-1] + elem)\n \n # Dictionary to store the mapping of numbers to their prefix sums\n d = collections.defaultdict(int) # --> only unique numbers here\n\n res = -float('inf')\n \n for n, ps in reversed(list(zip(nums, prefix_sum))): # here must be reverse, since d[n + k] - ps+n, 我们从左到右prefix sum\n\n if n + k in d:\n res = max(res, d[n + k] - ps+n)\n if n - k in d:\n res = max(res, d[n - k] - ps+n)\n \n d[n] = max(d[n], ps) if n in d else ps\n \n return res if res != -float('inf') else 0\n","memory":"36800"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \"\"\"\n TC: O(n)\n SC: O(n)\n \"\"\"\n\n prefix_sums = [nums[0]]\n for elem in nums[1:]:\n prefix_sums.append(prefix_sums[-1] + elem)\n \n # Dictionary to store the mapping of numbers to their prefix sums\n d = collections.defaultdict(int) # --> only unique numbers here\n\n res = -float('inf')\n\n # here must be reverse, since d[num + k] - prefix_sums+num, 我们从左到右prefix sum\n for num, prefix_sum in reversed(list(zip(nums, prefix_sums))): \n # [-1,3,2,4,5] k = 3\n # [-1,2,4,8,13]\n if num + k in d: # could be negative number\n res = max(res, d[num + k] - prefix_sum + num)\n if num - k in d:\n res = max(res, d[num - k] - prefix_sum + num)\n \n d[num] = max(d[num], prefix_sum) if num in d else prefix_sum # twice d[2], keep the best.\n \n return res if res != -float('inf') else 0\n","memory":"37000"},{"code":"class Solution:\n\n # prefix sum + process from right to left\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sum = []\n\n # init prefix sum\n for i, num in enumerate(nums):\n if i == 0:\n prefix_sum.append(num)\n else:\n prefix_sum.append(prefix_sum[-1] + num)\n\n # mapping for num -> max prefix sum (view from right to left)\n mapping = collections.defaultdict(int)\n\n result = float('-inf')\n\n # process from right to left\n for num, curr_prefix_sum in reversed(list(zip(nums, prefix_sum))):\n # good subarray is abs value; check both + and -\n if num + k in mapping:\n result = max(result, mapping[num + k] - curr_prefix_sum + num)\n \n if num - k in mapping:\n result = max(result, mapping[num - k] - curr_prefix_sum + num)\n\n # add current num and prefix sum to the mapping; update to max prefix sum value\n if num in mapping:\n mapping[num] = max(curr_prefix_sum, mapping[num])\n else:\n mapping[num] = curr_prefix_sum\n\n # may not have good subarray; must check\n if result == float('-inf'):\n return 0\n else:\n return result\n \n","memory":"37100"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [nums[0]]\n for n in nums[1:]:\n prefix.append(prefix[-1] + n)\n \n d = defaultdict(int)\n res = -math.inf\n f = -1\n for n, ps in reversed(list(zip(nums, prefix))):\n if n+k in d:\n f = 1\n res = max(res, d[n+k]-ps+n)\n if n-k in d:\n f = 1\n res = max(res, d[n-k]-ps+n)\n d[n] = max(d[n], ps) if n in d else ps\n return res if f == 1 else 0\n","memory":"37200"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix = [nums[0]]\n for n in nums[1:]:\n prefix.append(prefix[-1] + n)\n \n d = defaultdict(int)\n res = -math.inf\n f = -1\n for n, ps in reversed(list(zip(nums, prefix))):\n if n+k in d:\n f = 1\n res = max(res, d[n+k]-ps+n)\n if n-k in d:\n f = 1\n res = max(res, d[n-k]-ps+n)\n \n d[n] = max(d[n], ps) if n in d else ps\n return res if f == 1 else 0\n","memory":"37300"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n \n \n indexDict = defaultdict(list)\n minDict = defaultdict(int)\n prefixSum = [0]*len(nums)\n maxValue = -inf\n \n for i in range(len(nums)):\n if i == 0:\n prefixSum[i] = 0\n else: \n prefixSum[i] = prefixSum[i-1] + nums[i-1]\n \n for i, num in enumerate(nums):\n if num - k in indexDict:\n maxValue = max(maxValue, prefixSum[i] - minDict[num-k] + num)\n if num + k in indexDict:\n maxValue = max(maxValue, prefixSum[i] - minDict[num+k] + num)\n \n indexDict[num].append(i) \n # print(\"minDict_num :\", minDict[num])\n minDict[num] = min(minDict[num], prefixSum[i]) if num in minDict else prefixSum[i]\n \n \n \n \n return maxValue if maxValue != -inf else 0\n \n \n \n ","memory":"37400"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n # Initialize max_sum to a very small value to store the maximum subarray sum found\n max_sum = -float('inf')\n # Initialize prefix_sum to track the cumulative sum of elements from the start\n cum_sum = 0\n # Dictionary to store the minimum prefix sum for each number adjusted by `k`\n # This helps to quickly find the smallest prefix sum where the condition is met\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\n # Iterate over each number in the list nums with its index\n for i, num in enumerate(nums):\n # Update the dictionary to store the minimum prefix_sum seen for the current number\n # This ensures that we are only considering valid subarrays\n if val_to_min_prefix_sum[num] > cum_sum:\n val_to_min_prefix_sum[num] = cum_sum\n # Add the current number to the prefix_sum (cumulative sum)\n cum_sum += num\n # Update max_sum by considering the difference between the current prefix_sum\n # and the smallest prefix sum of the values `num + k` and `num - k`.\n # This ensures that the subarray respects the absolute difference constraint.\n max_sum = max(max_sum, cum_sum - val_to_min_prefix_sum[num + k], cum_sum - val_to_min_prefix_sum[num - k])\n return max_sum if max_sum > -float('inf') else 0","memory":"37500"},{"code":"from collections import defaultdict\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n history = defaultdict(lambda: float('inf'))\n current_sum = 0\n best = float('-inf')\n\n for n in nums:\n history[n] = min(history[n], current_sum)\n current_sum += n\n best = max(best, current_sum - history[n - k], current_sum - history[n + k])\n \n return best if best > float('-inf') else 0\n\n\n ","memory":"37600"},{"code":"# called good if the absolute difference between its first and last element is exactly k\n# maximum sum of a good subarray of nums.\n\n# Find all good subarrays\n# create num -> list of all idxes\n# for num in nums:\n# for all idxes where k-num appears, use prefix sum \n# take all sums of all good subarrays\n# take the max of those sums\n\n# nums may NOT be unique\n# nums can be negative\n# k is positive\n\n\n# [1,2,3,4,5,6]\n# 1\n# 1 2\n\n\nfrom collections import defaultdict\n\nclass Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n prefix_sums = defaultdict(lambda: float(\"inf\"))\n cursum = 0\n maxsum = float(\"-inf\")\n for idx, num in enumerate(nums):\n if cursum < prefix_sums[num]:\n prefix_sums[num] = cursum\n cursum += num\n maxsum = max(\n maxsum,\n cursum - prefix_sums[num+k],\n cursum - prefix_sums[num-k],\n )\n\n return maxsum if maxsum != float(\"-inf\") else 0","memory":"37700"},{"code":"class Solution:\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\n t={}\n c=0\n for i in range(len(nums)):\n c+=nums[i]\n t[nums[i]]=t.get(nums[i],[])\n heapq.heappush(t[nums[i]],(-c,i))\n ans=-float('inf')\n c=0\n for i in range(len(nums)):\n a1=nums[i]-k\n a2=k+nums[i]\n if(a1 in t):\n if(t[a1]):\n p,q=heapq.heappop(t[a1])\n while(t[a1] and q<i):\n p,q=heapq.heappop(t[a1])\n if(q>i):\n ans=max(ans,-p-c)\n heapq.heappush(t[a1],(p,q))\n if(a2 in t):\n if(t[a2]):\n p,q=heapq.heappop(t[a2])\n while(t[a2] and q<i):\n p,q=heapq.heappop(t[a2])\n if(q>i):\n ans=max(ans,-p-c)\n heapq.heappush(t[a2],(p,q))\n c+=nums[i]\n if(ans==-float('inf')):\n return 0\n return ans\n \n \n \n \n\n","memory":"38300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # [-1,3,2,4,5]\\n # [0,-1,2,4,8,13]\\n\\n # [-1] = 0...........-1--------->\\n # [-1,3] = -4.........2--------->\\n # [-1,3,2] = -3.......4--------->\\n # [-1,3,2,4] = -5.....8--------->\\n # [-1,3,2,4,5] = -6...13-------->\\n\\n # [3] = 0\\n # [3,2] = -1\\n # [3,2,4] = -1\\n # [3,2,4,5] = -2\\n \\n # [2] = 0\\n # [2,4] = -2\\n # [2,4,5] = -3\\n\\n # [4] = 0\\n # [4,5] = -1\\n\\n # [5] = 0\\n\\n # seen = {\\n # -1:0 j=0 ans = p[3]-p[0] = 4\\n # 3:1\\n # 2:2 j=2 ans = p[5]-p[2] = 13-2=11\\n # 4:3\\n # 5:4\\n # }\\n\\n\\n # Variables\\n n = len(nums)\\n maximum = float('-inf')\\n seen = {}\\n\\n # Create prefix array and store the sum up from idx 0 to idx i\\n prefix = [0] * (n+1)\\n for i,num in enumerate(nums):\\n prefix[i+1] = prefix[i] + num\\n\\n for i,num in enumerate(nums):\\n if num - k in seen:\\n print(\\\"once\\\", num)\\n j = seen[num-k]\\n maximum = max(maximum, prefix[i+1]-prefix[j])\\n\\n if num + k in seen:\\n print(\\\"twice\\\", num)\\n j = seen[num+k]\\n maximum = max(maximum, prefix[i+1]-prefix[j])\\n\\n if num in seen:\\n print(\\\"thrice\\\")\\n j = seen[num]\\n if prefix[i] - prefix[j] < 0:\\n print(\\\"when?\\\")\\n seen[num] = i\\n else:\\n seen[num] = i\\n print(seen)\\n return maximum if maximum > float('-inf') else 0\\n\\n\\n # # i and j are not inclusive\\n # for i in range(n):\\n # for j in range(i+1,n):\\n # # Generate all possible combinations of |nums[i]-nums[j]|\\n # combo = nums[i]-nums[j]\\n\\n # # If the value is equal to K, \\n # if abs(combo) == k:\\n # # Use prefix sums to calc the sum\\n # total = prefix[j+1]-prefix[i]\\n\\n # # Store the maximum as global max\\n # maximum = max(maximum, total)\\n\\n # # Return global maximum\\n # return maximum if maximum != float('-inf') else 0\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # prefix sum\\n prefix_dt = {}\\n cur_sum = 0\\n ans = float(\\\"-inf\\\")\\n for n in nums:\\n cur_sum += n\\n if n+k in prefix_dt:\\n ans = max(ans, cur_sum + n + k - prefix_dt[n+k])\\n if n-k in prefix_dt:\\n ans = max(ans, cur_sum + n - k - prefix_dt[n-k])\\n if n not in prefix_dt:\\n prefix_dt[n] = cur_sum\\n else:\\n prefix_dt[n] = min(prefix_dt[n], cur_sum)\\n #print(prefix_dt)\\n return ans if ans != float(\\\"-inf\\\") else 0\\n\\n # two pointers\\n max_sum = 0\\n ans = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n prefix = nums[i]\\n for j in range(i+1, len(nums)):\\n prefix += nums[j]\\n if abs(nums[i] - nums[j]) == k:\\n ans = max(ans, prefix)\\n return ans if ans != float(\\\"-inf\\\") else 0\\n\",\n \"memory\": \"29400\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\ngiven\\n[1,2,3,4,5,6]\\n\\nmapping\\n{\\n 1: 0,\\n 2: 1,\\n 3: 2,\\n 4: 3,\\n 5: 4,\\n 6: 5\\n}\\n\\niterate i from 0 to n\\n\\nif given[i] - k is in the array and the index of given[i] - k is before index i\\n\\nstart = mapping[value - k]\\n\\ncalculate sum(given[start:i+1])\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n best = float('-inf')\\n\\n # map value to not index but instead minimum prefix sum\\n # if 5 is twice in the array, 5 should map to the smallest prefix sum\\n # so if k = 3, when we come accross 8, the array has the largest possible sum\\n mapping = {}\\n prefix_sum = 0\\n\\n for i in range(len(nums)):\\n if nums[i] not in mapping or mapping[nums[i]] > prefix_sum:\\n mapping[nums[i]] = prefix_sum\\n \\n prefix_sum += nums[i]\\n for value in [nums[i] - k, nums[i] + k]:\\n if value not in mapping:\\n continue\\n best = max(best, prefix_sum - mapping[value])\\n\\n return best if best != float('-inf') else 0\\n\",\n \"memory\": \"29700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n preFixSum = {}\\n pre_sum = 0\\n res = float(\\\"-inf\\\")\\n \\n for num in nums:\\n preFixSum[num] = min(preFixSum.get(num, pre_sum), pre_sum)\\n pre_sum += num\\n \\n if (num - k) in preFixSum: \\n res = max(res, pre_sum - preFixSum[num - k])\\n if (num + k) in preFixSum:\\n res = max(res, pre_sum - preFixSum[num + k])\\n \\n return res if res != float(\\\"-inf\\\") else 0\\n \",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n record = {}\\n curr_sum = 0\\n max_sum = -float('inf')\\n for num in nums:\\n if (num not in record) or (curr_sum < record[num]):\\n record[num] = curr_sum\\n curr_sum += num\\n\\n if num+k in record:\\n max_sum = max(max_sum, curr_sum - record[num+k])\\n\\n if num-k in record:\\n max_sum = max(max_sum, curr_sum - record[num-k])\\n return 0 if max_sum == -float('inf') else max_sum\\n \",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n pre = [nums[0]]\\n s = set()\\n idx = defaultdict(int)\\n for i in range(1,n):\\n pre.append(pre[i-1] + nums[i])\\n\\n res = float('-inf')\\n for i in range(n):\\n l = nums[i]\\n if nums[i] not in s:\\n idx[nums[i]] = i\\n s.add(nums[i])\\n else:\\n if pre[idx[nums[i]]] > pre[i]:\\n idx[nums[i]] = i\\n \\n if k+l in s:\\n \\n # for j in range(len(idx[k+l])):\\n t = pre[i]\\n if idx[k+l] >0:\\n t -= pre[idx[k+l]-1] \\n if t> res:\\n res = t\\n \\n if l-k in s:\\n # for j in range(len(idx[l-k])):\\n t = pre[i]\\n if idx[l-k] >0:\\n t -= pre[idx[l-k]-1]\\n if t> res:\\n res = t\\n return res if res != float('-inf') else 0\\n \\n \\n\\n\\n \",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n '''\\n 1. Calculate the sum of the array\\n '''\\n # Initialize sumVal to keep track of the running sum and res to store the maximum sum of a good subarray\\n sumVal, res = 0, -math.inf\\n \\n # Create an empty dictionary mp to store the mapping of numbers to their prefix sums\\n mp = {}\\n \\n # Iterate through each number num in nums\\n for idx, num in enumerate(nums):\\n # Update mp[num] with the current sumVal if num is not in mp or if the current sumVal is smaller than mp[num]\\n if num not in mp or mp[num] > sumVal:\\n mp[num] = sumVal\\n \\n # Update sumVal by adding num to it, representing the running sum up to the current number\\n sumVal += num\\n \\n # Check if num - k exists in mp\\n if num - k in mp:\\n # If num - k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num - k]\\n res = max(sumVal - mp[num - k], res)\\n \\n # Check if num + k exists in mp\\n if num + k in mp:\\n # If num + k exists in mp, update res by taking the maximum of the current res and sumVal - mp[num + k]\\n res = max(sumVal - mp[num + k], res)\\n \\n # Return res if it is not equal to negative infinity, otherwise return 0\\n return res if res != -math.inf else 0\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n sumVal, res = 0, -math.inf\\n \\n mp = {} \\n for idx, num in enumerate(nums):\\n if num not in mp or mp[num] > sumVal:\\n mp[num] = sumVal\\n sumVal += num \\n if num - k in mp:\\n res = max(sumVal - mp[num - k], res)\\n if num + k in mp:\\n res = max(sumVal - mp[num + k], res)\\n return res if res != -math.inf else 0\\n \",\n \"memory\": \"30400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n ret_dict = defaultdict(lambda :inf)\\n cur = 0\\n result = -inf\\n for x in nums:\\n ret_dict[x] = min(cur,ret_dict[x])\\n cur +=x\\n\\n if x-k in ret_dict:\\n result = max(result,cur - ret_dict[x-k])\\n if x+k in ret_dict:\\n result = max(result,cur - ret_dict[x+k])\\n return result if result != -inf else 0\",\n \"memory\": \"30400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = {}\\n currentSum = 0\\n res = -inf\\n\\n for i in range(len(nums)): \\n if nums[i] not in prefix or prefix[nums[i]] > currentSum:\\n prefix[nums[i]] = currentSum\\n\\n currentSum += nums[i]\\n\\n for n in [nums[i] - k, nums[i] + k]:\\n if n in prefix:\\n res = max(res, currentSum - prefix[n])\\n\\n if res == -inf:\\n return 0\\n \\n return res\\n \\n \",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = float('-inf')\\n\\n cur_sum = 0\\n min_presum = {}\\n for n in nums:\\n \\n if n not in min_presum or min_presum[n] > cur_sum:\\n min_presum[n] = cur_sum\\n cur_sum += n\\n if n + k in min_presum:\\n res = max(res, cur_sum - min_presum[n+k])\\n if n - k in min_presum:\\n res = max(res, cur_sum - min_presum[n-k])\\n return res if res != float('-inf') else 0\\n\",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n\\n # inputs: -inf < nums[i] < inf, 1 <= k < inf, k > any good subarray? no good subarray, return 0 \\n # outputs: max sum else 0 with |nums[i]-nums[j]| == k\\n # special conditions: \\n # examples: [3,4,-2,3,8] k=6\\n # ideas: Two sum, sliding window/two pointers, hashmap, prefix sum\\n\\n # Brute force O(N^2) \\n # Global variable to track max\\n # nums[j] + k = nums[i] and nums[j] - k = nums[i]\\n # if not found in hashmap, save both\\n # Prefix sum to calc sum\\n n = len(nums)\\n prefix = [0] * (n+1)\\n\\n for i,num in enumerate(nums):\\n prefix[i+1] = prefix[i] + num\\n\\n # Store index of num\\n seen = {}\\n ans = -float('inf')\\n for i,num in enumerate(nums):\\n if num-k in seen:\\n j = seen[num-k]\\n ans = max(ans, prefix[i+1] - prefix[j])\\n\\n if num+k in seen:\\n j = seen[num+k]\\n ans = max(ans, prefix[i+1] - prefix[j])\\n\\n if num in seen:\\n j = seen[num]\\n if prefix[i] - prefix[j] < 0:\\n seen[num] = i\\n else:\\n seen[num] = i\\n\\n return ans if ans != -float('inf') else 0\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixSum = [0]\\n mp = dict()\\n goodSum = -float(\\\"inf\\\")\\n for i in range(len(nums)):\\n prefixSum.append(nums[i]+prefixSum[i])\\n mp[nums[i]] = min(mp.get(nums[i], float(\\\"inf\\\")), prefixSum[i])\\n prefixI = float(\\\"inf\\\")\\n if (nums[i] +k) in mp:\\n prefixI = min(mp[nums[i]+k], prefixI)\\n if (nums[i] -k) in mp:\\n prefixI = min(mp[nums[i]-k], prefixI)\\n if prefixI != float(\\\"inf\\\"):\\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\\n return goodSum if goodSum != -float(\\\"inf\\\") else 0\\n \\n \",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n # Create prefix sum array\\n pre = [0] * n\\n pre[0] = nums[0]\\n for i in range(1, n):\\n pre[i] = pre[i - 1] + nums[i]\\n \\n # Dictionary to store the last occurrence of each element\\n mp = {}\\n\\n # Initialize the max sum to a very low number\\n maxi = float('-inf')\\n\\n # Traverse through the nums array\\n for i in range(n):\\n # Update map with last occurrence of nums[i]\\n if nums[i] in mp:\\n if mp[nums[i]] > 0:\\n if pre[i-1] - pre[mp[nums[i]] - 1] >= 0:\\n pass # No action needed if prefix sum difference is non-negative\\n else:\\n mp[nums[i]] = i # Update map to the current index\\n else:\\n if pre[i - 1] >= 0:\\n pass # No action needed if prefix sum difference is non-negative\\n else:\\n mp[nums[i]] = i\\n else:\\n mp[nums[i]] = i\\n \\n # Check for nums[i] - k\\n if (nums[i] - k) in mp:\\n if mp[nums[i] - k] > 0:\\n maxi = max(maxi, pre[i] - pre[mp[nums[i] - k] - 1])\\n else:\\n maxi = max(maxi, pre[i])\\n \\n # Check for nums[i] + k\\n if (nums[i] + k) in mp:\\n if mp[nums[i] + k] > 0:\\n maxi = max(maxi, pre[i] - pre[mp[nums[i] + k] - 1])\\n else:\\n maxi = max(maxi, pre[i])\\n\\n # Return the maximum sum, or 0 if no valid subarray is found\\n if maxi == float('-inf'):\\n return 0\\n return maxi\\n\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n \\n di = {}\\n \\n ans = -math.inf\\n \\n pre = [0 for i in range(n)]\\n \\n pre[0] = nums[0]\\n \\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n \\n # print(pre)\\n \\n i = 0\\n f = -1\\n for x in nums:\\n \\n if(x-k in di):\\n f = 1\\n y = di[x-k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n if(x+k in di):\\n f = 1\\n y = di[x+k]\\n if(y != 0):\\n ans = max(ans,pre[i]-pre[y-1])\\n else:\\n ans = max(ans,pre[i])\\n \\n if(x in di):\\n curr = 0\\n if(di[x] == 0):\\n curr = 0\\n else:\\n curr = di[x]-1\\n \\n if(pre[curr] > pre[i-1]):\\n di[x] = i\\n else:\\n di[x] = i\\n \\n i += 1\\n \\n if(f == -1):\\n ans = 0\\n \\n return ans\\n \\n \\n \\n \\n \",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n result=-pow(10,15)\\n prefix_sum=[0]*len(nums)\\n prefix_sum[0]=nums[0]\\n for i in range(1,len(nums)):\\n prefix_sum[i]=nums[i]+prefix_sum[i-1]\\n map={}\\n for i in range(len(nums)):\\n if nums[i]-k in map:\\n idx=map[nums[i]-k]\\n sum= prefix_sum[i]-prefix_sum[idx-1] if idx>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i]+k in map:\\n idx=map[nums[i]+k]\\n sum= prefix_sum[i]-prefix_sum[idx-1] if map[nums[i]+k]>0 else prefix_sum[i]\\n result=max(result,sum)\\n if nums[i] not in map:\\n map[nums[i]]=i\\n else:\\n pref_sum = prefix_sum[map[nums[i]]-1] if map[nums[i]]>0 else 0\\n if prefix_sum[i-1]<pref_sum:\\n map[nums[i]]=i\\n if result== -pow(10,15):\\n return 0\\n else:\\n return result\\n \\n\\n\\n \",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n \\n def __init__(self):\\n self.ans = -math.inf\\n self.dic = {}\\n \\n\\n def get_max_subarray(self, index, pre, i):\\n res = self.dic[index]\\n if res != 0:\\n self.ans = max(self.ans, pre[i] - pre[res-1])\\n else:\\n self.ans = max(self.ans, pre[i])\\n\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n\\n pre = [ 0 for _ in range(n)]\\n pre[0] = nums[0]\\n\\n for i in range(1,n):\\n pre[i] = pre[i-1] + nums[i]\\n\\n found_good_subarray = False\\n i = 0\\n\\n for num in nums:\\n if num - k in self.dic:\\n found_good_subarray = True\\n self.get_max_subarray(num - k, pre, i)\\n \\n if num + k in self.dic:\\n found_good_subarray = True\\n self.get_max_subarray(num + k, pre,i)\\n\\n if num in self.dic:\\n curr = 0\\n if self.dic[num] != 0:\\n curr = self.dic[num] - 1\\n \\n if pre[curr] > pre[i - 1]:\\n self.dic[num] = i\\n else:\\n self.dic[num] = i\\n i += 1\\n\\n return self.ans if found_good_subarray else 0\\n \\n\\n\\n \",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n def find(num):\\n ps = float('-inf')\\n if num in num_index:\\n prev = num_index[num] - 1\\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\\n return ps\\n \\n pre_sum = []\\n cur_sum = 0\\n for num in nums:\\n cur_sum += num\\n pre_sum.append(cur_sum)\\n\\n num_index = {}\\n result = float('-inf')\\n for i, num in enumerate(nums):\\n small = num - k\\n large = num + k\\n result = max(result, find(small))\\n result = max(result, find(large))\\n \\n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\\n continue\\n else:\\n num_index[num] = i\\n \\n return result if result != float('-inf') else 0\\n\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n def find(num):\\n ps = float('-inf')\\n if num in num_index:\\n prev = num_index[num] - 1\\n ps = pre_sum[i] if prev == -1 else pre_sum[i] - pre_sum[prev]\\n return ps\\n \\n pre_sum = []\\n cur_sum = 0\\n for num in nums:\\n cur_sum += num\\n pre_sum.append(cur_sum)\\n\\n num_index = {}\\n result = float('-inf')\\n for i, num in enumerate(nums):\\n small = num - k\\n large = num + k\\n result = max(result, find(small))\\n result = max(result, find(large))\\n \\n if num in num_index and pre_sum[num_index[num]] < pre_sum[i]:\\n continue\\n else:\\n num_index[num] = i\\n \\n return result if result != float('-inf') else 0\\n\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix = [0] * n\\n prefix[0] = nums[0]\\n res = float('-inf')\\n\\n for i in range(1,n):\\n prefix[i] = prefix[i-1] + nums[i]\\n\\n idx_map = defaultdict(list)\\n\\n for i,num in enumerate(nums):\\n if num + k in idx_map:\\n res = max(res, prefix[i] - idx_map[num+k][0])\\n if num - k in idx_map:\\n res = max(res, prefix[i] - idx_map[num-k][0])\\n \\n if i == 0:\\n heappush(idx_map[num],0)\\n else:\\n heappush(idx_map[num],prefix[i-1])\\n \\n return res if res != float('-inf') else 0\\n \",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pref = [0]\\n s = 0\\n dic = {} #value:index\\n ret = float('-inf')\\n for i in range(len(nums)):\\n s += nums[i]\\n pref.append(s)\\n if nums[i] - k in dic:\\n ret = max(ret, pref[i + 1] - pref[dic[nums[i] - k]])\\n if nums[i] + k in dic:\\n ret = max(ret, pref[i + 1] - pref[dic[nums[i] + k]]) \\n if nums[i] not in dic:\\n dic[nums[i]] = i\\n if pref[i + 1] < pref[dic[nums[i]] + 1]:\\n dic[nums[i]] = i\\n\\n print(dic, pref)\\n\\n if ret == float('-inf'):\\n return 0\\n\\n return ret\\n\\n \\n \",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [0]\\n for n in nums:\\n prefix.append(prefix[-1] + n)\\n print(prefix)\\n \\n res = -float('inf')\\n d = collections.defaultdict(int)\\n for i,n in enumerate(nums):\\n if n+k in d:\\n res = max(res,prefix[i]-prefix[d[n+k]]+n)\\n if n-k in d:\\n res = max(res,prefix[i]-prefix[d[n-k]]+n)\\n \\n \\n d[n] = i if n not in d or prefix[i] < prefix[d[n]] else d[n]\\n return 0 if res == -float('inf') else res\\n \\n \",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefixSum = [0]\\n mp = dict()\\n goodSum = -float(\\\"inf\\\")\\n for i in range(len(nums)):\\n prefixSum.append(nums[i]+prefixSum[i])\\n mp[nums[i]] = min(mp.get(nums[i], float(\\\"inf\\\")), prefixSum[i])\\n prefixI = float(\\\"inf\\\")\\n if (nums[i] +k) in mp:\\n print(nums[i], i)\\n prefixI = min(mp[nums[i]+k], prefixI)\\n if (nums[i] -k) in mp:\\n prefixI = min(mp[nums[i]-k], prefixI)\\n if prefixI != float(\\\"inf\\\"):\\n goodSum = max(goodSum, prefixSum[i+1]-prefixI)\\n return goodSum if goodSum != -float(\\\"inf\\\") else 0\\n \\n \",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n res = float('-inf')\\n good_sub_found = False\\n\\n\\n prefix = [0] * len(nums)\\n prefix[0] = nums[0]\\n for i in range(1, len(nums)):\\n prefix[i] = prefix[i - 1] + nums[i]\\n\\n print(prefix)\\n print(nums)\\n hash_map = {}\\n for i in range(len(nums)):\\n diffSub = nums[i]-k\\n diffAdd = nums[i]+k\\n\\n if diffSub in hash_map:\\n j = hash_map[diffSub]\\n if j == 0:\\n res = max(res,prefix[i])\\n else:\\n res = max(res, prefix[i]-prefix[j-1])\\n if diffAdd in hash_map:\\n j = hash_map[diffAdd]\\n if j == 0:\\n res = max(res,prefix[i])\\n else:\\n res = max(res, prefix[i]-prefix[j-1])\\n if nums[i] in hash_map:\\n j = hash_map[nums[i]]\\n if prefix[i] - prefix[j] < 0:\\n hash_map[nums[i]] = i\\n else:\\n hash_map[nums[i]] = i\\n\\n\\n return res if res>float('-inf') else 0\\n \\n # for i in range(len(nums)):\\n # for j in range(i,len(nums)):\\n # diff = abs(nums[i]-nums[j])\\n # if diff == k:\\n # good_sub = True\\n # res = max(res,sum(nums[i:j+1]))\\n # return res if good_sub else 0\\n \",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # result=float(\\\"-inf\\\")\\n # for i in range(len(nums)):\\n # first=nums[i]\\n # sum=first\\n # for j in range(i+1,len(nums)):\\n # sum+=nums[j]\\n # if abs(first-nums[j])==k:\\n # result=max(result,sum)\\n # return result if result!=float(\\\"-inf\\\") else 0\\n\\n\\n #Using prefix sum\\n prefix=[0]*(len(nums)+1)\\n for i in range(len(nums)):\\n prefix[i+1]=nums[i]+prefix[i]\\n print(prefix)\\n\\n mp={}\\n result=float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if nums[i]-k in mp:\\n min_sum=mp[nums[i]-k]\\n result=max(result,prefix[i+1]-min_sum)\\n if nums[i]+k in mp:\\n min_sum=mp[nums[i]+k]\\n result=max(result,prefix[i+1]-min_sum)\\n mp[nums[i]]=min(mp.get(nums[i],float(\\\"inf\\\")),prefix[i])\\n return result if result!=float(\\\"-inf\\\") else 0\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # result=float(\\\"-inf\\\")\\n # for i in range(len(nums)):\\n # first=nums[i]\\n # sum=first\\n # for j in range(i+1,len(nums)):\\n # sum+=nums[j]\\n # if abs(first-nums[j])==k:\\n # result=max(result,sum)\\n # return result if result!=float(\\\"-inf\\\") else 0\\n\\n\\n #Using prefix sum\\n prefix=[0]*(len(nums)+1)\\n for i in range(len(nums)):\\n prefix[i+1]=nums[i]+prefix[i]\\n print(prefix)\\n\\n mp={}\\n result=float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if nums[i]-k in mp:\\n min_sum=mp[nums[i]-k]\\n result=max(result,prefix[i+1]-min_sum)\\n if nums[i]+k in mp:\\n min_sum=mp[nums[i]+k]\\n result=max(result,prefix[i+1]-min_sum)\\n mp[nums[i]]=min(mp.get(nums[i],float(\\\"inf\\\")),prefix[i])\\n return result if result!=float(\\\"-inf\\\") else 0\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n dic = {}\\n totalDic = {}\\n totalSum = 0\\n mx = -math.inf\\n for i in range(len(nums)):\\n totalSum += nums[i]\\n if dic.__contains__(nums[i]+k):\\n index = dic[nums[i]+k]\\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\\n \\n if dic.__contains__(nums[i]-k):\\n index = dic[nums[i]-k]\\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\\n \\n if not dic.__contains__(nums[i]):\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n else:\\n if totalSum - totalDic[nums[i]]<0:\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n return mx if mx != -math.inf else 0\",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n dic = {}\\n totalDic = {}\\n totalSum = 0\\n mx = -math.inf\\n for i in range(len(nums)):\\n if dic.__contains__(nums[i]+k):\\n mx = max(mx, totalSum - totalDic[nums[i]+k]+nums[i])\\n \\n if dic.__contains__(nums[i]-k):\\n mx = max(mx, totalSum - totalDic[nums[i]-k]+nums[i])\\n \\n if not dic.__contains__(nums[i]):\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n else:\\n if totalSum - totalDic[nums[i]]<0:\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n totalSum += nums[i]\\n \\n return mx if mx != -math.inf else 0\",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n seen = {}\\n prefix = []\\n ssum = 0\\n self.max_sum = float('-inf')\\n\\n def update_max_sum(key, i):\\n if key in seen:\\n index = seen[key][0]\\n # if i != index:\\n # return\\n total = prefix[i] - prefix[index] + nums[i]\\n self.max_sum = max(self.max_sum, total)\\n \\n for i, n in enumerate(nums):\\n prefix.append(ssum)\\n ssum = ssum + n\\n if n in seen:\\n idx = seen[n][-1]\\n prev_sum = prefix[idx]\\n seen[n][-1] = idx if prev_sum < prefix[i] else i\\n else:\\n seen[n] = [i]\\n\\n update_max_sum(n - k, i)\\n update_max_sum(n + k, i)\\n\\n return self.max_sum if self.max_sum != float('-inf') else 0\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # 1.3: Prefix Sum + Dict + only store idx with min prefix sum\\n # idea: for each num, when use it as start index, we only need the index with the smallest prefix sum\\n # => only store the index with the smallest prefix sum for each num\\n # O(n)\\n # O(n)\\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\\n for num in nums:\\n prefix_sum.append(prefix_sum[-1] + num)\\n # Optimize: store (idx, pref_sum[idx]) with smallest pref_sum for each num\\n prev_index = dict() \\n res = None\\n\\n for i, num in enumerate(nums):\\n if num + k in prev_index:\\n start_i = prev_index[num + k][0]\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n if num - k in prev_index:\\n start_i = prev_index[num - k][0]\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n # update prev_index if cur idx has smaller prefix sum\\n if num not in prev_index:\\n prev_index[num] = [i, prefix_sum[i]]\\n else:\\n if prefix_sum[i] < prev_index[num][1]:\\n prev_index[num] = [i, prefix_sum[i]]\\n \\n return 0 if res is None else res\\n\\n # 1.2: Prefix Sum + Dict + min Heap(optimize)\\n # think: don't want to loop through all start indexes, because number of valid start could be large\\n # idea: only want to know the start index with the smallest prefix sum\\n # => store indexes for each num sorted by prefix sum\\n # O(nlogn): push n nums to heap\\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\\n for num in nums:\\n prefix_sum.append(prefix_sum[-1] + num)\\n # Optimize: store idx of prev nums in minHeap, sorted by prefixsum[i]\\n prev_indexes = collections.defaultdict(list) \\n res = None\\n\\n for i, num in enumerate(nums):\\n if prev_indexes[num + k]:\\n start_i = prev_indexes[num + k][0][1]\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n if prev_indexes[num - k]:\\n start_i = prev_indexes[num - k][0][1]\\n\\n cur_sum = prefix_sum[i + 1] - prefix_sum[start_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n # Add cur index to min heap, sorted by prefix_sum[i]\\n heapq.heappush(prev_indexes[num], (prefix_sum[i], i))\\n return 0 if res is None else res\\n\\n\\n # 1. [!TLE 780/782] My Approach: Dict + Prefix Sum\\n # Challenge 1: how to find good subarray(similar to Two Sum)\\n # sol: record indexes of previous seen num, so at each num, can use any of the prev indexes of target num as start of subarray\\n # note: k>=1 so a single value is not valid subarray\\n # Challenge 2: don't want to sum subarray repeatedly\\n # sol: use prefix sum to allow O(1) calculate of subarray sum\\n # O(n^2): for each num, loop through all possible starts\\n\\n prefix_sum = [0] #prefix[i] = sum of nums[:i]\\n for num in nums:\\n prefix_sum.append(prefix_sum[-1] + num)\\n prev_indexes = collections.defaultdict(list) # store idx of prev nums\\n res = None\\n for i, num in enumerate(nums):\\n # check if target(num +/- k) start exists\\n for prev_i in prev_indexes[num - k]:\\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n for prev_i in prev_indexes[num + k]:\\n cur_sum = prefix_sum[i + 1] - prefix_sum[prev_i]\\n if res is None:\\n res = cur_sum\\n else:\\n res = max(res, cur_sum)\\n # add to prev_indexes\\n prev_indexes[num].append(i)\\n\\n return 0 if res is None else res\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n dic = {}\\n totalDic = {}\\n totalSum = 0\\n mx = -math.inf\\n for i in range(len(nums)):\\n totalSum += nums[i]\\n if dic.__contains__(nums[i]+k):\\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\\n \\n if dic.__contains__(nums[i]-k):\\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\\n \\n if not dic.__contains__(nums[i]):\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n else:\\n if totalSum - totalDic[nums[i]]<0:\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n return mx if mx != -math.inf else 0\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n dic = {}\\n totalDic = {}\\n totalSum = 0\\n mx = -math.inf\\n for i in range(len(nums)):\\n totalSum += nums[i]\\n if dic.__contains__(nums[i]+k):\\n mx = max(mx, totalSum - totalDic[nums[i]+k]+ nums[i]+k)\\n \\n if dic.__contains__(nums[i]-k):\\n mx = max(mx, totalSum - totalDic[nums[i]-k]+ nums[i]-k)\\n \\n if not dic.__contains__(nums[i]):\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n else:\\n if totalSum - totalDic[nums[i]]<0:\\n dic[nums[i]] = i\\n totalDic[nums[i]] = totalSum\\n return mx if mx != -math.inf else 0\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n presum = []\\n total = 0\\n for num in nums:\\n total += num\\n presum.append(total)\\n\\n ndict = defaultdict(list)\\n ans = - math.inf\\n for i, num in enumerate(nums):\\n if num + k in ndict or num - k in ndict:\\n idx = ndict[num + k] + ndict[num - k]\\n for j in idx:\\n subsum = presum[i] - presum[j - 1] if j != 0 else presum[i]\\n ans = max(ans, subsum)\\n if num not in ndict or len(ndict[num]) == 0:\\n ndict[num].append(i)\\n else:\\n j = ndict[num][-1]\\n subsum = presum[i - 1] - presum[j - 1] if j != 0 else presum[i - 1]\\n if subsum < 0:\\n ndict[num][-1] = i\\n \\n return ans if ans != -math.inf else 0\\n\\n \",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # brute force approach n^2 to find good subarrays\\n\\n prefixes = [0]\\n for num in nums:\\n prefixes.append(prefixes[-1] + num)\\n \\n max_good_sum = float('-inf')\\n counts = defaultdict(list)\\n\\n for j, num in enumerate(nums):\\n plus_k = num + k\\n minus_k = num - k\\n if num not in counts:\\n counts[num].append(j)\\n elif prefixes[j] - prefixes[counts[num][0]] < 0:\\n counts[num][0] = j\\n\\n if plus_k in counts:\\n for i in counts[plus_k]:\\n max_good_sum = max(max_good_sum, prefixes[j+1] - prefixes[i])\\n\\n if minus_k in counts:\\n for i in counts[minus_k]:\\n max_good_sum = max(max_good_sum, prefixes[j+1] - prefixes[i])\\n\\n \\n return max_good_sum if max_good_sum != float('-inf') else 0\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [nums[0]]\\n for n in nums[1:]:\\n prefix.append(prefix[-1]+n)\\n print(prefix)\\n \\n # 2. dict with\\n # key as a [number] in the list (from right side for list)\\n # value as prefix sum until that [nunber]\\n d = {}\\n \\n # 3. result\\n res = float('-inf')\\n for n,ps in zip(nums, prefix):\\n # 4. find the maximum prefix sum from the right side of array\\n # with n+k, n-k as key\\n\\n if n-k in d:\\n res = max(res, ps-d[n-k])\\n if n+k in d:\\n res = max(res, ps-d[n+k])\\n\\n # 5. add the current prefix sum with key n to the dictionary \\n d[n] = min(d[n], ps - n) if n in d else ps - n\\n return res if res != float('-inf') else 0\\n\\n \\n\\n\\n \",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix = [0] * (n+1)\\n indices = {}\\n curr_sum = 0\\n result = float('-inf')\\n\\n for i in range(1, len(prefix)):\\n prefix[i] = prefix[i-1] + nums[i-1]\\n \\n for i, val in enumerate(nums):\\n curr_sum += val\\n if val in indices:\\n if curr_sum < indices[val][1]:\\n indices[val] = (i, curr_sum)\\n else:\\n indices[val] = (i, curr_sum)\\n if val + k in indices:\\n index = indices[val+k][0]\\n result = max(result, prefix[i+1] - prefix[index])\\n if val - k in indices:\\n index = indices[val-k][0]\\n result = max(result, prefix[i+1] - prefix[index])\\n\\n return result if result != float('-inf') else 0\\n \\n \",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # res, cur, acc = -inf, 0, defaultdict(lambda: inf)\\n # for num in nums:\\n # acc[num] = min(acc[num], cur)\\n # cur += num\\n # res = max(res, cur-acc[num-k], cur-acc[num+k])\\n # return res if res > -inf else 0\\n\\n inds, acc, res = defaultdict(list), list(accumulate(nums,initial=0)), -inf\\n for i,num in enumerate(nums): inds[num].append(i)\\n\\n for num in inds:\\n if num+k in inds:\\n lList, rList = inds[num], inds[num+k]\\n ptr, cur, prev, l, r = 0, 0, rList[0], len(lList), len(rList)\\n while ptr < l and lList[ptr] < rList[0]: ptr += 1\\n for rInd in rList[1:]+[inf]:\\n while ptr < l and lList[ptr] < rInd:\\n cur += acc[lList[ptr]+1] - acc[prev]\\n if res < cur: res = cur\\n prev = lList[ptr]+1\\n ptr += 1\\n if ptr == l: break\\n cur += acc[rInd]-acc[prev]\\n if cur < 0: cur = 0\\n prev = rInd\\n ptr, cur, prev = 0, 0, lList[0]\\n while ptr < r and rList[ptr] < lList[0]: ptr += 1\\n for lInd in lList[1:]+[inf]:\\n while ptr < r and rList[ptr] < lInd:\\n cur += acc[rList[ptr]+1] - acc[prev]\\n if res < cur: res = cur\\n prev = rList[ptr]+1\\n ptr += 1\\n if ptr == r: break\\n cur += acc[lInd]-acc[prev]\\n if cur < 0: cur = 0\\n prev = lInd\\n \\n return res if res > -inf else 0\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n \\n Sliding Window O(N)\\n - sort first so O(NlogN)\\n \\n \\n - Brute Force O(N^2)\\n - for a given number, if n[i] is negative, then abs sum will be be maximied\\n - if n[i] is pos but n[j] is neg, then maximized,\\n - if both pos, then minimized\\n - \\n \\\"\\\"\\\"\\n # nums.sort()\\n prefix_sum = list(accumulate([0] + nums))\\n # print(nums)\\n \\n \\n cnt = 0\\n \\n max_val = float('-inf')\\n \\n visited = defaultdict(list)\\n \\n for j in range(len(nums)):\\n val = nums[j]\\n comp1 = val + k\\n comp2 = val - k\\n \\n if comp1 in visited:\\n visited[comp1].sort(key = lambda x: prefix_sum[j+1]-prefix_sum[x], reverse=True)\\n # for i in visited[comp1]:\\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\\n visited[comp1] = visited[comp1][:1]\\n max_val = max(max_val, prefix_sum[j+1]-prefix_sum[visited[comp1][0]])\\n if comp2 in visited:\\n # for i in visited[comp2]:\\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\\n visited[comp2].sort(key = lambda x: prefix_sum[j+1]-prefix_sum[x], reverse=True)\\n # for i in visited[comp1]:\\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\\n visited[comp2] = visited[comp2][:1]\\n max_val = max(max_val, prefix_sum[j+1]-prefix_sum[visited[comp2][0]])\\n \\n visited[val].append(j)\\n if max_val == float('-inf'):\\n return 0\\n return max_val\\n \\n \\n \\n \\n # for i in range(len(nums)):\\n # for j in range(i, len(nums)):\\n # if abs(nums[j]-nums[i]) == k:\\n # max_val = max(max_val, prefix_sum[j+1]-prefix_sum[i])\\n # if max_val == float('-inf'):\\n # return 0\\n # return max_val\",\n \"memory\": \"34000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n suffix_sum = [0 for i in range(len(nums) + 1)]\\n for i in range(len(nums) - 1, -1, -1):\\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\\n\\n prefix_sum = [0 for i in range(len(nums) + 1)]\\n prev = {}\\n prev_max_sums = {}\\n\\n ans = -inf\\n for i in range(1, len(nums) + 1):\\n low, high = nums[i-1] - k, nums[i-1] + k\\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\\n if low in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\\n if high in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\\n\\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\\n prev[nums[i-1]] = i - 1\\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\\n \\n if ans == -inf:\\n return 0\\n\\n return ans\\n\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n suffix_sum = [0 for i in range(len(nums) + 1)]\\n for i in range(len(nums) - 1, -1, -1):\\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\\n\\n prefix_sum = [0 for i in range(len(nums) + 1)]\\n prev = {}\\n prev_max_sums = {}\\n\\n ans = -inf\\n for i in range(1, len(nums) + 1):\\n low, high = nums[i-1] - k, nums[i-1] + k\\n prefix_sum[i] = prefix_sum[i-1] + nums[i-1]\\n if low in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[low]])\\n if high in prev:\\n ans = max(ans, prefix_sum[i] - prefix_sum[prev[high]])\\n\\n if prev_max_sums.get(nums[i-1], -inf) < suffix_sum[i-1]:\\n prev[nums[i-1]] = i - 1\\n prev_max_sums[nums[i-1]] = suffix_sum[i-1]\\n \\n if ans == -inf:\\n return 0\\n\\n return ans\\n\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n total = 0\\n res = -inf\\n prefix_v = defaultdict(lambda: inf)\\n\\n for v in nums:\\n res = max(res, total + v - min(prefix_v[v-k], prefix_v[v+k]))\\n prefix_v[v] = min(prefix_v[v], total)\\n total += v\\n\\n return res if res != -inf else 0\\n\",\n \"memory\": \"35300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n suffix_sum = [0 for i in range(len(nums) + 1)]\\n for i in range(len(nums) - 1, -1, -1):\\n suffix_sum[i] = suffix_sum[i+1] + nums[i]\\n\\n prefix_sum = [0]\\n prev = {}\\n\\n ans = -inf\\n for i in range(1, len(nums) + 1):\\n low, high = nums[i-1] - k, nums[i-1] + k\\n prefix_sum.append(prefix_sum[-1] + nums[i-1])\\n\\n if low in prev:\\n ans = max(ans, prefix_sum[-1] - prefix_sum[prev[low][0]])\\n if high in prev:\\n ans = max(ans, prefix_sum[-1] - prefix_sum[prev[high][0]])\\n\\n if prev.get(nums[i-1], (-1, -inf))[1] < suffix_sum[i-1]:\\n prev[nums[i-1]] = (i - 1, suffix_sum[i-1])\\n \\n if ans == -inf:\\n return 0\\n\\n return ans\\n\",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n9/8/24\\n\\npatterns \\n\\nlearnigns\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maximumSubarraySum(self, nums, k):\\n max_sum = -inf\\n prefix_sum = 0\\n val_to_min_prefix_sum = defaultdict(lambda: inf)\\n\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n \\n prefix_sum += num\\n\\n max_sum = max(\\n max_sum, \\n prefix_sum - val_to_min_prefix_sum[num + k],\\n prefix_sum - val_to_min_prefix_sum[num - k],\\n )\\n \\n return max_sum if max_sum > -inf else 0\\n\\n\\n # def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda: inf)\\n # for i, num in enumerate(nums):\\n # if val_to_min_prefix_sum[num] > prefix_sum:\\n # val_to_min_prefix_sum[num] = prefix_sum\\n # prefix_sum += num\\n # max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n # return max_sum if max_sum > -inf else 0 \\n \",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = nums.copy()\\n for i in range(1, len(prefix)):\\n prefix[i] = prefix[i] + prefix[i-1]\\n \\n res = float(\\\"-inf\\\")\\n need = {}\\n for i, n in enumerate(nums):\\n if n in need:\\n res = max(res, prefix[i] - need[n])\\n\\n summ = 0\\n if i > 0:\\n summ = prefix[i - 1]\\n \\n need[n - k] = min(need.get(n - k, float(\\\"inf\\\")), summ)\\n need[n + k] = min(need.get(n + k, float(\\\"inf\\\")), summ)\\n\\n return res if res != float('-inf') else 0\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"class Solution:\\n# def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n# max_sum = 0\\n\\n\\n# return max_sum\\n\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n max_sum, prefix_sum, val_to_min_prefix_sum = -inf, 0, defaultdict(lambda:inf)\\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n for a in nums:\\n pre[a] = min(pre[a], cur)\\n cur += a\\n res = max(res, cur - pre[a - k], cur - pre[a + k])\\n # print(a, pre, cur, res)\\n return res if res > -inf else 0\",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n # find all of the intervals and then check the sums. N^3 brute force?\\n # prefix sum and Kadane's\\n \\n max_sum= -inf \\n prefix_sum = 0 \\n # min prefix sum for that number, dict key is the number\\n val_to_min_prefix_sum = defaultdict(lambda: inf)\\n \\n for i, num in enumerate(nums):\\n if val_to_min_prefix_sum[num] > prefix_sum:\\n val_to_min_prefix_sum[num] = prefix_sum\\n prefix_sum += num\\n # need to check + or - k\\n # since we are traversing nums in one direction, we won't be checking for portion of nums that haven't been traversed\\n max_sum = max(max_sum, prefix_sum - val_to_min_prefix_sum[num + k], prefix_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -inf else 0 \",\n \"memory\": \"35800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # Q: What's the length of nums? (10**5) 100k\\n # \\n # So there are two problems:\\n # 1. Find whether at any given j, there's a i where i < j where nums[i] - nums[j] == k\\n # k is basically the difference we need\\n # 2. Find the sum of the array from i to j.\\n # We can do this using a prefix sum. We make a prefix sum array, and the sum from\\n # i to j is equal to sum[j] - sum[i]\\n # [1,2,3,4,5,6]\\n # [1,3,6,10,15,21]\\n\\n pre = defaultdict(lambda: inf)\\n cur = 0\\n res = -inf\\n\\n for num in nums:\\n pre[num] = min(pre[num], cur)\\n cur += num\\n res = max(res, cur - pre[num - k], cur - pre[num + k])\\n\\n \\n\\n\\n\\n \\n\\n\\n return res if res != -inf else 0\",\n \"memory\": \"35800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = [0]\\n interval_dict = {}\\n sum_tmp = 0\\n max_sum = -float(inf)\\n found = False\\n for curr_index, num in enumerate(nums):\\n sum_tmp += num\\n prefix_sum.append(sum_tmp)\\n\\n if num in interval_dict:\\n found = True\\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\\n\\n if num+k in interval_dict:\\n prev_index = interval_dict[num+k]\\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num+k] = curr_index\\n \\n if num-k in interval_dict:\\n prev_index = interval_dict[num-k]\\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num-k] = curr_index\\n \\n if not found:\\n return 0\\n else:\\n return max_sum\\n\\n \\n\",\n \"memory\": \"36100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = [0]\\n interval_dict = {}\\n sum_tmp = 0\\n max_sum = -float(inf)\\n found = False\\n for curr_index, num in enumerate(nums):\\n sum_tmp += num\\n prefix_sum.append(sum_tmp)\\n\\n if num in interval_dict:\\n found = True\\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\\n\\n if num+k in interval_dict:\\n prev_index = interval_dict[num+k]\\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num+k] = curr_index\\n \\n if num-k in interval_dict:\\n prev_index = interval_dict[num-k]\\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num-k] = curr_index\\n \\n if not found:\\n return 0\\n else:\\n return max_sum\\n\\n \\n\",\n \"memory\": \"36200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = [0]\\n interval_dict = {}\\n sum_tmp = 0\\n max_sum = -float(inf)\\n found = False\\n for curr_index, num in enumerate(nums):\\n sum_tmp += num\\n prefix_sum.append(sum_tmp)\\n\\n if num in interval_dict:\\n found = True\\n max_sum = max(max_sum, prefix_sum[-1] - prefix_sum[interval_dict[num]])\\n\\n if num+k in interval_dict:\\n prev_index = interval_dict[num+k]\\n interval_dict[num+k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num+k] = curr_index\\n \\n if num-k in interval_dict:\\n prev_index = interval_dict[num-k]\\n interval_dict[num-k] = curr_index if prefix_sum[curr_index] < prefix_sum[prev_index] else prev_index\\n else:\\n interval_dict[num-k] = curr_index\\n \\n if not found:\\n return 0\\n else:\\n return max_sum\\n\\n \\n\",\n \"memory\": \"36200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = [nums[0]]\\n s = 0\\n for n in nums[1:]:\\n prefix_sum.append(n + prefix_sum[-1])\\n n_to_maxPs = collections.Counter()\\n\\n maxSum = float('-inf')\\n for ni, ps in reversed(list(zip(nums, prefix_sum))):\\n # |nj - ni| = k => nj = ni + k or nj = ni - k \\n if ni + k in n_to_maxPs:\\n # subarray_sum(ni, nj) = prefix_sum(nj) - prefix_sum(ni) + ni\\n maxSum = max(maxSum, n_to_maxPs[ni + k] - ps + ni)\\n if ni - k in n_to_maxPs:\\n maxSum = max(maxSum, n_to_maxPs[ni - k] - ps + ni)\\n \\n n_to_maxPs[ni] = max(n_to_maxPs[ni], ps) if ni in n_to_maxPs else ps\\n return maxSum if maxSum != float('-inf') else 0\\n\\n\",\n \"memory\": \"36700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n TC: O(n)\\n SC: O(n)\\n \\\"\\\"\\\"\\n\\n prefix_sum = [nums[0]]\\n for elem in nums[1:]:\\n prefix_sum.append(prefix_sum[-1] + elem)\\n \\n # Dictionary to store the mapping of numbers to their prefix sums\\n d = collections.defaultdict(int) # --> only unique numbers here\\n\\n res = -float('inf')\\n \\n for n, ps in reversed(list(zip(nums, prefix_sum))): # here must be reverse, since d[n + k] - ps+n, 我们从左到右prefix sum\\n\\n if n + k in d:\\n res = max(res, d[n + k] - ps+n)\\n if n - k in d:\\n res = max(res, d[n - k] - ps+n)\\n \\n d[n] = max(d[n], ps) if n in d else ps\\n \\n return res if res != -float('inf') else 0\\n\",\n \"memory\": \"36800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n TC: O(n)\\n SC: O(n)\\n \\\"\\\"\\\"\\n\\n prefix_sums = [nums[0]]\\n for elem in nums[1:]:\\n prefix_sums.append(prefix_sums[-1] + elem)\\n \\n # Dictionary to store the mapping of numbers to their prefix sums\\n d = collections.defaultdict(int) # --> only unique numbers here\\n\\n res = -float('inf')\\n\\n # here must be reverse, since d[num + k] - prefix_sums+num, 我们从左到右prefix sum\\n for num, prefix_sum in reversed(list(zip(nums, prefix_sums))): \\n # [-1,3,2,4,5] k = 3\\n # [-1,2,4,8,13]\\n if num + k in d: # could be negative number\\n res = max(res, d[num + k] - prefix_sum + num)\\n if num - k in d:\\n res = max(res, d[num - k] - prefix_sum + num)\\n \\n d[num] = max(d[num], prefix_sum) if num in d else prefix_sum # twice d[2], keep the best.\\n \\n return res if res != -float('inf') else 0\\n\",\n \"memory\": \"37000\"\n },\n {\n \"code\": \"class Solution:\\n\\n # prefix sum + process from right to left\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sum = []\\n\\n # init prefix sum\\n for i, num in enumerate(nums):\\n if i == 0:\\n prefix_sum.append(num)\\n else:\\n prefix_sum.append(prefix_sum[-1] + num)\\n\\n # mapping for num -> max prefix sum (view from right to left)\\n mapping = collections.defaultdict(int)\\n\\n result = float('-inf')\\n\\n # process from right to left\\n for num, curr_prefix_sum in reversed(list(zip(nums, prefix_sum))):\\n # good subarray is abs value; check both + and -\\n if num + k in mapping:\\n result = max(result, mapping[num + k] - curr_prefix_sum + num)\\n \\n if num - k in mapping:\\n result = max(result, mapping[num - k] - curr_prefix_sum + num)\\n\\n # add current num and prefix sum to the mapping; update to max prefix sum value\\n if num in mapping:\\n mapping[num] = max(curr_prefix_sum, mapping[num])\\n else:\\n mapping[num] = curr_prefix_sum\\n\\n # may not have good subarray; must check\\n if result == float('-inf'):\\n return 0\\n else:\\n return result\\n \\n\",\n \"memory\": \"37100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [nums[0]]\\n for n in nums[1:]:\\n prefix.append(prefix[-1] + n)\\n \\n d = defaultdict(int)\\n res = -math.inf\\n f = -1\\n for n, ps in reversed(list(zip(nums, prefix))):\\n if n+k in d:\\n f = 1\\n res = max(res, d[n+k]-ps+n)\\n if n-k in d:\\n f = 1\\n res = max(res, d[n-k]-ps+n)\\n d[n] = max(d[n], ps) if n in d else ps\\n return res if f == 1 else 0\\n\",\n \"memory\": \"37200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix = [nums[0]]\\n for n in nums[1:]:\\n prefix.append(prefix[-1] + n)\\n \\n d = defaultdict(int)\\n res = -math.inf\\n f = -1\\n for n, ps in reversed(list(zip(nums, prefix))):\\n if n+k in d:\\n f = 1\\n res = max(res, d[n+k]-ps+n)\\n if n-k in d:\\n f = 1\\n res = max(res, d[n-k]-ps+n)\\n \\n d[n] = max(d[n], ps) if n in d else ps\\n return res if f == 1 else 0\\n\",\n \"memory\": \"37300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n \\n \\n indexDict = defaultdict(list)\\n minDict = defaultdict(int)\\n prefixSum = [0]*len(nums)\\n maxValue = -inf\\n \\n for i in range(len(nums)):\\n if i == 0:\\n prefixSum[i] = 0\\n else: \\n prefixSum[i] = prefixSum[i-1] + nums[i-1]\\n \\n for i, num in enumerate(nums):\\n if num - k in indexDict:\\n maxValue = max(maxValue, prefixSum[i] - minDict[num-k] + num)\\n if num + k in indexDict:\\n maxValue = max(maxValue, prefixSum[i] - minDict[num+k] + num)\\n \\n indexDict[num].append(i) \\n # print(\\\"minDict_num :\\\", minDict[num])\\n minDict[num] = min(minDict[num], prefixSum[i]) if num in minDict else prefixSum[i]\\n \\n \\n \\n \\n return maxValue if maxValue != -inf else 0\\n \\n \\n \\n \",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n # Initialize max_sum to a very small value to store the maximum subarray sum found\\n max_sum = -float('inf')\\n # Initialize prefix_sum to track the cumulative sum of elements from the start\\n cum_sum = 0\\n # Dictionary to store the minimum prefix sum for each number adjusted by `k`\\n # This helps to quickly find the smallest prefix sum where the condition is met\\n val_to_min_prefix_sum = defaultdict(lambda: float('inf'))\\n # Iterate over each number in the list nums with its index\\n for i, num in enumerate(nums):\\n # Update the dictionary to store the minimum prefix_sum seen for the current number\\n # This ensures that we are only considering valid subarrays\\n if val_to_min_prefix_sum[num] > cum_sum:\\n val_to_min_prefix_sum[num] = cum_sum\\n # Add the current number to the prefix_sum (cumulative sum)\\n cum_sum += num\\n # Update max_sum by considering the difference between the current prefix_sum\\n # and the smallest prefix sum of the values `num + k` and `num - k`.\\n # This ensures that the subarray respects the absolute difference constraint.\\n max_sum = max(max_sum, cum_sum - val_to_min_prefix_sum[num + k], cum_sum - val_to_min_prefix_sum[num - k])\\n return max_sum if max_sum > -float('inf') else 0\",\n \"memory\": \"37500\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n history = defaultdict(lambda: float('inf'))\\n current_sum = 0\\n best = float('-inf')\\n\\n for n in nums:\\n history[n] = min(history[n], current_sum)\\n current_sum += n\\n best = max(best, current_sum - history[n - k], current_sum - history[n + k])\\n \\n return best if best > float('-inf') else 0\\n\\n\\n \",\n \"memory\": \"37600\"\n },\n {\n \"code\": \"# called good if the absolute difference between its first and last element is exactly k\\n# maximum sum of a good subarray of nums.\\n\\n# Find all good subarrays\\n# create num -> list of all idxes\\n# for num in nums:\\n# for all idxes where k-num appears, use prefix sum \\n# take all sums of all good subarrays\\n# take the max of those sums\\n\\n# nums may NOT be unique\\n# nums can be negative\\n# k is positive\\n\\n\\n# [1,2,3,4,5,6]\\n# 1\\n# 1 2\\n\\n\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n prefix_sums = defaultdict(lambda: float(\\\"inf\\\"))\\n cursum = 0\\n maxsum = float(\\\"-inf\\\")\\n for idx, num in enumerate(nums):\\n if cursum < prefix_sums[num]:\\n prefix_sums[num] = cursum\\n cursum += num\\n maxsum = max(\\n maxsum,\\n cursum - prefix_sums[num+k],\\n cursum - prefix_sums[num-k],\\n )\\n\\n return maxsum if maxsum != float(\\\"-inf\\\") else 0\",\n \"memory\": \"37700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSubarraySum(self, nums: List[int], k: int) -> int:\\n t={}\\n c=0\\n for i in range(len(nums)):\\n c+=nums[i]\\n t[nums[i]]=t.get(nums[i],[])\\n heapq.heappush(t[nums[i]],(-c,i))\\n ans=-float('inf')\\n c=0\\n for i in range(len(nums)):\\n a1=nums[i]-k\\n a2=k+nums[i]\\n if(a1 in t):\\n if(t[a1]):\\n p,q=heapq.heappop(t[a1])\\n while(t[a1] and q<i):\\n p,q=heapq.heappop(t[a1])\\n if(q>i):\\n ans=max(ans,-p-c)\\n heapq.heappush(t[a1],(p,q))\\n if(a2 in t):\\n if(t[a2]):\\n p,q=heapq.heappop(t[a2])\\n while(t[a2] and q<i):\\n p,q=heapq.heappop(t[a2])\\n if(q>i):\\n ans=max(ans,-p-c)\\n heapq.heappush(t[a2],(p,q))\\n c+=nums[i]\\n if(ans==-float('inf')):\\n return 0\\n return ans\\n \\n \\n \\n \\n\\n\",\n \"memory\": \"38300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":62,"string":"62"}}},{"rowIdx":2443,"cells":{"question_id":{"kind":"number","value":3296,"string":"3,296"},"name":{"kind":"string","value":"minimum-time-to-revert-word-to-initial-state-ii"},"content":{"kind":"string","value":"<p>You are given a <strong>0-indexed</strong> string <code>word</code> and an integer <code>k</code>.</p>\n\n<p>At every second, you must perform the following operations:</p>\n\n<ul>\n\t<li>Remove the first <code>k</code> characters of <code>word</code>.</li>\n\t<li>Add any <code>k</code> characters to the end of <code>word</code>.</li>\n</ul>\n\n<p><strong>Note</strong> that you do not necessarily need to add the same characters that you removed. However, you must perform <strong>both</strong> operations at every second.</p>\n\n<p>Return <em>the <strong>minimum</strong> time greater than zero required for</em> <code>word</code> <em>to revert to its <strong>initial</strong> state</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> word = "abacaba", k = 3\n<strong>Output:</strong> 2\n<strong>Explanation:</strong> At the 1st second, we remove characters "aba" from the prefix of word, and add characters "bac" to the end of word. Thus, word becomes equal to "cababac".\nAt the 2nd second, we remove characters "cab" from the prefix of word, and add "aba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state.\nIt can be shown that 2 seconds is the minimum time greater than zero required for word to revert to its initial state.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> word = "abacaba", k = 4\n<strong>Output:</strong> 1\n<strong>Explanation:</strong> At the 1st second, we remove characters "abac" from the prefix of word, and add characters "caba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state.\nIt can be shown that 1 second is the minimum time greater than zero required for word to revert to its initial state.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> word = "abcbabcd", k = 2\n<strong>Output:</strong> 4\n<strong>Explanation:</strong> At every second, we will remove the first 2 characters of word, and add the same characters to the end of word.\nAfter 4 seconds, word becomes equal to "abcbabcd" and reverts to its initial state.\nIt can be shown that 4 seconds is the minimum time greater than zero required for word to revert to its initial state.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= word.length <= 10<sup>6</sup></code></li>\n\t<li><code>1 <= k <= word.length</code></li>\n\t<li><code>word</code> consists only of lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":35.64807390063188,"string":"35.648074"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["string","rolling-hash","string-matching","hash-function"],"string":"[\n \"string\",\n \"rolling-hash\",\n \"string-matching\",\n \"hash-function\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"446\", 2.381], [\"466\", 2.381], [\"488\", 2.381], [\"492\", 2.381], [\"548\", 2.381], [\"560\", 2.381], [\"586\", 2.381], [\"602\", 2.381], [\"608\", 2.381], [\"613\", 2.381], [\"617\", 2.381], [\"627\", 2.381], [\"704\", 2.381], [\"837\", 2.381], [\"861\", 2.381], [\"863\", 2.381], [\"878\", 2.381], [\"894\", 2.381], [\"902\", 2.381], [\"1221\", 2.381], [\"1223\", 2.381], [\"1278\", 2.381], [\"1289\", 2.381], [\"1290\", 2.381], [\"1309\", 2.381], [\"1343\", 2.381], [\"1379\", 2.381], [\"1385\", 2.381], [\"1402\", 2.381], [\"1417\", 2.381], [\"1419\", 2.381], [\"1421\", 2.381], [\"1422\", 2.381], [\"1427\", 2.381], [\"1432\", 2.381], [\"1496\", 2.381], [\"1550\", 2.381], [\"1978\", 2.381], [\"2497\", 2.381]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"25300\", 4.7619], [\"58100\", 4.7619], [\"58200\", 38.0952], [\"58300\", 26.1905], [\"58400\", 7.1429], [\"64700\", 4.7619], [\"88200\", 2.381], [\"97800\", 4.7619]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def get_lps(self, word) -> list[int]:\n n = len(word)\n lps = [0] * n\n left, right = 0, 1 \n while right < n:\n if word[left] == word[right]:\n left += 1\n lps[right] = left\n right += 1\n elif left > 0:\n left = lps[left-1]\n else:\n lps[right] = 0\n right += 1\n return lps\n\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n lps = self.get_lps(word)\n l = lps[-1]\n\n while l > 0 and (n-l) % k > 0:\n # Send the control fom suffix to prefix, since they are same.\n l = lps[l-1]\n\n return ceil((n-l)/k)","runtime":"446"},{"code":"import math\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n=len(word)\n lps=[0]*n\n idx=0\n j=1\n while j<n:\n if word[idx]==word[j]:\n idx+=1\n lps[j]=idx\n j+=1\n elif idx!=0:\n idx=lps[idx-1]\n else:\n lps[j]=0\n j+=1\n suffixlen=lps[n-1]\n while suffixlen>0 and (n-suffixlen)%k!=0:\n suffixlen=lps[suffixlen-1]\n if (n-suffixlen)%k==0:\n return (n-suffixlen)//k\n return math.ceil(n/k)","runtime":"466"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n lps = [0]*n\n preLPS = 0\n i = 1\n while i < n:\n if word[i] == word[preLPS]:\n lps[i] = preLPS + 1\n preLPS+=1\n i+=1\n else:\n if preLPS == 0:\n lps[i] = 0\n i+=1\n else:\n preLPS = lps[preLPS - 1]\n l = lps[-1]\n while l > 0 and (n-l)%k:\n l = lps[l-1]\n return (n - l + k - 1)//k\n","runtime":"488"},{"code":"from math import ceil\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n def computeLPSArray(pat):\n j = 0\n i = 1\n m = len(pat)\n lps = [0]*m\n while i < m:\n if pat[i] == pat[j]:\n lps[i] = j + 1\n i += 1\n j += 1\n else:\n if j!=0:\n j = lps[j-1]\n else:\n #lps[i] = 0\n i += 1 \n return lps \n lps = computeLPSArray(word)\n n = len(word)\n cur = lps[-1]\n while cur and (n-cur)%k:\n cur = lps[cur-1]\n if cur: return (n-cur)//k\n return ceil(n/k)","runtime":"492"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n lps = [0] * len(word)\n i = 1\n length = 0\n\n while i < len(word):\n if word[i] == word[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n\n border = lps[-1]\n while border:\n if (len(word) - border) % k == 0:\n return (len(word) - border) // k\n border = lps[border-1]\n\n\n # print(lps)\n return (len(word) - 1) // k + 1","runtime":"548"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n lps = [0] * len(word)\n i = 1\n length = 0\n\n while i < len(word):\n if word[i] == word[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n\n border = lps[-1]\n while border:\n if (len(word) - border) % k == 0:\n return (len(word) - border) // k\n border = lps[border-1]\n\n\n # print(lps)\n return (len(word) - 1) // k + 1","runtime":"560"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n lps = [0]*len(word)\n length = 0\n i = 1\n while i < len(word):\n if word[i] == word[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length-1]\n else:\n lps[i] = 0\n i += 1\n res = math.ceil(len(word)/k)\n length = lps[-1]\n while length != 0:\n distance = len(word) - length\n print(distance)\n if distance % k == 0:\n res = int(distance/k)\n break\n length = lps[length-1] \n return res","runtime":"586"},{"code":"import math\n\nclass Solution:\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\n # Create the Longest Prefix Suffix (LPS) array\n lps = [0] * len(s)\n\n # Initialize the pointers for the LPS computation\n lps_length, current_index = 0, 1\n \n # Compute the LPS array\n while current_index < len(s):\n if s[current_index] == s[lps_length]:\n lps[current_index] = lps_length + 1\n lps_length += 1\n current_index += 1\n elif lps_length == 0:\n current_index += 1\n else:\n lps_length = lps[lps_length - 1]\n\n # Adjust lps_length to ensure the remainder length is valid (multiple of k)\n while lps_length and (len(s) - lps_length) % k > 0:\n lps_length = lps[lps_length - 1]\n\n # Calculate the length to be removed and return the number of chunks required\n length_to_remove = len(s) - lps_length\n return math.ceil(length_to_remove / k)\n\n\n","runtime":"602"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n lps = [0] * len(word)\n i = 1\n length = 0\n\n while i < len(word):\n if word[i] == word[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n\n border = lps[-1]\n while border:\n if (len(word) - border) % k == 0:\n return (len(word) - border) // k\n border = lps[border-1]\n\n\n # print(lps)\n return (len(word) - 1) // k + 1","runtime":"608"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n def make_table(p):\n N = len(p)\n dp = [0] * N\n for i in range(1, N):\n j = dp[i-1]\n while j and p[i] != p[j]:\n j = dp[j-1]\n dp[i] = j + (p[i] == p[j])\n return dp\n \n dp = make_table(word)\n v = dp[-1]\n while v > 0 and (len(word)-v) % k != 0:\n v = dp[v-1]\n if v == 0:\n return ceil(len(word) / k)\n return (len(word)-v) // k","runtime":"613"},{"code":"class Solution:\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\n LPS = [0] * len(s)\n\n prevLPS, i = 0, 1\n while i < len(s):\n if s[i] == s[prevLPS]:\n LPS[i] = prevLPS + 1\n prevLPS += 1\n i += 1\n elif prevLPS == 0:\n i += 1\n else:\n prevLPS = LPS[prevLPS - 1]\n\n # second conditions check if removed length is valid (multiple of k)\n # if not, find previous matching prefix\n while prevLPS and (len(s) - prevLPS) % k > 0:\n prevLPS = LPS[prevLPS - 1]\n\n lenToBeRemoved = len(s) - prevLPS\n return math.ceil(lenToBeRemoved / k)","runtime":"617"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n pi = [0]*n\n for i in range(1,n):\n j = pi[i-1]\n while j>0 and word[i] != word[j]:\n j = pi[j-1]\n if word[i]==word[j]:\n j +=1\n pi[i] = j\n border = pi[-1]\n while border:\n if (len(word) - border) % k == 0:\n return (len(word) - border) // k\n border = pi[border-1]\n return (len(word) - 1) // k + 1","runtime":"627"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n def lsp(s):\n n = len(s)\n lsp = [0] * n\n for i in range(1, n):\n j = i - 1\n while j > 0 and s[i] != s[lsp[j]]:\n j = lsp[j] - 1\n if s[i] == s[lsp[j]]:\n lsp[i] = lsp[j] + 1\n return lsp\n \n n = len(word)\n \n lsp_list = lsp(word)\n \n l = lsp_list[-1]\n while l > 0 and (n - l) % k:\n l = lsp_list[l - 1]\n \n return ceil((n - l) / k)","runtime":"704"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \n first_indices = {}\n for idx, letter in enumerate(word):\n if letter not in first_indices:\n first_indices[letter] = idx\n minimum_i = max(first_indices.values()) + 1\n minimum_i = minimum_i + (k - minimum_i) % k\n for i in range(minimum_i, len(word)+k, k):\n if word.startswith(word[i:]):\n return i//k","runtime":"837"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n dp = [0]*n\n for i in range(1, n):\n v = dp[i-1]\n while v and word[v]!=word[i]:\n v = dp[v-1]\n dp[i] = v + (word[i]==word[v])\n v += word[i]==word[v]\n # print(dp, v)\n while v and (n-v)%k>0:\n v = dp[v-1]\n # print(v)\n return math.ceil((n-v)/k)\n \n ","runtime":"861"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \n first_indices = {}\n for idx, letter in enumerate(word):\n if letter not in first_indices:\n first_indices[letter] = idx\n minimum_i = max(first_indices.values()) + 1\n minimum_i = minimum_i + (k - minimum_i) % k\n for i in range(minimum_i, len(word)+k, k):\n if word.startswith(word[i:]):\n return i//k","runtime":"863"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n l, r, n = 0, 0, len(word)\n z = [0] * n\n for i in range(k, n, k):\n if i <= r:\n z[i] = min(r - i + 1, z[i - l])\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\n z[i] += 1\n if z[i] == n - i:\n return i // k\n if i + z[i] >= r:\n r = i + z[i] - 1\n l = i\n return ceil(len(word)/k)","runtime":"878"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n l, r, n = 0, 0, len(word)\n z = [0] * n\n for i in range(k, n, k):\n if i <= r:\n z[i] = min(r - i + 1, z[i - l])\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\n z[i] += 1\n if z[i] == n - i:\n return i // k\n if i + z[i] >= r:\n r = i + z[i] - 1\n l = i\n return ceil(len(word)/k) ","runtime":"894"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n kmp = [0] * len(word)\n ans = 0\n for i in range(1,len(word)):\n j = kmp[i-1]\n while j >0 and word[j] != word[i]:\n j = kmp[j-1]\n \n if word[j] == word[i]:\n kmp[i] = j+1\n\n if kmp[i] %k ==0:\n ans = max(ans, kmp[i])\n \n end = kmp[-1]\n while end:\n if (len(word) - end) %k == 0:\n return (len(word) - end) //k\n end = kmp[end-1]\n \n return (len(word) -1)//k + 1\n ","runtime":"902"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n z = [0] * n\n lo = hi = ii = 0 \n for i in range(1, n): \n if i <= hi: ii = i - lo \n if i + z[ii] <= hi: z[i] = z[ii]\n else: \n lo, hi = i, max(hi, i)\n while hi < n and word[hi] == word[hi-lo]: hi += 1\n z[i] = hi - lo \n hi -= 1\n for i, x in enumerate(range(0, len(word), k)):\n if z[x]+x == len(word): return i\n return i+1","runtime":"1221"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n MOD = 10**9 + 7\n n = len(word)\n prefix = [0] * (n + 1)\n powers = [1]\n for i in range(1, n + 1):\n powers.append((powers[i-1] * 131) % MOD)\n \n for i in range(n):\n prefix[i + 1] = prefix[i] + (ord(word[i]) - ord('a')) * powers[i] % MOD\n \n res = 0\n for i in range(k, len(word), k):\n res += 1\n c = n - i\n curr_hash = (prefix[n] - prefix[i]) % MOD\n wrd_hash = (prefix[c] * (powers[i])) % MOD\n if curr_hash == wrd_hash:\n return res\n return ceil(n / k)","runtime":"1223"},{"code":"class Solution:\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\n n = len(s)\n z = [0] * n\n l = r = 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(z[i - l], r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n l, r = i, i + z[i]\n z[i] += 1\n if i % k == 0 and z[i] >= n - i:\n return i // k\n return (n - 1) // k + 1\n\n","runtime":"1278"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n def z_function(S):\n \"\"\"\n Z Algorithm in O(n)\n :param S: text string to process\n :return: the Z array, where Z[i] = length of the longest common prefix of S[i:] and S\n \"\"\"\n n = len(S)\n Z = [0] * n\n l = r = 0\n\n for i in range(1, n):\n z = Z[i - l]\n if i + z >= r:\n z = max(r - i, 0)\n while i + z < n and S[z] == S[i + z]:\n z += 1\n\n l, r = i, i + z\n\n Z[i] = z\n\n Z[0] = n\n return Z\n\n Z = z_function(word)\n ans = ceil(len(word) / k)\n for i in range(1, len(Z)):\n x = Z[i]\n if (i % k) != 0:\n continue\n if x == len(word)-i:\n ans = min(ans, i // k)\n \n return ans\n ","runtime":"1289"},{"code":"class Solution:\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\n n = len(s)\n z = [0] * n\n l = r = 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(z[i - l], r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n l, r = i, i + z[i]\n z[i] += 1\n if i % k == 0 and z[i] >= n - i:\n return i // k\n return (n - 1) // k + 1\n\n","runtime":"1290"},{"code":"class Solution:\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\n n = len(s)\n z = [0] * n\n l = r = 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(z[i - l], r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n l, r = i, i + z[i]\n z[i] += 1\n if i % k == 0 and z[i] >= n - i:\n return i // k\n return (n - 1) // k + 1","runtime":"1309"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n z = [0] * n\n \n l, r = 0, 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(z[i - l], r - i + 1)\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\n z[i] += 1\n if i % k == 0 and z[i] == n - i:\n return i // k\n if i + z[i] - 1 > r:\n l, r = i, i + z[i] - 1\n \n \n return ceil(n / k)","runtime":"1343"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n P, M, n, exp = 31, 10**9+7, len(word), [1]\n for _ in range(n+1): exp.append(exp[-1] * P % M)\n h, ans, i = [0], 1, k\n for ch in word: h.append((h[-1] * P + ord(ch)) % M)\n def _should_stop(i):\n h1 = (h[n] - h[i] * exp[n - i] + M) % M\n h2 = (h[n-i] - h[0] * exp[n - i] + M) % M\n return h1 == h2\n while i <= n and not _should_stop(i):\n ans += 1\n i += k\n return ans","runtime":"1379"},{"code":"def z_function(s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z\n\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n if k >= n:\n return 1\n\n z = z_function(word)\n for op, offset in enumerate(range(k, n, k), start=1):\n if z[offset] == n - offset:\n return op\n return op + 1","runtime":"1385"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n \n def z_algo(s: str) -> List[int]: \n ans = [0] * len(s)\n lo = hi = ii = 0 \n for i in range(1, len(s)): \n if i <= hi: ii = i - lo \n if i + ans[ii] <= hi: ans[i] = ans[ii]\n else: \n lo, hi = i, max(hi, i)\n while hi < len(s) and s[hi] == s[hi-lo]: hi += 1\n ans[i] = hi - lo \n hi -= 1\n return ans \n \n z = z_algo(word)\n for i in range(0, ceil(len(word)/k)):\n if i*k + z[i*k] == len(word): return i\n return i+1","runtime":"1402"},{"code":"class Solution:\n # Same as 3029. Minimum Time to Revert Word to Initial State I\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n maxOps = (n - 1) // k + 1\n z = self._zFunction(word)\n\n for ans in range(1, maxOps):\n if z[ans * k] >= n - ans * k:\n return ans\n\n return maxOps\n\n def _zFunction(self, s: str) -> list[int]:\n \"\"\"\n Returns the z array, where z[i] is the length of the longest prefix of\n s[i..n) which is also a prefix of s.\n\n https://cp-algorithms.com/string/z-function.html#implementation\n \"\"\"\n n = len(s)\n z = [0] * n\n l = 0\n r = 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z","runtime":"1417"},{"code":"class Solution:\n # Same as 3029. Minimum Time to Revert Word to Initial State I\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n maxOps = (n - 1) // k + 1\n z = self._zFunction(word)\n\n for ans in range(1, maxOps):\n if z[ans * k] >= n - ans * k:\n return ans\n\n return maxOps\n\n def _zFunction(self, s: str) -> List[int]:\n \"\"\"\n Returns the z array, where z[i] is the length of the longest prefix of\n s[i..n) which is also a prefix of s.\n\n https://cp-algorithms.com/string/z-function.html#implementation\n \"\"\"\n n = len(s)\n z = [0] * n\n l = 0\n r = 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z","runtime":"1419"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n N = len(word)\n z = z_function(word)\n i = 0\n ans = 0\n while True:\n ans += 1\n i += k\n if i >= N or z[i] == N - i:\n break\n\n return ans\n\n\n\ndef z_function(s):\n N = len(s)\n z = [0]*N\n L = R = 0\n for i in range(1, N):\n if R < i: # not covered by previous z-box\n # z[i] = 0\n pass\n else: # partially or fully covered\n j = i-L\n if j+z[j] < z[L]: # fully covered\n z[i] = z[j]\n else:\n z[i] = R-i+1\n\n while i+z[i] < N and s[i+z[i]] == s[z[i]]: # remaining substring\n z[i] += 1\n if i+z[i]-1 > R: # R out of prev z-box, update R\n L = i\n R = i+z[i]-1\n return z","runtime":"1421"},{"code":"class Solution:\n # Same as 3029. Minimum Time to Revert Word to Initial State I\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n maxOps = (n - 1) // k + 1\n z = self._zFunction(word)\n\n for ans in range(1, maxOps):\n if z[ans * k] >= n - ans * k:\n return ans\n\n return maxOps\n\n def _zFunction(self, s: str) -> List[int]:\n \"\"\"\n Returns the z array, where z[i] is the length of the longest prefix of\n s[i..n) which is also a prefix of s.\n\n https://cp-algorithms.com/string/z-function.html#implementation\n \"\"\"\n n = len(s)\n z = [0] * n\n l = 0\n r = 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z","runtime":"1422"},{"code":"class Solution:\n # Same as 3029. Minimum Time to Revert Word to Initial State I\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n maxOps = (n - 1) // k + 1\n z = self._zFunction(word)\n\n for ans in range(1, maxOps):\n if z[ans * k] >= n - ans * k:\n return ans\n\n return maxOps\n\n def _zFunction(self, s: str) -> List[int]:\n \"\"\"\n Returns the z array, where z[i] is the length of the longest prefix of\n s[i..n) which is also a prefix of s.\n\n https://cp-algorithms.com/string/z-function.html#implementation\n \"\"\"\n n = len(s)\n z = [0] * n\n l = 0\n r = 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z","runtime":"1427"},{"code":"class Hashing:\n __slots__ = [\"mod\", \"h\", \"p\"]\n\n def __init__(self, s: str, base: int, mod: int):\n self.mod = mod\n self.h = [0] * (len(s) + 1)\n self.p = [1] * (len(s) + 1)\n for i in range(1, len(s) + 1):\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\n self.p[i] = (self.p[i - 1] * base) % mod\n\n def query(self, l: int, r: int) -> int:\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\n\n\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n hashing = Hashing(word, 13331, 998244353)\n n = len(word)\n for i in range(k, n, k):\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\n return i // k\n return (n + k - 1) // k\n","runtime":"1432"},{"code":"class Hashing:\n __slots__ = [\"mod\", \"h\", \"p\"]\n\n def __init__(self, s: str, base: int, mod: int):\n self.mod = mod\n self.h = [0] * (len(s) + 1)\n self.p = [1] * (len(s) + 1)\n for i in range(1, len(s) + 1):\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\n self.p[i] = (self.p[i - 1] * base) % mod\n\n def query(self, l: int, r: int) -> int:\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\n\n\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n hashing = Hashing(word, 13331, 998244353)\n n = len(word)\n for i in range(k, n, k):\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\n return i // k\n return (n + k - 1) // k","runtime":"1496"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n \n # Z-algorithm implementation\n def z_function(s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(r - i + 1, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] - 1 > r:\n l, r = i, i + z[i] - 1\n return z\n \n # Calculate Z-array\n z = z_function(word)\n \n # Find the minimum time\n for i in range(k, n, k):\n if z[i] == n - i:\n return i // k\n \n # If no match found, return ceil(n/k)\n return (n + k - 1) // k","runtime":"1550"}],"string":"[\n {\n \"code\": \"class Solution:\\n def get_lps(self, word) -> list[int]:\\n n = len(word)\\n lps = [0] * n\\n left, right = 0, 1 \\n while right < n:\\n if word[left] == word[right]:\\n left += 1\\n lps[right] = left\\n right += 1\\n elif left > 0:\\n left = lps[left-1]\\n else:\\n lps[right] = 0\\n right += 1\\n return lps\\n\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n lps = self.get_lps(word)\\n l = lps[-1]\\n\\n while l > 0 and (n-l) % k > 0:\\n # Send the control fom suffix to prefix, since they are same.\\n l = lps[l-1]\\n\\n return ceil((n-l)/k)\",\n \"runtime\": \"446\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n=len(word)\\n lps=[0]*n\\n idx=0\\n j=1\\n while j<n:\\n if word[idx]==word[j]:\\n idx+=1\\n lps[j]=idx\\n j+=1\\n elif idx!=0:\\n idx=lps[idx-1]\\n else:\\n lps[j]=0\\n j+=1\\n suffixlen=lps[n-1]\\n while suffixlen>0 and (n-suffixlen)%k!=0:\\n suffixlen=lps[suffixlen-1]\\n if (n-suffixlen)%k==0:\\n return (n-suffixlen)//k\\n return math.ceil(n/k)\",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n lps = [0]*n\\n preLPS = 0\\n i = 1\\n while i < n:\\n if word[i] == word[preLPS]:\\n lps[i] = preLPS + 1\\n preLPS+=1\\n i+=1\\n else:\\n if preLPS == 0:\\n lps[i] = 0\\n i+=1\\n else:\\n preLPS = lps[preLPS - 1]\\n l = lps[-1]\\n while l > 0 and (n-l)%k:\\n l = lps[l-1]\\n return (n - l + k - 1)//k\\n\",\n \"runtime\": \"488\"\n },\n {\n \"code\": \"from math import ceil\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n def computeLPSArray(pat):\\n j = 0\\n i = 1\\n m = len(pat)\\n lps = [0]*m\\n while i < m:\\n if pat[i] == pat[j]:\\n lps[i] = j + 1\\n i += 1\\n j += 1\\n else:\\n if j!=0:\\n j = lps[j-1]\\n else:\\n #lps[i] = 0\\n i += 1 \\n return lps \\n lps = computeLPSArray(word)\\n n = len(word)\\n cur = lps[-1]\\n while cur and (n-cur)%k:\\n cur = lps[cur-1]\\n if cur: return (n-cur)//k\\n return ceil(n/k)\",\n \"runtime\": \"492\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n lps = [0] * len(word)\\n i = 1\\n length = 0\\n\\n while i < len(word):\\n if word[i] == word[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n\\n border = lps[-1]\\n while border:\\n if (len(word) - border) % k == 0:\\n return (len(word) - border) // k\\n border = lps[border-1]\\n\\n\\n # print(lps)\\n return (len(word) - 1) // k + 1\",\n \"runtime\": \"548\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n lps = [0] * len(word)\\n i = 1\\n length = 0\\n\\n while i < len(word):\\n if word[i] == word[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n\\n border = lps[-1]\\n while border:\\n if (len(word) - border) % k == 0:\\n return (len(word) - border) // k\\n border = lps[border-1]\\n\\n\\n # print(lps)\\n return (len(word) - 1) // k + 1\",\n \"runtime\": \"560\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n lps = [0]*len(word)\\n length = 0\\n i = 1\\n while i < len(word):\\n if word[i] == word[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length-1]\\n else:\\n lps[i] = 0\\n i += 1\\n res = math.ceil(len(word)/k)\\n length = lps[-1]\\n while length != 0:\\n distance = len(word) - length\\n print(distance)\\n if distance % k == 0:\\n res = int(distance/k)\\n break\\n length = lps[length-1] \\n return res\",\n \"runtime\": \"586\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\\n # Create the Longest Prefix Suffix (LPS) array\\n lps = [0] * len(s)\\n\\n # Initialize the pointers for the LPS computation\\n lps_length, current_index = 0, 1\\n \\n # Compute the LPS array\\n while current_index < len(s):\\n if s[current_index] == s[lps_length]:\\n lps[current_index] = lps_length + 1\\n lps_length += 1\\n current_index += 1\\n elif lps_length == 0:\\n current_index += 1\\n else:\\n lps_length = lps[lps_length - 1]\\n\\n # Adjust lps_length to ensure the remainder length is valid (multiple of k)\\n while lps_length and (len(s) - lps_length) % k > 0:\\n lps_length = lps[lps_length - 1]\\n\\n # Calculate the length to be removed and return the number of chunks required\\n length_to_remove = len(s) - lps_length\\n return math.ceil(length_to_remove / k)\\n\\n\\n\",\n \"runtime\": \"602\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n lps = [0] * len(word)\\n i = 1\\n length = 0\\n\\n while i < len(word):\\n if word[i] == word[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n\\n border = lps[-1]\\n while border:\\n if (len(word) - border) % k == 0:\\n return (len(word) - border) // k\\n border = lps[border-1]\\n\\n\\n # print(lps)\\n return (len(word) - 1) // k + 1\",\n \"runtime\": \"608\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n def make_table(p):\\n N = len(p)\\n dp = [0] * N\\n for i in range(1, N):\\n j = dp[i-1]\\n while j and p[i] != p[j]:\\n j = dp[j-1]\\n dp[i] = j + (p[i] == p[j])\\n return dp\\n \\n dp = make_table(word)\\n v = dp[-1]\\n while v > 0 and (len(word)-v) % k != 0:\\n v = dp[v-1]\\n if v == 0:\\n return ceil(len(word) / k)\\n return (len(word)-v) // k\",\n \"runtime\": \"613\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\\n LPS = [0] * len(s)\\n\\n prevLPS, i = 0, 1\\n while i < len(s):\\n if s[i] == s[prevLPS]:\\n LPS[i] = prevLPS + 1\\n prevLPS += 1\\n i += 1\\n elif prevLPS == 0:\\n i += 1\\n else:\\n prevLPS = LPS[prevLPS - 1]\\n\\n # second conditions check if removed length is valid (multiple of k)\\n # if not, find previous matching prefix\\n while prevLPS and (len(s) - prevLPS) % k > 0:\\n prevLPS = LPS[prevLPS - 1]\\n\\n lenToBeRemoved = len(s) - prevLPS\\n return math.ceil(lenToBeRemoved / k)\",\n \"runtime\": \"617\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n pi = [0]*n\\n for i in range(1,n):\\n j = pi[i-1]\\n while j>0 and word[i] != word[j]:\\n j = pi[j-1]\\n if word[i]==word[j]:\\n j +=1\\n pi[i] = j\\n border = pi[-1]\\n while border:\\n if (len(word) - border) % k == 0:\\n return (len(word) - border) // k\\n border = pi[border-1]\\n return (len(word) - 1) // k + 1\",\n \"runtime\": \"627\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n def lsp(s):\\n n = len(s)\\n lsp = [0] * n\\n for i in range(1, n):\\n j = i - 1\\n while j > 0 and s[i] != s[lsp[j]]:\\n j = lsp[j] - 1\\n if s[i] == s[lsp[j]]:\\n lsp[i] = lsp[j] + 1\\n return lsp\\n \\n n = len(word)\\n \\n lsp_list = lsp(word)\\n \\n l = lsp_list[-1]\\n while l > 0 and (n - l) % k:\\n l = lsp_list[l - 1]\\n \\n return ceil((n - l) / k)\",\n \"runtime\": \"704\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \\n first_indices = {}\\n for idx, letter in enumerate(word):\\n if letter not in first_indices:\\n first_indices[letter] = idx\\n minimum_i = max(first_indices.values()) + 1\\n minimum_i = minimum_i + (k - minimum_i) % k\\n for i in range(minimum_i, len(word)+k, k):\\n if word.startswith(word[i:]):\\n return i//k\",\n \"runtime\": \"837\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n dp = [0]*n\\n for i in range(1, n):\\n v = dp[i-1]\\n while v and word[v]!=word[i]:\\n v = dp[v-1]\\n dp[i] = v + (word[i]==word[v])\\n v += word[i]==word[v]\\n # print(dp, v)\\n while v and (n-v)%k>0:\\n v = dp[v-1]\\n # print(v)\\n return math.ceil((n-v)/k)\\n \\n \",\n \"runtime\": \"861\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \\n first_indices = {}\\n for idx, letter in enumerate(word):\\n if letter not in first_indices:\\n first_indices[letter] = idx\\n minimum_i = max(first_indices.values()) + 1\\n minimum_i = minimum_i + (k - minimum_i) % k\\n for i in range(minimum_i, len(word)+k, k):\\n if word.startswith(word[i:]):\\n return i//k\",\n \"runtime\": \"863\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n l, r, n = 0, 0, len(word)\\n z = [0] * n\\n for i in range(k, n, k):\\n if i <= r:\\n z[i] = min(r - i + 1, z[i - l])\\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\\n z[i] += 1\\n if z[i] == n - i:\\n return i // k\\n if i + z[i] >= r:\\n r = i + z[i] - 1\\n l = i\\n return ceil(len(word)/k)\",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n l, r, n = 0, 0, len(word)\\n z = [0] * n\\n for i in range(k, n, k):\\n if i <= r:\\n z[i] = min(r - i + 1, z[i - l])\\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\\n z[i] += 1\\n if z[i] == n - i:\\n return i // k\\n if i + z[i] >= r:\\n r = i + z[i] - 1\\n l = i\\n return ceil(len(word)/k) \",\n \"runtime\": \"894\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n kmp = [0] * len(word)\\n ans = 0\\n for i in range(1,len(word)):\\n j = kmp[i-1]\\n while j >0 and word[j] != word[i]:\\n j = kmp[j-1]\\n \\n if word[j] == word[i]:\\n kmp[i] = j+1\\n\\n if kmp[i] %k ==0:\\n ans = max(ans, kmp[i])\\n \\n end = kmp[-1]\\n while end:\\n if (len(word) - end) %k == 0:\\n return (len(word) - end) //k\\n end = kmp[end-1]\\n \\n return (len(word) -1)//k + 1\\n \",\n \"runtime\": \"902\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n z = [0] * n\\n lo = hi = ii = 0 \\n for i in range(1, n): \\n if i <= hi: ii = i - lo \\n if i + z[ii] <= hi: z[i] = z[ii]\\n else: \\n lo, hi = i, max(hi, i)\\n while hi < n and word[hi] == word[hi-lo]: hi += 1\\n z[i] = hi - lo \\n hi -= 1\\n for i, x in enumerate(range(0, len(word), k)):\\n if z[x]+x == len(word): return i\\n return i+1\",\n \"runtime\": \"1221\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n MOD = 10**9 + 7\\n n = len(word)\\n prefix = [0] * (n + 1)\\n powers = [1]\\n for i in range(1, n + 1):\\n powers.append((powers[i-1] * 131) % MOD)\\n \\n for i in range(n):\\n prefix[i + 1] = prefix[i] + (ord(word[i]) - ord('a')) * powers[i] % MOD\\n \\n res = 0\\n for i in range(k, len(word), k):\\n res += 1\\n c = n - i\\n curr_hash = (prefix[n] - prefix[i]) % MOD\\n wrd_hash = (prefix[c] * (powers[i])) % MOD\\n if curr_hash == wrd_hash:\\n return res\\n return ceil(n / k)\",\n \"runtime\": \"1223\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\\n n = len(s)\\n z = [0] * n\\n l = r = 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(z[i - l], r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n l, r = i, i + z[i]\\n z[i] += 1\\n if i % k == 0 and z[i] >= n - i:\\n return i // k\\n return (n - 1) // k + 1\\n\\n\",\n \"runtime\": \"1278\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n def z_function(S):\\n \\\"\\\"\\\"\\n Z Algorithm in O(n)\\n :param S: text string to process\\n :return: the Z array, where Z[i] = length of the longest common prefix of S[i:] and S\\n \\\"\\\"\\\"\\n n = len(S)\\n Z = [0] * n\\n l = r = 0\\n\\n for i in range(1, n):\\n z = Z[i - l]\\n if i + z >= r:\\n z = max(r - i, 0)\\n while i + z < n and S[z] == S[i + z]:\\n z += 1\\n\\n l, r = i, i + z\\n\\n Z[i] = z\\n\\n Z[0] = n\\n return Z\\n\\n Z = z_function(word)\\n ans = ceil(len(word) / k)\\n for i in range(1, len(Z)):\\n x = Z[i]\\n if (i % k) != 0:\\n continue\\n if x == len(word)-i:\\n ans = min(ans, i // k)\\n \\n return ans\\n \",\n \"runtime\": \"1289\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\\n n = len(s)\\n z = [0] * n\\n l = r = 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(z[i - l], r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n l, r = i, i + z[i]\\n z[i] += 1\\n if i % k == 0 and z[i] >= n - i:\\n return i // k\\n return (n - 1) // k + 1\\n\\n\",\n \"runtime\": \"1290\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, s: str, k: int) -> int:\\n n = len(s)\\n z = [0] * n\\n l = r = 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(z[i - l], r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n l, r = i, i + z[i]\\n z[i] += 1\\n if i % k == 0 and z[i] >= n - i:\\n return i // k\\n return (n - 1) // k + 1\",\n \"runtime\": \"1309\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n z = [0] * n\\n \\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(z[i - l], r - i + 1)\\n while i + z[i] < n and word[z[i]] == word[i + z[i]]:\\n z[i] += 1\\n if i % k == 0 and z[i] == n - i:\\n return i // k\\n if i + z[i] - 1 > r:\\n l, r = i, i + z[i] - 1\\n \\n \\n return ceil(n / k)\",\n \"runtime\": \"1343\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n P, M, n, exp = 31, 10**9+7, len(word), [1]\\n for _ in range(n+1): exp.append(exp[-1] * P % M)\\n h, ans, i = [0], 1, k\\n for ch in word: h.append((h[-1] * P + ord(ch)) % M)\\n def _should_stop(i):\\n h1 = (h[n] - h[i] * exp[n - i] + M) % M\\n h2 = (h[n-i] - h[0] * exp[n - i] + M) % M\\n return h1 == h2\\n while i <= n and not _should_stop(i):\\n ans += 1\\n i += k\\n return ans\",\n \"runtime\": \"1379\"\n },\n {\n \"code\": \"def z_function(s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n if k >= n:\\n return 1\\n\\n z = z_function(word)\\n for op, offset in enumerate(range(k, n, k), start=1):\\n if z[offset] == n - offset:\\n return op\\n return op + 1\",\n \"runtime\": \"1385\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n \\n def z_algo(s: str) -> List[int]: \\n ans = [0] * len(s)\\n lo = hi = ii = 0 \\n for i in range(1, len(s)): \\n if i <= hi: ii = i - lo \\n if i + ans[ii] <= hi: ans[i] = ans[ii]\\n else: \\n lo, hi = i, max(hi, i)\\n while hi < len(s) and s[hi] == s[hi-lo]: hi += 1\\n ans[i] = hi - lo \\n hi -= 1\\n return ans \\n \\n z = z_algo(word)\\n for i in range(0, ceil(len(word)/k)):\\n if i*k + z[i*k] == len(word): return i\\n return i+1\",\n \"runtime\": \"1402\"\n },\n {\n \"code\": \"class Solution:\\n # Same as 3029. Minimum Time to Revert Word to Initial State I\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n maxOps = (n - 1) // k + 1\\n z = self._zFunction(word)\\n\\n for ans in range(1, maxOps):\\n if z[ans * k] >= n - ans * k:\\n return ans\\n\\n return maxOps\\n\\n def _zFunction(self, s: str) -> list[int]:\\n \\\"\\\"\\\"\\n Returns the z array, where z[i] is the length of the longest prefix of\\n s[i..n) which is also a prefix of s.\\n\\n https://cp-algorithms.com/string/z-function.html#implementation\\n \\\"\\\"\\\"\\n n = len(s)\\n z = [0] * n\\n l = 0\\n r = 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\",\n \"runtime\": \"1417\"\n },\n {\n \"code\": \"class Solution:\\n # Same as 3029. Minimum Time to Revert Word to Initial State I\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n maxOps = (n - 1) // k + 1\\n z = self._zFunction(word)\\n\\n for ans in range(1, maxOps):\\n if z[ans * k] >= n - ans * k:\\n return ans\\n\\n return maxOps\\n\\n def _zFunction(self, s: str) -> List[int]:\\n \\\"\\\"\\\"\\n Returns the z array, where z[i] is the length of the longest prefix of\\n s[i..n) which is also a prefix of s.\\n\\n https://cp-algorithms.com/string/z-function.html#implementation\\n \\\"\\\"\\\"\\n n = len(s)\\n z = [0] * n\\n l = 0\\n r = 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\",\n \"runtime\": \"1419\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n N = len(word)\\n z = z_function(word)\\n i = 0\\n ans = 0\\n while True:\\n ans += 1\\n i += k\\n if i >= N or z[i] == N - i:\\n break\\n\\n return ans\\n\\n\\n\\ndef z_function(s):\\n N = len(s)\\n z = [0]*N\\n L = R = 0\\n for i in range(1, N):\\n if R < i: # not covered by previous z-box\\n # z[i] = 0\\n pass\\n else: # partially or fully covered\\n j = i-L\\n if j+z[j] < z[L]: # fully covered\\n z[i] = z[j]\\n else:\\n z[i] = R-i+1\\n\\n while i+z[i] < N and s[i+z[i]] == s[z[i]]: # remaining substring\\n z[i] += 1\\n if i+z[i]-1 > R: # R out of prev z-box, update R\\n L = i\\n R = i+z[i]-1\\n return z\",\n \"runtime\": \"1421\"\n },\n {\n \"code\": \"class Solution:\\n # Same as 3029. Minimum Time to Revert Word to Initial State I\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n maxOps = (n - 1) // k + 1\\n z = self._zFunction(word)\\n\\n for ans in range(1, maxOps):\\n if z[ans * k] >= n - ans * k:\\n return ans\\n\\n return maxOps\\n\\n def _zFunction(self, s: str) -> List[int]:\\n \\\"\\\"\\\"\\n Returns the z array, where z[i] is the length of the longest prefix of\\n s[i..n) which is also a prefix of s.\\n\\n https://cp-algorithms.com/string/z-function.html#implementation\\n \\\"\\\"\\\"\\n n = len(s)\\n z = [0] * n\\n l = 0\\n r = 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\",\n \"runtime\": \"1422\"\n },\n {\n \"code\": \"class Solution:\\n # Same as 3029. Minimum Time to Revert Word to Initial State I\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n maxOps = (n - 1) // k + 1\\n z = self._zFunction(word)\\n\\n for ans in range(1, maxOps):\\n if z[ans * k] >= n - ans * k:\\n return ans\\n\\n return maxOps\\n\\n def _zFunction(self, s: str) -> List[int]:\\n \\\"\\\"\\\"\\n Returns the z array, where z[i] is the length of the longest prefix of\\n s[i..n) which is also a prefix of s.\\n\\n https://cp-algorithms.com/string/z-function.html#implementation\\n \\\"\\\"\\\"\\n n = len(s)\\n z = [0] * n\\n l = 0\\n r = 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\",\n \"runtime\": \"1427\"\n },\n {\n \"code\": \"class Hashing:\\n __slots__ = [\\\"mod\\\", \\\"h\\\", \\\"p\\\"]\\n\\n def __init__(self, s: str, base: int, mod: int):\\n self.mod = mod\\n self.h = [0] * (len(s) + 1)\\n self.p = [1] * (len(s) + 1)\\n for i in range(1, len(s) + 1):\\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\\n self.p[i] = (self.p[i - 1] * base) % mod\\n\\n def query(self, l: int, r: int) -> int:\\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\\n\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n hashing = Hashing(word, 13331, 998244353)\\n n = len(word)\\n for i in range(k, n, k):\\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\\n return i // k\\n return (n + k - 1) // k\\n\",\n \"runtime\": \"1432\"\n },\n {\n \"code\": \"class Hashing:\\n __slots__ = [\\\"mod\\\", \\\"h\\\", \\\"p\\\"]\\n\\n def __init__(self, s: str, base: int, mod: int):\\n self.mod = mod\\n self.h = [0] * (len(s) + 1)\\n self.p = [1] * (len(s) + 1)\\n for i in range(1, len(s) + 1):\\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\\n self.p[i] = (self.p[i - 1] * base) % mod\\n\\n def query(self, l: int, r: int) -> int:\\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\\n\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n hashing = Hashing(word, 13331, 998244353)\\n n = len(word)\\n for i in range(k, n, k):\\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\\n return i // k\\n return (n + k - 1) // k\",\n \"runtime\": \"1496\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n \\n # Z-algorithm implementation\\n def z_function(s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(r - i + 1, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] - 1 > r:\\n l, r = i, i + z[i] - 1\\n return z\\n \\n # Calculate Z-array\\n z = z_function(word)\\n \\n # Find the minimum time\\n for i in range(k, n, k):\\n if z[i] == n - i:\\n return i // k\\n \\n # If no match found, return ceil(n/k)\\n return (n + k - 1) // k\",\n \"runtime\": \"1550\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":37,"string":"37"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \n first_indices = {}\n for idx, letter in enumerate(word):\n if letter not in first_indices:\n first_indices[letter] = idx\n minimum_i = max(first_indices.values()) + 1\n minimum_i = minimum_i + (k - minimum_i) % k\n for i in range(minimum_i, len(word)+k, k):\n if word.startswith(word[i:]):\n return i//k","memory":"25300"},{"code":"def z_function(s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i < r:\n z[i] = min(r - i, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] > r:\n l = i\n r = i + z[i]\n return z\n\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n if k >= n:\n return 1\n\n z = z_function(word)\n for op, offset in enumerate(range(k, n, k), start=1):\n if z[offset] == n - offset:\n return op\n return op + 1","memory":"58100"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n lps = [0]*n\n preLPS = 0\n i = 1\n while i < n:\n if word[i] == word[preLPS]:\n lps[i] = preLPS + 1\n preLPS+=1\n i+=1\n else:\n if preLPS == 0:\n lps[i] = 0\n i+=1\n else:\n preLPS = lps[preLPS - 1]\n l = lps[-1]\n while l > 0 and (n-l)%k:\n l = lps[l-1]\n return (n - l + k - 1)//k\n","memory":"58200"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n n = len(word)\n \n # Z-algorithm implementation\n def z_function(s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r:\n z[i] = min(r - i + 1, z[i - l])\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\n z[i] += 1\n if i + z[i] - 1 > r:\n l, r = i, i + z[i] - 1\n return z\n \n # Calculate Z-array\n z = z_function(word)\n \n # Find the minimum time\n for i in range(k, n, k):\n if z[i] == n - i:\n return i // k\n \n # If no match found, return ceil(n/k)\n return (n + k - 1) // k","memory":"58300"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n lps = [0]*len(word)\n length = 0\n i = 1\n while i < len(word):\n if word[i] == word[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length-1]\n else:\n lps[i] = 0\n i += 1\n res = math.ceil(len(word)/k)\n length = lps[-1]\n while length != 0:\n distance = len(word) - length\n print(distance)\n if distance % k == 0:\n res = int(distance/k)\n break\n length = lps[length-1] \n return res","memory":"58400"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n if k >= len(word):\n return 1\n primes = [100000000000031, 100000000000067, 100000000000097]\n base = 26\n taillens = []\n time = 1\n while k*time <= len(word):\n taillen = len(word) - k*time\n taillens.append(taillen)\n time += 1\n tailhashes = [0]*len(primes)\n headhashes = [0]*len(primes)\n tailmuls = [1]*len(primes)\n tailpointer = len(word) - 1\n headpointer = 0\n ans = (len(word) // k) + 1\n while taillens:\n taillen = taillens.pop()\n # print(\"taillen\", taillen)\n while headpointer < taillen:\n # print(\"head\", word[headpointer], word[tailpointer])\n headnum = ord(word[headpointer]) - ord(\"a\")\n tailnum = ord(word[tailpointer]) - ord(\"a\")\n \n for i in range(len(primes)):\n headhashes[i] = (headhashes[i] * base + headnum) % primes[i]\n tailhashes[i] = (tailhashes[i] + tailmuls[i]*tailnum) % primes[i]\n tailmuls[i] = (tailmuls[i]*base) % primes[i]\n \n headpointer += 1\n tailpointer -= 1\n if all(headhashes[i] == tailhashes[i] for i in range(len(primes))):\n # print(\"matched\", word[:headpointer], word[tailpointer+1:])\n ans = len(taillens) + 1\n \n return ans\n","memory":"64700"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n # rolling hash with multiple primes\n if k >= len(word):\n return 1\n primes = [100000000000031, 100000000000067, 100000000000097]\n base = 26\n taillens = []\n time = 1\n while k*time <= len(word):\n taillen = len(word) - k*time\n taillens.append(taillen)\n time += 1\n tailhashes = [0]*len(primes)\n headhashes = [0]*len(primes)\n tailmuls = [1]*len(primes)\n tailpointer = len(word) - 1\n headpointer = 0\n ans = (len(word) // k) + 1\n while taillens:\n taillen = taillens.pop()\n # print(\"taillen\", taillen)\n while headpointer < taillen:\n # print(\"head\", word[headpointer], word[tailpointer])\n headnum = ord(word[headpointer]) - ord(\"a\")\n tailnum = ord(word[tailpointer]) - ord(\"a\")\n \n for i in range(len(primes)):\n headhashes[i] = (headhashes[i] * base + headnum) % primes[i]\n tailhashes[i] = (tailhashes[i] + tailmuls[i]*tailnum) % primes[i]\n tailmuls[i] = (tailmuls[i]*base) % primes[i]\n \n headpointer += 1\n tailpointer -= 1\n if all(headhashes[i] == tailhashes[i] for i in range(len(primes))):\n # print(\"matched\", word[:headpointer], word[tailpointer+1:])\n ans = len(taillens) + 1\n \n return ans\n\n\n # the brute force obviously TLE...\n # time = 1\n # while True:\n # if word.startswith(word[time * k : ]):\n # return time\n # time += 1\n","memory":"64700"},{"code":"class Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n MOD = 10**9 + 7\n n = len(word)\n prefix = [0] * (n + 1)\n powers = [1]\n for i in range(1, n + 1):\n powers.append((powers[i-1] * 131) % MOD)\n \n for i in range(n):\n prefix[i + 1] = prefix[i] + (ord(word[i]) - ord('a')) * powers[i] % MOD\n \n res = 0\n for i in range(k, len(word), k):\n res += 1\n c = n - i\n curr_hash = (prefix[n] - prefix[i]) % MOD\n wrd_hash = (prefix[c] * (powers[i])) % MOD\n if curr_hash == wrd_hash:\n return res\n return ceil(n / k)","memory":"88200"},{"code":"class Hashing:\n __slots__ = [\"mod\", \"h\", \"p\"]\n\n def __init__(self, s: str, base: int, mod: int):\n self.mod = mod\n self.h = [0] * (len(s) + 1)\n self.p = [1] * (len(s) + 1)\n for i in range(1, len(s) + 1):\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\n self.p[i] = (self.p[i - 1] * base) % mod\n\n def query(self, l: int, r: int) -> int:\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\n\n\nclass Solution:\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\n hashing = Hashing(word, 13331, 998244353)\n n = len(word)\n for i in range(k, n, k):\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\n return i // k\n return (n + k - 1) // k","memory":"97800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int: \\n first_indices = {}\\n for idx, letter in enumerate(word):\\n if letter not in first_indices:\\n first_indices[letter] = idx\\n minimum_i = max(first_indices.values()) + 1\\n minimum_i = minimum_i + (k - minimum_i) % k\\n for i in range(minimum_i, len(word)+k, k):\\n if word.startswith(word[i:]):\\n return i//k\",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"def z_function(s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i < r:\\n z[i] = min(r - i, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] > r:\\n l = i\\n r = i + z[i]\\n return z\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n if k >= n:\\n return 1\\n\\n z = z_function(word)\\n for op, offset in enumerate(range(k, n, k), start=1):\\n if z[offset] == n - offset:\\n return op\\n return op + 1\",\n \"memory\": \"58100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n lps = [0]*n\\n preLPS = 0\\n i = 1\\n while i < n:\\n if word[i] == word[preLPS]:\\n lps[i] = preLPS + 1\\n preLPS+=1\\n i+=1\\n else:\\n if preLPS == 0:\\n lps[i] = 0\\n i+=1\\n else:\\n preLPS = lps[preLPS - 1]\\n l = lps[-1]\\n while l > 0 and (n-l)%k:\\n l = lps[l-1]\\n return (n - l + k - 1)//k\\n\",\n \"memory\": \"58200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n n = len(word)\\n \\n # Z-algorithm implementation\\n def z_function(s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r:\\n z[i] = min(r - i + 1, z[i - l])\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:\\n z[i] += 1\\n if i + z[i] - 1 > r:\\n l, r = i, i + z[i] - 1\\n return z\\n \\n # Calculate Z-array\\n z = z_function(word)\\n \\n # Find the minimum time\\n for i in range(k, n, k):\\n if z[i] == n - i:\\n return i // k\\n \\n # If no match found, return ceil(n/k)\\n return (n + k - 1) // k\",\n \"memory\": \"58300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n lps = [0]*len(word)\\n length = 0\\n i = 1\\n while i < len(word):\\n if word[i] == word[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length-1]\\n else:\\n lps[i] = 0\\n i += 1\\n res = math.ceil(len(word)/k)\\n length = lps[-1]\\n while length != 0:\\n distance = len(word) - length\\n print(distance)\\n if distance % k == 0:\\n res = int(distance/k)\\n break\\n length = lps[length-1] \\n return res\",\n \"memory\": \"58400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n if k >= len(word):\\n return 1\\n primes = [100000000000031, 100000000000067, 100000000000097]\\n base = 26\\n taillens = []\\n time = 1\\n while k*time <= len(word):\\n taillen = len(word) - k*time\\n taillens.append(taillen)\\n time += 1\\n tailhashes = [0]*len(primes)\\n headhashes = [0]*len(primes)\\n tailmuls = [1]*len(primes)\\n tailpointer = len(word) - 1\\n headpointer = 0\\n ans = (len(word) // k) + 1\\n while taillens:\\n taillen = taillens.pop()\\n # print(\\\"taillen\\\", taillen)\\n while headpointer < taillen:\\n # print(\\\"head\\\", word[headpointer], word[tailpointer])\\n headnum = ord(word[headpointer]) - ord(\\\"a\\\")\\n tailnum = ord(word[tailpointer]) - ord(\\\"a\\\")\\n \\n for i in range(len(primes)):\\n headhashes[i] = (headhashes[i] * base + headnum) % primes[i]\\n tailhashes[i] = (tailhashes[i] + tailmuls[i]*tailnum) % primes[i]\\n tailmuls[i] = (tailmuls[i]*base) % primes[i]\\n \\n headpointer += 1\\n tailpointer -= 1\\n if all(headhashes[i] == tailhashes[i] for i in range(len(primes))):\\n # print(\\\"matched\\\", word[:headpointer], word[tailpointer+1:])\\n ans = len(taillens) + 1\\n \\n return ans\\n\",\n \"memory\": \"64700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n # rolling hash with multiple primes\\n if k >= len(word):\\n return 1\\n primes = [100000000000031, 100000000000067, 100000000000097]\\n base = 26\\n taillens = []\\n time = 1\\n while k*time <= len(word):\\n taillen = len(word) - k*time\\n taillens.append(taillen)\\n time += 1\\n tailhashes = [0]*len(primes)\\n headhashes = [0]*len(primes)\\n tailmuls = [1]*len(primes)\\n tailpointer = len(word) - 1\\n headpointer = 0\\n ans = (len(word) // k) + 1\\n while taillens:\\n taillen = taillens.pop()\\n # print(\\\"taillen\\\", taillen)\\n while headpointer < taillen:\\n # print(\\\"head\\\", word[headpointer], word[tailpointer])\\n headnum = ord(word[headpointer]) - ord(\\\"a\\\")\\n tailnum = ord(word[tailpointer]) - ord(\\\"a\\\")\\n \\n for i in range(len(primes)):\\n headhashes[i] = (headhashes[i] * base + headnum) % primes[i]\\n tailhashes[i] = (tailhashes[i] + tailmuls[i]*tailnum) % primes[i]\\n tailmuls[i] = (tailmuls[i]*base) % primes[i]\\n \\n headpointer += 1\\n tailpointer -= 1\\n if all(headhashes[i] == tailhashes[i] for i in range(len(primes))):\\n # print(\\\"matched\\\", word[:headpointer], word[tailpointer+1:])\\n ans = len(taillens) + 1\\n \\n return ans\\n\\n\\n # the brute force obviously TLE...\\n # time = 1\\n # while True:\\n # if word.startswith(word[time * k : ]):\\n # return time\\n # time += 1\\n\",\n \"memory\": \"64700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n MOD = 10**9 + 7\\n n = len(word)\\n prefix = [0] * (n + 1)\\n powers = [1]\\n for i in range(1, n + 1):\\n powers.append((powers[i-1] * 131) % MOD)\\n \\n for i in range(n):\\n prefix[i + 1] = prefix[i] + (ord(word[i]) - ord('a')) * powers[i] % MOD\\n \\n res = 0\\n for i in range(k, len(word), k):\\n res += 1\\n c = n - i\\n curr_hash = (prefix[n] - prefix[i]) % MOD\\n wrd_hash = (prefix[c] * (powers[i])) % MOD\\n if curr_hash == wrd_hash:\\n return res\\n return ceil(n / k)\",\n \"memory\": \"88200\"\n },\n {\n \"code\": \"class Hashing:\\n __slots__ = [\\\"mod\\\", \\\"h\\\", \\\"p\\\"]\\n\\n def __init__(self, s: str, base: int, mod: int):\\n self.mod = mod\\n self.h = [0] * (len(s) + 1)\\n self.p = [1] * (len(s) + 1)\\n for i in range(1, len(s) + 1):\\n self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod\\n self.p[i] = (self.p[i - 1] * base) % mod\\n\\n def query(self, l: int, r: int) -> int:\\n return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod\\n\\n\\nclass Solution:\\n def minimumTimeToInitialState(self, word: str, k: int) -> int:\\n hashing = Hashing(word, 13331, 998244353)\\n n = len(word)\\n for i in range(k, n, k):\\n if hashing.query(1, n - i) == hashing.query(i + 1, n):\\n return i // k\\n return (n + k - 1) // k\",\n \"memory\": \"97800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":9,"string":"9"}}},{"rowIdx":2444,"cells":{"question_id":{"kind":"number","value":1282,"string":"1,282"},"name":{"kind":"string","value":"number-of-valid-words-for-each-puzzle"},"content":{"kind":"string","value":"With respect to a given <code>puzzle</code> string, a <code>word</code> is <em>valid</em> if both the following conditions are satisfied:\n<ul>\n\t<li><code>word</code> contains the first letter of <code>puzzle</code>.</li>\n\t<li>For each letter in <code>word</code>, that letter is in <code>puzzle</code>.\n\t<ul>\n\t\t<li>For example, if the puzzle is <code>"abcdefg"</code>, then valid words are <code>"faced"</code>, <code>"cabbage"</code>, and <code>"baggage"</code>, while</li>\n\t\t<li>invalid words are <code>"beefed"</code> (does not include <code>'a'</code>) and <code>"based"</code> (includes <code>'s'</code> which is not in the puzzle).</li>\n\t</ul>\n\t</li>\n</ul>\nReturn <em>an array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> is the number of words in the given word list </em><code>words</code><em> that is valid with respect to the puzzle </em><code>puzzles[i]</code>.\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> words = ["aaaa","asas","able","ability","actt","actor","access"], puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]\n<strong>Output:</strong> [1,1,3,2,4,0]\n<strong>Explanation:</strong> \n1 valid word for "aboveyz" : "aaaa" \n1 valid word for "abrodyz" : "aaaa"\n3 valid words for "abslute" : "aaaa", "asas", "able"\n2 valid words for "absoryz" : "aaaa", "asas"\n4 valid words for "actresz" : "aaaa", "asas", "actt", "access"\nThere are no valid words for "gaswxyz" cause none of the words in the list contains letter 'g'.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> words = ["apple","pleas","please"], puzzles = ["aelwxyz","aelpxyz","aelpsxy","saelpxy","xaelpsy"]\n<strong>Output:</strong> [0,1,3,2,0]\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= words.length <= 10<sup>5</sup></code></li>\n\t<li><code>4 <= words[i].length <= 50</code></li>\n\t<li><code>1 <= puzzles.length <= 10<sup>4</sup></code></li>\n\t<li><code>puzzles[i].length == 7</code></li>\n\t<li><code>words[i]</code> and <code>puzzles[i]</code> consist of lowercase English letters.</li>\n\t<li>Each <code>puzzles[i] </code>does not contain repeated characters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":46.847885533531404,"string":"46.847886"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","string","bit-manipulation","trie"],"string":"[\n \"array\",\n \"hash-table\",\n \"string\",\n \"bit-manipulation\",\n \"trie\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"665\", 5.3438], [\"721\", 13.7409], [\"777\", 20.611400000000007], [\"833\", 16.794300000000003], [\"888\", 0.7634], [\"944\", 4.5802], [\"1000\", 4.580299999999999], [\"1056\", 3.8169999999999997], [\"1112\", 0.7634], [\"1167\", 1.5268], [\"1223\", 0.7634], [\"1279\", 0.7634], [\"1335\", 0.7634], [\"1390\", 1.5268], [\"1446\", 0.7634], [\"1502\", 0.7634], [\"1558\", 0.7634], [\"1614\", 3.0536], [\"1669\", 1.5268], [\"1725\", 0.7634], [\"1781\", 0.7634], [\"1837\", 0.7634], [\"1892\", 0.7634], [\"1948\", 0.7634], [\"2004\", 0.7634], [\"2060\", 0.7634], [\"2116\", 0.7634], [\"2171\", 0.7634], [\"2227\", 0.7634], [\"2283\", 0.7634], [\"2339\", 0.7634], [\"2394\", 0.7634], [\"2450\", 0.7634], [\"2506\", 0.7634]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"43800\", 0.7634], [\"44100\", 4.5802], [\"44200\", 14.5038], [\"44300\", 12.9771], [\"44400\", 12.2137], [\"44500\", 2.2901], [\"44600\", 1.5267], [\"44700\", 0.7634], [\"44800\", 0.7634], [\"44900\", 1.5267], [\"45100\", 2.2901], [\"45200\", 2.2901], [\"45300\", 0.7634], [\"45400\", 0.7634], [\"45600\", 1.5267], [\"45700\", 3.0534], [\"45800\", 7.6336], [\"45900\", 1.5267], [\"46000\", 1.5267], [\"46100\", 0.7634], [\"47700\", 0.7634], [\"48200\", 1.5267], [\"54400\", 0.7634], [\"54600\", 0.7634], [\"54900\", 0.7634], [\"55100\", 3.0534], [\"55200\", 6.1069], [\"55300\", 0.7634], [\"55400\", 0.7634], [\"56800\", 0.7634], [\"59800\", 2.2901]]}"},"rt_list":{"kind":"list like","value":[{"code":"from collections import Counter\nfrom itertools import combinations\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n word_count = Counter()\n for word in words:\n mask = 0\n for c in set(word):\n mask |= 1 << (ord(c) - ord('a'))\n word_count[mask] += 1\n \n result = []\n for puzzle in puzzles:\n first = 1 << (ord(puzzle[0]) - ord('a'))\n mask = 0\n for c in puzzle[1:]:\n mask |= 1 << (ord(c) - ord('a'))\n \n subset = mask\n count = word_count[first]\n while subset:\n count += word_count[subset | first]\n subset = (subset - 1) & mask\n \n result.append(count)\n \n return result","runtime":"665"},{"code":"from typing import List, Dict, Optional\n\nclass TrieNode:\n def __init__(self):\n self.children: Dict[str, TrieNode] = {}\n self.end_count: int = 0\n\nclass Solution:\n def add_word_to_trie(self, word: str, root: TrieNode):\n sorted_word = ''.join(sorted(set(word)))\n node = root\n for char in sorted_word:\n if char not in node.children:\n node.children[char] = TrieNode()\n node = node.children[char]\n node.end_count += 1\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n # old solution O(N^2) \n # lp = len(puzzles)\n # lw = len(words)\n # res = [0] * lp\n # word_sets = [set(word) for word in words]\n # for i in range(lp):\n # for j in range(lw):\n # if puzzles[i][0] in word_sets[j]:\n # if word_sets[j] <= set(puzzles[i]):\n # res[i] += 1\n # return res\n root = TrieNode()\n for word in words:\n self.add_word_to_trie(word, root)\n \n def search_in_trie(node: TrieNode, puzzle: str, first: str, has_first: bool) -> int:\n if not node:\n return 0\n count = 0\n if has_first:\n count += node.end_count\n \n for char in node.children:\n if char in puzzle:\n count += search_in_trie(node.children[char], puzzle, first, has_first or (char == first))\n return count\n \n results = []\n for puzzle in puzzles:\n results.append(search_in_trie(root, set(puzzle), puzzle[0], False))\n \n return results","runtime":"665"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n res = []\n\n dd = defaultdict(int)\n\n def bitmask(word):\n mask = 0\n\n for c in word:\n mask |= 1 << (ord(c) - ord(\"a\"))\n\n return mask\n\n for word in words:\n bt = bitmask(word)\n dd[bt] += 1\n\n for puzzle in puzzles:\n first = 1 << (ord(puzzle[0]) - ord(\"a\"))\n\n curr = dd[first]\n mask = bitmask(puzzle[1:])\n submask = mask\n while submask:\n curr += dd[submask | first]\n submask = (submask - 1) & mask\n res.append(curr)\n\n return res\n\n","runtime":"721"},{"code":"class Solution:\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n \n\n # Time: O(n*k + m*(l+n))\n # Space: O(n), where n, m = len(words), len(puzzles) and \n # k, l = mean(len(words[i])), mean(len(puzzles[i]))\n n, m = len(words), len(puzzles)\n\n def bitmask(w):\n num = 0\n for c in w:\n idx = ord(c) - ord('a')\n # Set the letter\n num = num | (1 << idx)\n return num\n\n # For each combination of letters (from words), counts the number of words\n num_words = defaultdict(int)\n for i in range(n):\n num = bitmask(words[i])\n num_words[num] += 1\n \n # For each puzzle permutation of letters, count the occurrencies\n res = [0]*m\n for j in range(m):\n\n # word must contain the first letter of puzzle\n first = puzzles[j][0]\n first_idx = (1 << (ord(first) - ord('a')))\n\n # Initialize with those words that only contains the first letters of puzzle\n count = num_words[first_idx]\n\n num = bitmask(puzzles[j][1:])\n # Iterate over every possible subset of puzzles[j]\n submask = num\n while submask:\n count += num_words[first_idx | submask]\n submask = (submask - 1) & num\n res[j] = count\n return res\n\n\n # TLE\n # Time: O(n*k + m*(l+n))\n # Space: O(n), where n, m = len(words), len(puzzles) and \n # k, l = mean(len(words[i])), mean(len(puzzles[i]))\n n, m = len(words), len(puzzles)\n char_words = {} # char_words['a'] = [[idx_words], [set_letters]]\n letters_words = defaultdict(set)\n words_letters = defaultdict(set)\n for i in range(n):\n for c in words[i]:\n letters_words[c].add(i)\n words_letters[i].add(c)\n\n res = [0]*m\n for j in range(m):\n first = puzzles[j][0]\n if first not in letters_words:\n continue\n letters_puzzle = set([c for c in puzzles[j]])\n for i in letters_words[first]:\n set_ = words_letters[i]\n num = len(set_)\n if len(set_.intersection(letters_puzzle)) == num:\n res[j] += 1\n return res\n","runtime":"721"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n d = {}\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << (ord(c) - ord('a'))\n d[mask] = d.get(mask, 0) + 1\n ans = []\n for puzzle in puzzles:\n total = 0\n mask = 0\n for i in range(1, 7):\n mask |= 1 << (ord(puzzle[i]) - ord('a'))\n subset = mask\n while subset:\n s = subset | (1 << (ord(puzzle[0]) - ord('a')))\n if s in d:\n total += d[s]\n subset = (subset - 1) & mask\n if (1 << (ord(puzzle[0]) - ord('a'))) in d:\n total += d[1 << (ord(puzzle[0]) - ord('a'))]\n ans.append(total)\n return ans","runtime":"777"},{"code":"class Solution:\n def mask(self, word: str) -> int:\n result = 0\n for ch in word:\n result |= 1 << (ord(ch)-ord('a'))\n return result\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n word_count = Counter(self.mask(word) for word in words)\n result = []\n for puzzle in puzzles:\n original_mask, first = self.mask(puzzle[1:]), self.mask(puzzle[0])\n curr_mask, count = original_mask, word_count[first]\n while curr_mask:\n count += word_count[curr_mask|first]\n curr_mask = (curr_mask-1)&original_mask\n result.append(count)\n return result","runtime":"777"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert each word and puzzle into a bitmask\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each bitmask in words\n word_count = Counter(word_bitmasks)\n \n result = []\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n count = 0\n \n # Generate all submasks of puzzle_bitmask\n submask = puzzle_bitmask\n while submask:\n if submask & first_letter_bit:\n count += word_count[submask]\n submask = (submask - 1) & puzzle_bitmask\n \n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","runtime":"833"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert words and puzzles to bitmasks\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each word bitmask\n word_counts = Counter(word_bitmasks)\n \n # Initialize the result list\n result = []\n \n # Process each puzzle\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n count = 0\n \n # Generate all submasks of the puzzle bitmask\n submask = puzzle_bitmask\n while submask:\n # Check if the submask contains the first letter of the puzzle\n if submask & first_letter_bit:\n count += word_counts[submask]\n \n # Move to the next submask\n submask = (submask - 1) & puzzle_bitmask\n \n # Append the count to the result list\n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","runtime":"833"},{"code":"\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n counts = collections.defaultdict(int)\n ans = [0] * len(puzzles)\n for word in words:\n bit = 0 # bit 是 word 的二进制表示\n for c in word:\n bit |= 1 << ord(c) - ord(\"a\")\n counts[bit] += 1\n for i, puzzle in enumerate(puzzles):\n bit = 0 # bit 是 puzzle 的二进制表示\n for c in puzzle:\n bit |= 1 << ord(c) - ord(\"a\")\n j = bit # j 是 bit 的子集\n # 倒序枚举 bit 的子集 j\n while j:\n # 单词 word 需要包含谜面的第一个字母\n if 1 << ord(puzzle[0]) - ord(\"a\") & j:\n ans[i] += counts[j]\n j = bit & (j - 1)\n return ans\n","runtime":"888"},{"code":"class Solution:\n def get_valid_submasks(self, puzzle):\n contains = [False] * 26\n for l in puzzle: contains[ord(l) - 97] = True\n contains = [i for i, c in enumerate(contains) if c]\n cannot_skip = ord(puzzle[0]) - 97\n res = []\n for c in itertools.product(\n *[\n [0, 1 << i] if i != cannot_skip else [1 << i] for i in contains\n ]\n ):\n res.append(sum(c))\n return res\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n counter = defaultdict(int)\n for word in words:\n word = set(word)\n if len(word) > 7:\n continue\n counter[sum(1 << i for i in range(26) if chr(i + 97) in word)] += 1\n \n res = [0] * len(puzzles)\n for i, p in enumerate(puzzles):\n res[i] += sum(counter[mask] for mask in self.get_valid_submasks(p))\n return res\n\n \n ","runtime":"944"},{"code":"class Solution:\n def findNumOfValidWords(self, words, puzzles):\n wh, res = defaultdict(int), []\n for w in words:\n h = ''.join(sorted(set(w)))\n if len(h) > 7: continue\n wh[h] += 1\n for w in puzzles:\n n, c, sw, rc = len(w)-1, w[0], w[1:], 0\n for i in range(n+1):\n for x in combinations(sw, i):\n w1 = ''.join(sorted(''.join(x)+c))\n if w1 in wh: rc += wh[w1]\n res.append(rc)\n return res","runtime":"944"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(list(set(val)))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node:\n return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","runtime":"1000"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(list(set(val)))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node: return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n # uniq = []\n # for word in words:\n # uniq.append(sorted(list(set(word))))\n # words = uniq\n\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","runtime":"1000"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n words = [sorted(set(w)) for w in words]\n puzzles = [(p[0], set(p)) for p in puzzles]\n trees = [Trie() for _ in range(26)]\n for w in words:\n for char in w:\n trees[ord(char) - 97].insert(w)\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\n\nclass Node(object):\n def __init__(self, val):\n self.val = val\n self.children = {}\n self.tail = 0\n \nclass Trie(object):\n def __init__(self):\n self.root = Node(None)\n \n def insert(self, word):\n curr = self.root\n for char in word:\n if char not in curr.children:\n curr.children[char] = Node(char)\n curr = curr.children[char]\n curr.tail += 1\n \n def puzzle_match(self, puzzle):\n def helper(node):\n nonlocal res\n res += node.tail\n for child in node.children:\n if child in puzzle:\n helper(node.children[child])\n res = 0\n helper(self.root)\n return res","runtime":"1056"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n words = [sorted(set(w)) for w in words]\n puzzles = [(p[0], set(p)) for p in puzzles]\n trees = [Trie() for _ in range(26)]\n for w in words:\n for char in w:\n trees[ord(char) - 97].insert(w)\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\n\nclass Node(object):\n def __init__(self, val):\n self.val = val\n self.children = {}\n self.tail = 0\n \nclass Trie(object):\n def __init__(self):\n self.root = Node(None)\n \n def insert(self, word):\n curr = self.root\n for char in word:\n if char not in curr.children:\n curr.children[char] = Node(char)\n curr = curr.children[char]\n curr.tail += 1\n \n def puzzle_match(self, puzzle):\n def helper(node):\n nonlocal res\n res += node.tail\n for child in node.children:\n if child in puzzle:\n helper(node.children[child])\n res = 0\n helper(self.root)\n return res","runtime":"1056"},{"code":"from typing import List\nfrom collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n word_counter = Counter(frozenset(word) for word in words)\n result = []\n \n for puzzle in puzzles:\n first_letter = puzzle[0]\n puzzle_set = set(puzzle)\n count = 0\n \n for subset in self.generate_subsets(puzzle_set):\n if first_letter in subset:\n count += word_counter[frozenset(subset)]\n \n result.append(count)\n \n return result\n \n def generate_subsets(self, s):\n if not s:\n yield set()\n else:\n elem = s.pop()\n for subset in self.generate_subsets(s):\n yield subset\n yield subset | {elem}\n s.add(elem)","runtime":"1112"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n answer = []\n counts = Counter()\n\n for word in words:\n abbrev = ''.join(sorted(list(set(word))))\n counts[abbrev] += 1\n \n for puzzle in puzzles:\n count = 0\n for size in range(7):\n for indices in itertools.combinations(range(1, 7), size):\n match = [puzzle[0]]\n for i in indices:\n match.append(puzzle[i])\n match = ''.join(sorted(match))\n count += counts[match]\n answer.append(count)\n \n return answer\n ","runtime":"1167"},{"code":"class Solution:\n def gen_combinations(self, word):\n if not word:\n yield 0\n else:\n c = word.pop()\n for v in self.gen_combinations(word):\n yield v\n yield v | (1 << (ord(c) - ord('a')))\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n table = defaultdict(Counter)\n for w in words:\n chars = set(list(w)) \n if len(chars) > 7:\n continue\n h = reduce(operator.or_, [1 << (ord(c) - ord('a')) for c in chars], 0)\n for c in chars:\n table[c][h] += 1\n for i, p in enumerate(puzzles):\n puzzles[i] = sum(table[p[0]][h] for h in self.gen_combinations(list(p)))\n return puzzles","runtime":"1167"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n\n words = [\"\".join(sorted(set(w))) for w in words]\n ct = Counter(words)\n words = [set(w) for w in list(set(words))]\n\n dt = defaultdict(lambda: [])\n for ws in words:\n for c in list(ws):\n dt[c].append(ws)\n\n res = []\n for p in puzzles:\n t = 0\n ps = set(p)\n for ws in dt[p[0]]:\n if ws.issubset(ps):\n t += ct[\"\".join(sorted(list(ws)))] \n res.append(t)\n \n return res","runtime":"1223"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n '''\n word:\n all letters of word are in puzzle\n first letter of puzzle is in word\n\n We need to (mainly) store two things for each puzzle\n\n first letter of word is in puzzle \n\n so we can index puzzles by first letter\n\n each word is <= 50\n\n each puzzle is <= 7 (very short)\n\n multiple of the same character in word can map to one character in puzzle\n\n\n bitmask?\n\n '''\n\n freq = defaultdict(int)\n\n for w in words:\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n \n freq[x] += 1\n\n lookup = defaultdict(list)\n\n for index, w in enumerate(puzzles):\n first_letter = 1 << (ord(w[0]) - ord('a'))\n\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n\n lookup[first_letter].append([index, x, 0])\n\n \n arr = list(freq.items())\n\n for x, amount in arr:\n for i in range(26):\n if (1 << i) & x:\n for y in lookup[1 << i]:\n if (x & y[1]) == x:\n y[2] += amount\n\n \n ans = [None] * len(puzzles)\n for key in lookup.keys():\n for index, _, count in lookup[key]:\n ans[index] = count\n\n return ans\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n ","runtime":"1279"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n '''\n word:\n all letters of word are in puzzle\n first letter of puzzle is in word\n\n We need to (mainly) store two things for each puzzle\n\n first letter of word is in puzzle \n\n so we can index puzzles by first letter\n\n each word is <= 50\n\n each puzzle is <= 7 (very short)\n\n multiple of the same character in word can map to one character in puzzle\n\n\n bitmask?\n\n '''\n\n freq = defaultdict(int)\n\n for w in words:\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n \n freq[x] += 1\n\n lookup = defaultdict(list)\n\n for index, w in enumerate(puzzles):\n first_letter = 1 << (ord(w[0]) - ord('a'))\n\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n\n lookup[first_letter].append([index, x, 0])\n\n \n arr = list(freq.items())\n\n for x, amount in arr:\n for i in range(26):\n if (1 << i) & x:\n for y in lookup[1 << i]:\n if (x & y[1]) == x:\n y[2] += amount\n\n \n ans = [None] * len(puzzles)\n for key in lookup.keys():\n for index, _, count in lookup[key]:\n ans[index] = count\n\n return ans","runtime":"1335"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n '''\n word:\n all letters of word are in puzzle\n first letter of puzzle is in word\n\n We need to (mainly) store two things for each puzzle\n\n first letter of word is in puzzle \n\n so we can index puzzles by first letter\n\n each word is <= 50\n\n each puzzle is <= 7 (very short)\n\n multiple of the same character in word can map to one character in puzzle\n\n\n bitmask?\n\n '''\n\n freq = defaultdict(int)\n\n for w in words:\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n \n freq[x] += 1\n\n lookup = defaultdict(list)\n\n for index, w in enumerate(puzzles):\n first_letter = 1 << (ord(w[0]) - ord('a'))\n\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n\n lookup[first_letter].append([index, x, 0])\n\n \n arr = list(freq.items())\n\n for x, amount in arr:\n for i in range(26):\n if (1 << i) & x:\n for y in lookup[1 << i]:\n if (x & y[1]) == x:\n y[2] += amount\n\n \n ans = [None] * len(puzzles)\n for key in lookup.keys():\n for index, _, count in lookup[key]:\n ans[index] = count\n\n return ans\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n ","runtime":"1390"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n def word_to_bin(w):\n b = 0\n w = set(w)\n for i in range(26):\n if chr(ord('a')+i) in w:\n b+=1<<i\n return b\n words = [word_to_bin(w) for w in words]\n data = [Counter([w for w in words if (w&(1<<i))]) for i in range(26)]\n ans = []\n for puzzle in puzzles:\n d = data[ord(puzzle[0])-ord('a')]\n p = word_to_bin(puzzle)\n total = 0\n for w in d:\n if (~p)&w==0:\n total+=d[w]\n ans.append(total)\n return ans","runtime":"1390"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Preprocess words\n word_bitmasks = Counter()\n for word in words:\n mask = 0\n for char in word:\n mask |= 1 << (ord(char) - ord('a'))\n word_bitmasks[mask] += 1\n \n # Function to generate all subsets of a set\n def subsets(arr):\n for i in range(1 << len(arr)):\n yield [arr[j] for j in range(len(arr)) if i & (1 << j)]\n \n # Count valid words for each puzzle\n result = []\n for puzzle in puzzles:\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n other_letters = [1 << (ord(char) - ord('a')) for char in puzzle[1:]]\n count = 0\n \n # Iterate over all subsets of other_letters\n for subset in subsets(other_letters):\n mask = first_letter_bit | sum(subset)\n count += word_bitmasks[mask]\n \n result.append(count)\n \n return result\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","runtime":"1446"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << ord(puzzle[0]) - ord('a')\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n\n return ans\n ","runtime":"1502"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << ord(puzzle[0]) - ord('a')\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n\n return ans\n","runtime":"1558"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << ord(puzzle[0]) - ord('a')\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n return ans ","runtime":"1614"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << ord(puzzle[0]) - ord('a')\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n\n return ans","runtime":"1614"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << ord(puzzle[0]) - ord('a')\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n return ans","runtime":"1669"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n l=[]\n for i in range(len(words)):\n s=0\n for j in words[i]:\n s=s|(1<<(ord(j))-97)\n l+=[s]\n l.sort()\n ans=[]\n for i in range(len(puzzles)):\n s=0\n l1=[]\n for j in puzzles[i]:\n s=s|(1<<(ord(j))-97)\n l1+=[ord(j)-97]\n b1=bisect.bisect_right(l,2**l1[0]-1)\n b2=bisect.bisect_left(l,2**l1[0]+1)\n c=b2-b1\n a=l1.pop(0)\n for k in range(1,2**(len(l1))):\n s1=2**a\n count=0\n while k!=0:\n if k&1!=0:\n s1+=2**l1[count]\n k=k>>1\n count+=1\n b1=bisect.bisect_right(l,s1-1)\n b2=bisect.bisect_left(l,s1+1)\n c+=b2-b1\n ans+=[c]\n return ans","runtime":"1669"},{"code":"class Solution:\n def findNumOfValidWords(\n self,\n words: list[str],\n puzzles: list[str],\n ) -> list[int]:\n ans = []\n binaryCount = collections.Counter()\n\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << string.ascii_lowercase.index(c)\n binaryCount[mask] += 1\n\n for puzzle in puzzles:\n valid = 0\n n = len(puzzle) - 1\n for i in range(1 << n):\n mask = 1 << string.ascii_lowercase.index(puzzle[0])\n for j in range(n):\n if i >> j & 1:\n mask |= 1 << string.ascii_lowercase.index(puzzle[j + 1])\n if mask in binaryCount:\n valid += binaryCount[mask]\n ans.append(valid)\n\n return ans\n","runtime":"1725"},{"code":"class TrieNode:\n def __init__(self):\n self.childs = {}\n self.leaf = 0\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def add(self, word):\n p = self.root\n for ch in word:\n if ch not in p.childs:\n p.childs[ch] = TrieNode()\n p = p.childs[ch]\n p.leaf += 1\n\n def search(self, target):\n p = self.root\n for ch in target:\n if ch not in p.childs:\n return 0\n p = p.childs[ch]\n return p.leaf\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n sorted_words = [sorted(list(set(x))) for x in words]\n first = [x[0] for x in puzzles]\n sorted_puzzles = [sorted(x) for x in puzzles]\n tree = Trie()\n for word in sorted_words:\n tree.add(word)\n res = []\n for i, puzzle in enumerate(sorted_puzzles):\n N = len(puzzle)\n cnt = 0\n for j in range(1, 1 << N):\n target = []\n use = False\n for k in range(N):\n if j & (1 << k):\n if puzzle[k] == first[i]:\n use = True\n target.append(puzzle[k])\n\n if use:\n cnt += tree.search(target)\n\n res.append(cnt)\n return res\n","runtime":"1781"},{"code":"class TrieNode:\n def __init__(self):\n self.childs = {}\n self.leaf = 0\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def add(self, word):\n p = self.root\n for ch in word:\n if ch not in p.childs:\n p.childs[ch] = TrieNode()\n p = p.childs[ch]\n p.leaf += 1\n\n def search(self, target):\n p = self.root\n for ch in target:\n if ch not in p.childs:\n return 0\n p = p.childs[ch]\n return p.leaf\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n sorted_words = [sorted(list(set(x))) for x in words]\n sorted_puzzles = [sorted(x) for x in puzzles]\n tree = Trie()\n for word in sorted_words:\n tree.add(word)\n res = []\n for i, puzzle in enumerate(sorted_puzzles):\n N = len(puzzle)\n cnt = 0\n for j in range(1, 1 << N):\n target = []\n use = False\n for k in range(N):\n if j & (1 << k):\n if puzzle[k] == puzzles[i][0]:\n use = True\n target.append(puzzle[k])\n\n if use:\n cnt += tree.search(target)\n\n res.append(cnt)\n return res\n","runtime":"1837"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n\n res = []\n dicto = {}\n\n for puzzle in puzzles:\n\n cur = [0]\n newcur = []\n for letter in puzzle:\n for el in cur:\n newcur.append(el)\n newcur.append(el+2**(ord(letter) - ord('a')))\n cur, newcur = newcur, []\n #print(puzzle, len(cur))\n for submask in cur:\n if submask > 0:\n if submask not in dicto:\n dicto[submask] = {}\n if 2**(ord(puzzle[0])-ord('a')) not in dicto[submask]:\n dicto[submask][2**(ord(puzzle[0])-ord('a')) ] = 0\n res.append(cur)\n\n #print(res[0])\n\n puzzles = [[sum(2**(ord(el)-ord('a')) for el in puzzle ), 2**(ord(puzzle[0]) - ord('a'))] for puzzle in puzzles]\n words = [sum(2**(ord(el)-ord('a')) for el in set(word)) for word in words]\n\n \n #print(puzzles)\n #print(words)\n \n \n for word in words:\n if word in dicto:\n for el in dicto[word]:\n if word & el > 0:\n \n dicto[word][el] += 1\n #print(word, el, dicto[word][el])\n \n output = []\n\n for i in range(len(puzzles)):\n submasks = res[i]\n total = 0\n for submask in submasks:\n if submask > 0:\n total += dicto[submask][puzzles[i][1]]\n output.append(total)\n\n return output\n ","runtime":"1892"},{"code":"class TrieNode:\n def __init__(self):\n self.childs = {}\n self.leaf = 0\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def add(self, word):\n p = self.root\n for ch in word:\n if ch not in p.childs:\n p.childs[ch] = TrieNode()\n p = p.childs[ch]\n p.leaf += 1\n\n def search(self, target):\n p = self.root\n for ch in target:\n if ch not in p.childs:\n return 0\n p = p.childs[ch]\n return p.leaf\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n sorted_words = [sorted(list(set(x))) for x in words]\n sorted_puzzles = [sorted(x) for x in puzzles]\n tree = Trie()\n for word in sorted_words:\n tree.add(word)\n res = []\n for i, puzzle in enumerate(sorted_puzzles):\n N = len(puzzle)\n cnt = 0\n for j in range(1, 1 << N):\n target = []\n use = False\n for k in range(N):\n if j & (1 << k):\n if puzzle[k] == puzzles[i][0]:\n use = True\n target.append(puzzle[k])\n\n if use:\n cnt += tree.search(target)\n\n res.append(cnt)\n return res","runtime":"1948"},{"code":"import numpy as np\n\ndef bitmask(w):\n res = 0\n for c in set(w):\n res += (1<<(ord(c)-ord('a')))\n return res\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n N = len(puzzles)\n pz = np.array([bitmask(p) for p in puzzles], dtype=np.int32)\n p1 = np.array([bitmask(p[:1]) for p in puzzles], dtype=np.int32)\n ans = np.zeros(N, dtype=np.int32)\n for w in words:\n m = bitmask(w)\n l1 = (p1&m).astype(bool)\n l2 = (pz&m)==m\n ans += (l1&l2)\n return [int(x) for x in ans]","runtime":"2004"},{"code":"class Solution:\n def getBitMask(self,word):\n mask = 0\n for char in word:\n shift = ord(char)-ord(\"a\")\n mask |= 1<<shift\n return mask\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n freq = {}\n for word in words:\n mask = self.getBitMask(word)\n freq[mask] = freq.get(mask,0)+1\n ans = [0 for _ in range(len(puzzles))]\n index = 0\n for puzzle in puzzles:\n i = ord(puzzle[0]) - ord(\"a\")\n submask = 1<<i\n puzzle_mask = self.getBitMask(puzzle)\n for mask in freq:\n if ((submask & mask) == submask) and ((puzzle_mask & mask) == mask):\n ans[index] += freq[mask]\n index+=1\n return ans\n \n\n ","runtime":"2060"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n m = len(words)\n n = len(puzzles)\n wordBitmasks = [0]*m\n a = ord('a')\n for i, word in enumerate(words):\n for letter in word:\n wordBitmasks[i] |= (1 << (ord(letter) - a))\n #wordBitmasks.sort()\n counts = defaultdict(lambda : 0)\n for wordBitmask in wordBitmasks:\n counts[wordBitmask] += 1\n #print(counts)\n answer = [0]*n\n for i, puzzle in enumerate(puzzles):\n puzzleBitmask = 0\n for letter in puzzle:\n puzzleBitmask |= (1 << (ord(letter) - a))\n firstLetter = (1 << (ord(puzzle[0]) - a))\n for wordBitmask in counts:\n if firstLetter | wordBitmask != wordBitmask:\n continue\n if wordBitmask | puzzleBitmask != puzzleBitmask:\n continue\n answer[i] += counts[wordBitmask]\n return answer\n \n ","runtime":"2116"},{"code":"class Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n a = ord('a')\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - a)\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - a)\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n word_sets = defaultdict(int)\n for word in words:\n word_set = 0\n for ch in word:\n bit = 1 << (ord(ch) - a)\n word_set |= bit\n if (bin(word_set).count('1')) <= 7:\n word_sets[word_set] += 1\n \n for puzzle in puzzles:\n result.append(self.checkWords(word_sets, puzzle))\n \n return result\n","runtime":"2171"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n words = [set(w) for w in words]\n new_words = {}\n for word in words:\n w = set(word)\n wk = \"\".join(sorted(w))\n new_words.setdefault(wk, [w, 0])\n new_words[wk][1] += 1\n\n new_puzzles = []\n for puzzle in puzzles:\n p = set(puzzle)\n normp = \"\".join(sorted(p))\n pk = f\"{puzzle[0]}-{normp}\"\n new_puzzles.append((pk, puzzle[0], p))\n\n puzzles = [(p[0], set(p)) for p in puzzles]\n\n out = []\n cache = {}\n for pk, l, p in new_puzzles:\n if pk not in cache:\n count = 0\n for w, v in new_words.values():\n if l in w and not w - p:\n count += v\n cache[pk] = count\n out.append(cache[pk])\n \n return out\n ","runtime":"2227"},{"code":"from collections import Counter\n\nclass Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n a = ord('a')\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - a)\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - a)\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n word_sets = []\n for word in words:\n word_set = 0\n for ch in word:\n bit = 1 << (ord(ch) - a)\n word_set |= bit\n if (bin(word_set).count('1')) <= 7:\n word_sets.append(word_set)\n cnt = Counter(word_sets)\n \n for puzzle in puzzles:\n result.append(self.checkWords(cnt, puzzle))\n \n return result\n","runtime":"2283"},{"code":"from collections import Counter\nfrom functools import reduce\nimport operator\n\nclass Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - ord('a'))\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - ord('a'))\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n # word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\n word_sets = []\n for word in words:\n word_set = 0\n for ch in word:\n bit = 1 << (ord(ch) - a)\n word_set |= bit\n # if (bin(word_set).count('1')) <= 7:\n # word_sets.append(word_set)\n word_sets.append(word_set)\n cnt = Counter(word_sets)\n \n for puzzle in puzzles:\n result.append(self.checkWords(cnt, puzzle))\n \n return result\n","runtime":"2339"},{"code":"from collections import Counter\nfrom functools import reduce\nimport operator\n\nclass Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n a = ord('a')\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - a)\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - a)\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n # word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\n word_sets = []\n for word in words:\n word_set = 0\n for ch in word:\n bit = 1 << (ord(ch) - a)\n word_set |= bit\n # if (bin(word_set).count('1')) <= 7:\n # word_sets.append(word_set)\n word_sets.append(word_set)\n cnt = Counter(word_sets)\n \n for puzzle in puzzles:\n result.append(self.checkWords(cnt, puzzle))\n \n return result\n","runtime":"2394"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n words = [set(w) for w in words]\n new_words = {}\n for word in words:\n w = set(word)\n wk = \"\".join(sorted(w))\n new_words.setdefault(wk, [w, 0])\n new_words[wk][1] += 1\n\n new_puzzles = []\n for puzzle in puzzles:\n p = set(puzzle)\n normp = \"\".join(sorted(p))\n pk = f\"{puzzle[0]}-{normp}\"\n new_puzzles.append((pk, puzzle[0], p))\n\n puzzles = [(p[0], set(p)) for p in puzzles]\n\n out = []\n cache = {}\n for pk, l, p in new_puzzles:\n if pk not in cache:\n count = 0\n for w, v in new_words.values():\n if l in w and not w - p:\n count += v\n cache[pk] = count\n out.append(cache[pk])\n \n return out\n ","runtime":"2450"},{"code":"from collections import Counter\nfrom functools import reduce\nimport operator\n\nclass Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n a = ord('a')\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - a)\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - a)\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\n # for word in words:\n # word_set = 0\n # for ch in word:\n # bit = 1 << (ord(ch) - a)\n # word_set |= bit\n # # if (bin(word_set).count('1')) <= 7:\n # # word_sets.append(word_set)\n # word_sets.append(word_set)\n cnt = Counter(word_sets)\n \n for puzzle in puzzles:\n result.append(self.checkWords(cnt, puzzle))\n \n return result\n","runtime":"2506"}],"string":"[\n {\n \"code\": \"from collections import Counter\\nfrom itertools import combinations\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n word_count = Counter()\\n for word in words:\\n mask = 0\\n for c in set(word):\\n mask |= 1 << (ord(c) - ord('a'))\\n word_count[mask] += 1\\n \\n result = []\\n for puzzle in puzzles:\\n first = 1 << (ord(puzzle[0]) - ord('a'))\\n mask = 0\\n for c in puzzle[1:]:\\n mask |= 1 << (ord(c) - ord('a'))\\n \\n subset = mask\\n count = word_count[first]\\n while subset:\\n count += word_count[subset | first]\\n subset = (subset - 1) & mask\\n \\n result.append(count)\\n \\n return result\",\n \"runtime\": \"665\"\n },\n {\n \"code\": \"from typing import List, Dict, Optional\\n\\nclass TrieNode:\\n def __init__(self):\\n self.children: Dict[str, TrieNode] = {}\\n self.end_count: int = 0\\n\\nclass Solution:\\n def add_word_to_trie(self, word: str, root: TrieNode):\\n sorted_word = ''.join(sorted(set(word)))\\n node = root\\n for char in sorted_word:\\n if char not in node.children:\\n node.children[char] = TrieNode()\\n node = node.children[char]\\n node.end_count += 1\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n # old solution O(N^2) \\n # lp = len(puzzles)\\n # lw = len(words)\\n # res = [0] * lp\\n # word_sets = [set(word) for word in words]\\n # for i in range(lp):\\n # for j in range(lw):\\n # if puzzles[i][0] in word_sets[j]:\\n # if word_sets[j] <= set(puzzles[i]):\\n # res[i] += 1\\n # return res\\n root = TrieNode()\\n for word in words:\\n self.add_word_to_trie(word, root)\\n \\n def search_in_trie(node: TrieNode, puzzle: str, first: str, has_first: bool) -> int:\\n if not node:\\n return 0\\n count = 0\\n if has_first:\\n count += node.end_count\\n \\n for char in node.children:\\n if char in puzzle:\\n count += search_in_trie(node.children[char], puzzle, first, has_first or (char == first))\\n return count\\n \\n results = []\\n for puzzle in puzzles:\\n results.append(search_in_trie(root, set(puzzle), puzzle[0], False))\\n \\n return results\",\n \"runtime\": \"665\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n res = []\\n\\n dd = defaultdict(int)\\n\\n def bitmask(word):\\n mask = 0\\n\\n for c in word:\\n mask |= 1 << (ord(c) - ord(\\\"a\\\"))\\n\\n return mask\\n\\n for word in words:\\n bt = bitmask(word)\\n dd[bt] += 1\\n\\n for puzzle in puzzles:\\n first = 1 << (ord(puzzle[0]) - ord(\\\"a\\\"))\\n\\n curr = dd[first]\\n mask = bitmask(puzzle[1:])\\n submask = mask\\n while submask:\\n curr += dd[submask | first]\\n submask = (submask - 1) & mask\\n res.append(curr)\\n\\n return res\\n\\n\",\n \"runtime\": \"721\"\n },\n {\n \"code\": \"class Solution:\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n \\n\\n # Time: O(n*k + m*(l+n))\\n # Space: O(n), where n, m = len(words), len(puzzles) and \\n # k, l = mean(len(words[i])), mean(len(puzzles[i]))\\n n, m = len(words), len(puzzles)\\n\\n def bitmask(w):\\n num = 0\\n for c in w:\\n idx = ord(c) - ord('a')\\n # Set the letter\\n num = num | (1 << idx)\\n return num\\n\\n # For each combination of letters (from words), counts the number of words\\n num_words = defaultdict(int)\\n for i in range(n):\\n num = bitmask(words[i])\\n num_words[num] += 1\\n \\n # For each puzzle permutation of letters, count the occurrencies\\n res = [0]*m\\n for j in range(m):\\n\\n # word must contain the first letter of puzzle\\n first = puzzles[j][0]\\n first_idx = (1 << (ord(first) - ord('a')))\\n\\n # Initialize with those words that only contains the first letters of puzzle\\n count = num_words[first_idx]\\n\\n num = bitmask(puzzles[j][1:])\\n # Iterate over every possible subset of puzzles[j]\\n submask = num\\n while submask:\\n count += num_words[first_idx | submask]\\n submask = (submask - 1) & num\\n res[j] = count\\n return res\\n\\n\\n # TLE\\n # Time: O(n*k + m*(l+n))\\n # Space: O(n), where n, m = len(words), len(puzzles) and \\n # k, l = mean(len(words[i])), mean(len(puzzles[i]))\\n n, m = len(words), len(puzzles)\\n char_words = {} # char_words['a'] = [[idx_words], [set_letters]]\\n letters_words = defaultdict(set)\\n words_letters = defaultdict(set)\\n for i in range(n):\\n for c in words[i]:\\n letters_words[c].add(i)\\n words_letters[i].add(c)\\n\\n res = [0]*m\\n for j in range(m):\\n first = puzzles[j][0]\\n if first not in letters_words:\\n continue\\n letters_puzzle = set([c for c in puzzles[j]])\\n for i in letters_words[first]:\\n set_ = words_letters[i]\\n num = len(set_)\\n if len(set_.intersection(letters_puzzle)) == num:\\n res[j] += 1\\n return res\\n\",\n \"runtime\": \"721\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n d = {}\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << (ord(c) - ord('a'))\\n d[mask] = d.get(mask, 0) + 1\\n ans = []\\n for puzzle in puzzles:\\n total = 0\\n mask = 0\\n for i in range(1, 7):\\n mask |= 1 << (ord(puzzle[i]) - ord('a'))\\n subset = mask\\n while subset:\\n s = subset | (1 << (ord(puzzle[0]) - ord('a')))\\n if s in d:\\n total += d[s]\\n subset = (subset - 1) & mask\\n if (1 << (ord(puzzle[0]) - ord('a'))) in d:\\n total += d[1 << (ord(puzzle[0]) - ord('a'))]\\n ans.append(total)\\n return ans\",\n \"runtime\": \"777\"\n },\n {\n \"code\": \"class Solution:\\n def mask(self, word: str) -> int:\\n result = 0\\n for ch in word:\\n result |= 1 << (ord(ch)-ord('a'))\\n return result\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n word_count = Counter(self.mask(word) for word in words)\\n result = []\\n for puzzle in puzzles:\\n original_mask, first = self.mask(puzzle[1:]), self.mask(puzzle[0])\\n curr_mask, count = original_mask, word_count[first]\\n while curr_mask:\\n count += word_count[curr_mask|first]\\n curr_mask = (curr_mask-1)&original_mask\\n result.append(count)\\n return result\",\n \"runtime\": \"777\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert each word and puzzle into a bitmask\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each bitmask in words\\n word_count = Counter(word_bitmasks)\\n \\n result = []\\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n count = 0\\n \\n # Generate all submasks of puzzle_bitmask\\n submask = puzzle_bitmask\\n while submask:\\n if submask & first_letter_bit:\\n count += word_count[submask]\\n submask = (submask - 1) & puzzle_bitmask\\n \\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"runtime\": \"833\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert words and puzzles to bitmasks\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each word bitmask\\n word_counts = Counter(word_bitmasks)\\n \\n # Initialize the result list\\n result = []\\n \\n # Process each puzzle\\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n count = 0\\n \\n # Generate all submasks of the puzzle bitmask\\n submask = puzzle_bitmask\\n while submask:\\n # Check if the submask contains the first letter of the puzzle\\n if submask & first_letter_bit:\\n count += word_counts[submask]\\n \\n # Move to the next submask\\n submask = (submask - 1) & puzzle_bitmask\\n \\n # Append the count to the result list\\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"runtime\": \"833\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n counts = collections.defaultdict(int)\\n ans = [0] * len(puzzles)\\n for word in words:\\n bit = 0 # bit 是 word 的二进制表示\\n for c in word:\\n bit |= 1 << ord(c) - ord(\\\"a\\\")\\n counts[bit] += 1\\n for i, puzzle in enumerate(puzzles):\\n bit = 0 # bit 是 puzzle 的二进制表示\\n for c in puzzle:\\n bit |= 1 << ord(c) - ord(\\\"a\\\")\\n j = bit # j 是 bit 的子集\\n # 倒序枚举 bit 的子集 j\\n while j:\\n # 单词 word 需要包含谜面的第一个字母\\n if 1 << ord(puzzle[0]) - ord(\\\"a\\\") & j:\\n ans[i] += counts[j]\\n j = bit & (j - 1)\\n return ans\\n\",\n \"runtime\": \"888\"\n },\n {\n \"code\": \"class Solution:\\n def get_valid_submasks(self, puzzle):\\n contains = [False] * 26\\n for l in puzzle: contains[ord(l) - 97] = True\\n contains = [i for i, c in enumerate(contains) if c]\\n cannot_skip = ord(puzzle[0]) - 97\\n res = []\\n for c in itertools.product(\\n *[\\n [0, 1 << i] if i != cannot_skip else [1 << i] for i in contains\\n ]\\n ):\\n res.append(sum(c))\\n return res\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n counter = defaultdict(int)\\n for word in words:\\n word = set(word)\\n if len(word) > 7:\\n continue\\n counter[sum(1 << i for i in range(26) if chr(i + 97) in word)] += 1\\n \\n res = [0] * len(puzzles)\\n for i, p in enumerate(puzzles):\\n res[i] += sum(counter[mask] for mask in self.get_valid_submasks(p))\\n return res\\n\\n \\n \",\n \"runtime\": \"944\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n wh, res = defaultdict(int), []\\n for w in words:\\n h = ''.join(sorted(set(w)))\\n if len(h) > 7: continue\\n wh[h] += 1\\n for w in puzzles:\\n n, c, sw, rc = len(w)-1, w[0], w[1:], 0\\n for i in range(n+1):\\n for x in combinations(sw, i):\\n w1 = ''.join(sorted(''.join(x)+c))\\n if w1 in wh: rc += wh[w1]\\n res.append(rc)\\n return res\",\n \"runtime\": \"944\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(list(set(val)))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node:\\n return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"runtime\": \"1000\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(list(set(val)))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node: return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n # uniq = []\\n # for word in words:\\n # uniq.append(sorted(list(set(word))))\\n # words = uniq\\n\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"runtime\": \"1000\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n words = [sorted(set(w)) for w in words]\\n puzzles = [(p[0], set(p)) for p in puzzles]\\n trees = [Trie() for _ in range(26)]\\n for w in words:\\n for char in w:\\n trees[ord(char) - 97].insert(w)\\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\\n\\nclass Node(object):\\n def __init__(self, val):\\n self.val = val\\n self.children = {}\\n self.tail = 0\\n \\nclass Trie(object):\\n def __init__(self):\\n self.root = Node(None)\\n \\n def insert(self, word):\\n curr = self.root\\n for char in word:\\n if char not in curr.children:\\n curr.children[char] = Node(char)\\n curr = curr.children[char]\\n curr.tail += 1\\n \\n def puzzle_match(self, puzzle):\\n def helper(node):\\n nonlocal res\\n res += node.tail\\n for child in node.children:\\n if child in puzzle:\\n helper(node.children[child])\\n res = 0\\n helper(self.root)\\n return res\",\n \"runtime\": \"1056\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n words = [sorted(set(w)) for w in words]\\n puzzles = [(p[0], set(p)) for p in puzzles]\\n trees = [Trie() for _ in range(26)]\\n for w in words:\\n for char in w:\\n trees[ord(char) - 97].insert(w)\\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\\n\\nclass Node(object):\\n def __init__(self, val):\\n self.val = val\\n self.children = {}\\n self.tail = 0\\n \\nclass Trie(object):\\n def __init__(self):\\n self.root = Node(None)\\n \\n def insert(self, word):\\n curr = self.root\\n for char in word:\\n if char not in curr.children:\\n curr.children[char] = Node(char)\\n curr = curr.children[char]\\n curr.tail += 1\\n \\n def puzzle_match(self, puzzle):\\n def helper(node):\\n nonlocal res\\n res += node.tail\\n for child in node.children:\\n if child in puzzle:\\n helper(node.children[child])\\n res = 0\\n helper(self.root)\\n return res\",\n \"runtime\": \"1056\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n word_counter = Counter(frozenset(word) for word in words)\\n result = []\\n \\n for puzzle in puzzles:\\n first_letter = puzzle[0]\\n puzzle_set = set(puzzle)\\n count = 0\\n \\n for subset in self.generate_subsets(puzzle_set):\\n if first_letter in subset:\\n count += word_counter[frozenset(subset)]\\n \\n result.append(count)\\n \\n return result\\n \\n def generate_subsets(self, s):\\n if not s:\\n yield set()\\n else:\\n elem = s.pop()\\n for subset in self.generate_subsets(s):\\n yield subset\\n yield subset | {elem}\\n s.add(elem)\",\n \"runtime\": \"1112\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n answer = []\\n counts = Counter()\\n\\n for word in words:\\n abbrev = ''.join(sorted(list(set(word))))\\n counts[abbrev] += 1\\n \\n for puzzle in puzzles:\\n count = 0\\n for size in range(7):\\n for indices in itertools.combinations(range(1, 7), size):\\n match = [puzzle[0]]\\n for i in indices:\\n match.append(puzzle[i])\\n match = ''.join(sorted(match))\\n count += counts[match]\\n answer.append(count)\\n \\n return answer\\n \",\n \"runtime\": \"1167\"\n },\n {\n \"code\": \"class Solution:\\n def gen_combinations(self, word):\\n if not word:\\n yield 0\\n else:\\n c = word.pop()\\n for v in self.gen_combinations(word):\\n yield v\\n yield v | (1 << (ord(c) - ord('a')))\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n table = defaultdict(Counter)\\n for w in words:\\n chars = set(list(w)) \\n if len(chars) > 7:\\n continue\\n h = reduce(operator.or_, [1 << (ord(c) - ord('a')) for c in chars], 0)\\n for c in chars:\\n table[c][h] += 1\\n for i, p in enumerate(puzzles):\\n puzzles[i] = sum(table[p[0]][h] for h in self.gen_combinations(list(p)))\\n return puzzles\",\n \"runtime\": \"1167\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n\\n words = [\\\"\\\".join(sorted(set(w))) for w in words]\\n ct = Counter(words)\\n words = [set(w) for w in list(set(words))]\\n\\n dt = defaultdict(lambda: [])\\n for ws in words:\\n for c in list(ws):\\n dt[c].append(ws)\\n\\n res = []\\n for p in puzzles:\\n t = 0\\n ps = set(p)\\n for ws in dt[p[0]]:\\n if ws.issubset(ps):\\n t += ct[\\\"\\\".join(sorted(list(ws)))] \\n res.append(t)\\n \\n return res\",\n \"runtime\": \"1223\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n '''\\n word:\\n all letters of word are in puzzle\\n first letter of puzzle is in word\\n\\n We need to (mainly) store two things for each puzzle\\n\\n first letter of word is in puzzle \\n\\n so we can index puzzles by first letter\\n\\n each word is <= 50\\n\\n each puzzle is <= 7 (very short)\\n\\n multiple of the same character in word can map to one character in puzzle\\n\\n\\n bitmask?\\n\\n '''\\n\\n freq = defaultdict(int)\\n\\n for w in words:\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n \\n freq[x] += 1\\n\\n lookup = defaultdict(list)\\n\\n for index, w in enumerate(puzzles):\\n first_letter = 1 << (ord(w[0]) - ord('a'))\\n\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n\\n lookup[first_letter].append([index, x, 0])\\n\\n \\n arr = list(freq.items())\\n\\n for x, amount in arr:\\n for i in range(26):\\n if (1 << i) & x:\\n for y in lookup[1 << i]:\\n if (x & y[1]) == x:\\n y[2] += amount\\n\\n \\n ans = [None] * len(puzzles)\\n for key in lookup.keys():\\n for index, _, count in lookup[key]:\\n ans[index] = count\\n\\n return ans\\n\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"1279\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n '''\\n word:\\n all letters of word are in puzzle\\n first letter of puzzle is in word\\n\\n We need to (mainly) store two things for each puzzle\\n\\n first letter of word is in puzzle \\n\\n so we can index puzzles by first letter\\n\\n each word is <= 50\\n\\n each puzzle is <= 7 (very short)\\n\\n multiple of the same character in word can map to one character in puzzle\\n\\n\\n bitmask?\\n\\n '''\\n\\n freq = defaultdict(int)\\n\\n for w in words:\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n \\n freq[x] += 1\\n\\n lookup = defaultdict(list)\\n\\n for index, w in enumerate(puzzles):\\n first_letter = 1 << (ord(w[0]) - ord('a'))\\n\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n\\n lookup[first_letter].append([index, x, 0])\\n\\n \\n arr = list(freq.items())\\n\\n for x, amount in arr:\\n for i in range(26):\\n if (1 << i) & x:\\n for y in lookup[1 << i]:\\n if (x & y[1]) == x:\\n y[2] += amount\\n\\n \\n ans = [None] * len(puzzles)\\n for key in lookup.keys():\\n for index, _, count in lookup[key]:\\n ans[index] = count\\n\\n return ans\",\n \"runtime\": \"1335\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n '''\\n word:\\n all letters of word are in puzzle\\n first letter of puzzle is in word\\n\\n We need to (mainly) store two things for each puzzle\\n\\n first letter of word is in puzzle \\n\\n so we can index puzzles by first letter\\n\\n each word is <= 50\\n\\n each puzzle is <= 7 (very short)\\n\\n multiple of the same character in word can map to one character in puzzle\\n\\n\\n bitmask?\\n\\n '''\\n\\n freq = defaultdict(int)\\n\\n for w in words:\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n \\n freq[x] += 1\\n\\n lookup = defaultdict(list)\\n\\n for index, w in enumerate(puzzles):\\n first_letter = 1 << (ord(w[0]) - ord('a'))\\n\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n\\n lookup[first_letter].append([index, x, 0])\\n\\n \\n arr = list(freq.items())\\n\\n for x, amount in arr:\\n for i in range(26):\\n if (1 << i) & x:\\n for y in lookup[1 << i]:\\n if (x & y[1]) == x:\\n y[2] += amount\\n\\n \\n ans = [None] * len(puzzles)\\n for key in lookup.keys():\\n for index, _, count in lookup[key]:\\n ans[index] = count\\n\\n return ans\\n\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"1390\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n def word_to_bin(w):\\n b = 0\\n w = set(w)\\n for i in range(26):\\n if chr(ord('a')+i) in w:\\n b+=1<<i\\n return b\\n words = [word_to_bin(w) for w in words]\\n data = [Counter([w for w in words if (w&(1<<i))]) for i in range(26)]\\n ans = []\\n for puzzle in puzzles:\\n d = data[ord(puzzle[0])-ord('a')]\\n p = word_to_bin(puzzle)\\n total = 0\\n for w in d:\\n if (~p)&w==0:\\n total+=d[w]\\n ans.append(total)\\n return ans\",\n \"runtime\": \"1390\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Preprocess words\\n word_bitmasks = Counter()\\n for word in words:\\n mask = 0\\n for char in word:\\n mask |= 1 << (ord(char) - ord('a'))\\n word_bitmasks[mask] += 1\\n \\n # Function to generate all subsets of a set\\n def subsets(arr):\\n for i in range(1 << len(arr)):\\n yield [arr[j] for j in range(len(arr)) if i & (1 << j)]\\n \\n # Count valid words for each puzzle\\n result = []\\n for puzzle in puzzles:\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n other_letters = [1 << (ord(char) - ord('a')) for char in puzzle[1:]]\\n count = 0\\n \\n # Iterate over all subsets of other_letters\\n for subset in subsets(other_letters):\\n mask = first_letter_bit | sum(subset)\\n count += word_bitmasks[mask]\\n \\n result.append(count)\\n \\n return result\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"runtime\": \"1446\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << ord(puzzle[0]) - ord('a')\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n\\n return ans\\n \",\n \"runtime\": \"1502\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << ord(puzzle[0]) - ord('a')\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n\\n return ans\\n\",\n \"runtime\": \"1558\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << ord(puzzle[0]) - ord('a')\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n return ans \",\n \"runtime\": \"1614\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << ord(puzzle[0]) - ord('a')\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n\\n return ans\",\n \"runtime\": \"1614\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << ord(puzzle[0]) - ord('a')\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << ord(puzzle[j + 1]) - ord('a')\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n return ans\",\n \"runtime\": \"1669\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n l=[]\\n for i in range(len(words)):\\n s=0\\n for j in words[i]:\\n s=s|(1<<(ord(j))-97)\\n l+=[s]\\n l.sort()\\n ans=[]\\n for i in range(len(puzzles)):\\n s=0\\n l1=[]\\n for j in puzzles[i]:\\n s=s|(1<<(ord(j))-97)\\n l1+=[ord(j)-97]\\n b1=bisect.bisect_right(l,2**l1[0]-1)\\n b2=bisect.bisect_left(l,2**l1[0]+1)\\n c=b2-b1\\n a=l1.pop(0)\\n for k in range(1,2**(len(l1))):\\n s1=2**a\\n count=0\\n while k!=0:\\n if k&1!=0:\\n s1+=2**l1[count]\\n k=k>>1\\n count+=1\\n b1=bisect.bisect_right(l,s1-1)\\n b2=bisect.bisect_left(l,s1+1)\\n c+=b2-b1\\n ans+=[c]\\n return ans\",\n \"runtime\": \"1669\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(\\n self,\\n words: list[str],\\n puzzles: list[str],\\n ) -> list[int]:\\n ans = []\\n binaryCount = collections.Counter()\\n\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << string.ascii_lowercase.index(c)\\n binaryCount[mask] += 1\\n\\n for puzzle in puzzles:\\n valid = 0\\n n = len(puzzle) - 1\\n for i in range(1 << n):\\n mask = 1 << string.ascii_lowercase.index(puzzle[0])\\n for j in range(n):\\n if i >> j & 1:\\n mask |= 1 << string.ascii_lowercase.index(puzzle[j + 1])\\n if mask in binaryCount:\\n valid += binaryCount[mask]\\n ans.append(valid)\\n\\n return ans\\n\",\n \"runtime\": \"1725\"\n },\n {\n \"code\": \"class TrieNode:\\n def __init__(self):\\n self.childs = {}\\n self.leaf = 0\\n\\nclass Trie:\\n def __init__(self):\\n self.root = TrieNode()\\n\\n def add(self, word):\\n p = self.root\\n for ch in word:\\n if ch not in p.childs:\\n p.childs[ch] = TrieNode()\\n p = p.childs[ch]\\n p.leaf += 1\\n\\n def search(self, target):\\n p = self.root\\n for ch in target:\\n if ch not in p.childs:\\n return 0\\n p = p.childs[ch]\\n return p.leaf\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n sorted_words = [sorted(list(set(x))) for x in words]\\n first = [x[0] for x in puzzles]\\n sorted_puzzles = [sorted(x) for x in puzzles]\\n tree = Trie()\\n for word in sorted_words:\\n tree.add(word)\\n res = []\\n for i, puzzle in enumerate(sorted_puzzles):\\n N = len(puzzle)\\n cnt = 0\\n for j in range(1, 1 << N):\\n target = []\\n use = False\\n for k in range(N):\\n if j & (1 << k):\\n if puzzle[k] == first[i]:\\n use = True\\n target.append(puzzle[k])\\n\\n if use:\\n cnt += tree.search(target)\\n\\n res.append(cnt)\\n return res\\n\",\n \"runtime\": \"1781\"\n },\n {\n \"code\": \"class TrieNode:\\n def __init__(self):\\n self.childs = {}\\n self.leaf = 0\\n\\nclass Trie:\\n def __init__(self):\\n self.root = TrieNode()\\n\\n def add(self, word):\\n p = self.root\\n for ch in word:\\n if ch not in p.childs:\\n p.childs[ch] = TrieNode()\\n p = p.childs[ch]\\n p.leaf += 1\\n\\n def search(self, target):\\n p = self.root\\n for ch in target:\\n if ch not in p.childs:\\n return 0\\n p = p.childs[ch]\\n return p.leaf\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n sorted_words = [sorted(list(set(x))) for x in words]\\n sorted_puzzles = [sorted(x) for x in puzzles]\\n tree = Trie()\\n for word in sorted_words:\\n tree.add(word)\\n res = []\\n for i, puzzle in enumerate(sorted_puzzles):\\n N = len(puzzle)\\n cnt = 0\\n for j in range(1, 1 << N):\\n target = []\\n use = False\\n for k in range(N):\\n if j & (1 << k):\\n if puzzle[k] == puzzles[i][0]:\\n use = True\\n target.append(puzzle[k])\\n\\n if use:\\n cnt += tree.search(target)\\n\\n res.append(cnt)\\n return res\\n\",\n \"runtime\": \"1837\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n\\n res = []\\n dicto = {}\\n\\n for puzzle in puzzles:\\n\\n cur = [0]\\n newcur = []\\n for letter in puzzle:\\n for el in cur:\\n newcur.append(el)\\n newcur.append(el+2**(ord(letter) - ord('a')))\\n cur, newcur = newcur, []\\n #print(puzzle, len(cur))\\n for submask in cur:\\n if submask > 0:\\n if submask not in dicto:\\n dicto[submask] = {}\\n if 2**(ord(puzzle[0])-ord('a')) not in dicto[submask]:\\n dicto[submask][2**(ord(puzzle[0])-ord('a')) ] = 0\\n res.append(cur)\\n\\n #print(res[0])\\n\\n puzzles = [[sum(2**(ord(el)-ord('a')) for el in puzzle ), 2**(ord(puzzle[0]) - ord('a'))] for puzzle in puzzles]\\n words = [sum(2**(ord(el)-ord('a')) for el in set(word)) for word in words]\\n\\n \\n #print(puzzles)\\n #print(words)\\n \\n \\n for word in words:\\n if word in dicto:\\n for el in dicto[word]:\\n if word & el > 0:\\n \\n dicto[word][el] += 1\\n #print(word, el, dicto[word][el])\\n \\n output = []\\n\\n for i in range(len(puzzles)):\\n submasks = res[i]\\n total = 0\\n for submask in submasks:\\n if submask > 0:\\n total += dicto[submask][puzzles[i][1]]\\n output.append(total)\\n\\n return output\\n \",\n \"runtime\": \"1892\"\n },\n {\n \"code\": \"class TrieNode:\\n def __init__(self):\\n self.childs = {}\\n self.leaf = 0\\n\\nclass Trie:\\n def __init__(self):\\n self.root = TrieNode()\\n\\n def add(self, word):\\n p = self.root\\n for ch in word:\\n if ch not in p.childs:\\n p.childs[ch] = TrieNode()\\n p = p.childs[ch]\\n p.leaf += 1\\n\\n def search(self, target):\\n p = self.root\\n for ch in target:\\n if ch not in p.childs:\\n return 0\\n p = p.childs[ch]\\n return p.leaf\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n sorted_words = [sorted(list(set(x))) for x in words]\\n sorted_puzzles = [sorted(x) for x in puzzles]\\n tree = Trie()\\n for word in sorted_words:\\n tree.add(word)\\n res = []\\n for i, puzzle in enumerate(sorted_puzzles):\\n N = len(puzzle)\\n cnt = 0\\n for j in range(1, 1 << N):\\n target = []\\n use = False\\n for k in range(N):\\n if j & (1 << k):\\n if puzzle[k] == puzzles[i][0]:\\n use = True\\n target.append(puzzle[k])\\n\\n if use:\\n cnt += tree.search(target)\\n\\n res.append(cnt)\\n return res\",\n \"runtime\": \"1948\"\n },\n {\n \"code\": \"import numpy as np\\n\\ndef bitmask(w):\\n res = 0\\n for c in set(w):\\n res += (1<<(ord(c)-ord('a')))\\n return res\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n N = len(puzzles)\\n pz = np.array([bitmask(p) for p in puzzles], dtype=np.int32)\\n p1 = np.array([bitmask(p[:1]) for p in puzzles], dtype=np.int32)\\n ans = np.zeros(N, dtype=np.int32)\\n for w in words:\\n m = bitmask(w)\\n l1 = (p1&m).astype(bool)\\n l2 = (pz&m)==m\\n ans += (l1&l2)\\n return [int(x) for x in ans]\",\n \"runtime\": \"2004\"\n },\n {\n \"code\": \"class Solution:\\n def getBitMask(self,word):\\n mask = 0\\n for char in word:\\n shift = ord(char)-ord(\\\"a\\\")\\n mask |= 1<<shift\\n return mask\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n freq = {}\\n for word in words:\\n mask = self.getBitMask(word)\\n freq[mask] = freq.get(mask,0)+1\\n ans = [0 for _ in range(len(puzzles))]\\n index = 0\\n for puzzle in puzzles:\\n i = ord(puzzle[0]) - ord(\\\"a\\\")\\n submask = 1<<i\\n puzzle_mask = self.getBitMask(puzzle)\\n for mask in freq:\\n if ((submask & mask) == submask) and ((puzzle_mask & mask) == mask):\\n ans[index] += freq[mask]\\n index+=1\\n return ans\\n \\n\\n \",\n \"runtime\": \"2060\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n m = len(words)\\n n = len(puzzles)\\n wordBitmasks = [0]*m\\n a = ord('a')\\n for i, word in enumerate(words):\\n for letter in word:\\n wordBitmasks[i] |= (1 << (ord(letter) - a))\\n #wordBitmasks.sort()\\n counts = defaultdict(lambda : 0)\\n for wordBitmask in wordBitmasks:\\n counts[wordBitmask] += 1\\n #print(counts)\\n answer = [0]*n\\n for i, puzzle in enumerate(puzzles):\\n puzzleBitmask = 0\\n for letter in puzzle:\\n puzzleBitmask |= (1 << (ord(letter) - a))\\n firstLetter = (1 << (ord(puzzle[0]) - a))\\n for wordBitmask in counts:\\n if firstLetter | wordBitmask != wordBitmask:\\n continue\\n if wordBitmask | puzzleBitmask != puzzleBitmask:\\n continue\\n answer[i] += counts[wordBitmask]\\n return answer\\n \\n \",\n \"runtime\": \"2116\"\n },\n {\n \"code\": \"class Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n a = ord('a')\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - a)\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - a)\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n word_sets = defaultdict(int)\\n for word in words:\\n word_set = 0\\n for ch in word:\\n bit = 1 << (ord(ch) - a)\\n word_set |= bit\\n if (bin(word_set).count('1')) <= 7:\\n word_sets[word_set] += 1\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(word_sets, puzzle))\\n \\n return result\\n\",\n \"runtime\": \"2171\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n words = [set(w) for w in words]\\n new_words = {}\\n for word in words:\\n w = set(word)\\n wk = \\\"\\\".join(sorted(w))\\n new_words.setdefault(wk, [w, 0])\\n new_words[wk][1] += 1\\n\\n new_puzzles = []\\n for puzzle in puzzles:\\n p = set(puzzle)\\n normp = \\\"\\\".join(sorted(p))\\n pk = f\\\"{puzzle[0]}-{normp}\\\"\\n new_puzzles.append((pk, puzzle[0], p))\\n\\n puzzles = [(p[0], set(p)) for p in puzzles]\\n\\n out = []\\n cache = {}\\n for pk, l, p in new_puzzles:\\n if pk not in cache:\\n count = 0\\n for w, v in new_words.values():\\n if l in w and not w - p:\\n count += v\\n cache[pk] = count\\n out.append(cache[pk])\\n \\n return out\\n \",\n \"runtime\": \"2227\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n a = ord('a')\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - a)\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - a)\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n word_sets = []\\n for word in words:\\n word_set = 0\\n for ch in word:\\n bit = 1 << (ord(ch) - a)\\n word_set |= bit\\n if (bin(word_set).count('1')) <= 7:\\n word_sets.append(word_set)\\n cnt = Counter(word_sets)\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(cnt, puzzle))\\n \\n return result\\n\",\n \"runtime\": \"2283\"\n },\n {\n \"code\": \"from collections import Counter\\nfrom functools import reduce\\nimport operator\\n\\nclass Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - ord('a'))\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - ord('a'))\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n # word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\\n word_sets = []\\n for word in words:\\n word_set = 0\\n for ch in word:\\n bit = 1 << (ord(ch) - a)\\n word_set |= bit\\n # if (bin(word_set).count('1')) <= 7:\\n # word_sets.append(word_set)\\n word_sets.append(word_set)\\n cnt = Counter(word_sets)\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(cnt, puzzle))\\n \\n return result\\n\",\n \"runtime\": \"2339\"\n },\n {\n \"code\": \"from collections import Counter\\nfrom functools import reduce\\nimport operator\\n\\nclass Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n a = ord('a')\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - a)\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - a)\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n # word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\\n word_sets = []\\n for word in words:\\n word_set = 0\\n for ch in word:\\n bit = 1 << (ord(ch) - a)\\n word_set |= bit\\n # if (bin(word_set).count('1')) <= 7:\\n # word_sets.append(word_set)\\n word_sets.append(word_set)\\n cnt = Counter(word_sets)\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(cnt, puzzle))\\n \\n return result\\n\",\n \"runtime\": \"2394\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n words = [set(w) for w in words]\\n new_words = {}\\n for word in words:\\n w = set(word)\\n wk = \\\"\\\".join(sorted(w))\\n new_words.setdefault(wk, [w, 0])\\n new_words[wk][1] += 1\\n\\n new_puzzles = []\\n for puzzle in puzzles:\\n p = set(puzzle)\\n normp = \\\"\\\".join(sorted(p))\\n pk = f\\\"{puzzle[0]}-{normp}\\\"\\n new_puzzles.append((pk, puzzle[0], p))\\n\\n puzzles = [(p[0], set(p)) for p in puzzles]\\n\\n out = []\\n cache = {}\\n for pk, l, p in new_puzzles:\\n if pk not in cache:\\n count = 0\\n for w, v in new_words.values():\\n if l in w and not w - p:\\n count += v\\n cache[pk] = count\\n out.append(cache[pk])\\n \\n return out\\n \",\n \"runtime\": \"2450\"\n },\n {\n \"code\": \"from collections import Counter\\nfrom functools import reduce\\nimport operator\\n\\nclass Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n a = ord('a')\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - a)\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - a)\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\\n # for word in words:\\n # word_set = 0\\n # for ch in word:\\n # bit = 1 << (ord(ch) - a)\\n # word_set |= bit\\n # # if (bin(word_set).count('1')) <= 7:\\n # # word_sets.append(word_set)\\n # word_sets.append(word_set)\\n cnt = Counter(word_sets)\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(cnt, puzzle))\\n \\n return result\\n\",\n \"runtime\": \"2506\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":45,"string":"45"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(sorted(list(set(val))))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node: return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n # uniq = []\n # for word in words:\n # uniq.append(sorted(list(set(word))))\n # words = uniq\n\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"43800"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n d = {}\n for word in words:\n mask = 0\n for c in word:\n mask |= 1 << (ord(c) - ord('a'))\n d[mask] = d.get(mask, 0) + 1\n ans = []\n for puzzle in puzzles:\n total = 0\n mask = 0\n for i in range(1, 7):\n mask |= 1 << (ord(puzzle[i]) - ord('a'))\n subset = mask\n while subset:\n s = subset | (1 << (ord(puzzle[0]) - ord('a')))\n if s in d:\n total += d[s]\n subset = (subset - 1) & mask\n if (1 << (ord(puzzle[0]) - ord('a'))) in d:\n total += d[1 << (ord(puzzle[0]) - ord('a'))]\n ans.append(total)\n return ans","memory":"44100"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Preprocess words\n word_bitmasks = Counter()\n for word in words:\n mask = 0\n for char in word:\n mask |= 1 << (ord(char) - ord('a'))\n word_bitmasks[mask] += 1\n \n # Function to generate all subsets of a set\n def subsets(arr):\n for i in range(1 << len(arr)):\n yield [arr[j] for j in range(len(arr)) if i & (1 << j)]\n \n # Count valid words for each puzzle\n result = []\n for puzzle in puzzles:\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n other_letters = [1 << (ord(char) - ord('a')) for char in puzzle[1:]]\n count = 0\n \n # Iterate over all subsets of other_letters\n for subset in subsets(other_letters):\n mask = first_letter_bit | sum(subset)\n count += word_bitmasks[mask]\n \n result.append(count)\n \n return result\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","memory":"44200"},{"code":"from typing import List\nfrom collections import Counter\n\nclass Solution:\n def mask(self, word: str) -> int:\n \"\"\"Generate a bitmask for a given word.\"\"\"\n result = 0\n for ch in word:\n # Set the bit corresponding to the character in the word\n result |= 1 << (ord(ch) - ord('a'))\n return result\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n # Count the frequency of each word's bitmask\n word_count = Counter(self.mask(word) for word in words)\n result = []\n\n for puzzle in puzzles:\n # Create a bitmask for the puzzle excluding the first character\n original_mask = self.mask(puzzle[1:])\n # Create a bitmask for the first character of the puzzle\n first = self.mask(puzzle[0])\n curr_mask = original_mask\n count = word_count[first] # Start with words that only contain the first letter\n\n # Iterate through all submasks of the puzzle's bitmask\n while curr_mask:\n # Count words that match the current submask and include the first letter\n count += word_count[curr_mask | first]\n # Generate the next submask\n curr_mask = (curr_mask - 1) & original_mask\n\n result.append(count)\n\n return result","memory":"44300"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert word to bitmask\n def word_to_bitmask(word):\n mask = 0\n for char in word:\n mask |= 1 << (ord(char) - ord('a'))\n return mask\n\n # Count bitmasks of words\n word_bitmasks = Counter(word_to_bitmask(word) for word in words)\n\n # Function to count valid words for a puzzle\n def count_valid_words(puzzle):\n # Convert puzzle to bitmask\n puzzle_mask = word_to_bitmask(puzzle)\n first_letter_mask = 1 << (ord(puzzle[0]) - ord('a'))\n \n # Generate all subsets of puzzle_mask that include the first letter\n subset_mask = puzzle_mask\n valid_count = 0\n while subset_mask:\n if subset_mask & first_letter_mask:\n valid_count += word_bitmasks[subset_mask]\n subset_mask = (subset_mask - 1) & puzzle_mask\n \n return valid_count\n\n # Count valid words for each puzzle\n return [count_valid_words(puzzle) for puzzle in puzzles]\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","memory":"44300"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n\n # Helper function to create a bitmask from a word, where each bit in the integer represents\n # the presence of a unique character in the word.\n def bitmask(word: str) -> int:\n mask = 0\n # Iterate through each letter in the word and set the corresponding bit in the mask.\n for letter in word:\n mask |= 1 << (ord(letter) - ord('a')) # 'a' corresponds to the first bit, 'b' to the second, etc.\n return mask\n\n # Create a bitmask for each word and count how many times each unique bitmask appears using a Counter.\n # This gives us a dictionary where the key is the bitmask of the word, and the value is the frequency of that bitmask.\n word_count = Counter(bitmask(word) for word in words)\n\n # Initialize an empty list to store the result for each puzzle.\n result = []\n \n # Iterate through each puzzle.\n for puzzle in puzzles:\n # Create a bitmask for the first letter of the puzzle, since this letter must always be present in valid words.\n first = 1 << (ord(puzzle[0]) - ord('a')) # Create bitmask for the first character only\n count = word_count[first] # Initialize count with the number of words that consist only of the first letter\n\n # Create a bitmask for the remaining characters in the puzzle (excluding the first character).\n # The first character is handled separately, so the rest of the puzzle is processed here.\n mask = bitmask(puzzle[1:]) # Create a bitmask for the characters in puzzle[1:]\n \n # Iterate over every possible subset of the puzzle's characters (ignoring the first character for now).\n submask = mask\n while submask:\n # Add the first character to the submask and check if this combination matches any word bitmask.\n # Use the OR operation to combine the submask with the first character.\n count += word_count[submask | first] # Check if this submask (with the first character) exists in word_count\n \n # Generate the next submask by removing one bit from the current submask.\n # This way, we explore all subsets of the puzzle's characters.\n submask = (submask - 1) & mask\n\n # Append the total count for this puzzle to the result list.\n result.append(count)\n\n # Return the list of results, where each entry corresponds to the number of valid words for each puzzle.\n return result\n","memory":"44400"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n '''\n word:\n all letters of word are in puzzle\n first letter of puzzle is in word\n\n We need to (mainly) store two things for each puzzle\n\n first letter of word is in puzzle \n\n so we can index puzzles by first letter\n\n each word is <= 50\n\n each puzzle is <= 7 (very short)\n\n multiple of the same character in word can map to one character in puzzle\n\n\n bitmask?\n\n '''\n\n freq = defaultdict(int)\n\n for w in words:\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n \n freq[x] += 1\n\n lookup = defaultdict(list)\n\n for index, w in enumerate(puzzles):\n first_letter = 1 << (ord(w[0]) - ord('a'))\n\n x = 0\n for c in w:\n x |= (1 << (ord(c) - ord('a')))\n\n lookup[first_letter].append([index, x, 0])\n\n \n arr = list(freq.items())\n\n for x, amount in arr:\n for i in range(26):\n if (1 << i) & x:\n for y in lookup[1 << i]:\n if (x & y[1]) == x:\n y[2] += amount\n\n \n ans = [None] * len(puzzles)\n for key in lookup.keys():\n for index, _, count in lookup[key]:\n ans[index] = count\n\n return ans\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n ","memory":"44500"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(list(set(val)))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node: return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n # uniq = []\n # for word in words:\n # uniq.append(sorted(list(set(word))))\n # words = uniq\n\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"44600"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(sorted(list(set(val))))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node:\n return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"44600"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(list(set(val)))\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node:\n return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"44700"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n m = len(words)\n n = len(puzzles)\n wordBitmasks = [0]*m\n a = ord('a')\n for i, word in enumerate(words):\n for letter in word:\n wordBitmasks[i] |= (1 << (ord(letter) - a))\n #wordBitmasks.sort()\n counts = defaultdict(lambda : 0)\n for wordBitmask in wordBitmasks:\n counts[wordBitmask] += 1\n #print(counts)\n answer = [0]*n\n for i, puzzle in enumerate(puzzles):\n puzzleBitmask = 0\n for letter in puzzle:\n puzzleBitmask |= (1 << (ord(letter) - a))\n firstLetter = (1 << (ord(puzzle[0]) - a))\n for wordBitmask in counts:\n if firstLetter | wordBitmask != wordBitmask:\n continue\n if wordBitmask | puzzleBitmask != puzzleBitmask:\n continue\n answer[i] += counts[wordBitmask]\n return answer\n \n ","memory":"44800"},{"code":"from collections import defaultdict\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert word to bitmask\n def word_to_bitmask(word):\n mask = 0\n for char in word:\n mask |= (1 << (ord(char) - ord('a')))\n return mask\n\n # Check if word is valid for puzzle\n def is_valid(word_mask, puzzle_mask, first_letter_mask):\n return (word_mask & first_letter_mask) and (word_mask & puzzle_mask) == word_mask\n\n # Convert puzzles to bitmasks\n puzzle_bitmasks = [word_to_bitmask(puzzle) for puzzle in puzzles]\n first_letter_bitmasks = [1 << (ord(puzzle[0]) - ord('a')) for puzzle in puzzles]\n\n # Count words by their bitmasks\n word_bitmask_counts = defaultdict(int)\n for word in words:\n word_bitmask_counts[word_to_bitmask(word)] += 1\n\n # Initialize result array\n result = [0] * len(puzzles)\n\n # Check each puzzle against all words\n for i, (puzzle_mask, first_letter_mask) in enumerate(zip(puzzle_bitmasks, first_letter_bitmasks)):\n for word_mask, count in word_bitmask_counts.items():\n if is_valid(word_mask, puzzle_mask, first_letter_mask):\n result[i] += count\n\n return result\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","memory":"44900"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert each word into a bitmask\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n \n # Count the frequency of each bitmask\n word_counts = Counter(word_bitmasks)\n \n # Initialize the result list\n result = []\n \n # Process each puzzle\n for puzzle in puzzles:\n # Convert the puzzle to a bitmask\n puzzle_bitmask = self.word_to_bitmask(puzzle)\n first_letter_bitmask = 1 << (ord(puzzle[0]) - ord('a'))\n \n # Initialize the count of valid words for this puzzle\n count = 0\n \n # Generate all subsets of the puzzle bitmask\n subset_bitmask = puzzle_bitmask\n while subset_bitmask > 0:\n # Check if the subset contains the first letter of the puzzle\n if subset_bitmask & first_letter_bitmask:\n # Add the count of words with this subset bitmask\n count += word_counts[subset_bitmask]\n \n # Generate the next subset by removing the lowest set bit\n subset_bitmask = (subset_bitmask - 1) & puzzle_bitmask\n \n # Append the count to the result list\n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","memory":"45100"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert each word into a bitmask\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n \n # Count the occurrence of each bitmask\n word_counts = Counter(word_bitmasks)\n \n # Initialize the result list\n result = []\n \n # Process each puzzle\n for puzzle in puzzles:\n # Convert the puzzle into a bitmask\n puzzle_bitmask = self.word_to_bitmask(puzzle)\n first_letter_bitmask = 1 << (ord(puzzle[0]) - ord('a'))\n \n # Initialize the submask to the puzzle bitmask\n submask = puzzle_bitmask\n valid_count = 0\n \n # Iterate over all subsets of the puzzle bitmask\n while submask > 0:\n # Check if the subset contains the first letter of the puzzle\n if submask & first_letter_bitmask:\n valid_count += word_counts[submask]\n \n # Move to the next subset\n submask = (submask - 1) & puzzle_bitmask\n \n # Add the count of valid words for this puzzle to the result\n result.append(valid_count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for letter in word:\n bitmask |= 1 << (ord(letter) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","memory":"45200"},{"code":"from collections import Counter\nfrom functools import reduce\nimport operator\n\nclass Solution:\n\n def checkWords(self, words, puzzle: str) -> int:\n a = ord('a')\n cnt = 0\n puzzle_set = 0\n for ch in puzzle:\n bit = 1 << (ord(ch) - a)\n puzzle_set |= bit\n \n first_letter_mask = 1 << (ord(puzzle[0]) - a)\n\n for word_set, n in words.items():\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\n cnt += n\n\n return cnt\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n result = []\n\n a = ord('a')\n\n word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\n # for word in words:\n # word_set = 0\n # for ch in word:\n # bit = 1 << (ord(ch) - a)\n # word_set |= bit\n # # if (bin(word_set).count('1')) <= 7:\n # # word_sets.append(word_set)\n # word_sets.append(word_set)\n cnt = Counter(word_sets)\n \n for puzzle in puzzles:\n result.append(self.checkWords(cnt, puzzle))\n \n return result\n","memory":"45300"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(val)\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node: return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(sorted(list(set(word))))\n words = uniq\n\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"45400"},{"code":"class Solution:\n def findNumOfValidWords(self, words, puzzles):\n wh, res = defaultdict(int), []\n for w in words:\n h = ''.join(sorted(set(w)))\n if len(h) > 7: continue\n wh[h] += 1\n for w in puzzles:\n n, c, sw, rc = len(w)-1, w[0], w[1:], 0\n for i in range(n+1):\n for x in combinations(sw, i):\n w1 = ''.join(sorted(''.join(x)+c))\n if w1 in wh: rc += wh[w1]\n res.append(rc)\n return res","memory":"45600"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert each word and puzzle into a bitmask\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each bitmask in words\n word_count = Counter(word_bitmasks)\n \n result = []\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n count = 0\n \n # Generate all submasks of puzzle_bitmask\n submask = puzzle_bitmask\n while submask:\n if submask & first_letter_bit:\n count += word_count[submask]\n submask = (submask - 1) & puzzle_bitmask\n \n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","memory":"45700"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert words and puzzles to bitmasks\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each word bitmask\n word_counts = Counter(word_bitmasks)\n \n # Initialize the result list\n result = []\n \n # Process each puzzle\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n count = 0\n \n # Generate all submasks of the puzzle bitmask\n submask = puzzle_bitmask\n while submask:\n # Check if the submask contains the first letter of the puzzle\n if submask & first_letter_bit:\n count += word_counts[submask]\n \n # Move to the next submask\n submask = (submask - 1) & puzzle_bitmask\n \n # Append the count to the result list\n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]","memory":"45800"},{"code":"from collections import Counter\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert each word and puzzle into a bitmask\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each bitmask in the words list\n word_freq = Counter(word_bitmasks)\n \n # Initialize the result list\n result = []\n \n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n subset_count = 0\n \n # Generate all subsets of the puzzle bitmask that include the first letter\n subset = puzzle_bitmask\n while subset:\n if subset & first_letter_bit:\n subset_count += word_freq[subset]\n subset = (subset - 1) & puzzle_bitmask\n \n # Add the count to the result list\n result.append(subset_count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","memory":"45800"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n return sol3(words, puzzles)\n\ndef sol1(words, puzzles):\n def is_good(puzzle, word):\n if puzzle[0] not in word:\n return False\n for ch in word:\n if ch not in puzzle:\n return False\n return True\n\n ans = []\n for puzzle in puzzles:\n cnt = 0\n for word in words:\n if is_good(puzzle, word):\n cnt += 1\n ans.append(cnt)\n return ans\n\ndef sol2(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(set(word))\n words = uniq\n\n uniq = []\n for puzzle in puzzles:\n uniq.append(set(puzzle))\n\n def is_good(idx, word):\n if puzzles[i][0] not in word:\n return False\n for ch in word:\n if ch not in uniq[i]:\n return False\n return True\n\n ans = []\n for i in range(len(puzzles)):\n cnt = 0\n for word in words:\n if is_good(puzzles[i], word):\n cnt += 1\n ans.append(cnt)\n return ans\n\nclass Node:\n def __init__(self):\n self.kids = defaultdict(Node)\n self.is_terminal = False\n self.cnt = 0\n self.chars = set()\n\nclass Trie:\n def __init__(self, vals):\n self.root = Node()\n for val in vals:\n self.append(val)\n\n def append(self, word):\n node = self.root\n for ch in word:\n if not node.kids[ch]:\n node.kids[ch] = Node()\n node = node.kids[ch]\n node.is_terminal = True\n node.cnt += 1\n node.chars = set(word)\n\n def search(self, word, node):\n if not node: return 0\n ans = 0\n for ch in word:\n if ch in node.kids:\n ans += self.search(word, node.kids[ch])\n if node.is_terminal and word[0] in node.chars:\n return ans + node.cnt\n return ans\n\ndef sol3(words, puzzles):\n uniq = []\n for word in words:\n uniq.append(sorted(list(set(word))))\n words = sorted(uniq)\n\n trie = Trie(words)\n\n ans = []\n for puzzle in puzzles:\n ans.append(trie.search(puzzle, trie.root))\n return ans\n","memory":"45900"},{"code":"class TrieNode:\n def __init__(self):\n self.childs = {}\n self.leaf = 0\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def add(self, word):\n p = self.root\n for ch in word:\n if ch not in p.childs:\n p.childs[ch] = TrieNode()\n p = p.childs[ch]\n p.leaf += 1\n\n def search(self, target):\n p = self.root\n for ch in target:\n if ch not in p.childs:\n return 0\n p = p.childs[ch]\n return p.leaf\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n sorted_words = [sorted(list(set(x))) for x in words]\n sorted_puzzles = [sorted(x) for x in puzzles]\n tree = Trie()\n for word in sorted_words:\n tree.add(word)\n res = []\n for i, puzzle in enumerate(sorted_puzzles):\n N = len(puzzle)\n cnt = 0\n for j in range(1, 1 << N):\n target = []\n use = False\n for k in range(N):\n if j & (1 << k):\n if puzzle[k] == puzzles[i][0]:\n use = True\n target.append(puzzle[k])\n\n if use:\n cnt += tree.search(target)\n\n res.append(cnt)\n return res","memory":"46000"},{"code":"class TrieNode:\n def __init__(self):\n self.childs = {}\n self.leaf = 0\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode()\n\n def add(self, word):\n p = self.root\n for ch in word:\n if ch not in p.childs:\n p.childs[ch] = TrieNode()\n p = p.childs[ch]\n p.leaf += 1\n\n def search(self, target):\n p = self.root\n for ch in target:\n if ch not in p.childs:\n return 0\n p = p.childs[ch]\n return p.leaf\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n sorted_words = [sorted(list(set(x))) for x in words]\n sorted_puzzles = [sorted(x) for x in puzzles]\n tree = Trie()\n for word in sorted_words:\n tree.add(word)\n res = []\n for i, puzzle in enumerate(sorted_puzzles):\n N = len(puzzle)\n cnt = 0\n for j in range(1, 1 << N):\n target = []\n use = False\n for k in range(N):\n if j & (1 << k):\n if puzzle[k] == puzzles[i][0]:\n use = True\n target.append(puzzle[k])\n\n if use:\n cnt += tree.search(target)\n\n res.append(cnt)\n return res\n","memory":"46100"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n SIZE = 26 # 26 letters in the alphabet\n trie = [[0] * SIZE] # we use list to mimic the trie tree\n count = [0] # the number of words ending at node i\n for word in words:\n word = sorted(set(word))\n if len(word) <= 7: # longer words are never valid\n # insert into trie\n node = 0\n for letter in word:\n i = ord(letter) - ord('a')\n if trie[node][i] == 0: # push empty node\n trie.append([0] * SIZE)\n count.append(0)\n trie[node][i] = len(trie) - 1\n node = trie[node][i]\n count[node] += 1\n\n # search for valid words\n def dfs(node: int, has_first: bool):\n total = count[node] if has_first else 0\n for letter in puzzle: # catch puzzle from outside environment\n i = ord(letter) - ord('a')\n if trie[node][i]:\n total += dfs(trie[node][i], has_first or letter == puzzle[0])\n return total\n\n result = []\n for puzzle in puzzles:\n result.append(dfs(0, False))\n return result\n ","memory":"47700"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n trie = {}\n sorted_words = [sorted(set(w)) for w in words]\n sorted_words = [''.join(w) for w in sorted_words]\n counter = Counter(sorted_words)\n print(counter)\n for w in counter:\n curr = trie\n for c in w:\n if c not in curr: curr[c] = {}\n curr = curr[c]\n if '.' not in curr: curr['.'] = 0\n curr['.'] += counter[w]\n output = [0 for _ in puzzles]\n def rec(s, curr, visited, first):\n total = curr['.'] if first in visited else 0\n for x in s.intersection(set(curr)):\n total += rec(s, curr[x], visited.union({x}), first)\n return total\n cache = {}\n for i, p in enumerate(puzzles):\n output[i] = rec(set(p), trie, set(), p[0])\n return output","memory":"48200"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n trie = {}\n sorted_words = [sorted(set(w)) for w in words]\n sorted_words = [''.join(w) for w in sorted_words]\n counter = Counter(sorted_words)\n for w in counter:\n curr = trie\n for c in w:\n if c not in curr: curr[c] = {}\n curr = curr[c]\n if '.' not in curr: curr['.'] = 0\n curr['.'] += counter[w]\n output = [0 for _ in puzzles]\n def rec(s, curr, visited, first):\n total = curr['.'] if first in visited else 0\n for x in s.intersection(set(curr)):\n total += rec(s, curr[x], visited.union({x}), first)\n return total\n cache = {}\n for i, p in enumerate(puzzles):\n output[i] = rec(set(p), trie, set(), p[0])\n return output","memory":"48200"},{"code":"class Solution:\n def getWordMask(self, word: str) -> int:\n bitmask = 0\n for char in word:\n bitmask |= 1 << ord(char) - ord('a')\n return bitmask\n \n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n maskFreq, res = defaultdict(int), []\n for word in words:\n maskFreq[self.getWordMask(word)] += 1\n for puzzle in puzzles:\n mask = self.getWordMask(puzzle)\n submask, first, curr = mask, 1 << ord(puzzle[0]) - ord('a'), 0\n while submask:\n if submask & first:\n curr += maskFreq[submask]\n submask = (submask - 1) & mask\n res.append(curr)\n return res","memory":"54400"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puz: List[str]) -> List[int]:\n def bitMask(word):\n mask = 0\n for c in word:\n i = ord(c) - ord('a')\n mask |= 1<<i\n return mask\n wmask = defaultdict(int)\n for w in words:\n wmask[bitMask(w)] += 1\n \n res = [0] * len(puz)\n # runs len(puz) times\n for i in range(len(puz)):\n pmask = Mmask = bitMask(puz[i])\n I = ord(puz[i][0]) - ord('a')\n\n # runs 1<<(len(set(puz[i]))) times\n while pmask:\n if (pmask>>I) & 1:\n res[i] += wmask[pmask]\n pmask = (pmask-1) & Mmask\n \n return res\n\n\n ","memory":"54600"},{"code":"from collections import defaultdict\n\nclass Solution:\n def findNumOfValidWords(self, words, puzzles):\n # Convert words and puzzles to bitmasks\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\n \n # Count the frequency of each bitmask in the words list\n bitmask_freq = defaultdict(int)\n for bitmask in word_bitmasks:\n bitmask_freq[bitmask] += 1\n \n # Initialize the result list\n result = []\n \n # For each puzzle, count the number of valid words\n for puzzle_bitmask, first_letter_bit in zip(puzzle_bitmasks, [1 << (ord(puzzle[0]) - ord('a')) for puzzle in puzzles]):\n count = 0\n \n # Generate all subsets of the puzzle bitmask including the first letter\n subset = puzzle_bitmask\n while subset:\n if subset & first_letter_bit:\n count += bitmask_freq[subset]\n subset = (subset - 1) & puzzle_bitmask\n \n result.append(count)\n \n return result\n \n def word_to_bitmask(self, word):\n bitmask = 0\n for char in word:\n bitmask |= 1 << (ord(char) - ord('a'))\n return bitmask\n\n# Example usage:\nsolution = Solution()\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"]\npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]","memory":"54900"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n # Function to convert a word to its bitmask representation\n def word_to_bitmask(word):\n bitmask = 0\n for char in word:\n bitmask |= (1 << (ord(char) - ord('a')))\n return bitmask\n\n # Create a frequency dictionary for bitmasks of words\n word_count = defaultdict(int)\n for word in words:\n bitmask = word_to_bitmask(word)\n # Add to the dictionary if the word is valid (up to 7 unique characters)\n if bin(bitmask).count('1') <= 7:\n word_count[bitmask] += 1\n\n results = []\n\n # Process each puzzle\n for puzzle in puzzles:\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n puzzle_bitmask = word_to_bitmask(puzzle)\n\n # Generate subsets of puzzle characters excluding the first letter\n subset = puzzle_bitmask\n count = 0\n submask = subset\n\n while submask:\n # Check if the submask includes the first letter\n if submask & first_letter_bit:\n count += word_count[submask]\n \n # Get the next submask\n submask = (submask - 1) & puzzle_bitmask\n\n results.append(count)\n\n return results\n","memory":"55100"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n # Function to convert a word to its bitmask representation\n def word_to_bitmask(word):\n bitmask = 0\n for char in word:\n bitmask |= (1 << (ord(char) - ord('a')))\n return bitmask\n\n # Create a frequency dictionary for bitmasks of words\n word_count = defaultdict(int)\n for word in words:\n bitmask = word_to_bitmask(word)\n # Add to the dictionary if the word is valid (up to 7 unique characters)\n if bin(bitmask).count('1') <= 7:\n word_count[bitmask] += 1\n\n results = []\n\n # Process each puzzle\n for puzzle in puzzles:\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\n puzzle_bitmask = word_to_bitmask(puzzle)\n\n # Generate subsets of puzzle characters excluding the first letter\n subset = puzzle_bitmask\n count = 0\n submask = subset\n\n while submask:\n # Check if the submask includes the first letter\n if submask & first_letter_bit:\n count += word_count[submask]\n \n # Get the next submask\n submask = (submask - 1) & puzzle_bitmask\n\n results.append(count)\n\n return results\n","memory":"55200"},{"code":"class Solution:\n def get_valid_submasks(self, puzzle):\n contains = [False] * 26\n for l in puzzle: contains[ord(l) - 97] = True\n contains = [i for i, c in enumerate(contains) if c]\n cannot_skip = ord(puzzle[0]) - 97\n res = []\n for c in itertools.product(\n *[\n [0, 1 << i] if i != cannot_skip else [1 << i] for i in contains\n ]\n ):\n res.append(sum(c))\n return res\n\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n counter = defaultdict(int)\n for word in words:\n word = set(word)\n if len(word) > 7:\n continue\n counter[sum(1 << i for i in range(26) if chr(i + 97) in word)] += 1\n \n res = [0] * len(puzzles)\n for i, p in enumerate(puzzles):\n res[i] += sum(counter[mask] for mask in self.get_valid_submasks(p))\n return res\n\n \n ","memory":"55200"},{"code":"from collections import defaultdict\nfrom typing import List\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n def bitmask(word):\n mask = 0\n for char in word:\n mask |= (1 << (ord(char) - ord('a')))\n return mask\n \n word_count = defaultdict(int)\n for word in words:\n mask = bitmask(word)\n word_count[mask] += 1\n \n result = []\n for puzzle in puzzles:\n first_char_mask = 1 << (ord(puzzle[0]) - ord('a'))\n puzzle_mask = bitmask(puzzle)\n \n submask = puzzle_mask\n count = 0\n while submask:\n if submask & first_char_mask:\n count += word_count[submask]\n submask = (submask - 1) & puzzle_mask\n \n result.append(count)\n \n return result","memory":"55300"},{"code":"from collections import defaultdict\nfrom typing import List\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n word_count = defaultdict(int)\n \n for word in words:\n mask = 0\n for ch in set(word):\n mask |= (1 << (ord(ch) - ord('a')))\n word_count[mask] += 1\n \n results = []\n \n for puzzle in puzzles:\n first = 1 << (ord(puzzle[0]) - ord('a'))\n count = 0\n mask = 0\n for ch in puzzle:\n mask |= (1 << (ord(ch) - ord('a')))\n \n submask = mask\n while submask:\n if submask & first:\n count += word_count[submask]\n submask = (submask - 1) & mask\n \n results.append(count)\n \n return results","memory":"55400"},{"code":"import numpy as np\n\ndef bitmask(w):\n res = 0\n for c in set(w):\n res += (1<<(ord(c)-ord('a')))\n return res\n\nclass Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n N = len(puzzles)\n pz = np.array([bitmask(p) for p in puzzles], dtype=np.int32)\n p1 = np.array([bitmask(p[:1]) for p in puzzles], dtype=np.int32)\n ans = np.zeros(N, dtype=np.int32)\n for w in words:\n m = bitmask(w)\n l1 = (p1&m).astype(bool)\n l2 = (pz&m)==m\n ans += (l1&l2)\n return [int(x) for x in ans]","memory":"56800"},{"code":"class Solution:\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\n words = [sorted(set(w)) for w in words]\n puzzles = [(p[0], set(p)) for p in puzzles]\n trees = [Trie() for _ in range(26)]\n for w in words:\n for char in w:\n trees[ord(char) - 97].insert(w)\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\n\nclass Node(object):\n def __init__(self, val):\n self.val = val\n self.children = {}\n self.tail = 0\n \nclass Trie(object):\n def __init__(self):\n self.root = Node(None)\n \n def insert(self, word):\n curr = self.root\n for char in word:\n if char not in curr.children:\n curr.children[char] = Node(char)\n curr = curr.children[char]\n curr.tail += 1\n \n def puzzle_match(self, puzzle):\n def helper(node):\n nonlocal res\n res += node.tail\n for child in node.children:\n if child in puzzle:\n helper(node.children[child])\n res = 0\n helper(self.root)\n return res","memory":"59800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(sorted(list(set(val))))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node: return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n # uniq = []\\n # for word in words:\\n # uniq.append(sorted(list(set(word))))\\n # words = uniq\\n\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"43800\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n d = {}\\n for word in words:\\n mask = 0\\n for c in word:\\n mask |= 1 << (ord(c) - ord('a'))\\n d[mask] = d.get(mask, 0) + 1\\n ans = []\\n for puzzle in puzzles:\\n total = 0\\n mask = 0\\n for i in range(1, 7):\\n mask |= 1 << (ord(puzzle[i]) - ord('a'))\\n subset = mask\\n while subset:\\n s = subset | (1 << (ord(puzzle[0]) - ord('a')))\\n if s in d:\\n total += d[s]\\n subset = (subset - 1) & mask\\n if (1 << (ord(puzzle[0]) - ord('a'))) in d:\\n total += d[1 << (ord(puzzle[0]) - ord('a'))]\\n ans.append(total)\\n return ans\",\n \"memory\": \"44100\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Preprocess words\\n word_bitmasks = Counter()\\n for word in words:\\n mask = 0\\n for char in word:\\n mask |= 1 << (ord(char) - ord('a'))\\n word_bitmasks[mask] += 1\\n \\n # Function to generate all subsets of a set\\n def subsets(arr):\\n for i in range(1 << len(arr)):\\n yield [arr[j] for j in range(len(arr)) if i & (1 << j)]\\n \\n # Count valid words for each puzzle\\n result = []\\n for puzzle in puzzles:\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n other_letters = [1 << (ord(char) - ord('a')) for char in puzzle[1:]]\\n count = 0\\n \\n # Iterate over all subsets of other_letters\\n for subset in subsets(other_letters):\\n mask = first_letter_bit | sum(subset)\\n count += word_bitmasks[mask]\\n \\n result.append(count)\\n \\n return result\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"memory\": \"44200\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import Counter\\n\\nclass Solution:\\n def mask(self, word: str) -> int:\\n \\\"\\\"\\\"Generate a bitmask for a given word.\\\"\\\"\\\"\\n result = 0\\n for ch in word:\\n # Set the bit corresponding to the character in the word\\n result |= 1 << (ord(ch) - ord('a'))\\n return result\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n # Count the frequency of each word's bitmask\\n word_count = Counter(self.mask(word) for word in words)\\n result = []\\n\\n for puzzle in puzzles:\\n # Create a bitmask for the puzzle excluding the first character\\n original_mask = self.mask(puzzle[1:])\\n # Create a bitmask for the first character of the puzzle\\n first = self.mask(puzzle[0])\\n curr_mask = original_mask\\n count = word_count[first] # Start with words that only contain the first letter\\n\\n # Iterate through all submasks of the puzzle's bitmask\\n while curr_mask:\\n # Count words that match the current submask and include the first letter\\n count += word_count[curr_mask | first]\\n # Generate the next submask\\n curr_mask = (curr_mask - 1) & original_mask\\n\\n result.append(count)\\n\\n return result\",\n \"memory\": \"44300\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert word to bitmask\\n def word_to_bitmask(word):\\n mask = 0\\n for char in word:\\n mask |= 1 << (ord(char) - ord('a'))\\n return mask\\n\\n # Count bitmasks of words\\n word_bitmasks = Counter(word_to_bitmask(word) for word in words)\\n\\n # Function to count valid words for a puzzle\\n def count_valid_words(puzzle):\\n # Convert puzzle to bitmask\\n puzzle_mask = word_to_bitmask(puzzle)\\n first_letter_mask = 1 << (ord(puzzle[0]) - ord('a'))\\n \\n # Generate all subsets of puzzle_mask that include the first letter\\n subset_mask = puzzle_mask\\n valid_count = 0\\n while subset_mask:\\n if subset_mask & first_letter_mask:\\n valid_count += word_bitmasks[subset_mask]\\n subset_mask = (subset_mask - 1) & puzzle_mask\\n \\n return valid_count\\n\\n # Count valid words for each puzzle\\n return [count_valid_words(puzzle) for puzzle in puzzles]\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"memory\": \"44300\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n\\n # Helper function to create a bitmask from a word, where each bit in the integer represents\\n # the presence of a unique character in the word.\\n def bitmask(word: str) -> int:\\n mask = 0\\n # Iterate through each letter in the word and set the corresponding bit in the mask.\\n for letter in word:\\n mask |= 1 << (ord(letter) - ord('a')) # 'a' corresponds to the first bit, 'b' to the second, etc.\\n return mask\\n\\n # Create a bitmask for each word and count how many times each unique bitmask appears using a Counter.\\n # This gives us a dictionary where the key is the bitmask of the word, and the value is the frequency of that bitmask.\\n word_count = Counter(bitmask(word) for word in words)\\n\\n # Initialize an empty list to store the result for each puzzle.\\n result = []\\n \\n # Iterate through each puzzle.\\n for puzzle in puzzles:\\n # Create a bitmask for the first letter of the puzzle, since this letter must always be present in valid words.\\n first = 1 << (ord(puzzle[0]) - ord('a')) # Create bitmask for the first character only\\n count = word_count[first] # Initialize count with the number of words that consist only of the first letter\\n\\n # Create a bitmask for the remaining characters in the puzzle (excluding the first character).\\n # The first character is handled separately, so the rest of the puzzle is processed here.\\n mask = bitmask(puzzle[1:]) # Create a bitmask for the characters in puzzle[1:]\\n \\n # Iterate over every possible subset of the puzzle's characters (ignoring the first character for now).\\n submask = mask\\n while submask:\\n # Add the first character to the submask and check if this combination matches any word bitmask.\\n # Use the OR operation to combine the submask with the first character.\\n count += word_count[submask | first] # Check if this submask (with the first character) exists in word_count\\n \\n # Generate the next submask by removing one bit from the current submask.\\n # This way, we explore all subsets of the puzzle's characters.\\n submask = (submask - 1) & mask\\n\\n # Append the total count for this puzzle to the result list.\\n result.append(count)\\n\\n # Return the list of results, where each entry corresponds to the number of valid words for each puzzle.\\n return result\\n\",\n \"memory\": \"44400\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n '''\\n word:\\n all letters of word are in puzzle\\n first letter of puzzle is in word\\n\\n We need to (mainly) store two things for each puzzle\\n\\n first letter of word is in puzzle \\n\\n so we can index puzzles by first letter\\n\\n each word is <= 50\\n\\n each puzzle is <= 7 (very short)\\n\\n multiple of the same character in word can map to one character in puzzle\\n\\n\\n bitmask?\\n\\n '''\\n\\n freq = defaultdict(int)\\n\\n for w in words:\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n \\n freq[x] += 1\\n\\n lookup = defaultdict(list)\\n\\n for index, w in enumerate(puzzles):\\n first_letter = 1 << (ord(w[0]) - ord('a'))\\n\\n x = 0\\n for c in w:\\n x |= (1 << (ord(c) - ord('a')))\\n\\n lookup[first_letter].append([index, x, 0])\\n\\n \\n arr = list(freq.items())\\n\\n for x, amount in arr:\\n for i in range(26):\\n if (1 << i) & x:\\n for y in lookup[1 << i]:\\n if (x & y[1]) == x:\\n y[2] += amount\\n\\n \\n ans = [None] * len(puzzles)\\n for key in lookup.keys():\\n for index, _, count in lookup[key]:\\n ans[index] = count\\n\\n return ans\\n\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"memory\": \"44500\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(list(set(val)))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node: return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n # uniq = []\\n # for word in words:\\n # uniq.append(sorted(list(set(word))))\\n # words = uniq\\n\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"44600\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(sorted(list(set(val))))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node:\\n return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"44600\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(list(set(val)))\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node:\\n return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"44700\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n m = len(words)\\n n = len(puzzles)\\n wordBitmasks = [0]*m\\n a = ord('a')\\n for i, word in enumerate(words):\\n for letter in word:\\n wordBitmasks[i] |= (1 << (ord(letter) - a))\\n #wordBitmasks.sort()\\n counts = defaultdict(lambda : 0)\\n for wordBitmask in wordBitmasks:\\n counts[wordBitmask] += 1\\n #print(counts)\\n answer = [0]*n\\n for i, puzzle in enumerate(puzzles):\\n puzzleBitmask = 0\\n for letter in puzzle:\\n puzzleBitmask |= (1 << (ord(letter) - a))\\n firstLetter = (1 << (ord(puzzle[0]) - a))\\n for wordBitmask in counts:\\n if firstLetter | wordBitmask != wordBitmask:\\n continue\\n if wordBitmask | puzzleBitmask != puzzleBitmask:\\n continue\\n answer[i] += counts[wordBitmask]\\n return answer\\n \\n \",\n \"memory\": \"44800\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert word to bitmask\\n def word_to_bitmask(word):\\n mask = 0\\n for char in word:\\n mask |= (1 << (ord(char) - ord('a')))\\n return mask\\n\\n # Check if word is valid for puzzle\\n def is_valid(word_mask, puzzle_mask, first_letter_mask):\\n return (word_mask & first_letter_mask) and (word_mask & puzzle_mask) == word_mask\\n\\n # Convert puzzles to bitmasks\\n puzzle_bitmasks = [word_to_bitmask(puzzle) for puzzle in puzzles]\\n first_letter_bitmasks = [1 << (ord(puzzle[0]) - ord('a')) for puzzle in puzzles]\\n\\n # Count words by their bitmasks\\n word_bitmask_counts = defaultdict(int)\\n for word in words:\\n word_bitmask_counts[word_to_bitmask(word)] += 1\\n\\n # Initialize result array\\n result = [0] * len(puzzles)\\n\\n # Check each puzzle against all words\\n for i, (puzzle_mask, first_letter_mask) in enumerate(zip(puzzle_bitmasks, first_letter_bitmasks)):\\n for word_mask, count in word_bitmask_counts.items():\\n if is_valid(word_mask, puzzle_mask, first_letter_mask):\\n result[i] += count\\n\\n return result\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"memory\": \"44900\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert each word into a bitmask\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n \\n # Count the frequency of each bitmask\\n word_counts = Counter(word_bitmasks)\\n \\n # Initialize the result list\\n result = []\\n \\n # Process each puzzle\\n for puzzle in puzzles:\\n # Convert the puzzle to a bitmask\\n puzzle_bitmask = self.word_to_bitmask(puzzle)\\n first_letter_bitmask = 1 << (ord(puzzle[0]) - ord('a'))\\n \\n # Initialize the count of valid words for this puzzle\\n count = 0\\n \\n # Generate all subsets of the puzzle bitmask\\n subset_bitmask = puzzle_bitmask\\n while subset_bitmask > 0:\\n # Check if the subset contains the first letter of the puzzle\\n if subset_bitmask & first_letter_bitmask:\\n # Add the count of words with this subset bitmask\\n count += word_counts[subset_bitmask]\\n \\n # Generate the next subset by removing the lowest set bit\\n subset_bitmask = (subset_bitmask - 1) & puzzle_bitmask\\n \\n # Append the count to the result list\\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"memory\": \"45100\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert each word into a bitmask\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n \\n # Count the occurrence of each bitmask\\n word_counts = Counter(word_bitmasks)\\n \\n # Initialize the result list\\n result = []\\n \\n # Process each puzzle\\n for puzzle in puzzles:\\n # Convert the puzzle into a bitmask\\n puzzle_bitmask = self.word_to_bitmask(puzzle)\\n first_letter_bitmask = 1 << (ord(puzzle[0]) - ord('a'))\\n \\n # Initialize the submask to the puzzle bitmask\\n submask = puzzle_bitmask\\n valid_count = 0\\n \\n # Iterate over all subsets of the puzzle bitmask\\n while submask > 0:\\n # Check if the subset contains the first letter of the puzzle\\n if submask & first_letter_bitmask:\\n valid_count += word_counts[submask]\\n \\n # Move to the next subset\\n submask = (submask - 1) & puzzle_bitmask\\n \\n # Add the count of valid words for this puzzle to the result\\n result.append(valid_count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for letter in word:\\n bitmask |= 1 << (ord(letter) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"memory\": \"45200\"\n },\n {\n \"code\": \"from collections import Counter\\nfrom functools import reduce\\nimport operator\\n\\nclass Solution:\\n\\n def checkWords(self, words, puzzle: str) -> int:\\n a = ord('a')\\n cnt = 0\\n puzzle_set = 0\\n for ch in puzzle:\\n bit = 1 << (ord(ch) - a)\\n puzzle_set |= bit\\n \\n first_letter_mask = 1 << (ord(puzzle[0]) - a)\\n\\n for word_set, n in words.items():\\n if word_set & ~puzzle_set <= 0 and first_letter_mask & word_set != 0:\\n cnt += n\\n\\n return cnt\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n result = []\\n\\n a = ord('a')\\n\\n word_sets = [reduce(operator.or_, map(lambda ch: 1 << (ord(ch) - a), word)) for word in words]\\n # for word in words:\\n # word_set = 0\\n # for ch in word:\\n # bit = 1 << (ord(ch) - a)\\n # word_set |= bit\\n # # if (bin(word_set).count('1')) <= 7:\\n # # word_sets.append(word_set)\\n # word_sets.append(word_set)\\n cnt = Counter(word_sets)\\n \\n for puzzle in puzzles:\\n result.append(self.checkWords(cnt, puzzle))\\n \\n return result\\n\",\n \"memory\": \"45300\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(val)\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node: return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(sorted(list(set(word))))\\n words = uniq\\n\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"45400\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n wh, res = defaultdict(int), []\\n for w in words:\\n h = ''.join(sorted(set(w)))\\n if len(h) > 7: continue\\n wh[h] += 1\\n for w in puzzles:\\n n, c, sw, rc = len(w)-1, w[0], w[1:], 0\\n for i in range(n+1):\\n for x in combinations(sw, i):\\n w1 = ''.join(sorted(''.join(x)+c))\\n if w1 in wh: rc += wh[w1]\\n res.append(rc)\\n return res\",\n \"memory\": \"45600\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert each word and puzzle into a bitmask\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each bitmask in words\\n word_count = Counter(word_bitmasks)\\n \\n result = []\\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n count = 0\\n \\n # Generate all submasks of puzzle_bitmask\\n submask = puzzle_bitmask\\n while submask:\\n if submask & first_letter_bit:\\n count += word_count[submask]\\n submask = (submask - 1) & puzzle_bitmask\\n \\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"memory\": \"45700\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert words and puzzles to bitmasks\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each word bitmask\\n word_counts = Counter(word_bitmasks)\\n \\n # Initialize the result list\\n result = []\\n \\n # Process each puzzle\\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n count = 0\\n \\n # Generate all submasks of the puzzle bitmask\\n submask = puzzle_bitmask\\n while submask:\\n # Check if the submask contains the first letter of the puzzle\\n if submask & first_letter_bit:\\n count += word_counts[submask]\\n \\n # Move to the next submask\\n submask = (submask - 1) & puzzle_bitmask\\n \\n # Append the count to the result list\\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1, 1, 3, 2, 4, 0]\",\n \"memory\": \"45800\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert each word and puzzle into a bitmask\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each bitmask in the words list\\n word_freq = Counter(word_bitmasks)\\n \\n # Initialize the result list\\n result = []\\n \\n for puzzle, puzzle_bitmask in zip(puzzles, puzzle_bitmasks):\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n subset_count = 0\\n \\n # Generate all subsets of the puzzle bitmask that include the first letter\\n subset = puzzle_bitmask\\n while subset:\\n if subset & first_letter_bit:\\n subset_count += word_freq[subset]\\n subset = (subset - 1) & puzzle_bitmask\\n \\n # Add the count to the result list\\n result.append(subset_count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"memory\": \"45800\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n return sol3(words, puzzles)\\n\\ndef sol1(words, puzzles):\\n def is_good(puzzle, word):\\n if puzzle[0] not in word:\\n return False\\n for ch in word:\\n if ch not in puzzle:\\n return False\\n return True\\n\\n ans = []\\n for puzzle in puzzles:\\n cnt = 0\\n for word in words:\\n if is_good(puzzle, word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\ndef sol2(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(set(word))\\n words = uniq\\n\\n uniq = []\\n for puzzle in puzzles:\\n uniq.append(set(puzzle))\\n\\n def is_good(idx, word):\\n if puzzles[i][0] not in word:\\n return False\\n for ch in word:\\n if ch not in uniq[i]:\\n return False\\n return True\\n\\n ans = []\\n for i in range(len(puzzles)):\\n cnt = 0\\n for word in words:\\n if is_good(puzzles[i], word):\\n cnt += 1\\n ans.append(cnt)\\n return ans\\n\\nclass Node:\\n def __init__(self):\\n self.kids = defaultdict(Node)\\n self.is_terminal = False\\n self.cnt = 0\\n self.chars = set()\\n\\nclass Trie:\\n def __init__(self, vals):\\n self.root = Node()\\n for val in vals:\\n self.append(val)\\n\\n def append(self, word):\\n node = self.root\\n for ch in word:\\n if not node.kids[ch]:\\n node.kids[ch] = Node()\\n node = node.kids[ch]\\n node.is_terminal = True\\n node.cnt += 1\\n node.chars = set(word)\\n\\n def search(self, word, node):\\n if not node: return 0\\n ans = 0\\n for ch in word:\\n if ch in node.kids:\\n ans += self.search(word, node.kids[ch])\\n if node.is_terminal and word[0] in node.chars:\\n return ans + node.cnt\\n return ans\\n\\ndef sol3(words, puzzles):\\n uniq = []\\n for word in words:\\n uniq.append(sorted(list(set(word))))\\n words = sorted(uniq)\\n\\n trie = Trie(words)\\n\\n ans = []\\n for puzzle in puzzles:\\n ans.append(trie.search(puzzle, trie.root))\\n return ans\\n\",\n \"memory\": \"45900\"\n },\n {\n \"code\": \"class TrieNode:\\n def __init__(self):\\n self.childs = {}\\n self.leaf = 0\\n\\nclass Trie:\\n def __init__(self):\\n self.root = TrieNode()\\n\\n def add(self, word):\\n p = self.root\\n for ch in word:\\n if ch not in p.childs:\\n p.childs[ch] = TrieNode()\\n p = p.childs[ch]\\n p.leaf += 1\\n\\n def search(self, target):\\n p = self.root\\n for ch in target:\\n if ch not in p.childs:\\n return 0\\n p = p.childs[ch]\\n return p.leaf\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n sorted_words = [sorted(list(set(x))) for x in words]\\n sorted_puzzles = [sorted(x) for x in puzzles]\\n tree = Trie()\\n for word in sorted_words:\\n tree.add(word)\\n res = []\\n for i, puzzle in enumerate(sorted_puzzles):\\n N = len(puzzle)\\n cnt = 0\\n for j in range(1, 1 << N):\\n target = []\\n use = False\\n for k in range(N):\\n if j & (1 << k):\\n if puzzle[k] == puzzles[i][0]:\\n use = True\\n target.append(puzzle[k])\\n\\n if use:\\n cnt += tree.search(target)\\n\\n res.append(cnt)\\n return res\",\n \"memory\": \"46000\"\n },\n {\n \"code\": \"class TrieNode:\\n def __init__(self):\\n self.childs = {}\\n self.leaf = 0\\n\\nclass Trie:\\n def __init__(self):\\n self.root = TrieNode()\\n\\n def add(self, word):\\n p = self.root\\n for ch in word:\\n if ch not in p.childs:\\n p.childs[ch] = TrieNode()\\n p = p.childs[ch]\\n p.leaf += 1\\n\\n def search(self, target):\\n p = self.root\\n for ch in target:\\n if ch not in p.childs:\\n return 0\\n p = p.childs[ch]\\n return p.leaf\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n sorted_words = [sorted(list(set(x))) for x in words]\\n sorted_puzzles = [sorted(x) for x in puzzles]\\n tree = Trie()\\n for word in sorted_words:\\n tree.add(word)\\n res = []\\n for i, puzzle in enumerate(sorted_puzzles):\\n N = len(puzzle)\\n cnt = 0\\n for j in range(1, 1 << N):\\n target = []\\n use = False\\n for k in range(N):\\n if j & (1 << k):\\n if puzzle[k] == puzzles[i][0]:\\n use = True\\n target.append(puzzle[k])\\n\\n if use:\\n cnt += tree.search(target)\\n\\n res.append(cnt)\\n return res\\n\",\n \"memory\": \"46100\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n SIZE = 26 # 26 letters in the alphabet\\n trie = [[0] * SIZE] # we use list to mimic the trie tree\\n count = [0] # the number of words ending at node i\\n for word in words:\\n word = sorted(set(word))\\n if len(word) <= 7: # longer words are never valid\\n # insert into trie\\n node = 0\\n for letter in word:\\n i = ord(letter) - ord('a')\\n if trie[node][i] == 0: # push empty node\\n trie.append([0] * SIZE)\\n count.append(0)\\n trie[node][i] = len(trie) - 1\\n node = trie[node][i]\\n count[node] += 1\\n\\n # search for valid words\\n def dfs(node: int, has_first: bool):\\n total = count[node] if has_first else 0\\n for letter in puzzle: # catch puzzle from outside environment\\n i = ord(letter) - ord('a')\\n if trie[node][i]:\\n total += dfs(trie[node][i], has_first or letter == puzzle[0])\\n return total\\n\\n result = []\\n for puzzle in puzzles:\\n result.append(dfs(0, False))\\n return result\\n \",\n \"memory\": \"47700\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n trie = {}\\n sorted_words = [sorted(set(w)) for w in words]\\n sorted_words = [''.join(w) for w in sorted_words]\\n counter = Counter(sorted_words)\\n print(counter)\\n for w in counter:\\n curr = trie\\n for c in w:\\n if c not in curr: curr[c] = {}\\n curr = curr[c]\\n if '.' not in curr: curr['.'] = 0\\n curr['.'] += counter[w]\\n output = [0 for _ in puzzles]\\n def rec(s, curr, visited, first):\\n total = curr['.'] if first in visited else 0\\n for x in s.intersection(set(curr)):\\n total += rec(s, curr[x], visited.union({x}), first)\\n return total\\n cache = {}\\n for i, p in enumerate(puzzles):\\n output[i] = rec(set(p), trie, set(), p[0])\\n return output\",\n \"memory\": \"48200\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n trie = {}\\n sorted_words = [sorted(set(w)) for w in words]\\n sorted_words = [''.join(w) for w in sorted_words]\\n counter = Counter(sorted_words)\\n for w in counter:\\n curr = trie\\n for c in w:\\n if c not in curr: curr[c] = {}\\n curr = curr[c]\\n if '.' not in curr: curr['.'] = 0\\n curr['.'] += counter[w]\\n output = [0 for _ in puzzles]\\n def rec(s, curr, visited, first):\\n total = curr['.'] if first in visited else 0\\n for x in s.intersection(set(curr)):\\n total += rec(s, curr[x], visited.union({x}), first)\\n return total\\n cache = {}\\n for i, p in enumerate(puzzles):\\n output[i] = rec(set(p), trie, set(), p[0])\\n return output\",\n \"memory\": \"48200\"\n },\n {\n \"code\": \"class Solution:\\n def getWordMask(self, word: str) -> int:\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << ord(char) - ord('a')\\n return bitmask\\n \\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n maskFreq, res = defaultdict(int), []\\n for word in words:\\n maskFreq[self.getWordMask(word)] += 1\\n for puzzle in puzzles:\\n mask = self.getWordMask(puzzle)\\n submask, first, curr = mask, 1 << ord(puzzle[0]) - ord('a'), 0\\n while submask:\\n if submask & first:\\n curr += maskFreq[submask]\\n submask = (submask - 1) & mask\\n res.append(curr)\\n return res\",\n \"memory\": \"54400\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puz: List[str]) -> List[int]:\\n def bitMask(word):\\n mask = 0\\n for c in word:\\n i = ord(c) - ord('a')\\n mask |= 1<<i\\n return mask\\n wmask = defaultdict(int)\\n for w in words:\\n wmask[bitMask(w)] += 1\\n \\n res = [0] * len(puz)\\n # runs len(puz) times\\n for i in range(len(puz)):\\n pmask = Mmask = bitMask(puz[i])\\n I = ord(puz[i][0]) - ord('a')\\n\\n # runs 1<<(len(set(puz[i]))) times\\n while pmask:\\n if (pmask>>I) & 1:\\n res[i] += wmask[pmask]\\n pmask = (pmask-1) & Mmask\\n \\n return res\\n\\n\\n \",\n \"memory\": \"54600\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def findNumOfValidWords(self, words, puzzles):\\n # Convert words and puzzles to bitmasks\\n word_bitmasks = [self.word_to_bitmask(word) for word in words]\\n puzzle_bitmasks = [self.word_to_bitmask(puzzle) for puzzle in puzzles]\\n \\n # Count the frequency of each bitmask in the words list\\n bitmask_freq = defaultdict(int)\\n for bitmask in word_bitmasks:\\n bitmask_freq[bitmask] += 1\\n \\n # Initialize the result list\\n result = []\\n \\n # For each puzzle, count the number of valid words\\n for puzzle_bitmask, first_letter_bit in zip(puzzle_bitmasks, [1 << (ord(puzzle[0]) - ord('a')) for puzzle in puzzles]):\\n count = 0\\n \\n # Generate all subsets of the puzzle bitmask including the first letter\\n subset = puzzle_bitmask\\n while subset:\\n if subset & first_letter_bit:\\n count += bitmask_freq[subset]\\n subset = (subset - 1) & puzzle_bitmask\\n \\n result.append(count)\\n \\n return result\\n \\n def word_to_bitmask(self, word):\\n bitmask = 0\\n for char in word:\\n bitmask |= 1 << (ord(char) - ord('a'))\\n return bitmask\\n\\n# Example usage:\\nsolution = Solution()\\nwords = [\\\"aaaa\\\",\\\"asas\\\",\\\"able\\\",\\\"ability\\\",\\\"actt\\\",\\\"actor\\\",\\\"access\\\"]\\npuzzles = [\\\"aboveyz\\\",\\\"abrodyz\\\",\\\"abslute\\\",\\\"absoryz\\\",\\\"actresz\\\",\\\"gaswxyz\\\"]\\nprint(solution.findNumOfValidWords(words, puzzles)) # Output: [1,1,3,2,4,0]\",\n \"memory\": \"54900\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n # Function to convert a word to its bitmask representation\\n def word_to_bitmask(word):\\n bitmask = 0\\n for char in word:\\n bitmask |= (1 << (ord(char) - ord('a')))\\n return bitmask\\n\\n # Create a frequency dictionary for bitmasks of words\\n word_count = defaultdict(int)\\n for word in words:\\n bitmask = word_to_bitmask(word)\\n # Add to the dictionary if the word is valid (up to 7 unique characters)\\n if bin(bitmask).count('1') <= 7:\\n word_count[bitmask] += 1\\n\\n results = []\\n\\n # Process each puzzle\\n for puzzle in puzzles:\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n puzzle_bitmask = word_to_bitmask(puzzle)\\n\\n # Generate subsets of puzzle characters excluding the first letter\\n subset = puzzle_bitmask\\n count = 0\\n submask = subset\\n\\n while submask:\\n # Check if the submask includes the first letter\\n if submask & first_letter_bit:\\n count += word_count[submask]\\n \\n # Get the next submask\\n submask = (submask - 1) & puzzle_bitmask\\n\\n results.append(count)\\n\\n return results\\n\",\n \"memory\": \"55100\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n # Function to convert a word to its bitmask representation\\n def word_to_bitmask(word):\\n bitmask = 0\\n for char in word:\\n bitmask |= (1 << (ord(char) - ord('a')))\\n return bitmask\\n\\n # Create a frequency dictionary for bitmasks of words\\n word_count = defaultdict(int)\\n for word in words:\\n bitmask = word_to_bitmask(word)\\n # Add to the dictionary if the word is valid (up to 7 unique characters)\\n if bin(bitmask).count('1') <= 7:\\n word_count[bitmask] += 1\\n\\n results = []\\n\\n # Process each puzzle\\n for puzzle in puzzles:\\n first_letter_bit = 1 << (ord(puzzle[0]) - ord('a'))\\n puzzle_bitmask = word_to_bitmask(puzzle)\\n\\n # Generate subsets of puzzle characters excluding the first letter\\n subset = puzzle_bitmask\\n count = 0\\n submask = subset\\n\\n while submask:\\n # Check if the submask includes the first letter\\n if submask & first_letter_bit:\\n count += word_count[submask]\\n \\n # Get the next submask\\n submask = (submask - 1) & puzzle_bitmask\\n\\n results.append(count)\\n\\n return results\\n\",\n \"memory\": \"55200\"\n },\n {\n \"code\": \"class Solution:\\n def get_valid_submasks(self, puzzle):\\n contains = [False] * 26\\n for l in puzzle: contains[ord(l) - 97] = True\\n contains = [i for i, c in enumerate(contains) if c]\\n cannot_skip = ord(puzzle[0]) - 97\\n res = []\\n for c in itertools.product(\\n *[\\n [0, 1 << i] if i != cannot_skip else [1 << i] for i in contains\\n ]\\n ):\\n res.append(sum(c))\\n return res\\n\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n counter = defaultdict(int)\\n for word in words:\\n word = set(word)\\n if len(word) > 7:\\n continue\\n counter[sum(1 << i for i in range(26) if chr(i + 97) in word)] += 1\\n \\n res = [0] * len(puzzles)\\n for i, p in enumerate(puzzles):\\n res[i] += sum(counter[mask] for mask in self.get_valid_submasks(p))\\n return res\\n\\n \\n \",\n \"memory\": \"55200\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom typing import List\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n def bitmask(word):\\n mask = 0\\n for char in word:\\n mask |= (1 << (ord(char) - ord('a')))\\n return mask\\n \\n word_count = defaultdict(int)\\n for word in words:\\n mask = bitmask(word)\\n word_count[mask] += 1\\n \\n result = []\\n for puzzle in puzzles:\\n first_char_mask = 1 << (ord(puzzle[0]) - ord('a'))\\n puzzle_mask = bitmask(puzzle)\\n \\n submask = puzzle_mask\\n count = 0\\n while submask:\\n if submask & first_char_mask:\\n count += word_count[submask]\\n submask = (submask - 1) & puzzle_mask\\n \\n result.append(count)\\n \\n return result\",\n \"memory\": \"55300\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom typing import List\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n word_count = defaultdict(int)\\n \\n for word in words:\\n mask = 0\\n for ch in set(word):\\n mask |= (1 << (ord(ch) - ord('a')))\\n word_count[mask] += 1\\n \\n results = []\\n \\n for puzzle in puzzles:\\n first = 1 << (ord(puzzle[0]) - ord('a'))\\n count = 0\\n mask = 0\\n for ch in puzzle:\\n mask |= (1 << (ord(ch) - ord('a')))\\n \\n submask = mask\\n while submask:\\n if submask & first:\\n count += word_count[submask]\\n submask = (submask - 1) & mask\\n \\n results.append(count)\\n \\n return results\",\n \"memory\": \"55400\"\n },\n {\n \"code\": \"import numpy as np\\n\\ndef bitmask(w):\\n res = 0\\n for c in set(w):\\n res += (1<<(ord(c)-ord('a')))\\n return res\\n\\nclass Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n N = len(puzzles)\\n pz = np.array([bitmask(p) for p in puzzles], dtype=np.int32)\\n p1 = np.array([bitmask(p[:1]) for p in puzzles], dtype=np.int32)\\n ans = np.zeros(N, dtype=np.int32)\\n for w in words:\\n m = bitmask(w)\\n l1 = (p1&m).astype(bool)\\n l2 = (pz&m)==m\\n ans += (l1&l2)\\n return [int(x) for x in ans]\",\n \"memory\": \"56800\"\n },\n {\n \"code\": \"class Solution:\\n def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:\\n words = [sorted(set(w)) for w in words]\\n puzzles = [(p[0], set(p)) for p in puzzles]\\n trees = [Trie() for _ in range(26)]\\n for w in words:\\n for char in w:\\n trees[ord(char) - 97].insert(w)\\n return [trees[ord(f) - 97].puzzle_match(p) for f,p in puzzles]\\n\\nclass Node(object):\\n def __init__(self, val):\\n self.val = val\\n self.children = {}\\n self.tail = 0\\n \\nclass Trie(object):\\n def __init__(self):\\n self.root = Node(None)\\n \\n def insert(self, word):\\n curr = self.root\\n for char in word:\\n if char not in curr.children:\\n curr.children[char] = Node(char)\\n curr = curr.children[char]\\n curr.tail += 1\\n \\n def puzzle_match(self, puzzle):\\n def helper(node):\\n nonlocal res\\n res += node.tail\\n for child in node.children:\\n if child in puzzle:\\n helper(node.children[child])\\n res = 0\\n helper(self.root)\\n return res\",\n \"memory\": \"59800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":36,"string":"36"}}},{"rowIdx":2445,"cells":{"question_id":{"kind":"number","value":3434,"string":"3,434"},"name":{"kind":"string","value":"find-the-number-of-distinct-colors-among-the-balls"},"content":{"kind":"string","value":"<p>You are given an integer <code>limit</code> and a 2D array <code>queries</code> of size <code>n x 2</code>.</p>\n\n<p>There are <code>limit + 1</code> balls with <strong>distinct</strong> labels in the range <code>[0, limit]</code>. Initially, all balls are uncolored. For every query in <code>queries</code> that is of the form <code>[x, y]</code>, you mark ball <code>x</code> with the color <code>y</code>. After each query, you need to find the number of <strong>distinct</strong> colors among the balls.</p>\n\n<p>Return an array <code>result</code> of length <code>n</code>, where <code>result[i]</code> denotes the number of distinct colors <em>after</em> <code>i<sup>th</sup></code> query.</p>\n\n<p><strong>Note</strong> that when answering a query, lack of a color <em>will not</em> be considered as a color.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">limit = 4, queries = [[1,4],[2,5],[1,3],[3,4]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1,2,2,3]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/17/ezgifcom-crop.gif\" style=\"width: 455px; height: 145px;\" /></p>\n\n<ul>\n\t<li>After query 0, ball 1 has color 4.</li>\n\t<li>After query 1, ball 1 has color 4, and ball 2 has color 5.</li>\n\t<li>After query 2, ball 1 has color 3, and ball 2 has color 5.</li>\n\t<li>After query 3, ball 1 has color 3, ball 2 has color 5, and ball 3 has color 4.</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">limit = 4, queries = [[0,1],[1,2],[2,2],[3,4],[4,5]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[1,2,2,3,4]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><strong><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/17/ezgifcom-crop2.gif\" style=\"width: 457px; height: 144px;\" /></strong></p>\n\n<ul>\n\t<li>After query 0, ball 0 has color 1.</li>\n\t<li>After query 1, ball 0 has color 1, and ball 1 has color 2.</li>\n\t<li>After query 2, ball 0 has color 1, and balls 1 and 2 have color 2.</li>\n\t<li>After query 3, ball 0 has color 1, balls 1 and 2 have color 2, and ball 3 has color 4.</li>\n\t<li>After query 4, ball 0 has color 1, balls 1 and 2 have color 2, ball 3 has color 4, and ball 4 has color 5.</li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= limit <= 10<sup>9</sup></code></li>\n\t<li><code>1 <= n == queries.length <= 10<sup>5</sup></code></li>\n\t<li><code>queries[i].length == 2</code></li>\n\t<li><code>0 <= queries[i][0] <= limit</code></li>\n\t<li><code>1 <= queries[i][1] <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":41.242734427241395,"string":"41.242734"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table","simulation"],"string":"[\n \"array\",\n \"hash-table\",\n \"simulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1109\", 0.939], [\"1111\", 0.4695], [\"1113\", 0.939], [\"1115\", 0.4695], [\"1117\", 1.4085], [\"1119\", 1.8779], [\"1121\", 1.4085], [\"1122\", 1.4085], [\"1124\", 0.4695], [\"1126\", 0.939], [\"1128\", 0.4695], [\"1130\", 1.8779], [\"1132\", 0.939], [\"1133\", 2.3474], [\"1135\", 3.2864], [\"1137\", 0.939], [\"1139\", 1.4085], [\"1141\", 1.4085], [\"1143\", 0.4695], [\"1145\", 1.4085], [\"1146\", 2.8169], [\"1148\", 1.4085], [\"1150\", 1.8779], [\"1152\", 3.2864], [\"1154\", 1.4085], [\"1156\", 1.4085], [\"1158\", 0.4695], [\"1159\", 0.4695], [\"1161\", 2.3474], [\"1163\", 0.4695], [\"1165\", 1.4085], [\"1167\", 0.4695], [\"1169\", 2.3474], [\"1170\", 0.939], [\"1172\", 1.4085], [\"1174\", 1.8779], [\"1176\", 1.4085], [\"1178\", 0.4695], [\"1180\", 1.8779], [\"1182\", 0.4695], [\"1183\", 1.8779], [\"1185\", 1.8779], [\"1187\", 1.4085], [\"1189\", 0.939], [\"1191\", 3.2864], [\"1193\", 0.4695], [\"1195\", 0.939], [\"1196\", 1.878], [\"1198\", 1.8780000000000001], [\"1200\", 1.4085], [\"1202\", 1.8780000000000001], [\"1204\", 2.3474], [\"1206\", 1.4084999999999999], [\"1207\", 0.939], [\"1209\", 1.4084999999999999], [\"1211\", 1.4085], [\"1213\", 1.8780000000000001], [\"1215\", 1.8780000000000001], [\"1217\", 1.4084999999999999], [\"1219\", 0.939], [\"1220\", 0.939], [\"1222\", 0.939], [\"1224\", 0.939], [\"1226\", 0.939], [\"1228\", 1.4085], [\"1230\", 0.939], [\"1232\", 0.4695], [\"1233\", 0.4695], [\"1235\", 0.4695], [\"1237\", 0.939], [\"1239\", 0.4695], [\"1241\", 0.939]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"67100\", 0.4695], [\"67800\", 0.4695], [\"68200\", 2.3474], [\"68300\", 15.0235], [\"68400\", 30.0469], [\"68500\", 15.9624], [\"68600\", 10.3286], [\"68700\", 3.2864], [\"68800\", 0.4695], [\"69000\", 0.4695], [\"69100\", 0.939], [\"69200\", 1.4085], [\"69300\", 0.939], [\"69800\", 1.4085], [\"70400\", 0.4695], [\"71600\", 0.4695], [\"81300\", 0.4695], [\"81900\", 0.4695], [\"82000\", 2.8169], [\"82100\", 1.8779], [\"82200\", 3.2864]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = {}\n ht={}\n count = 0\n ans=[]\n for qr in queries:\n [x,y]=qr\n if(colors.get(x) is None):\n \n colors[x]=y\n if(ht.get(y) is None or ht[y]==0):\n ht[y]=0\n count+=1\n \n else:\n ht[colors[x]]-=1\n if(ht[colors[x]]==0):\n count-=1\n colors[x]=y\n if(ht.get(y) is None or ht[y]==0):\n ht[y]=0\n count+=1\n ht[y]+=1\n ans.append(count)\n # print(ht,colors)\n return ans\n \n \n","runtime":"1109"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n ball2color = {}\n color2cnt = {}\n for ball, color in queries:\n if ball in ball2color:\n old_color = ball2color[ball]\n color2cnt[old_color] -= 1\n if color2cnt[old_color] == 0:\n del color2cnt[old_color]\n ball2color[ball] = color\n if color not in color2cnt:\n color2cnt[color] = 0\n color2cnt[color] += 1\n res.append(len(color2cnt))\n return res\n","runtime":"1109"},{"code":"\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_counts = {}\n colors = {}\n\n result = []\n for index, color in queries:\n old = colors.get(index)\n colors[index] = color\n if old == color:\n result.append(len(color_counts))\n else:\n color_counts[color] = color_counts.get(color, 0) + 1\n if old is not None:\n color_counts[old] -= 1\n if color_counts[old] == 0:\n color_counts.pop(old)\n result.append(len(color_counts))\n return result","runtime":"1111"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color = {}\n color_count = {}\n output = []\n for x, y in queries:\n if color.get(x, 0) != 0:\n color_count[color[x]] -= 1\n if color_count[color[x]] == 0:\n del color_count[color[x]]\n color[x] = y\n color_count[y] = color_count.get(y, 0) + 1\n output.append(len(color_count))\n return output","runtime":"1113"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = dict()\n d = dict()\n res = []\n for a,b in queries:\n if a not in colors:\n colors[a] = b\n if b in d:\n d[b] += 1\n else:\n d[b] = 1\n else:\n d[colors[a]] -= 1\n if d[colors[a]] == 0:\n del d[colors[a]]\n colors[a] = b\n if b in d:\n d[b] += 1\n else:\n d[b] = 1\n res.append(len(d))\n return res\n\n \n\n ","runtime":"1115"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1117"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_count = {}\n ball_color = {}\n result = []\n for ball, color in queries:\n if ball in ball_color:\n color_count[ball_color[ball]] -= 1\n if not color_count[ball_color[ball]]:\n del color_count[ball_color[ball]]\n ball_color[ball] = color\n if color in color_count:\n color_count[color] += 1\n else:\n color_count[color] = 1\n result.append(len(color_count))\n return result","runtime":"1119"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = dict()\n balls = dict()\n o = []\n for b, c in queries:\n #print(b,c,colors, balls)\n if not b in balls:\n balls[b] = c \n if c not in colors:\n colors[c] = 1\n else:\n colors[c]+=1\n else:\n ci = balls[b] # couleur ini\n balls[b] = c\n colors[ci] -= 1\n if c in colors:\n colors[c] += 1\n else:\n colors[c] = 1\n if colors[ci] == 0:\n del colors[ci]\n o.append(len(colors))\n return o\n ","runtime":"1121"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n answer = []\n\n balls_colors = {}\n colors_occurences = {}\n\n for query in queries:\n if query[0] in balls_colors:\n color = balls_colors[query[0]]\n\n colors_occurences[color] -= 1\n if colors_occurences[color] == 0:\n colors_occurences.pop(color)\n \n if query[1] not in colors_occurences:\n colors_occurences[query[1]] = 1\n else:\n colors_occurences[query[1]] += 1\n \n balls_colors[query[0]] = query[1]\n else:\n balls_colors[query[0]] = query[1]\n\n if query[1] not in colors_occurences:\n colors_occurences[query[1]] = 1\n else:\n colors_occurences[query[1]] += 1\n\n answer.append(len(colors_occurences))\n \n return answer\n","runtime":"1122"},{"code":"class Solution:\n\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_ball = {}\n eff_color = {}\n nbr_colors = 0\n ans = []\n for b, c in queries:\n if b in color_ball:\n eff_color[color_ball[b]] -= 1\n if eff_color[color_ball[b]] == 0:\n nbr_colors -= 1\n color_ball[b] = c\n eff_color[c] = eff_color.get(c, 0) + 1\n if eff_color[c] == 1:\n nbr_colors += 1\n ans.append(nbr_colors)\n return ans","runtime":"1124"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n # Initialize a dictionary to store colors for each ball\n ball_colors = {}\n\n # Initialize a dictionary to store the count of each color\n color_counts = {}\n\n # Initialize an array to store the result\n result = []\n\n # Iterate through each query\n for query in queries:\n ball, color = query\n\n # If the ball already has a color, decrease the count of its previous color\n if ball in ball_colors:\n prev_color = ball_colors[ball]\n color_counts[prev_color] -= 1\n if color_counts[prev_color] == 0:\n del color_counts[prev_color]\n\n # Update the color of the ball\n ball_colors[ball] = color\n\n # Increase the count of the current color\n color_counts[color] = color_counts.get(color, 0) + 1\n\n # Update the result with the number of distinct colors\n result.append(len(color_counts))\n\n return result","runtime":"1126"},{"code":"class Solution:\n \n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n d = dict()\n colors = defaultdict(int)\n \n res = []\n\n for ball, color in queries:\n old_color = d.get(ball)\n if color != old_color:\n d[ball] = color\n colors[color] += 1\n\n if colors.get(old_color):\n colors[old_color] -= 1\n if colors.get(old_color) == 0: colors.pop(old_color)\n \n res.append(len(colors))\n \n return res","runtime":"1126"},{"code":"from collections import defaultdict\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n balls = {}\n ans = []\n for ball, color in queries:\n if ball in balls:\n colors[balls[ball]] -= 1\n if colors[balls[ball]] == 0:\n del colors[balls[ball]]\n balls[ball] = color\n colors[color] += 1\n ans.append(len(colors))\n return ans\n ","runtime":"1128"},{"code":"from collections import Counter\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ans = []\n colors = Counter()\n state = dict()\n for i, c in queries:\n old = state.get(i, -1)\n if old >= 0:\n colors[old] -= 1\n if colors[old] == 0:\n colors.pop(old)\n colors[c] += 1\n state[i] = c\n ans.append(len(colors))\n return ans\n","runtime":"1130"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = {}\n balls = {}\n\n ans = []\n for q in queries:\n ball, color = q\n if ball in balls:\n prev_color = balls.get(ball)\n colors[prev_color] -= 1\n\n if colors[prev_color] == 0:\n colors.pop(prev_color)\n\n balls[ball] = color\n colors[color] = colors.get(color, 0) + 1\n else:\n balls[ball] = color\n colors[color] = colors.get(color, 0) + 1\n \n ans.append(len(colors))\n \n return ans\n","runtime":"1132"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1133"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res, balls, colors = [], {}, {}\n for ball, color in queries:\n if ball not in balls or color != balls[ball]:\n colors[color] = colors.get(color, 0) + 1\n if ball in balls:\n colors[balls[ball]] -= int(color != balls[ball])\n if colors[balls[ball]] == 0:\n del colors[balls[ball]]\n balls[ball] = color\n res.append(len(colors))\n return res","runtime":"1135"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_colors = {}\n count = {}\n diff_colors = set()\n solution = []\n\n for ball_num, color in queries:\n if ball_num in ball_colors:\n old_color = ball_colors[ball_num]\n count[old_color] -= 1\n if count[old_color] == 0:\n diff_colors.remove(old_color)\n\n ball_colors[ball_num] = color\n if color in count:\n count[color] += 1\n else:\n count[color] = 1\n diff_colors.add(color)\n \n solution.append(len(diff_colors))\n \n return solution","runtime":"1137"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_colors = {} # To store the color of each ball\n color_count = {} # To store how many balls have a certain color\n distinct_colors = 0 # To track the number of distinct colors\n result = []\n \n for ball, color in queries:\n if ball in ball_colors:\n old_color = ball_colors[ball]\n if old_color == color:\n # No change needed, continue\n result.append(distinct_colors)\n continue\n \n # Decrease the count of the old color\n color_count[old_color] -= 1\n if color_count[old_color] == 0:\n distinct_colors -= 1 # This color is no longer in use\n \n # Assign the new color to the ball\n ball_colors[ball] = color\n \n # Update the count of the new color\n if color not in color_count:\n color_count[color] = 0\n color_count[color] += 1\n if color_count[color] == 1:\n distinct_colors += 1 # This is a new distinct color\n \n # Append the current count of distinct colors\n result.append(distinct_colors)\n \n return result\n\n ","runtime":"1139"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n num={}\n ans=[]\n d={}\n c=0\n for i,j in queries:\n if i in num:\n if d[num[i]]==1: \n c-=1\n d[num[i]]-=1\n \n if j not in d or d[j]==0:\n c+=1\n d[j]=1\n else:\n d[j]+=1\n ans.append(c) \n num[i]=j\n \n return ans ","runtime":"1141"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res\n ","runtime":"1143"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls, colorCounter = dict(), dict()\n result = list()\n for ball, color in queries:\n if ball in balls: \n colorCounter[balls[ball]]-=1\n if colorCounter[balls[ball]] == 0:\n del colorCounter[balls[ball]]\n balls[ball] = color\n if color in colorCounter:\n colorCounter[color] += 1\n else:\n colorCounter[color] = 1\n result.append(len(colorCounter))\n return result\n ","runtime":"1145"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n s = dict()\n colors = defaultdict(int)\n ans = []\n col = 0\n\n for x,y in queries:\n if colors[y] == 0:\n col += 1\n colors[y] += 1\n if x in s:\n colors[s[x]] -= 1\n if colors[s[x]] == 0:\n col -= 1\n s[x] = y\n\n ans.append(col)\n\n return ans","runtime":"1146"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = {}\n ans = [0]\n balls = {}\n\n for ball,color in queries:\n c = 0 if ball not in balls else balls[ball]\n inc = 0\n if c != 0:\n if colors[c] == 1:\n inc -= 1\n colors.pop(c)\n else:\n colors[c] -= 1\n\n\n if color in colors:\n colors[color] += 1\n else:\n colors[color] = 1\n inc += 1\n ans.append(ans[-1]+inc)\n balls[ball] = color\n return ans[1:]\n","runtime":"1148"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n limit += 1\n arr = defaultdict(int)\n d = defaultdict(int)\n ans = []\n\n for x,y in queries:\n prev = arr[x]\n if prev:\n d[prev] -= 1\n if d[prev] == 0:\n del d[prev]\n arr[x] = y\n d[y] += 1\n \n ans.append(len(d))\n return ans","runtime":"1150"},{"code":"from collections import defaultdict\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n num_balls_by_color = defaultdict(int)\n color_by_ball = {}\n ans = []\n for ball, color in queries:\n if ball in color_by_ball:\n old_color = color_by_ball[ball]\n num_balls_by_color[old_color] -= 1\n if num_balls_by_color[old_color] == 0:\n del num_balls_by_color[old_color]\n color_by_ball[ball] = color\n num_balls_by_color[color] += 1\n ans.append(len(num_balls_by_color))\n return ans\n\n \n","runtime":"1152"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n res = []\n memo = dict()\n for x,y in queries:\n if colors[x] == 0:\n colors[x] = y \n if y in memo:\n memo[y] += 1\n else:\n memo[y] = 1\n res.append(len(memo))\n elif colors[x] == y:\n res.append(len(memo))\n else:\n if memo[colors[x]] == 1:\n del memo[colors[x]]\n else:\n memo[colors[x]] -= 1 \n if y in memo:\n memo[y] += 1\n else:\n memo[y] = 1\n colors[x] = y \n res.append(len(memo))\n \n return res\n\n ","runtime":"1154"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_to_color = {}\n color_to_count = defaultdict(int)\n total_colors = 0\n res = []\n for ball, color in queries:\n if ball in ball_to_color:\n color_to_count[ball_to_color[ball]] -= 1\n if color_to_count[ball_to_color[ball]] == 0:\n total_colors -= 1\n\n if color_to_count[color] == 0:\n total_colors += 1\n\n ball_to_color[ball] = color\n color_to_count[color] += 1\n\n res.append(total_colors)\n\n return res","runtime":"1156"},{"code":"class Solution:\n def __init__(self):\n self.d1 = {}\n self.d2 = {}\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n for q in queries:\n idx, col = q[0], q[1]\n\n if idx in self.d1:\n self.d2[self.d1[idx]] -= 1\n if self.d2[self.d1[idx]] == 0:\n del self.d2[self.d1[idx]]\n\n self.d1[idx] = col\n if col in self.d2:\n self.d2[col] += 1\n else:\n self.d2[col] = 1\n\n res.append(len(self.d2))\n\n return res\n\n \n\n\n\n \n\n\n ","runtime":"1158"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors, balls, ans = defaultdict(int), {}, []\n for b, c in queries:\n if b in balls:\n if colors[balls[b]] == 1:\n del colors[balls[b]]\n else:\n colors[balls[b]] -= 1\n balls[b] = c\n colors[c] += 1\n ans.append(len(colors))\n return ans","runtime":"1159"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_counts = {}\n ball_colors = {}\n total = 0\n result = []\n for q in queries:\n i, c = q\n if color_counts.get(c, 0) == 0:\n color_counts[c] = 1\n total += 1\n else:\n color_counts[c] += 1\n if i in ball_colors:\n curr_c = ball_colors[i]\n color_counts[curr_c] -= 1\n if color_counts[curr_c] == 0:\n total -= 1\n \n ball_colors[i] = c\n result.append(total)\n \n return result","runtime":"1161"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ballColors = {}\n colorCounts = {}\n\n results = []\n ans = 0\n\n for ball, color in queries:\n if ball in ballColors:\n prevColor = ballColors[ball]\n ballColors[ball] = color\n if prevColor == color:\n pass\n else:\n colorCounts[prevColor] -= 1\n if color in colorCounts:\n colorCounts[color] += 1\n else:\n colorCounts[color] = 1\n if colorCounts[prevColor] == 0 and colorCounts[color] == 1:\n pass\n elif colorCounts[prevColor] == 0:\n ans -= 1\n elif colorCounts[color] == 1:\n ans += 1\n else:\n ballColors[ball] = color\n if color in colorCounts:\n colorCounts[color] += 1\n else:\n colorCounts[color] = 1\n \n if colorCounts[color] == 1:\n ans += 1\n \n results.append(ans)\n \n return results","runtime":"1163"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n C = defaultdict(int)\n d = {} # pilka i kolor\n n = len(queries)\n cnt = 0\n T = []\n for i in range(n):\n color = queries[i][1]\n ball = queries[i][0]\n if ball not in d:\n d[ball] = color\n if C[color]==0:\n cnt+=1\n C[color]+=1\n else:\n pcol = d[ball]\n d[ball] = color\n C[pcol]-=1\n if C[pcol]==0: cnt-=1\n if C[color]==0: cnt+=1\n C[color]+=1\n T.append(cnt)\n return T","runtime":"1165"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_colors = {}\n colors_count = {}\n c = set()\n res = []\n for x,y in queries:\n if x in ball_colors:\n old = ball_colors[x]\n colors_count[old]-=1\n if colors_count[old]==0:\n c.remove(old)\n \n ball_colors[x]=y\n if y in colors_count:\n colors_count[y]+=1\n else:\n colors_count[y]=1\n c.add(y)\n\n res.append(len(c))\n\n return res","runtime":"1167"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1169"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_colors = {}\n count = {}\n diff_colors = set()\n solution = []\n\n for ball_num, color in queries:\n if ball_num in ball_colors:\n old_color = ball_colors[ball_num]\n count[old_color] -= 1\n if count[old_color] == 0:\n diff_colors.remove(old_color)\n\n ball_colors[ball_num] = color\n if color in count:\n count[color] += 1\n else:\n count[color] = 1\n diff_colors.add(color)\n \n solution.append(len(diff_colors))\n \n return solution","runtime":"1170"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_dict = dict() # need to get old color\n color_dict = defaultdict(int) # need to check how many balls have certain color for subtraction (upon replacement)\n res = []\n count = 0\n for ball, color in queries:\n if ball in ball_dict:\n old_color = ball_dict[ball]\n if color_dict[old_color] == 1:\n count -= 1\n color_dict.pop(old_color)\n else:\n color_dict[old_color] -= 1\n ball_dict[ball] = color\n if color not in color_dict:\n count += 1\n color_dict[color] += 1\n res.append(count)\n return res","runtime":"1172"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_count = {}\n ball_color = {}\n result = []\n for ball, color in queries:\n if ball in ball_color:\n current_color = ball_color[ball]\n color_count[current_color] -= 1\n if not color_count[current_color]:\n del color_count[current_color]\n ball_color[ball] = color\n if color in color_count:\n color_count[color] += 1\n else:\n color_count[color] = 1\n result.append(len(color_count))\n return result","runtime":"1174"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_count = {}\n ball_color = {}\n result = []\n for ball, color in queries:\n if ball in ball_color:\n current_color = ball_color[ball]\n color_count[current_color] -= 1\n if not color_count[current_color]:\n del color_count[current_color]\n ball_color[ball] = color\n if color in color_count:\n color_count[color] += 1\n else:\n color_count[color] = 1\n result.append(len(color_count))\n return result","runtime":"1176"},{"code":"from collections import defaultdict\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n balls = defaultdict(int)\n distinct_colors = []\n \n for ball, color in queries: \n if ball in balls:\n prev_color = balls[ball]\n colors[prev_color] -= 1\n if colors[prev_color] == 0: \n del colors[prev_color]\n balls[ball] = color\n colors[color] += 1\n distinct_colors.append(len(colors))\n \n \n return distinct_colors\n ","runtime":"1178"},{"code":"from collections import defaultdict\nfrom typing import List\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n color_frequency = {}\n\n output = []\n for index, color in queries:\n if colors[index] != 0:\n color_frequency[colors[index]] -= 1\n if color_frequency[colors[index]] == 0:\n del color_frequency[colors[index]]\n\n colors[index] = color\n\n if color not in color_frequency:\n color_frequency[color] = 1\n else:\n color_frequency[color] += 1\n\n output.append(len(color_frequency))\n \n return output\n\n \n \n ","runtime":"1180"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n dct_c = defaultdict(int)\n dct_b = defaultdict(int)\n cnt = 0\n res = [] \n for query in queries:\n b, c = query\n if dct_b[b] in dct_c:\n dct_c[dct_b[b]] -= 1 \n if dct_c[dct_b[b]] == 0:\n cnt -= 1\n dct_b[b] = c\n dct_c[c] += 1\n if dct_c[c] == 1:\n cnt += 1\n res.append(cnt)\n return res\n \n","runtime":"1182"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n myHash = {}\n cnt = defaultdict(int)\n res = []\n\n for x, y in queries:\n cnt[y] += 1\n\n if x in myHash:\n cnt[myHash[x]] -= 1\n if cnt[myHash[x]] == 0:\n cnt.pop(myHash[x])\n \n myHash[x] = y\n \n res.append(len(cnt))\n \n return res\n ","runtime":"1183"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_count = {}\n ball_color = {}\n result = []\n for ball, color in queries:\n if ball in ball_color:\n color_count[ball_color[ball]] -= 1\n if not color_count[ball_color[ball]]:\n del color_count[ball_color[ball]]\n ball_color[ball] = color\n if color in color_count:\n color_count[color] += 1\n else:\n color_count[color] = 1\n result.append(len(color_count))\n return result","runtime":"1185"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n balls = defaultdict(int)\n distinct_colors = 0\n ret = []\n for ball, color in queries:\n if balls[ball] != color:\n if balls[ball]:\n colors[balls[ball]] -= 1\n if colors[balls[ball]] == 0:\n distinct_colors -= 1 \n balls[ball] = color\n if not colors[color]:\n distinct_colors += 1\n colors[color] += 1\n ret.append(distinct_colors)\n return ret","runtime":"1187"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_counter = Counter()\n idx_map_colors = {}\n\n res = []\n for i, color in queries:\n if i in idx_map_colors:\n old_color = idx_map_colors[i]\n if color_counter[old_color] == 1:\n del color_counter[old_color]\n else:\n color_counter[old_color] -= 1\n\n idx_map_colors[i] = color\n color_counter[color] += 1\n\n res.append(len(color_counter))\n\n return res\n","runtime":"1189"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n map = {} # ball : color\n count = defaultdict(int) # color : count\n distinct = 0\n ans = []\n \n for x, y in queries:\n if x in map:\n count[map[x]] -= 1\n if count[map[x]] == 0:\n distinct -= 1\n del count[map[x]]\n \n map[x] = y\n \n if count[y] == 0:\n distinct += 1\n count[y] += 1\n \n ans.append(distinct)\n \n return ans\n \n \n ","runtime":"1191"},{"code":"from collections import defaultdict\nfrom collections import defaultdict\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_color, color_balls = {}, defaultdict(set)\n result = []\n\n for ball,color in queries:\n oldcolor = ball_color.get(ball)\n if oldcolor:\n color_balls[oldcolor].remove(ball)\n if not color_balls[oldcolor]:\n del color_balls[oldcolor]\n ball_color[ball] = color\n color_balls[color].add(ball)\n result.append(len(color_balls))\n return result\n\n def queryResults2(self, limit: int, queries: List[List[int]]) -> List[int]:\n result = []\n ball_color = {}\n dcolors = set()\n\n for ball,color in queries:\n ball_color[ball] = color\n dcolors = len({color for color in ball_color.values()})\n result.append(dcolors)\n return result","runtime":"1191"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n ballLookUp = dict()\n colorLookUp = dict()\n colorLookUp[-1] = 0\n t = 0\n for ball, color in queries:\n if ball not in ballLookUp:\n ballLookUp[ball] = -1\n \n colorLookUp[ballLookUp[ball]] -= 1\n if colorLookUp[ballLookUp[ball]] == 0:\n t -= 1\n ballLookUp[ball] = color\n if color not in colorLookUp:\n colorLookUp[color] = 1\n else:\n colorLookUp[color] += 1\n if colorLookUp[color] == 1:\n t += 1\n res.append(t)\n\n return res","runtime":"1193"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_color = {}\n color_ct = {}\n out = []\n for q in queries:\n if q[0] in ball_color:\n color_ct[ball_color[q[0]]] -= 1\n if color_ct[ball_color[q[0]]] == 0:\n color_ct.pop(ball_color[q[0]])\n ball_color[q[0]] = q[1]\n if ball_color[q[0]] not in color_ct:\n color_ct[ball_color[q[0]]] = 0\n color_ct[ball_color[q[0]]] += 1\n out.append(len(color_ct))\n\n return out","runtime":"1195"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls={}\n color_count={}\n zero=0\n res=[]\n for a,b in queries:\n if a in balls:\n color_count[balls[a]]-=1\n if color_count[balls[a]]==0:\n zero+=1\n balls[a]=b\n if color_count.get(b,-1)==0:\n zero-=1\n color_count[b]=1+color_count.get(b,0)\n res.append(len(color_count)-zero)\n return res\n\n \n \n ","runtime":"1198"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n # limit = 10**9\n # balls = [False] * (limit + 1)\n\n # for q in queries:\n # print(balls)\n # print(q)\n # if not balls[q[0]]:\n # balls[q[0]] = True\n # balls[q[0]] = q[1]\n\n # print(balls)\n # return 3\n\n answer = []\n ball_color = {}\n color_balls = defaultdict(set)\n for (q_ball, q_color) in queries:\n\n \n if q_ball in ball_color:\n old_color = ball_color[q_ball]\n # remove old entry\n color_balls[old_color].remove(q_ball)\n if not color_balls[old_color]:\n del color_balls[old_color]\n\n ball_color[q_ball] = q_color\n color_balls[q_color].add(q_ball)\n answer.append(len(color_balls))\n\n # print(ball_color)\n # print(color_balls)\n # print(answer)\n\n return answer\n ","runtime":"1198"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = dict()\n # unqiueColorCnt = 0\n colorCounters = defaultdict(int)\n \n ans = []\n for q in queries:\n idx, color = q\n if idx in colors:\n oriColor = colors[idx]\n colorCounters[oriColor] -= 1\n if colorCounters[oriColor] == 0: del colorCounters[oriColor]\n \n colors[idx] = color\n colorCounters[color] += 1\n # if color not in colorCounters: colorCounters[color] = 1\n # else: colorCounters[color] += 1\n ans.append(len(colorCounters))\n return ans\n ","runtime":"1200"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls, colors, ans = {}, {}, []\n for ball, color in queries:\n if ball in balls:\n colors[balls[ball]].remove(ball)\n if not colors[balls[ball]]:\n del colors[balls[ball]]\n balls[ball] = color\n if color not in colors:\n colors[color] = set()\n colors[color].add(ball)\n ans.append(len(colors))\n return ans","runtime":"1202"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n value_map = {} # Store only the modified indices and their values\n unique_values = {} # Dictionary to track occurrences of non-zero values\n result = []\n\n for a, b in queries:\n # If the current value at index `a` is already non-zero, adjust its count in unique_values\n if a in value_map and value_map[a] != 0:\n unique_values[value_map[a]] -= 1\n if unique_values[value_map[a]] == 0:\n del unique_values[value_map[a]] # Remove it from the dictionary if count is 0\n\n # Update the value at index `a`\n value_map[a] = b\n\n # If the new value is non-zero, add it to the unique_values set\n if b != 0:\n if b not in unique_values:\n unique_values[b] = 0\n unique_values[b] += 1\n\n # Append the count of unique non-zero values\n result.append(len(unique_values))\n\n return result\n","runtime":"1202"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls = {}\n colors = {}\n result = [0]*len(queries)\n distinct = 0\n for i in range(len(queries)):\n ball, color = queries[i]\n if ball in balls:\n colors[balls[ball]].remove(ball)\n distinct -= 1 if not colors[balls[ball]] else 0\n distinct += 1 if color not in colors or not colors[color] else 0\n balls[ball] = color\n if color not in colors:\n colors[color] = set()\n colors[color].add(ball)\n result[i] = distinct\n return result","runtime":"1204"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n m = {}\n btoc = {}\n res = []\n sofar = 0\n for b,c in queries:\n oldc = 0\n if b in btoc:\n oldc = btoc[b]\n btoc[b] = c\n if oldc:\n m[oldc].discard(b)\n if len(m[oldc]) == 0:\n sofar -= 1\n if c not in m:\n m[c] = set()\n if len(m[c]) == 0:\n sofar += 1\n m[c].add(b)\n res.append(sofar)\n return res","runtime":"1204"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n state = {}\n result = []\n unique = set()\n colors = defaultdict(int)\n for q in queries:\n ball = q[0]\n color = q[1]\n if ball in state:\n colors[state[ball]] -= 1\n if colors[state[ball]] == 0:\n unique.remove(state[ball]) \n unique.add(color)\n colors[color] += 1\n state[ball] = color\n result.append(len(unique))\n\n return result\n\n \n\n\n return result\n","runtime":"1206"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1206"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n used_colors = defaultdict(int)\n ball_colors = defaultdict(int)\n res = []\n count = 0\n\n for ball, color in queries:\n if ball_colors[ball] != color:\n used_colors[ball_colors[ball]] -= 1\n used_colors[color] += 1\n if used_colors[ball_colors[ball]] == 0:\n count -= 1\n if used_colors[color] == 1:\n count += 1\n ball_colors[ball] = color\n res.append(count)\n \n return res","runtime":"1207"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1209"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colour_dict = {}\n balls = {}\n res = []\n for i in range(len(queries)):\n if queries[i][1] in colour_dict:\n colour_dict[queries[i][1]] += 1\n else:\n colour_dict[queries[i][1]] = 1\n if queries[i][0] in balls:\n colour_dict[balls[queries[i][0]]] -= 1\n if colour_dict[balls[queries[i][0]]] == 0:\n colour_dict.pop(balls[queries[i][0]])\n balls[queries[i][0]] = queries[i][1]\n res.append(len(colour_dict))\n return res","runtime":"1209"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls, colors, ans = {}, {}, []\n for ball, color in queries:\n if ball in balls:\n colors[balls[ball]].remove(ball)\n if not colors[balls[ball]]:\n del colors[balls[ball]]\n balls[ball] = color\n if color not in colors:\n colors[color] = set()\n colors[color].add(ball)\n ans.append(len(colors.keys()))\n return ans","runtime":"1211"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n prev_color = defaultdict(int)\n freq = defaultdict(int)\n \n res = []\n for q in queries:\n ball, new_color = q\n prev = prev_color[ball]\n freq[prev] -= 1\n if freq[prev] <= 0:\n freq.pop(prev)\n prev_color[ball] = new_color\n freq[new_color] += 1\n res.append(len(freq))\n \n return res","runtime":"1213"},{"code":"from collections import defaultdict\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls_by_color = defaultdict(set)\n color_by_ball = {}\n ans = []\n for ball, color in queries:\n if ball in color_by_ball:\n old_color = color_by_ball[ball]\n balls_by_color[old_color].remove(ball)\n if len(balls_by_color[old_color]) == 0:\n del balls_by_color[old_color]\n color_by_ball[ball] = color\n balls_by_color[color].add(ball)\n ans.append(len(balls_by_color))\n return ans\n\n \n","runtime":"1213"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n count = Counter()\n d = {}\n for q in queries:\n curr_val = d.get(q[0])\n if not curr_val:\n count[q[1]] += 1\n else:\n count[curr_val] -= 1\n if count[curr_val] == 0:\n del count[curr_val]\n count[q[1]] += 1\n d[q[0]] = q[1]\n res.append(len(count.keys()))\n\n\n return res","runtime":"1215"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = {}\n c = Counter()\n ans = []\n for ball, val in queries:\n cur = colors.get(ball, -1)\n if cur == -1:\n c[val] +=1\n else:\n c[cur] -= 1\n c[val] += 1\n if c[cur] == 0:\n del c[cur]\n colors[ball] = val\n ans.append(len(c))\n return ans","runtime":"1215"},{"code":"from collections import Counter\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n counts = Counter()\n color_map = {}\n step_counts = []\n\n for q in queries:\n i = q[0]\n color = q[1]\n if i in color_map:\n old_color = color_map[i]\n if color != old_color:\n counts[color] += 1\n counts[old_color] -= 1\n if counts[old_color] == 0:\n del counts[old_color]\n else:\n counts[color] +=1\n color_map[i] = color\n \n step_counts.append(len(counts))\n return step_counts","runtime":"1217"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n used_colors = defaultdict(int)\n ball_colors = defaultdict(int)\n res = []\n count = 0\n\n for ball, color in queries:\n if ball_colors[ball] != color:\n used_colors[ball_colors[ball]] -= 1\n used_colors[color] += 1\n if used_colors[ball_colors[ball]] == 0:\n count -= 1\n if used_colors[color] == 1:\n count += 1\n ball_colors[ball] = color\n res.append(count)\n \n return res","runtime":"1217"},{"code":"from collections import defaultdict\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_color, color_balls = {}, defaultdict(set)\n result = []\n\n for ball,color in queries:\n oldcolor = ball_color.get(ball)\n if oldcolor:\n color_balls[oldcolor].remove(ball)\n if not color_balls[oldcolor]:\n del color_balls[oldcolor]\n ball_color[ball] = color\n color_balls[color].add(ball)\n result.append(len(color_balls))\n return result\n\n def queryResults2(self, limit: int, queries: List[List[int]]) -> List[int]:\n result = []\n ball_color = {}\n dcolors = set()\n\n for ball,color in queries:\n ball_color[ball] = color\n dcolors = len({color for color in ball_color.values()})\n result.append(dcolors)\n return result","runtime":"1219"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n ball_dict = dict() # ball -> color mapping\n color_dict = defaultdict(list) # color -> set of balls mapping\n res = []\n\n for q in queries:\n if q[0] in ball_dict.keys():\n prev_color = ball_dict[q[0]]\n if prev_color in color_dict.keys() and len(color_dict[prev_color]) <= 1:\n del color_dict[prev_color]\n else:\n color_dict[prev_color].remove(q[0])\n\n ball_dict[q[0]] = q[1]\n color_dict[q[1]].append(q[0])\n\n #print(\"ball_dict\", ball_dict)\n #print(\"color_dict\", color_dict)\n res.append(len(color_dict.keys()))\n \n return res\n","runtime":"1220"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","runtime":"1222"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_color = {} \n color_count = defaultdict(int) \n distinct_colors = 0 \n ans = []\n\n for b, c in queries:\n if b in ball_color:\n prev_color = ball_color[b]\n color_count[prev_color] -= 1\n if color_count[prev_color] == 0:\n distinct_colors -= 1\n\n if c != 0:\n if color_count[c] == 0:\n distinct_colors += 1\n color_count[c] += 1\n ball_color[b] = c \n else:\n if b in ball_color:\n del ball_color[b] \n \n ans.append(distinct_colors)\n return ans","runtime":"1222"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n ballLookUp = dict()\n colorLookUp = dict()\n colorLookUp[-1] = 0\n t = 0\n for ball, color in queries:\n if ball not in ballLookUp:\n ballLookUp[ball] = -1\n \n colorLookUp[ballLookUp[ball]] -= 1\n if colorLookUp[ballLookUp[ball]] == 0:\n t -= 1\n ballLookUp[ball] = color\n if color not in colorLookUp:\n colorLookUp[color] = 1\n else:\n colorLookUp[color] += 1\n if colorLookUp[color] == 1:\n t += 1\n res.append(t)\n\n return res","runtime":"1224"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n locks = {}\n colors = defaultdict(set)\n res = []\n\n for ball, color in queries:\n if ball not in locks:\n locks[ball] = color\n colors[color].add(ball)\n else:\n currColor = locks[ball]\n colors[currColor].remove(ball)\n if len(colors[currColor]) <= 0:\n del colors[currColor]\n\n locks[ball] = color\n colors[color].add(ball)\n\n res.append(len(colors))\n\n return res","runtime":"1226"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n answer = []\n ball_color = {}\n color_balls = defaultdict(set)\n for (q_ball, q_color) in queries:\n\n \n # if ball already has a color, remove old entry and update color tracking\n if q_ball in ball_color:\n old_color = ball_color[q_ball]\n\n if old_color != q_color: \n color_balls[old_color].remove(q_ball)\n if not color_balls[old_color]:\n # if empty set, remove it to allow len() to work on dict\n del color_balls[old_color]\n\n ball_color[q_ball] = q_color\n color_balls[q_color].add(q_ball)\n answer.append(len(color_balls))\n\n\n return answer\n ","runtime":"1228"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n res = []\n ball2Color = {}\n color2Ball = {}\n\n for q in queries:\n if q[0] in ball2Color:\n color2Ball[ball2Color[q[0]]].remove(q[0])\n\n if len(color2Ball[ball2Color[q[0]]]) == 0:\n del color2Ball[ball2Color[q[0]]]\n\n ball2Color[q[0]] = q[1]\n\n if q[1] in color2Ball:\n color2Ball[q[1]].add(q[0])\n else:\n color2Ball[q[1]] = set([q[0]])\n\n res.append(len(color2Ball))\n\n return res\n","runtime":"1230"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = dict()\n colors_reverse = defaultdict(set)\n result = []\n for b, c in queries:\n if b in colors:\n colors_reverse[colors[b]].remove(b)\n if not colors_reverse[colors[b]]:\n del colors_reverse[colors[b]]\n colors[b] = c\n colors_reverse[colors[b]].add(b)\n result.append(len(colors_reverse))\n return result","runtime":"1232"},{"code":"from collections import defaultdict\n\nv = False\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(set)\n balls = {}\n ret = []\n for i, (label, color) in enumerate(queries):\n if v: print(f\"{i=}: {balls=} {colors=}\")\n old_color = balls.get(label, None)\n if old_color == color:\n ret.append(len(colors))\n continue\n if old_color:\n colors[old_color].remove(label)\n if len(colors[old_color]) == 0:\n del colors[old_color]\n colors[color].add(label)\n balls[label] = color\n ret.append(len(colors))\n return ret","runtime":"1233"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n balls = defaultdict(int)\n n = len(queries)\n answer = [-1] * n\n for i in range(n):\n colors[queries[i][1]] += 1 \n colors[balls[queries[i][0]]] -= 1\n if colors[balls[queries[i][0]]] <= 0:\n colors.pop(balls[queries[i][0]])\n balls[queries[i][0]] = queries[i][1]\n answer[i] = len(colors)\n return answer","runtime":"1235"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n counts = Counter()\n res = []\n colors = Counter()\n for x,y in queries:\n if colors[x]:\n counts[colors[x]] -= 1\n if counts[colors[x]] == 0:\n del counts[colors[x]]\n counts[y] += 1\n colors[x] = y\n res.append(len(counts))\n \n return res\n \n ","runtime":"1237"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n g = {}\n cnt = Counter()\n ans = []\n for x, y in queries:\n cnt[y] += 1\n if x in g:\n cnt[g[x]] -= 1\n if cnt[g[x]] == 0:\n cnt.pop(g[x])\n g[x] = y\n ans.append(len(cnt))\n return ans","runtime":"1239"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ballstore = {} # Stores the color assigned to each ball\n colorstore = {} # Stores the list of balls associated with each color\n final = []\n non_empty_colors = 0 # Counter for non-empty color groups\n\n for ball, color in queries:\n if color not in colorstore:\n colorstore[color] = set() # Use set instead of list for faster operations\n \n # If the ball is already assigned to a color, remove it from the old color\n if ball in ballstore:\n old_color = ballstore[ball]\n if ball in colorstore[old_color]:\n colorstore[old_color].remove(ball)\n # If old color group becomes empty, decrement the counter\n if len(colorstore[old_color]) == 0:\n non_empty_colors -= 1\n \n # Add the ball to the new color group\n colorstore[color].add(ball)\n # Assign the ball to the color\n ballstore[ball] = color\n\n # If the color group was previously empty and now has balls, increment the counter\n if len(colorstore[color]) == 1:\n non_empty_colors += 1\n\n # Append the current number of non-empty color groups to the result list\n final.append(non_empty_colors)\n\n return final\n","runtime":"1241"}],"string":"[\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = {}\\n ht={}\\n count = 0\\n ans=[]\\n for qr in queries:\\n [x,y]=qr\\n if(colors.get(x) is None):\\n \\n colors[x]=y\\n if(ht.get(y) is None or ht[y]==0):\\n ht[y]=0\\n count+=1\\n \\n else:\\n ht[colors[x]]-=1\\n if(ht[colors[x]]==0):\\n count-=1\\n colors[x]=y\\n if(ht.get(y) is None or ht[y]==0):\\n ht[y]=0\\n count+=1\\n ht[y]+=1\\n ans.append(count)\\n # print(ht,colors)\\n return ans\\n \\n \\n\",\n \"runtime\": \"1109\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n ball2color = {}\\n color2cnt = {}\\n for ball, color in queries:\\n if ball in ball2color:\\n old_color = ball2color[ball]\\n color2cnt[old_color] -= 1\\n if color2cnt[old_color] == 0:\\n del color2cnt[old_color]\\n ball2color[ball] = color\\n if color not in color2cnt:\\n color2cnt[color] = 0\\n color2cnt[color] += 1\\n res.append(len(color2cnt))\\n return res\\n\",\n \"runtime\": \"1109\"\n },\n {\n \"code\": \"\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_counts = {}\\n colors = {}\\n\\n result = []\\n for index, color in queries:\\n old = colors.get(index)\\n colors[index] = color\\n if old == color:\\n result.append(len(color_counts))\\n else:\\n color_counts[color] = color_counts.get(color, 0) + 1\\n if old is not None:\\n color_counts[old] -= 1\\n if color_counts[old] == 0:\\n color_counts.pop(old)\\n result.append(len(color_counts))\\n return result\",\n \"runtime\": \"1111\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color = {}\\n color_count = {}\\n output = []\\n for x, y in queries:\\n if color.get(x, 0) != 0:\\n color_count[color[x]] -= 1\\n if color_count[color[x]] == 0:\\n del color_count[color[x]]\\n color[x] = y\\n color_count[y] = color_count.get(y, 0) + 1\\n output.append(len(color_count))\\n return output\",\n \"runtime\": \"1113\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = dict()\\n d = dict()\\n res = []\\n for a,b in queries:\\n if a not in colors:\\n colors[a] = b\\n if b in d:\\n d[b] += 1\\n else:\\n d[b] = 1\\n else:\\n d[colors[a]] -= 1\\n if d[colors[a]] == 0:\\n del d[colors[a]]\\n colors[a] = b\\n if b in d:\\n d[b] += 1\\n else:\\n d[b] = 1\\n res.append(len(d))\\n return res\\n\\n \\n\\n \",\n \"runtime\": \"1115\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1117\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_count = {}\\n ball_color = {}\\n result = []\\n for ball, color in queries:\\n if ball in ball_color:\\n color_count[ball_color[ball]] -= 1\\n if not color_count[ball_color[ball]]:\\n del color_count[ball_color[ball]]\\n ball_color[ball] = color\\n if color in color_count:\\n color_count[color] += 1\\n else:\\n color_count[color] = 1\\n result.append(len(color_count))\\n return result\",\n \"runtime\": \"1119\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = dict()\\n balls = dict()\\n o = []\\n for b, c in queries:\\n #print(b,c,colors, balls)\\n if not b in balls:\\n balls[b] = c \\n if c not in colors:\\n colors[c] = 1\\n else:\\n colors[c]+=1\\n else:\\n ci = balls[b] # couleur ini\\n balls[b] = c\\n colors[ci] -= 1\\n if c in colors:\\n colors[c] += 1\\n else:\\n colors[c] = 1\\n if colors[ci] == 0:\\n del colors[ci]\\n o.append(len(colors))\\n return o\\n \",\n \"runtime\": \"1121\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n answer = []\\n\\n balls_colors = {}\\n colors_occurences = {}\\n\\n for query in queries:\\n if query[0] in balls_colors:\\n color = balls_colors[query[0]]\\n\\n colors_occurences[color] -= 1\\n if colors_occurences[color] == 0:\\n colors_occurences.pop(color)\\n \\n if query[1] not in colors_occurences:\\n colors_occurences[query[1]] = 1\\n else:\\n colors_occurences[query[1]] += 1\\n \\n balls_colors[query[0]] = query[1]\\n else:\\n balls_colors[query[0]] = query[1]\\n\\n if query[1] not in colors_occurences:\\n colors_occurences[query[1]] = 1\\n else:\\n colors_occurences[query[1]] += 1\\n\\n answer.append(len(colors_occurences))\\n \\n return answer\\n\",\n \"runtime\": \"1122\"\n },\n {\n \"code\": \"class Solution:\\n\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_ball = {}\\n eff_color = {}\\n nbr_colors = 0\\n ans = []\\n for b, c in queries:\\n if b in color_ball:\\n eff_color[color_ball[b]] -= 1\\n if eff_color[color_ball[b]] == 0:\\n nbr_colors -= 1\\n color_ball[b] = c\\n eff_color[c] = eff_color.get(c, 0) + 1\\n if eff_color[c] == 1:\\n nbr_colors += 1\\n ans.append(nbr_colors)\\n return ans\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n # Initialize a dictionary to store colors for each ball\\n ball_colors = {}\\n\\n # Initialize a dictionary to store the count of each color\\n color_counts = {}\\n\\n # Initialize an array to store the result\\n result = []\\n\\n # Iterate through each query\\n for query in queries:\\n ball, color = query\\n\\n # If the ball already has a color, decrease the count of its previous color\\n if ball in ball_colors:\\n prev_color = ball_colors[ball]\\n color_counts[prev_color] -= 1\\n if color_counts[prev_color] == 0:\\n del color_counts[prev_color]\\n\\n # Update the color of the ball\\n ball_colors[ball] = color\\n\\n # Increase the count of the current color\\n color_counts[color] = color_counts.get(color, 0) + 1\\n\\n # Update the result with the number of distinct colors\\n result.append(len(color_counts))\\n\\n return result\",\n \"runtime\": \"1126\"\n },\n {\n \"code\": \"class Solution:\\n \\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n d = dict()\\n colors = defaultdict(int)\\n \\n res = []\\n\\n for ball, color in queries:\\n old_color = d.get(ball)\\n if color != old_color:\\n d[ball] = color\\n colors[color] += 1\\n\\n if colors.get(old_color):\\n colors[old_color] -= 1\\n if colors.get(old_color) == 0: colors.pop(old_color)\\n \\n res.append(len(colors))\\n \\n return res\",\n \"runtime\": \"1126\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n balls = {}\\n ans = []\\n for ball, color in queries:\\n if ball in balls:\\n colors[balls[ball]] -= 1\\n if colors[balls[ball]] == 0:\\n del colors[balls[ball]]\\n balls[ball] = color\\n colors[color] += 1\\n ans.append(len(colors))\\n return ans\\n \",\n \"runtime\": \"1128\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ans = []\\n colors = Counter()\\n state = dict()\\n for i, c in queries:\\n old = state.get(i, -1)\\n if old >= 0:\\n colors[old] -= 1\\n if colors[old] == 0:\\n colors.pop(old)\\n colors[c] += 1\\n state[i] = c\\n ans.append(len(colors))\\n return ans\\n\",\n \"runtime\": \"1130\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = {}\\n balls = {}\\n\\n ans = []\\n for q in queries:\\n ball, color = q\\n if ball in balls:\\n prev_color = balls.get(ball)\\n colors[prev_color] -= 1\\n\\n if colors[prev_color] == 0:\\n colors.pop(prev_color)\\n\\n balls[ball] = color\\n colors[color] = colors.get(color, 0) + 1\\n else:\\n balls[ball] = color\\n colors[color] = colors.get(color, 0) + 1\\n \\n ans.append(len(colors))\\n \\n return ans\\n\",\n \"runtime\": \"1132\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res, balls, colors = [], {}, {}\\n for ball, color in queries:\\n if ball not in balls or color != balls[ball]:\\n colors[color] = colors.get(color, 0) + 1\\n if ball in balls:\\n colors[balls[ball]] -= int(color != balls[ball])\\n if colors[balls[ball]] == 0:\\n del colors[balls[ball]]\\n balls[ball] = color\\n res.append(len(colors))\\n return res\",\n \"runtime\": \"1135\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_colors = {}\\n count = {}\\n diff_colors = set()\\n solution = []\\n\\n for ball_num, color in queries:\\n if ball_num in ball_colors:\\n old_color = ball_colors[ball_num]\\n count[old_color] -= 1\\n if count[old_color] == 0:\\n diff_colors.remove(old_color)\\n\\n ball_colors[ball_num] = color\\n if color in count:\\n count[color] += 1\\n else:\\n count[color] = 1\\n diff_colors.add(color)\\n \\n solution.append(len(diff_colors))\\n \\n return solution\",\n \"runtime\": \"1137\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_colors = {} # To store the color of each ball\\n color_count = {} # To store how many balls have a certain color\\n distinct_colors = 0 # To track the number of distinct colors\\n result = []\\n \\n for ball, color in queries:\\n if ball in ball_colors:\\n old_color = ball_colors[ball]\\n if old_color == color:\\n # No change needed, continue\\n result.append(distinct_colors)\\n continue\\n \\n # Decrease the count of the old color\\n color_count[old_color] -= 1\\n if color_count[old_color] == 0:\\n distinct_colors -= 1 # This color is no longer in use\\n \\n # Assign the new color to the ball\\n ball_colors[ball] = color\\n \\n # Update the count of the new color\\n if color not in color_count:\\n color_count[color] = 0\\n color_count[color] += 1\\n if color_count[color] == 1:\\n distinct_colors += 1 # This is a new distinct color\\n \\n # Append the current count of distinct colors\\n result.append(distinct_colors)\\n \\n return result\\n\\n \",\n \"runtime\": \"1139\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n num={}\\n ans=[]\\n d={}\\n c=0\\n for i,j in queries:\\n if i in num:\\n if d[num[i]]==1: \\n c-=1\\n d[num[i]]-=1\\n \\n if j not in d or d[j]==0:\\n c+=1\\n d[j]=1\\n else:\\n d[j]+=1\\n ans.append(c) \\n num[i]=j\\n \\n return ans \",\n \"runtime\": \"1141\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\\n \",\n \"runtime\": \"1143\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls, colorCounter = dict(), dict()\\n result = list()\\n for ball, color in queries:\\n if ball in balls: \\n colorCounter[balls[ball]]-=1\\n if colorCounter[balls[ball]] == 0:\\n del colorCounter[balls[ball]]\\n balls[ball] = color\\n if color in colorCounter:\\n colorCounter[color] += 1\\n else:\\n colorCounter[color] = 1\\n result.append(len(colorCounter))\\n return result\\n \",\n \"runtime\": \"1145\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n s = dict()\\n colors = defaultdict(int)\\n ans = []\\n col = 0\\n\\n for x,y in queries:\\n if colors[y] == 0:\\n col += 1\\n colors[y] += 1\\n if x in s:\\n colors[s[x]] -= 1\\n if colors[s[x]] == 0:\\n col -= 1\\n s[x] = y\\n\\n ans.append(col)\\n\\n return ans\",\n \"runtime\": \"1146\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = {}\\n ans = [0]\\n balls = {}\\n\\n for ball,color in queries:\\n c = 0 if ball not in balls else balls[ball]\\n inc = 0\\n if c != 0:\\n if colors[c] == 1:\\n inc -= 1\\n colors.pop(c)\\n else:\\n colors[c] -= 1\\n\\n\\n if color in colors:\\n colors[color] += 1\\n else:\\n colors[color] = 1\\n inc += 1\\n ans.append(ans[-1]+inc)\\n balls[ball] = color\\n return ans[1:]\\n\",\n \"runtime\": \"1148\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n limit += 1\\n arr = defaultdict(int)\\n d = defaultdict(int)\\n ans = []\\n\\n for x,y in queries:\\n prev = arr[x]\\n if prev:\\n d[prev] -= 1\\n if d[prev] == 0:\\n del d[prev]\\n arr[x] = y\\n d[y] += 1\\n \\n ans.append(len(d))\\n return ans\",\n \"runtime\": \"1150\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n num_balls_by_color = defaultdict(int)\\n color_by_ball = {}\\n ans = []\\n for ball, color in queries:\\n if ball in color_by_ball:\\n old_color = color_by_ball[ball]\\n num_balls_by_color[old_color] -= 1\\n if num_balls_by_color[old_color] == 0:\\n del num_balls_by_color[old_color]\\n color_by_ball[ball] = color\\n num_balls_by_color[color] += 1\\n ans.append(len(num_balls_by_color))\\n return ans\\n\\n \\n\",\n \"runtime\": \"1152\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n res = []\\n memo = dict()\\n for x,y in queries:\\n if colors[x] == 0:\\n colors[x] = y \\n if y in memo:\\n memo[y] += 1\\n else:\\n memo[y] = 1\\n res.append(len(memo))\\n elif colors[x] == y:\\n res.append(len(memo))\\n else:\\n if memo[colors[x]] == 1:\\n del memo[colors[x]]\\n else:\\n memo[colors[x]] -= 1 \\n if y in memo:\\n memo[y] += 1\\n else:\\n memo[y] = 1\\n colors[x] = y \\n res.append(len(memo))\\n \\n return res\\n\\n \",\n \"runtime\": \"1154\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_to_color = {}\\n color_to_count = defaultdict(int)\\n total_colors = 0\\n res = []\\n for ball, color in queries:\\n if ball in ball_to_color:\\n color_to_count[ball_to_color[ball]] -= 1\\n if color_to_count[ball_to_color[ball]] == 0:\\n total_colors -= 1\\n\\n if color_to_count[color] == 0:\\n total_colors += 1\\n\\n ball_to_color[ball] = color\\n color_to_count[color] += 1\\n\\n res.append(total_colors)\\n\\n return res\",\n \"runtime\": \"1156\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.d1 = {}\\n self.d2 = {}\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n for q in queries:\\n idx, col = q[0], q[1]\\n\\n if idx in self.d1:\\n self.d2[self.d1[idx]] -= 1\\n if self.d2[self.d1[idx]] == 0:\\n del self.d2[self.d1[idx]]\\n\\n self.d1[idx] = col\\n if col in self.d2:\\n self.d2[col] += 1\\n else:\\n self.d2[col] = 1\\n\\n res.append(len(self.d2))\\n\\n return res\\n\\n \\n\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"1158\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors, balls, ans = defaultdict(int), {}, []\\n for b, c in queries:\\n if b in balls:\\n if colors[balls[b]] == 1:\\n del colors[balls[b]]\\n else:\\n colors[balls[b]] -= 1\\n balls[b] = c\\n colors[c] += 1\\n ans.append(len(colors))\\n return ans\",\n \"runtime\": \"1159\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_counts = {}\\n ball_colors = {}\\n total = 0\\n result = []\\n for q in queries:\\n i, c = q\\n if color_counts.get(c, 0) == 0:\\n color_counts[c] = 1\\n total += 1\\n else:\\n color_counts[c] += 1\\n if i in ball_colors:\\n curr_c = ball_colors[i]\\n color_counts[curr_c] -= 1\\n if color_counts[curr_c] == 0:\\n total -= 1\\n \\n ball_colors[i] = c\\n result.append(total)\\n \\n return result\",\n \"runtime\": \"1161\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ballColors = {}\\n colorCounts = {}\\n\\n results = []\\n ans = 0\\n\\n for ball, color in queries:\\n if ball in ballColors:\\n prevColor = ballColors[ball]\\n ballColors[ball] = color\\n if prevColor == color:\\n pass\\n else:\\n colorCounts[prevColor] -= 1\\n if color in colorCounts:\\n colorCounts[color] += 1\\n else:\\n colorCounts[color] = 1\\n if colorCounts[prevColor] == 0 and colorCounts[color] == 1:\\n pass\\n elif colorCounts[prevColor] == 0:\\n ans -= 1\\n elif colorCounts[color] == 1:\\n ans += 1\\n else:\\n ballColors[ball] = color\\n if color in colorCounts:\\n colorCounts[color] += 1\\n else:\\n colorCounts[color] = 1\\n \\n if colorCounts[color] == 1:\\n ans += 1\\n \\n results.append(ans)\\n \\n return results\",\n \"runtime\": \"1163\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n C = defaultdict(int)\\n d = {} # pilka i kolor\\n n = len(queries)\\n cnt = 0\\n T = []\\n for i in range(n):\\n color = queries[i][1]\\n ball = queries[i][0]\\n if ball not in d:\\n d[ball] = color\\n if C[color]==0:\\n cnt+=1\\n C[color]+=1\\n else:\\n pcol = d[ball]\\n d[ball] = color\\n C[pcol]-=1\\n if C[pcol]==0: cnt-=1\\n if C[color]==0: cnt+=1\\n C[color]+=1\\n T.append(cnt)\\n return T\",\n \"runtime\": \"1165\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_colors = {}\\n colors_count = {}\\n c = set()\\n res = []\\n for x,y in queries:\\n if x in ball_colors:\\n old = ball_colors[x]\\n colors_count[old]-=1\\n if colors_count[old]==0:\\n c.remove(old)\\n \\n ball_colors[x]=y\\n if y in colors_count:\\n colors_count[y]+=1\\n else:\\n colors_count[y]=1\\n c.add(y)\\n\\n res.append(len(c))\\n\\n return res\",\n \"runtime\": \"1167\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1169\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_colors = {}\\n count = {}\\n diff_colors = set()\\n solution = []\\n\\n for ball_num, color in queries:\\n if ball_num in ball_colors:\\n old_color = ball_colors[ball_num]\\n count[old_color] -= 1\\n if count[old_color] == 0:\\n diff_colors.remove(old_color)\\n\\n ball_colors[ball_num] = color\\n if color in count:\\n count[color] += 1\\n else:\\n count[color] = 1\\n diff_colors.add(color)\\n \\n solution.append(len(diff_colors))\\n \\n return solution\",\n \"runtime\": \"1170\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_dict = dict() # need to get old color\\n color_dict = defaultdict(int) # need to check how many balls have certain color for subtraction (upon replacement)\\n res = []\\n count = 0\\n for ball, color in queries:\\n if ball in ball_dict:\\n old_color = ball_dict[ball]\\n if color_dict[old_color] == 1:\\n count -= 1\\n color_dict.pop(old_color)\\n else:\\n color_dict[old_color] -= 1\\n ball_dict[ball] = color\\n if color not in color_dict:\\n count += 1\\n color_dict[color] += 1\\n res.append(count)\\n return res\",\n \"runtime\": \"1172\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_count = {}\\n ball_color = {}\\n result = []\\n for ball, color in queries:\\n if ball in ball_color:\\n current_color = ball_color[ball]\\n color_count[current_color] -= 1\\n if not color_count[current_color]:\\n del color_count[current_color]\\n ball_color[ball] = color\\n if color in color_count:\\n color_count[color] += 1\\n else:\\n color_count[color] = 1\\n result.append(len(color_count))\\n return result\",\n \"runtime\": \"1174\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_count = {}\\n ball_color = {}\\n result = []\\n for ball, color in queries:\\n if ball in ball_color:\\n current_color = ball_color[ball]\\n color_count[current_color] -= 1\\n if not color_count[current_color]:\\n del color_count[current_color]\\n ball_color[ball] = color\\n if color in color_count:\\n color_count[color] += 1\\n else:\\n color_count[color] = 1\\n result.append(len(color_count))\\n return result\",\n \"runtime\": \"1176\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n balls = defaultdict(int)\\n distinct_colors = []\\n \\n for ball, color in queries: \\n if ball in balls:\\n prev_color = balls[ball]\\n colors[prev_color] -= 1\\n if colors[prev_color] == 0: \\n del colors[prev_color]\\n balls[ball] = color\\n colors[color] += 1\\n distinct_colors.append(len(colors))\\n \\n \\n return distinct_colors\\n \",\n \"runtime\": \"1178\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom typing import List\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n color_frequency = {}\\n\\n output = []\\n for index, color in queries:\\n if colors[index] != 0:\\n color_frequency[colors[index]] -= 1\\n if color_frequency[colors[index]] == 0:\\n del color_frequency[colors[index]]\\n\\n colors[index] = color\\n\\n if color not in color_frequency:\\n color_frequency[color] = 1\\n else:\\n color_frequency[color] += 1\\n\\n output.append(len(color_frequency))\\n \\n return output\\n\\n \\n \\n \",\n \"runtime\": \"1180\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n dct_c = defaultdict(int)\\n dct_b = defaultdict(int)\\n cnt = 0\\n res = [] \\n for query in queries:\\n b, c = query\\n if dct_b[b] in dct_c:\\n dct_c[dct_b[b]] -= 1 \\n if dct_c[dct_b[b]] == 0:\\n cnt -= 1\\n dct_b[b] = c\\n dct_c[c] += 1\\n if dct_c[c] == 1:\\n cnt += 1\\n res.append(cnt)\\n return res\\n \\n\",\n \"runtime\": \"1182\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n myHash = {}\\n cnt = defaultdict(int)\\n res = []\\n\\n for x, y in queries:\\n cnt[y] += 1\\n\\n if x in myHash:\\n cnt[myHash[x]] -= 1\\n if cnt[myHash[x]] == 0:\\n cnt.pop(myHash[x])\\n \\n myHash[x] = y\\n \\n res.append(len(cnt))\\n \\n return res\\n \",\n \"runtime\": \"1183\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_count = {}\\n ball_color = {}\\n result = []\\n for ball, color in queries:\\n if ball in ball_color:\\n color_count[ball_color[ball]] -= 1\\n if not color_count[ball_color[ball]]:\\n del color_count[ball_color[ball]]\\n ball_color[ball] = color\\n if color in color_count:\\n color_count[color] += 1\\n else:\\n color_count[color] = 1\\n result.append(len(color_count))\\n return result\",\n \"runtime\": \"1185\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n balls = defaultdict(int)\\n distinct_colors = 0\\n ret = []\\n for ball, color in queries:\\n if balls[ball] != color:\\n if balls[ball]:\\n colors[balls[ball]] -= 1\\n if colors[balls[ball]] == 0:\\n distinct_colors -= 1 \\n balls[ball] = color\\n if not colors[color]:\\n distinct_colors += 1\\n colors[color] += 1\\n ret.append(distinct_colors)\\n return ret\",\n \"runtime\": \"1187\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_counter = Counter()\\n idx_map_colors = {}\\n\\n res = []\\n for i, color in queries:\\n if i in idx_map_colors:\\n old_color = idx_map_colors[i]\\n if color_counter[old_color] == 1:\\n del color_counter[old_color]\\n else:\\n color_counter[old_color] -= 1\\n\\n idx_map_colors[i] = color\\n color_counter[color] += 1\\n\\n res.append(len(color_counter))\\n\\n return res\\n\",\n \"runtime\": \"1189\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n map = {} # ball : color\\n count = defaultdict(int) # color : count\\n distinct = 0\\n ans = []\\n \\n for x, y in queries:\\n if x in map:\\n count[map[x]] -= 1\\n if count[map[x]] == 0:\\n distinct -= 1\\n del count[map[x]]\\n \\n map[x] = y\\n \\n if count[y] == 0:\\n distinct += 1\\n count[y] += 1\\n \\n ans.append(distinct)\\n \\n return ans\\n \\n \\n \",\n \"runtime\": \"1191\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_color, color_balls = {}, defaultdict(set)\\n result = []\\n\\n for ball,color in queries:\\n oldcolor = ball_color.get(ball)\\n if oldcolor:\\n color_balls[oldcolor].remove(ball)\\n if not color_balls[oldcolor]:\\n del color_balls[oldcolor]\\n ball_color[ball] = color\\n color_balls[color].add(ball)\\n result.append(len(color_balls))\\n return result\\n\\n def queryResults2(self, limit: int, queries: List[List[int]]) -> List[int]:\\n result = []\\n ball_color = {}\\n dcolors = set()\\n\\n for ball,color in queries:\\n ball_color[ball] = color\\n dcolors = len({color for color in ball_color.values()})\\n result.append(dcolors)\\n return result\",\n \"runtime\": \"1191\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n ballLookUp = dict()\\n colorLookUp = dict()\\n colorLookUp[-1] = 0\\n t = 0\\n for ball, color in queries:\\n if ball not in ballLookUp:\\n ballLookUp[ball] = -1\\n \\n colorLookUp[ballLookUp[ball]] -= 1\\n if colorLookUp[ballLookUp[ball]] == 0:\\n t -= 1\\n ballLookUp[ball] = color\\n if color not in colorLookUp:\\n colorLookUp[color] = 1\\n else:\\n colorLookUp[color] += 1\\n if colorLookUp[color] == 1:\\n t += 1\\n res.append(t)\\n\\n return res\",\n \"runtime\": \"1193\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_color = {}\\n color_ct = {}\\n out = []\\n for q in queries:\\n if q[0] in ball_color:\\n color_ct[ball_color[q[0]]] -= 1\\n if color_ct[ball_color[q[0]]] == 0:\\n color_ct.pop(ball_color[q[0]])\\n ball_color[q[0]] = q[1]\\n if ball_color[q[0]] not in color_ct:\\n color_ct[ball_color[q[0]]] = 0\\n color_ct[ball_color[q[0]]] += 1\\n out.append(len(color_ct))\\n\\n return out\",\n \"runtime\": \"1195\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls={}\\n color_count={}\\n zero=0\\n res=[]\\n for a,b in queries:\\n if a in balls:\\n color_count[balls[a]]-=1\\n if color_count[balls[a]]==0:\\n zero+=1\\n balls[a]=b\\n if color_count.get(b,-1)==0:\\n zero-=1\\n color_count[b]=1+color_count.get(b,0)\\n res.append(len(color_count)-zero)\\n return res\\n\\n \\n \\n \",\n \"runtime\": \"1198\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n # limit = 10**9\\n # balls = [False] * (limit + 1)\\n\\n # for q in queries:\\n # print(balls)\\n # print(q)\\n # if not balls[q[0]]:\\n # balls[q[0]] = True\\n # balls[q[0]] = q[1]\\n\\n # print(balls)\\n # return 3\\n\\n answer = []\\n ball_color = {}\\n color_balls = defaultdict(set)\\n for (q_ball, q_color) in queries:\\n\\n \\n if q_ball in ball_color:\\n old_color = ball_color[q_ball]\\n # remove old entry\\n color_balls[old_color].remove(q_ball)\\n if not color_balls[old_color]:\\n del color_balls[old_color]\\n\\n ball_color[q_ball] = q_color\\n color_balls[q_color].add(q_ball)\\n answer.append(len(color_balls))\\n\\n # print(ball_color)\\n # print(color_balls)\\n # print(answer)\\n\\n return answer\\n \",\n \"runtime\": \"1198\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = dict()\\n # unqiueColorCnt = 0\\n colorCounters = defaultdict(int)\\n \\n ans = []\\n for q in queries:\\n idx, color = q\\n if idx in colors:\\n oriColor = colors[idx]\\n colorCounters[oriColor] -= 1\\n if colorCounters[oriColor] == 0: del colorCounters[oriColor]\\n \\n colors[idx] = color\\n colorCounters[color] += 1\\n # if color not in colorCounters: colorCounters[color] = 1\\n # else: colorCounters[color] += 1\\n ans.append(len(colorCounters))\\n return ans\\n \",\n \"runtime\": \"1200\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls, colors, ans = {}, {}, []\\n for ball, color in queries:\\n if ball in balls:\\n colors[balls[ball]].remove(ball)\\n if not colors[balls[ball]]:\\n del colors[balls[ball]]\\n balls[ball] = color\\n if color not in colors:\\n colors[color] = set()\\n colors[color].add(ball)\\n ans.append(len(colors))\\n return ans\",\n \"runtime\": \"1202\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n value_map = {} # Store only the modified indices and their values\\n unique_values = {} # Dictionary to track occurrences of non-zero values\\n result = []\\n\\n for a, b in queries:\\n # If the current value at index `a` is already non-zero, adjust its count in unique_values\\n if a in value_map and value_map[a] != 0:\\n unique_values[value_map[a]] -= 1\\n if unique_values[value_map[a]] == 0:\\n del unique_values[value_map[a]] # Remove it from the dictionary if count is 0\\n\\n # Update the value at index `a`\\n value_map[a] = b\\n\\n # If the new value is non-zero, add it to the unique_values set\\n if b != 0:\\n if b not in unique_values:\\n unique_values[b] = 0\\n unique_values[b] += 1\\n\\n # Append the count of unique non-zero values\\n result.append(len(unique_values))\\n\\n return result\\n\",\n \"runtime\": \"1202\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls = {}\\n colors = {}\\n result = [0]*len(queries)\\n distinct = 0\\n for i in range(len(queries)):\\n ball, color = queries[i]\\n if ball in balls:\\n colors[balls[ball]].remove(ball)\\n distinct -= 1 if not colors[balls[ball]] else 0\\n distinct += 1 if color not in colors or not colors[color] else 0\\n balls[ball] = color\\n if color not in colors:\\n colors[color] = set()\\n colors[color].add(ball)\\n result[i] = distinct\\n return result\",\n \"runtime\": \"1204\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n m = {}\\n btoc = {}\\n res = []\\n sofar = 0\\n for b,c in queries:\\n oldc = 0\\n if b in btoc:\\n oldc = btoc[b]\\n btoc[b] = c\\n if oldc:\\n m[oldc].discard(b)\\n if len(m[oldc]) == 0:\\n sofar -= 1\\n if c not in m:\\n m[c] = set()\\n if len(m[c]) == 0:\\n sofar += 1\\n m[c].add(b)\\n res.append(sofar)\\n return res\",\n \"runtime\": \"1204\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n state = {}\\n result = []\\n unique = set()\\n colors = defaultdict(int)\\n for q in queries:\\n ball = q[0]\\n color = q[1]\\n if ball in state:\\n colors[state[ball]] -= 1\\n if colors[state[ball]] == 0:\\n unique.remove(state[ball]) \\n unique.add(color)\\n colors[color] += 1\\n state[ball] = color\\n result.append(len(unique))\\n\\n return result\\n\\n \\n\\n\\n return result\\n\",\n \"runtime\": \"1206\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1206\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n used_colors = defaultdict(int)\\n ball_colors = defaultdict(int)\\n res = []\\n count = 0\\n\\n for ball, color in queries:\\n if ball_colors[ball] != color:\\n used_colors[ball_colors[ball]] -= 1\\n used_colors[color] += 1\\n if used_colors[ball_colors[ball]] == 0:\\n count -= 1\\n if used_colors[color] == 1:\\n count += 1\\n ball_colors[ball] = color\\n res.append(count)\\n \\n return res\",\n \"runtime\": \"1207\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colour_dict = {}\\n balls = {}\\n res = []\\n for i in range(len(queries)):\\n if queries[i][1] in colour_dict:\\n colour_dict[queries[i][1]] += 1\\n else:\\n colour_dict[queries[i][1]] = 1\\n if queries[i][0] in balls:\\n colour_dict[balls[queries[i][0]]] -= 1\\n if colour_dict[balls[queries[i][0]]] == 0:\\n colour_dict.pop(balls[queries[i][0]])\\n balls[queries[i][0]] = queries[i][1]\\n res.append(len(colour_dict))\\n return res\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls, colors, ans = {}, {}, []\\n for ball, color in queries:\\n if ball in balls:\\n colors[balls[ball]].remove(ball)\\n if not colors[balls[ball]]:\\n del colors[balls[ball]]\\n balls[ball] = color\\n if color not in colors:\\n colors[color] = set()\\n colors[color].add(ball)\\n ans.append(len(colors.keys()))\\n return ans\",\n \"runtime\": \"1211\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n prev_color = defaultdict(int)\\n freq = defaultdict(int)\\n \\n res = []\\n for q in queries:\\n ball, new_color = q\\n prev = prev_color[ball]\\n freq[prev] -= 1\\n if freq[prev] <= 0:\\n freq.pop(prev)\\n prev_color[ball] = new_color\\n freq[new_color] += 1\\n res.append(len(freq))\\n \\n return res\",\n \"runtime\": \"1213\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls_by_color = defaultdict(set)\\n color_by_ball = {}\\n ans = []\\n for ball, color in queries:\\n if ball in color_by_ball:\\n old_color = color_by_ball[ball]\\n balls_by_color[old_color].remove(ball)\\n if len(balls_by_color[old_color]) == 0:\\n del balls_by_color[old_color]\\n color_by_ball[ball] = color\\n balls_by_color[color].add(ball)\\n ans.append(len(balls_by_color))\\n return ans\\n\\n \\n\",\n \"runtime\": \"1213\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n count = Counter()\\n d = {}\\n for q in queries:\\n curr_val = d.get(q[0])\\n if not curr_val:\\n count[q[1]] += 1\\n else:\\n count[curr_val] -= 1\\n if count[curr_val] == 0:\\n del count[curr_val]\\n count[q[1]] += 1\\n d[q[0]] = q[1]\\n res.append(len(count.keys()))\\n\\n\\n return res\",\n \"runtime\": \"1215\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = {}\\n c = Counter()\\n ans = []\\n for ball, val in queries:\\n cur = colors.get(ball, -1)\\n if cur == -1:\\n c[val] +=1\\n else:\\n c[cur] -= 1\\n c[val] += 1\\n if c[cur] == 0:\\n del c[cur]\\n colors[ball] = val\\n ans.append(len(c))\\n return ans\",\n \"runtime\": \"1215\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n counts = Counter()\\n color_map = {}\\n step_counts = []\\n\\n for q in queries:\\n i = q[0]\\n color = q[1]\\n if i in color_map:\\n old_color = color_map[i]\\n if color != old_color:\\n counts[color] += 1\\n counts[old_color] -= 1\\n if counts[old_color] == 0:\\n del counts[old_color]\\n else:\\n counts[color] +=1\\n color_map[i] = color\\n \\n step_counts.append(len(counts))\\n return step_counts\",\n \"runtime\": \"1217\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n used_colors = defaultdict(int)\\n ball_colors = defaultdict(int)\\n res = []\\n count = 0\\n\\n for ball, color in queries:\\n if ball_colors[ball] != color:\\n used_colors[ball_colors[ball]] -= 1\\n used_colors[color] += 1\\n if used_colors[ball_colors[ball]] == 0:\\n count -= 1\\n if used_colors[color] == 1:\\n count += 1\\n ball_colors[ball] = color\\n res.append(count)\\n \\n return res\",\n \"runtime\": \"1217\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_color, color_balls = {}, defaultdict(set)\\n result = []\\n\\n for ball,color in queries:\\n oldcolor = ball_color.get(ball)\\n if oldcolor:\\n color_balls[oldcolor].remove(ball)\\n if not color_balls[oldcolor]:\\n del color_balls[oldcolor]\\n ball_color[ball] = color\\n color_balls[color].add(ball)\\n result.append(len(color_balls))\\n return result\\n\\n def queryResults2(self, limit: int, queries: List[List[int]]) -> List[int]:\\n result = []\\n ball_color = {}\\n dcolors = set()\\n\\n for ball,color in queries:\\n ball_color[ball] = color\\n dcolors = len({color for color in ball_color.values()})\\n result.append(dcolors)\\n return result\",\n \"runtime\": \"1219\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n ball_dict = dict() # ball -> color mapping\\n color_dict = defaultdict(list) # color -> set of balls mapping\\n res = []\\n\\n for q in queries:\\n if q[0] in ball_dict.keys():\\n prev_color = ball_dict[q[0]]\\n if prev_color in color_dict.keys() and len(color_dict[prev_color]) <= 1:\\n del color_dict[prev_color]\\n else:\\n color_dict[prev_color].remove(q[0])\\n\\n ball_dict[q[0]] = q[1]\\n color_dict[q[1]].append(q[0])\\n\\n #print(\\\"ball_dict\\\", ball_dict)\\n #print(\\\"color_dict\\\", color_dict)\\n res.append(len(color_dict.keys()))\\n \\n return res\\n\",\n \"runtime\": \"1220\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"runtime\": \"1222\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_color = {} \\n color_count = defaultdict(int) \\n distinct_colors = 0 \\n ans = []\\n\\n for b, c in queries:\\n if b in ball_color:\\n prev_color = ball_color[b]\\n color_count[prev_color] -= 1\\n if color_count[prev_color] == 0:\\n distinct_colors -= 1\\n\\n if c != 0:\\n if color_count[c] == 0:\\n distinct_colors += 1\\n color_count[c] += 1\\n ball_color[b] = c \\n else:\\n if b in ball_color:\\n del ball_color[b] \\n \\n ans.append(distinct_colors)\\n return ans\",\n \"runtime\": \"1222\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n ballLookUp = dict()\\n colorLookUp = dict()\\n colorLookUp[-1] = 0\\n t = 0\\n for ball, color in queries:\\n if ball not in ballLookUp:\\n ballLookUp[ball] = -1\\n \\n colorLookUp[ballLookUp[ball]] -= 1\\n if colorLookUp[ballLookUp[ball]] == 0:\\n t -= 1\\n ballLookUp[ball] = color\\n if color not in colorLookUp:\\n colorLookUp[color] = 1\\n else:\\n colorLookUp[color] += 1\\n if colorLookUp[color] == 1:\\n t += 1\\n res.append(t)\\n\\n return res\",\n \"runtime\": \"1224\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n locks = {}\\n colors = defaultdict(set)\\n res = []\\n\\n for ball, color in queries:\\n if ball not in locks:\\n locks[ball] = color\\n colors[color].add(ball)\\n else:\\n currColor = locks[ball]\\n colors[currColor].remove(ball)\\n if len(colors[currColor]) <= 0:\\n del colors[currColor]\\n\\n locks[ball] = color\\n colors[color].add(ball)\\n\\n res.append(len(colors))\\n\\n return res\",\n \"runtime\": \"1226\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n answer = []\\n ball_color = {}\\n color_balls = defaultdict(set)\\n for (q_ball, q_color) in queries:\\n\\n \\n # if ball already has a color, remove old entry and update color tracking\\n if q_ball in ball_color:\\n old_color = ball_color[q_ball]\\n\\n if old_color != q_color: \\n color_balls[old_color].remove(q_ball)\\n if not color_balls[old_color]:\\n # if empty set, remove it to allow len() to work on dict\\n del color_balls[old_color]\\n\\n ball_color[q_ball] = q_color\\n color_balls[q_color].add(q_ball)\\n answer.append(len(color_balls))\\n\\n\\n return answer\\n \",\n \"runtime\": \"1228\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n res = []\\n ball2Color = {}\\n color2Ball = {}\\n\\n for q in queries:\\n if q[0] in ball2Color:\\n color2Ball[ball2Color[q[0]]].remove(q[0])\\n\\n if len(color2Ball[ball2Color[q[0]]]) == 0:\\n del color2Ball[ball2Color[q[0]]]\\n\\n ball2Color[q[0]] = q[1]\\n\\n if q[1] in color2Ball:\\n color2Ball[q[1]].add(q[0])\\n else:\\n color2Ball[q[1]] = set([q[0]])\\n\\n res.append(len(color2Ball))\\n\\n return res\\n\",\n \"runtime\": \"1230\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = dict()\\n colors_reverse = defaultdict(set)\\n result = []\\n for b, c in queries:\\n if b in colors:\\n colors_reverse[colors[b]].remove(b)\\n if not colors_reverse[colors[b]]:\\n del colors_reverse[colors[b]]\\n colors[b] = c\\n colors_reverse[colors[b]].add(b)\\n result.append(len(colors_reverse))\\n return result\",\n \"runtime\": \"1232\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nv = False\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(set)\\n balls = {}\\n ret = []\\n for i, (label, color) in enumerate(queries):\\n if v: print(f\\\"{i=}: {balls=} {colors=}\\\")\\n old_color = balls.get(label, None)\\n if old_color == color:\\n ret.append(len(colors))\\n continue\\n if old_color:\\n colors[old_color].remove(label)\\n if len(colors[old_color]) == 0:\\n del colors[old_color]\\n colors[color].add(label)\\n balls[label] = color\\n ret.append(len(colors))\\n return ret\",\n \"runtime\": \"1233\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n balls = defaultdict(int)\\n n = len(queries)\\n answer = [-1] * n\\n for i in range(n):\\n colors[queries[i][1]] += 1 \\n colors[balls[queries[i][0]]] -= 1\\n if colors[balls[queries[i][0]]] <= 0:\\n colors.pop(balls[queries[i][0]])\\n balls[queries[i][0]] = queries[i][1]\\n answer[i] = len(colors)\\n return answer\",\n \"runtime\": \"1235\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n counts = Counter()\\n res = []\\n colors = Counter()\\n for x,y in queries:\\n if colors[x]:\\n counts[colors[x]] -= 1\\n if counts[colors[x]] == 0:\\n del counts[colors[x]]\\n counts[y] += 1\\n colors[x] = y\\n res.append(len(counts))\\n \\n return res\\n \\n \",\n \"runtime\": \"1237\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n g = {}\\n cnt = Counter()\\n ans = []\\n for x, y in queries:\\n cnt[y] += 1\\n if x in g:\\n cnt[g[x]] -= 1\\n if cnt[g[x]] == 0:\\n cnt.pop(g[x])\\n g[x] = y\\n ans.append(len(cnt))\\n return ans\",\n \"runtime\": \"1239\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ballstore = {} # Stores the color assigned to each ball\\n colorstore = {} # Stores the list of balls associated with each color\\n final = []\\n non_empty_colors = 0 # Counter for non-empty color groups\\n\\n for ball, color in queries:\\n if color not in colorstore:\\n colorstore[color] = set() # Use set instead of list for faster operations\\n \\n # If the ball is already assigned to a color, remove it from the old color\\n if ball in ballstore:\\n old_color = ballstore[ball]\\n if ball in colorstore[old_color]:\\n colorstore[old_color].remove(ball)\\n # If old color group becomes empty, decrement the counter\\n if len(colorstore[old_color]) == 0:\\n non_empty_colors -= 1\\n \\n # Add the ball to the new color group\\n colorstore[color].add(ball)\\n # Assign the ball to the color\\n ballstore[ball] = color\\n\\n # If the color group was previously empty and now has balls, increment the counter\\n if len(colorstore[color]) == 1:\\n non_empty_colors += 1\\n\\n # Append the current number of non-empty color groups to the result list\\n final.append(non_empty_colors)\\n\\n return final\\n\",\n \"runtime\": \"1241\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":83,"string":"83"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n b_colors = {}\n col_count = {}\n dis_colors = set()\n res = []\n\n for x, y in queries:\n if x in b_colors:\n old_color = b_colors[x]\n col_count[old_color] -= 1\n if col_count[old_color] == 0:\n dis_colors.remove(old_color)\n\n b_colors[x] = y\n if y in col_count:\n col_count[y] += 1\n else:\n col_count[y] = 1\n dis_colors.add(y)\n \n res.append(len(dis_colors))\n \n return res","memory":"67100"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color_counts = {}\n ball_colors = {}\n total = 0\n result = []\n for q in queries:\n i, c = q\n if color_counts.get(c, 0) == 0:\n color_counts[c] = 1\n total += 1\n else:\n color_counts[c] += 1\n if i in ball_colors:\n curr_c = ball_colors[i]\n color_counts[curr_c] -= 1\n if color_counts[curr_c] == 0:\n total -= 1\n \n ball_colors[i] = c\n result.append(total)\n \n return result","memory":"67800"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_dict = dict()\n color_dict = defaultdict(int)\n res = []\n count = 0\n for ball, color in queries:\n if ball not in ball_dict:\n ball_dict[ball] = color\n if color not in color_dict:\n count += 1\n color_dict[color] += 1\n else:\n old_color = ball_dict[ball]\n if color_dict[old_color] == 1:\n count -= 1\n color_dict.pop(old_color)\n else:\n color_dict[old_color] -= 1\n ball_dict[ball] = color\n if color not in color_dict:\n count += 1\n color_dict[color] += 1\n res.append(count)\n return res","memory":"68200"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_color = {} \n color_count = defaultdict(int) \n distinct_colors = 0 \n ans = []\n\n for b, c in queries:\n if b in ball_color:\n prev_color = ball_color[b]\n color_count[prev_color] -= 1\n if color_count[prev_color] == 0:\n distinct_colors -= 1\n\n if c != 0:\n if color_count[c] == 0:\n distinct_colors += 1\n color_count[c] += 1\n ball_color[b] = c \n else:\n if b in ball_color:\n del ball_color[b] \n \n ans.append(distinct_colors)\n return ans","memory":"68300"},{"code":"from collections import defaultdict\n\nclass Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n num_balls_by_color = defaultdict(int)\n color_by_ball = {}\n ans = []\n for ball, color in queries:\n if ball in color_by_ball:\n old_color = color_by_ball[ball]\n num_balls_by_color[old_color] -= 1\n if num_balls_by_color[old_color] == 0:\n del num_balls_by_color[old_color]\n color_by_ball[ball] = color\n num_balls_by_color[color] += 1\n ans.append(len(num_balls_by_color))\n return ans\n\n \n","memory":"68400"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n myHash = {}\n cnt = defaultdict(int)\n res = []\n\n for x, y in queries:\n cnt[y] += 1\n\n if x in myHash:\n cnt[myHash[x]] -= 1\n if cnt[myHash[x]] == 0:\n cnt.pop(myHash[x])\n \n myHash[x] = y\n \n res.append(len(cnt))\n \n return res\n ","memory":"68500"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_colors = {} # To store the color of each ball\n color_count = {} # To store how many balls have a certain color\n distinct_colors = 0 # To track the number of distinct colors\n result = []\n \n for ball, color in queries:\n if ball in ball_colors:\n old_color = ball_colors[ball]\n if old_color == color:\n # No change needed, continue\n result.append(distinct_colors)\n continue\n \n # Decrease the count of the old color\n color_count[old_color] -= 1\n if color_count[old_color] == 0:\n distinct_colors -= 1 # This color is no longer in use\n \n # Assign the new color to the ball\n ball_colors[ball] = color\n \n # Update the count of the new color\n if color not in color_count:\n color_count[color] = 0\n color_count[color] += 1\n if color_count[color] == 1:\n distinct_colors += 1 # This is a new distinct color\n \n # Append the current count of distinct colors\n result.append(distinct_colors)\n \n return result\n\n ","memory":"68600"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n color = {}\n color_count = {}\n output = []\n for x, y in queries:\n if color.get(x, 0) != 0:\n color_count[color[x]] -= 1\n if color_count[color[x]] == 0:\n del color_count[color[x]]\n color[x] = y\n color_count[y] = color_count.get(y, 0) + 1\n output.append(len(color_count))\n return output","memory":"68700"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n limit += 1\n arr = defaultdict(int)\n d = defaultdict(int)\n ans = []\n\n for x,y in queries:\n prev = arr[x]\n if prev:\n d[prev] -= 1\n if d[prev] == 0:\n del d[prev]\n arr[x] = y\n d[y] += 1\n \n ans.append(len(d))\n return ans","memory":"68800"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = {}\n ans = [0]\n balls = defaultdict(int)\n\n for ball,color in queries:\n c = balls[ball]\n inc = 0\n if c != 0:\n if colors[c] == 1:\n inc -= 1\n colors.pop(c)\n else:\n colors[c] -= 1\n\n\n if color in colors:\n colors[color] += 1\n else:\n colors[color] = 1\n inc += 1\n ans.append(ans[-1]+inc)\n balls[ball] = color\n return ans[1:]\n","memory":"69000"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n res = [0]*len(queries)\n ball_dic = dict()\n colors_dic = defaultdict(int)\n count = 0\n for i, [ball, color] in enumerate(queries):\n if ball in ball_dic:\n prev_color = ball_dic[ball]\n colors_dic[prev_color]-=1\n if colors_dic[prev_color] == 0:\n del colors_dic[prev_color]\n ball_dic[ball] = color\n colors_dic[color]+=1\n res[i] = len(colors_dic.keys())\n \n return res","memory":"69100"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n res = [0]*len(queries)\n ball_dic = dict()\n colors_dic = defaultdict(int)\n count = 0\n for i, [ball, color] in enumerate(queries):\n if ball not in ball_dic:\n ball_dic[ball] = color\n colors_dic[color]+=1\n else:\n prev_color = ball_dic[ball]\n colors_dic[prev_color]-=1\n if colors_dic[prev_color] == 0:\n del colors_dic[prev_color]\n ball_dic[ball] = color\n colors_dic[color]+=1\n \n res[i] = len(colors_dic.keys())\n \n return res","memory":"69200"},{"code":"class Solution:\n def queryResults(self, l: int, q: List[List[int]]) -> List[int]:\n c,u,o=defaultdict(int),defaultdict(int),[0]*len(q)\n for e,(x,y) in enumerate(q):\n if (z:=c[x]):\n if u[z]==1:\n del u[z]\n else: u[z]-=1\n c[x]=y\n u[y]+=1\n o[e]=len(u)\n return o","memory":"69300"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n \n # idx = color\n dc = {}\n # color = idx\n dc2 = defaultdict(list)\n res = []\n for f,c in queries:\n if f in dc:\n dc2[dc[f]].remove(f)\n if len(dc2[dc[f]])==0:\n del dc2[dc[f]]\n \n dc[f]=c\n dc2[c].append(f)\n \n res.append(len(dc2))\n\n return res","memory":"69800"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n prev_color = defaultdict(int)\n freq = defaultdict(int)\n \n res = []\n for q in queries:\n ball, new_color = q\n prev = prev_color[ball]\n freq[prev] -= 1\n if freq[prev] <= 0:\n freq.pop(prev)\n prev_color[ball] = new_color\n freq[new_color] += 1\n res.append(len(freq))\n \n return res","memory":"70400"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors = defaultdict(int)\n balls = defaultdict(int)\n n = len(queries)\n answer = [-1] * n\n for i in range(n):\n colors[queries[i][1]] += 1 \n colors[balls[queries[i][0]]] -= 1\n if colors[balls[queries[i][0]]] <= 0:\n colors.pop(balls[queries[i][0]])\n balls[queries[i][0]] = queries[i][1]\n answer[i] = len(colors)\n return answer","memory":"71600"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n answer = []\n ball_color = {}\n color_balls = defaultdict(set)\n for (q_ball, q_color) in queries:\n\n \n # if ball already has a color, remove old entry and update color tracking\n if q_ball in ball_color:\n old_color = ball_color[q_ball]\n\n if old_color != q_color: \n color_balls[old_color].remove(q_ball)\n if not color_balls[old_color]:\n # if empty set, remove it to allow len() to work on dict\n del color_balls[old_color]\n\n ball_color[q_ball] = q_color\n color_balls[q_color].add(q_ball)\n answer.append(len(color_balls))\n\n\n return answer\n ","memory":"81300"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls, colors, ans = {}, {}, []\n for ball, color in queries:\n if ball in balls:\n colors[balls[ball]].remove(ball)\n if not colors[balls[ball]]:\n del colors[balls[ball]]\n balls[ball] = color\n if color not in colors:\n colors[color] = set()\n colors[color].add(ball)\n ans.append(len(colors))\n return ans","memory":"81900"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n balls = {}\n colors = {}\n result = [0]*len(queries)\n distinct = 0\n for i in range(len(queries)):\n ball, color = queries[i]\n if ball in balls:\n colors[balls[ball]].remove(ball)\n distinct -= 1 if not colors[balls[ball]] else 0\n distinct += 1 if color not in colors or not colors[color] else 0\n balls[ball] = color\n if color not in colors:\n colors[color] = set()\n colors[color].add(ball)\n result[i] = distinct\n return result","memory":"82000"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n colors, BallSet = {}, defaultdict(set)\n res = []\n for x,y in queries:\n if x in colors:\n old_color = colors[x]\n BallSet[old_color].remove(x)\n if not BallSet[old_color]:\n del BallSet[old_color]\n\n colors[x] = y\n BallSet[y].add(x)\n res.append(len(BallSet))\n \n return res","memory":"82100"},{"code":"class Solution:\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\n ball_map={}\n color_map={}\n results=[]\n result=0\n\n cache_unique_colors=set()\n for x, y in queries:\n\n old_ball_color=ball_map.get(x)\n if old_ball_color:\n color_map[old_ball_color].remove(x)\n if len(color_map[old_ball_color])==0:\n del color_map[old_ball_color]\n ball_map[x]=y\n\n if not color_map.get(y):\n color_map[y]=set()\n color_map[y].add(x)\n\n results.append(len(color_map))\n return results\n ","memory":"82200"}],"string":"[\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n b_colors = {}\\n col_count = {}\\n dis_colors = set()\\n res = []\\n\\n for x, y in queries:\\n if x in b_colors:\\n old_color = b_colors[x]\\n col_count[old_color] -= 1\\n if col_count[old_color] == 0:\\n dis_colors.remove(old_color)\\n\\n b_colors[x] = y\\n if y in col_count:\\n col_count[y] += 1\\n else:\\n col_count[y] = 1\\n dis_colors.add(y)\\n \\n res.append(len(dis_colors))\\n \\n return res\",\n \"memory\": \"67100\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color_counts = {}\\n ball_colors = {}\\n total = 0\\n result = []\\n for q in queries:\\n i, c = q\\n if color_counts.get(c, 0) == 0:\\n color_counts[c] = 1\\n total += 1\\n else:\\n color_counts[c] += 1\\n if i in ball_colors:\\n curr_c = ball_colors[i]\\n color_counts[curr_c] -= 1\\n if color_counts[curr_c] == 0:\\n total -= 1\\n \\n ball_colors[i] = c\\n result.append(total)\\n \\n return result\",\n \"memory\": \"67800\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_dict = dict()\\n color_dict = defaultdict(int)\\n res = []\\n count = 0\\n for ball, color in queries:\\n if ball not in ball_dict:\\n ball_dict[ball] = color\\n if color not in color_dict:\\n count += 1\\n color_dict[color] += 1\\n else:\\n old_color = ball_dict[ball]\\n if color_dict[old_color] == 1:\\n count -= 1\\n color_dict.pop(old_color)\\n else:\\n color_dict[old_color] -= 1\\n ball_dict[ball] = color\\n if color not in color_dict:\\n count += 1\\n color_dict[color] += 1\\n res.append(count)\\n return res\",\n \"memory\": \"68200\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_color = {} \\n color_count = defaultdict(int) \\n distinct_colors = 0 \\n ans = []\\n\\n for b, c in queries:\\n if b in ball_color:\\n prev_color = ball_color[b]\\n color_count[prev_color] -= 1\\n if color_count[prev_color] == 0:\\n distinct_colors -= 1\\n\\n if c != 0:\\n if color_count[c] == 0:\\n distinct_colors += 1\\n color_count[c] += 1\\n ball_color[b] = c \\n else:\\n if b in ball_color:\\n del ball_color[b] \\n \\n ans.append(distinct_colors)\\n return ans\",\n \"memory\": \"68300\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n num_balls_by_color = defaultdict(int)\\n color_by_ball = {}\\n ans = []\\n for ball, color in queries:\\n if ball in color_by_ball:\\n old_color = color_by_ball[ball]\\n num_balls_by_color[old_color] -= 1\\n if num_balls_by_color[old_color] == 0:\\n del num_balls_by_color[old_color]\\n color_by_ball[ball] = color\\n num_balls_by_color[color] += 1\\n ans.append(len(num_balls_by_color))\\n return ans\\n\\n \\n\",\n \"memory\": \"68400\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n myHash = {}\\n cnt = defaultdict(int)\\n res = []\\n\\n for x, y in queries:\\n cnt[y] += 1\\n\\n if x in myHash:\\n cnt[myHash[x]] -= 1\\n if cnt[myHash[x]] == 0:\\n cnt.pop(myHash[x])\\n \\n myHash[x] = y\\n \\n res.append(len(cnt))\\n \\n return res\\n \",\n \"memory\": \"68500\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_colors = {} # To store the color of each ball\\n color_count = {} # To store how many balls have a certain color\\n distinct_colors = 0 # To track the number of distinct colors\\n result = []\\n \\n for ball, color in queries:\\n if ball in ball_colors:\\n old_color = ball_colors[ball]\\n if old_color == color:\\n # No change needed, continue\\n result.append(distinct_colors)\\n continue\\n \\n # Decrease the count of the old color\\n color_count[old_color] -= 1\\n if color_count[old_color] == 0:\\n distinct_colors -= 1 # This color is no longer in use\\n \\n # Assign the new color to the ball\\n ball_colors[ball] = color\\n \\n # Update the count of the new color\\n if color not in color_count:\\n color_count[color] = 0\\n color_count[color] += 1\\n if color_count[color] == 1:\\n distinct_colors += 1 # This is a new distinct color\\n \\n # Append the current count of distinct colors\\n result.append(distinct_colors)\\n \\n return result\\n\\n \",\n \"memory\": \"68600\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n color = {}\\n color_count = {}\\n output = []\\n for x, y in queries:\\n if color.get(x, 0) != 0:\\n color_count[color[x]] -= 1\\n if color_count[color[x]] == 0:\\n del color_count[color[x]]\\n color[x] = y\\n color_count[y] = color_count.get(y, 0) + 1\\n output.append(len(color_count))\\n return output\",\n \"memory\": \"68700\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n limit += 1\\n arr = defaultdict(int)\\n d = defaultdict(int)\\n ans = []\\n\\n for x,y in queries:\\n prev = arr[x]\\n if prev:\\n d[prev] -= 1\\n if d[prev] == 0:\\n del d[prev]\\n arr[x] = y\\n d[y] += 1\\n \\n ans.append(len(d))\\n return ans\",\n \"memory\": \"68800\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = {}\\n ans = [0]\\n balls = defaultdict(int)\\n\\n for ball,color in queries:\\n c = balls[ball]\\n inc = 0\\n if c != 0:\\n if colors[c] == 1:\\n inc -= 1\\n colors.pop(c)\\n else:\\n colors[c] -= 1\\n\\n\\n if color in colors:\\n colors[color] += 1\\n else:\\n colors[color] = 1\\n inc += 1\\n ans.append(ans[-1]+inc)\\n balls[ball] = color\\n return ans[1:]\\n\",\n \"memory\": \"69000\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n res = [0]*len(queries)\\n ball_dic = dict()\\n colors_dic = defaultdict(int)\\n count = 0\\n for i, [ball, color] in enumerate(queries):\\n if ball in ball_dic:\\n prev_color = ball_dic[ball]\\n colors_dic[prev_color]-=1\\n if colors_dic[prev_color] == 0:\\n del colors_dic[prev_color]\\n ball_dic[ball] = color\\n colors_dic[color]+=1\\n res[i] = len(colors_dic.keys())\\n \\n return res\",\n \"memory\": \"69100\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n res = [0]*len(queries)\\n ball_dic = dict()\\n colors_dic = defaultdict(int)\\n count = 0\\n for i, [ball, color] in enumerate(queries):\\n if ball not in ball_dic:\\n ball_dic[ball] = color\\n colors_dic[color]+=1\\n else:\\n prev_color = ball_dic[ball]\\n colors_dic[prev_color]-=1\\n if colors_dic[prev_color] == 0:\\n del colors_dic[prev_color]\\n ball_dic[ball] = color\\n colors_dic[color]+=1\\n \\n res[i] = len(colors_dic.keys())\\n \\n return res\",\n \"memory\": \"69200\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, l: int, q: List[List[int]]) -> List[int]:\\n c,u,o=defaultdict(int),defaultdict(int),[0]*len(q)\\n for e,(x,y) in enumerate(q):\\n if (z:=c[x]):\\n if u[z]==1:\\n del u[z]\\n else: u[z]-=1\\n c[x]=y\\n u[y]+=1\\n o[e]=len(u)\\n return o\",\n \"memory\": \"69300\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n \\n # idx = color\\n dc = {}\\n # color = idx\\n dc2 = defaultdict(list)\\n res = []\\n for f,c in queries:\\n if f in dc:\\n dc2[dc[f]].remove(f)\\n if len(dc2[dc[f]])==0:\\n del dc2[dc[f]]\\n \\n dc[f]=c\\n dc2[c].append(f)\\n \\n res.append(len(dc2))\\n\\n return res\",\n \"memory\": \"69800\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n prev_color = defaultdict(int)\\n freq = defaultdict(int)\\n \\n res = []\\n for q in queries:\\n ball, new_color = q\\n prev = prev_color[ball]\\n freq[prev] -= 1\\n if freq[prev] <= 0:\\n freq.pop(prev)\\n prev_color[ball] = new_color\\n freq[new_color] += 1\\n res.append(len(freq))\\n \\n return res\",\n \"memory\": \"70400\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors = defaultdict(int)\\n balls = defaultdict(int)\\n n = len(queries)\\n answer = [-1] * n\\n for i in range(n):\\n colors[queries[i][1]] += 1 \\n colors[balls[queries[i][0]]] -= 1\\n if colors[balls[queries[i][0]]] <= 0:\\n colors.pop(balls[queries[i][0]])\\n balls[queries[i][0]] = queries[i][1]\\n answer[i] = len(colors)\\n return answer\",\n \"memory\": \"71600\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n answer = []\\n ball_color = {}\\n color_balls = defaultdict(set)\\n for (q_ball, q_color) in queries:\\n\\n \\n # if ball already has a color, remove old entry and update color tracking\\n if q_ball in ball_color:\\n old_color = ball_color[q_ball]\\n\\n if old_color != q_color: \\n color_balls[old_color].remove(q_ball)\\n if not color_balls[old_color]:\\n # if empty set, remove it to allow len() to work on dict\\n del color_balls[old_color]\\n\\n ball_color[q_ball] = q_color\\n color_balls[q_color].add(q_ball)\\n answer.append(len(color_balls))\\n\\n\\n return answer\\n \",\n \"memory\": \"81300\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls, colors, ans = {}, {}, []\\n for ball, color in queries:\\n if ball in balls:\\n colors[balls[ball]].remove(ball)\\n if not colors[balls[ball]]:\\n del colors[balls[ball]]\\n balls[ball] = color\\n if color not in colors:\\n colors[color] = set()\\n colors[color].add(ball)\\n ans.append(len(colors))\\n return ans\",\n \"memory\": \"81900\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n balls = {}\\n colors = {}\\n result = [0]*len(queries)\\n distinct = 0\\n for i in range(len(queries)):\\n ball, color = queries[i]\\n if ball in balls:\\n colors[balls[ball]].remove(ball)\\n distinct -= 1 if not colors[balls[ball]] else 0\\n distinct += 1 if color not in colors or not colors[color] else 0\\n balls[ball] = color\\n if color not in colors:\\n colors[color] = set()\\n colors[color].add(ball)\\n result[i] = distinct\\n return result\",\n \"memory\": \"82000\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n colors, BallSet = {}, defaultdict(set)\\n res = []\\n for x,y in queries:\\n if x in colors:\\n old_color = colors[x]\\n BallSet[old_color].remove(x)\\n if not BallSet[old_color]:\\n del BallSet[old_color]\\n\\n colors[x] = y\\n BallSet[y].add(x)\\n res.append(len(BallSet))\\n \\n return res\",\n \"memory\": \"82100\"\n },\n {\n \"code\": \"class Solution:\\n def queryResults(self, limit: int, queries: List[List[int]]) -> List[int]:\\n ball_map={}\\n color_map={}\\n results=[]\\n result=0\\n\\n cache_unique_colors=set()\\n for x, y in queries:\\n\\n old_ball_color=ball_map.get(x)\\n if old_ball_color:\\n color_map[old_ball_color].remove(x)\\n if len(color_map[old_ball_color])==0:\\n del color_map[old_ball_color]\\n ball_map[x]=y\\n\\n if not color_map.get(y):\\n color_map[y]=set()\\n color_map[y].add(x)\\n\\n results.append(len(color_map))\\n return results\\n \",\n \"memory\": \"82200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":21,"string":"21"}}},{"rowIdx":2446,"cells":{"question_id":{"kind":"number","value":3435,"string":"3,435"},"name":{"kind":"string","value":"block-placement-queries"},"content":{"kind":"string","value":"<p>There exists an infinite number line, with its origin at 0 and extending towards the <strong>positive</strong> x-axis.</p>\n\n<p>You are given a 2D array <code>queries</code>, which contains two types of queries:</p>\n\n<ol>\n\t<li>For a query of type 1, <code>queries[i] = [1, x]</code>. Build an obstacle at distance <code>x</code> from the origin. It is guaranteed that there is <strong>no</strong> obstacle at distance <code>x</code> when the query is asked.</li>\n\t<li>For a query of type 2, <code>queries[i] = [2, x, sz]</code>. Check if it is possible to place a block of size <code>sz</code> <em>anywhere</em> in the range <code>[0, x]</code> on the line, such that the block <strong>entirely</strong> lies in the range <code>[0, x]</code>. A block <strong>cannot </strong>be placed if it intersects with any obstacle, but it may touch it. Note that you do<strong> not</strong> actually place the block. Queries are separate.</li>\n</ol>\n\n<p>Return a boolean array <code>results</code>, where <code>results[i]</code> is <code>true</code> if you can place the block specified in the <code>i<sup>th</sup></code> query of type 2, and <code>false</code> otherwise.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">queries = [[1,2],[2,3,3],[2,3,1],[2,2,2]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">[false,true,true]</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><strong><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/22/example0block.png\" style=\"padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 309px; height: 129px;\" /></strong></p>\n\n<p>For query 0, place an obstacle at <code>x = 2</code>. A block of size at most 2 can be placed before <code>x = 3</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">queries = </span>[[1,7],[2,7,6],[1,2],[2,7,5],[2,7,6]]<!-- notionvc: 4a471445-5af1-4d72-b11b-94d351a2c8e9 --></p>\n\n<p><strong>Output:</strong> [true,true,false]</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><strong><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/22/example1block.png\" style=\"padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 310px; height: 130px;\" /></strong></p>\n\n<ul>\n\t<li>Place an obstacle at <code>x = 7</code> for query 0. A block of size at most 7 can be placed before <code>x = 7</code>.</li>\n\t<li>Place an obstacle at <code>x = 2</code> for query 2. Now, a block of size at most 5 can be placed before <code>x = 7</code>, and a block of size at most 2 before <code>x = 2</code>.</li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= queries.length <= 15 * 10<sup>4</sup></code></li>\n\t<li><code>2 <= queries[i].length <= 3</code></li>\n\t<li><code>1 <= queries[i][0] <= 2</code></li>\n\t<li><code>1 <= x, sz <= min(5 * 10<sup>4</sup>, 3 * queries.length)</code></li>\n\t<li>The input is generated such that for queries of type 1, no obstacle exists at distance <code>x</code> when the query is asked.</li>\n\t<li>The input is generated such that there is at least one query of type 2.</li>\n</ul>\n"},"acRate":{"kind":"number","value":14.17569880205362,"string":"14.175699"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","binary-search","binary-indexed-tree","segment-tree"],"string":"[\n \"array\",\n \"binary-search\",\n \"binary-indexed-tree\",\n \"segment-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"4109\", 5.5559], [\"4196\", 3.1748], [\"4283\", 0.7937], [\"4370\", 0.7937], [\"4456\", 0.7937], [\"4543\", 0.7937], [\"4630\", 0.7937], [\"4717\", 0.7937], [\"4804\", 1.5874], [\"4891\", 3.1748], [\"4978\", 1.5874], [\"5064\", 5.5558], [\"5151\", 3.1748], [\"5238\", 1.5874], [\"5325\", 0.7937], [\"5412\", 0.7937], [\"5499\", 0.7937], [\"5586\", 1.5873], [\"5672\", 0.7937], [\"5759\", 5.5559], [\"5846\", 4.7622], [\"5933\", 5.5559], [\"6020\", 4.762099999999999], [\"6107\", 1.5874], [\"6194\", 3.1748], [\"6280\", 1.5874], [\"6367\", 5.5558000000000005], [\"6454\", 2.3811], [\"6541\", 1.5874], [\"6628\", 0.7937], [\"6715\", 1.5874], [\"6802\", 0.7937], [\"6889\", 0.7937], [\"6975\", 0.7937], [\"7062\", 0.7937], [\"7149\", 0.7937], [\"7236\", 0.7937], [\"7323\", 0.7937], [\"7410\", 0.7937], [\"7497\", 0.7937], [\"7583\", 0.7937], [\"7670\", 0.7937], [\"7757\", 0.7937], [\"7844\", 0.7937], [\"7931\", 0.7937], [\"8018\", 0.7937], [\"8105\", 0.7937], [\"8191\", 0.7937], [\"8278\", 0.7937], [\"8365\", 0.7937], [\"8452\", 0.7937], [\"8539\", 0.7937], [\"8626\", 0.7937], [\"8713\", 0.7937], [\"8800\", 0.7937], [\"8886\", 0.7937], [\"8973\", 0.7937]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"86200\", 0.7937], [\"86400\", 0.7937], [\"86600\", 2.381], [\"86700\", 1.5873], [\"86800\", 1.5873], [\"86900\", 7.1429], [\"87000\", 2.381], [\"87200\", 2.381], [\"87300\", 1.5873], [\"87400\", 6.3492], [\"87500\", 7.9365], [\"87600\", 1.5873], [\"87900\", 1.5873], [\"88000\", 7.9365], [\"88100\", 3.1746], [\"88200\", 6.3492], [\"88300\", 4.7619], [\"88400\", 2.381], [\"88600\", 2.381], [\"88700\", 1.5873], [\"88800\", 2.381], [\"89000\", 1.5873], [\"89100\", 12.6984], [\"89200\", 3.9683], [\"89300\", 0.7937], [\"89400\", 0.7937], [\"89500\", 1.5873], [\"89600\", 2.381], [\"89700\", 1.5873]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n def beam_search(list_of_values, value):\n start = -1\n end = len(list_of_values)\n while end - start > 1:\n mid = (start + end) // 2\n if list_of_values[mid] >= value:\n end = mid\n if list_of_values[mid] <= value:\n start = mid\n return start, end\n \n value_list = [0]\n axis = []\n for query in queries:\n if query[0] == 1:\n value_list.append(query[1])\n else:\n axis.append(True)\n value_list = sorted(value_list)\n axis_perimeter = len(axis)\n mid = 0\n search_weights = []\n search_values = []\n for i in range(len(value_list) - 1):\n weight = value_list[i + 1] - value_list[i]\n if weight > mid:\n search_weights.append(weight)\n search_values.append(value_list[i])\n mid = weight\n\n query_len = len(queries)\n\n for q_i in range(len(queries)):\n query = queries[query_len - 1 - q_i]\n if query[0] == 1:\n value = query[1]\n i, i = beam_search(value_list, value) # these are equal in this case \n v_s, v_e = beam_search(search_values, value_list[i - 1])\n if i < len(value_list) - 1:\n weight = value_list[i + 1] - value_list[i - 1]\n w_s, w_e = beam_search(search_weights, weight)\n del search_weights[v_e : w_s + 1]\n del search_values[v_e : w_s + 1]\n if v_s < w_s or v_s == w_s and v_e <= w_e:\n search_weights.insert(v_e, weight)\n search_values.insert(v_e, value_list[i - 1])\n elif v_s == v_e:\n del search_weights[v_e]\n del search_values[v_e]\n del value_list[i]\n else:\n axis_perimeter -= 1 \n value = query[1]\n weight = query[2]\n i_s, i_e = beam_search(search_weights, weight)\n if i_e == len(search_weights):\n axis[axis_perimeter] = value - weight >= value_list[-1]\n else:\n axis[axis_perimeter] = value - weight >= search_values[i_e]\n return axis\n","runtime":"4109"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n def bsearch(l, v):\n b = -1\n e = len(l)\n while e - b > 1:\n m = (b + e) // 2\n if l[m] >= v:\n e = m\n if l[m] <= v:\n b = m\n return b, e\n l = [0]\n a = []\n for q in queries:\n if q[0] == 1:\n l.append(q[1])\n else:\n a.append(True)\n l = sorted(l)\n p = len(a)\n m = 0\n sw = []\n sv = []\n for i in range(len(l) - 1):\n w = l[i + 1] - l[i]\n if w > m:\n sw.append(w)\n sv.append(l[i])\n m = w\n n = len(queries)\n # print(l, sv, sw)\n for j in range(len(queries)):\n q = queries[n - 1 - j]\n if q[0] == 1:\n v = q[1]\n i, i = bsearch(l, v)\n vb, ve = bsearch(sv, l[i - 1])\n if i < len(l) - 1:\n w = l[i + 1] - l[i - 1]\n wb, we = bsearch(sw, w)\n # if wb == 7 and w == 12:\n # print(v, i, vb, ve, sv)\n # print('---', wb, we, sw)\n del sw[ve: wb + 1]\n del sv[ve: wb + 1]\n if vb < wb or vb == wb and ve <= we:\n sw.insert(ve, w)\n sv.insert(ve, l[i - 1])\n elif vb == ve:\n del sw[ve]\n del sv[ve]\n del l[i]\n else:\n p -= 1\n v = q[1]\n w = q[2]\n ib, ie = bsearch(sw, w)\n # if p == 23272:\n # print('====================', v, w, ib, ie, sv, sw)\n if ie == len(sw):\n a[p] = v - w >= l[-1]\n else:\n a[p] = v - w >= sv[ie]\n return a","runtime":"4109"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n def bsearch(l, v):\n b = -1\n e = len(l)\n while e - b > 1:\n m = (b + e) // 2\n if l[m] >= v:\n e = m\n if l[m] <= v:\n b = m\n return b, e\n l = [0]\n a = []\n for q in queries:\n if q[0] == 1:\n l.append(q[1])\n else:\n a.append(True)\n l = sorted(l)\n p = len(a)\n m = 0\n sw = []\n sv = []\n for i in range(len(l) - 1):\n w = l[i + 1] - l[i]\n if w > m:\n sw.append(w)\n sv.append(l[i])\n m = w\n n = len(queries)\n # print(l, sv, sw)\n for j in range(len(queries)):\n q = queries[n - 1 - j]\n if q[0] == 1:\n v = q[1]\n i, i = bsearch(l, v)\n vb, ve = bsearch(sv, l[i - 1])\n if i < len(l) - 1:\n w = l[i + 1] - l[i - 1]\n wb, we = bsearch(sw, w)\n # if wb == 7 and w == 12:\n # print(v, i, vb, ve, sv)\n # print('---', wb, we, sw)\n del sw[ve: wb + 1]\n del sv[ve: wb + 1]\n if vb < wb or vb == wb and ve <= we:\n sw.insert(ve, w)\n sv.insert(ve, l[i - 1])\n elif vb == ve:\n del sw[ve]\n del sv[ve]\n del l[i]\n else:\n p -= 1\n v = q[1]\n w = q[2]\n ib, ie = bsearch(sw, w)\n # if p == 23272:\n # print('====================', v, w, ib, ie, sv, sw)\n if ie == len(sw):\n a[p] = v - w >= l[-1]\n else:\n a[p] = v - w >= sv[ie]\n return a","runtime":"4196"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # modified binary search to find boundary of value in value list range\n def boundary_search(list_of_values, value):\n start = -1\n end = len(list_of_values)\n while end - start > 1:\n mid = (start + end) // 2\n if list_of_values[mid] >= value:\n end = mid\n if list_of_values[mid] <= value:\n start = mid\n return start, end\n \n # value list starts at 0\n value_list = [0]\n # axis starts empty \n axis = []\n # iterate queries\n # on type 1, place the obstacle in the value list \n # on type 2, append true \n for query in queries:\n if query[0] == 1:\n value_list.append(query[1])\n else:\n axis.append(True)\n # sort the x values in ascending order of query type 1\n value_list = sorted(value_list)\n # determine your axial perimeter originally as the length of axis\n # these are you type 2 that you need to consider, a perimeter of the number of options \n axis_perimeter = len(axis)\n # set max weight to 0\n max_weight = 0\n # set an array of search weights and values\n search_weights = []\n search_values = []\n for i in range(len(value_list) - 1):\n # get your weight current as the value list difference of one ahead and current\n weight = value_list[i + 1] - value_list[i]\n # if the weight is greater than the max_weight, append the weight and the ith value list of position\n # then set max weight to the new weight \n if weight > max_weight:\n search_weights.append(weight)\n search_values.append(value_list[i])\n max_weight = weight\n\n # now get the length of your queries \n query_len = len(queries)\n # then, loop over and process it \n for q_i in range(len(queries)):\n # use the original query size less one, less the ith query position to get the current query\n query = queries[query_len - 1 - q_i]\n # if of type 1\n if query[0] == 1:\n # get the value \n value = query[1]\n # use the boundary search to get the start and end positions\n i, i = boundary_search(value_list, value) # these are equal in this case \n # get the value bounding as needed \n v_s, v_e = boundary_search(search_values, value_list[i - 1])\n # if the index is in range currently \n if i < len(value_list) - 1:\n # get the weight as the difference of boundary positions \n weight = value_list[i + 1] - value_list[i - 1]\n # use this to get the bounds of that weight \n w_s, w_e = boundary_search(search_weights, weight)\n # use this to remove segments from these sections\n # this is an abstraction of a segment tree approach\n del search_weights[v_e : w_s + 1]\n del search_values[v_e : w_s + 1]\n # if value start is lt weight start or they are equal and value end bounds \n if v_s < w_s or (v_s == w_s and v_e <= w_e):\n # then we need to reinsert at the value end position the weight and value respectively\n search_weights.insert(v_e, weight)\n search_values.insert(v_e, value_list[i - 1])\n elif v_s == v_e:\n # otherwise, if not in range, remove these end points\n del search_weights[v_e]\n del search_values[v_e]\n # at end, remove an item from value list at index i \n del value_list[i]\n else:\n # if not of type 1, reduce the perimeter by 1 for the number of options \n axis_perimeter -= 1 \n # get the value and weight \n value = query[1]\n weight = query[2]\n # find the bounds that are acceptable \n i_s, i_e = boundary_search(search_weights, weight)\n # if the index ending is of matching length, \n # at the axis perimeter, mark the relation of value and weight difference to your greatest positional obstacle \n # otherwise, mark it in relation of value and weight difference to the values at index end boundary\n if i_e == len(search_weights):\n axis[axis_perimeter] = value - weight >= value_list[-1]\n else:\n axis[axis_perimeter] = value - weight >= search_values[i_e]\n # when done your completed axis contains your answer \n return axis\n","runtime":"4196"},{"code":"from typing import List\nimport bisect\n\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n obstacles = [0]\n n = min(5 * 10**4, len(queries) * 3)\n obstacles.append(n)\n \n to_add = []\n results = []\n\n for q in queries:\n if q[0] == 1:\n to_add.append(q[1])\n \n obstacles.extend(to_add)\n obstacles = sorted(set(obstacles))\n \n bit = BIT(n + 1)\n\n for i in range(1, len(obstacles)):\n bit.add(obstacles[i], obstacles[i] - obstacles[i - 1])\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n idx = bisect.bisect_left(obstacles, x)\n if idx < len(obstacles) - 1:\n after = obstacles[idx + 1]\n else:\n after = n\n if idx > 0:\n before = obstacles[idx - 1]\n else:\n before = 0\n bit.add(after, after - before)\n obstacles.pop(idx)\n else:\n _, x, sz = q\n idx = bisect.bisect_right(obstacles, x)\n before = obstacles[idx - 1]\n results.append(bit.query(before) >= sz or (x - before) >= sz)\n \n results.reverse()\n return results\n","runtime":"4283"},{"code":"from typing import List\nimport bisect\n\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n obstacles = [0]\n n = min(5 * 10**4, len(queries) * 3)\n obstacles.append(n)\n \n to_add = []\n results = []\n\n for q in queries:\n if q[0] == 1:\n to_add.append(q[1])\n \n obstacles.extend(to_add)\n obstacles = sorted(set(obstacles))\n \n bit = BIT(n + 1)\n\n for i in range(1, len(obstacles)):\n bit.add(obstacles[i], obstacles[i] - obstacles[i - 1])\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n idx = bisect.bisect_left(obstacles, x)\n if idx < len(obstacles) - 1:\n after = obstacles[idx + 1]\n else:\n after = n\n if idx > 0:\n before = obstacles[idx - 1]\n else:\n before = 0\n bit.add(after, after - before)\n obstacles.pop(idx)\n else:\n _, x, sz = q\n idx = bisect.bisect_right(obstacles, x)\n before = obstacles[idx - 1]\n results.append(bit.query(before) >= sz or (x - before) >= sz)\n \n results.reverse()\n return results","runtime":"4543"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n barriers = SortedList()\n barriers.add(0)\n for query in queries:\n if query[0] == 1:\n it = query[1]\n barriers.add(it)\n holes = SortedList()\n holes.add(float(\"inf\"))\n hole2start = {float(\"inf\"): barriers[-1]}\n for pos in range(len(barriers) - 1):\n start = barriers[pos]\n end = barriers[pos + 1]\n size = end - start\n if size:\n pos = holes.bisect_left(size)\n hole_size = holes[pos]\n if hole2start[hole_size] > start:\n if hole_size > size:\n holes.add(size)\n hole2start[size] = start\n barriers.add(float(\"inf\"))\n result = []\n for query in reversed(queries):\n if query[0] == 1:\n it = query[1]\n pos = barriers.bisect_left(it)\n left = barriers[pos - 1]\n right = barriers[pos + 1]\n size = right - left\n hole_pos = holes.bisect_left(size)\n if hole2start[holes[hole_pos]] > left:\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\n del hole2start[holes[hole_pos - 1]]\n del holes[hole_pos - 1]\n hole_pos -= 1\n hole2start[size] = left\n if holes[hole_pos] != size:\n holes.add(size)\n barriers.remove(it)\n else:\n _, start, size = query\n hole_pos = holes.bisect_left(size)\n hole = holes[hole_pos]\n result.append(hole2start[hole] <= start - size)\n result.reverse()\n return result","runtime":"4630"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n barriers = SortedList()\n barriers.add(0)\n for query in queries:\n if query[0] == 1:\n it = query[1]\n barriers.add(it)\n holes = SortedList()\n holes.add(float(\"inf\"))\n hole2start = {float(\"inf\"): barriers[-1]}\n for pos in range(len(barriers) - 1):\n start = barriers[pos]\n end = barriers[pos + 1]\n size = end - start\n if size:\n pos = holes.bisect_left(size)\n hole_size = holes[pos]\n if hole2start[hole_size] > start:\n if hole_size > size:\n holes.add(size)\n hole2start[size] = start\n barriers.add(float(\"inf\"))\n result = []\n for query in reversed(queries):\n if query[0] == 1:\n it = query[1]\n pos = barriers.bisect_left(it)\n left = barriers[pos - 1]\n right = barriers[pos + 1]\n size = right - left\n hole_pos = holes.bisect_left(size)\n if hole2start[holes[hole_pos]] > left:\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\n del hole2start[holes[hole_pos - 1]]\n del holes[hole_pos - 1]\n hole_pos -= 1\n hole2start[size] = left\n if holes[hole_pos] != size:\n holes.add(size)\n barriers.remove(it)\n else:\n _, start, size = query\n hole_pos = holes.bisect_left(size)\n hole = holes[hole_pos]\n result.append(hole2start[hole] <= start - size)\n result.reverse()\n return result\n","runtime":"4717"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n \n\n barriers = SortedList() # Sorted list to maintain barrier positions\n barriers.add(0) # Add initial barrier at position 0\n\n # Process the add-barrier queries to populate the barriers list\n for query in queries:\n if query[0] == 1:\n it = query[1]\n barriers.add(it)\n\n holes = SortedList() # Sorted list to maintain hole sizes\n holes.add(float('inf')) # Initialize with an infinitely large hole\n hole2start = {float('inf'): barriers[-1]}\n\n # Calculate initial hole sizes based on the barriers\n for pos in range(len(barriers) - 1):\n start = barriers[pos]\n end = barriers[pos + 1]\n size = end - start\n if size:\n pos = holes.bisect_left(size)\n hole_size = holes[pos]\n if hole2start[hole_size] > start:\n if hole_size > size:\n holes.add(size)\n hole2start[size] = start\n\n barriers.add(float('inf')) # Add an infinite barrier at the end\n\n result = []\n # Process the queries in reverse order\n for query in reversed(queries):\n if query[0] == 1: # If it's an add-barrier query\n it = query[1]\n pos = barriers.bisect_left(it)\n left = barriers[pos - 1]\n right = barriers[pos + 1]\n size = right - left\n\n hole_pos = holes.bisect_left(size)\n if hole2start[holes[hole_pos]] > left:\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\n hole2start.pop(holes[hole_pos - 1])\n holes.pop(hole_pos - 1)\n hole_pos -= 1\n\n hole2start[size] = left\n if holes[hole_pos] != size:\n holes.add(size)\n\n barriers.remove(it)\n else: # If it's a check-hole query\n _, start, size = query\n hole_pos = holes.bisect_left(size)\n hole = holes[hole_pos]\n result.append(hole2start[hole] <= start - size)\n\n result.reverse() # Reverse the result to match the original query order\n\n return result","runtime":"4804"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n obsticals = dict()\n obsticalss = []\n result = []\n for query in queries:\n if query[0] == 1:\n #obsticalss.append(query[1])\n #obsticalss.sort()\n if not len(obsticalss) < 3:\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1])\n obsticalss.insert(index, query[1])\n else:\n obsticalss.append(query[1])\n obsticalss.sort()\n index = obsticalss.index(query[1])\n obsticals[query[1]] = max(query[1] - obsticalss[index-1], obsticals[obsticalss[index-1]]) if index != 0 else query[1]\n for why in range(index+1, len(obsticalss)):\n prev = obsticals[obsticalss[why]]\n obsticals[obsticalss[why]] = max(obsticalss[why] - obsticalss[why-1], obsticals[obsticalss[why-1]])\n if prev == obsticals[obsticalss[why]]:\n break\n else:\n try:\n if obsticals[query[1]] >= query[2]:\n result.append(True)\n else:\n result.append(False)\n except:\n if not len(obsticalss) < 3:\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1]) - 1\n else:\n ok = obsticalss[:]\n ok.append(query[1])\n ok.sort()\n index = ok.index(query[1]) - 1\n\n if index == -1:\n if query[1] >= query[2]:\n result.append(True)\n else:\n result.append(False)\n elif obsticals[obsticalss[index]] >= query[2] or (query[1] - obsticalss[index]) >= query[2]:\n result.append(True)\n else:\n result.append(False)\n return result\n \n def BinarySearchModified(self, arr, low, high, x):\n while high - low > 1:\n mid = low + (high - low)//2\n if arr[mid] > x:\n if arr[low] < x:\n high = mid\n else:\n return low\n else:\n if arr[high] > x:\n low = mid\n else:\n return high+1\n return high\n","runtime":"4804"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n barriers = SortedList() # Sorted list to maintain barrier positions\n barriers.add(0) # Add initial barrier at position 0\n\n # Process the add-barrier queries to populate the barriers list\n for query in queries:\n if query[0] == 1:\n it = query[1]\n barriers.add(it)\n\n holes = SortedList() # Sorted list to maintain hole sizes\n holes.add(float('inf')) # Initialize with an infinitely large hole\n hole2start = {float('inf'): barriers[-1]}\n\n # Calculate initial hole sizes based on the barriers\n for pos in range(len(barriers) - 1):\n start = barriers[pos]\n end = barriers[pos + 1]\n size = end - start\n if size:\n pos = holes.bisect_left(size)\n hole_size = holes[pos]\n if hole2start[hole_size] > start:\n if hole_size > size:\n holes.add(size)\n hole2start[size] = start\n\n barriers.add(float('inf')) # Add an infinite barrier at the end\n \n result = []\n # Process the queries in reverse order\n for query in reversed(queries):\n if query[0] == 1: # If it's an add-barrier query\n it = query[1]\n pos = barriers.bisect_left(it)\n left = barriers[pos - 1]\n right = barriers[pos + 1]\n size = right - left\n\n hole_pos = holes.bisect_left(size)\n if hole2start[holes[hole_pos]] > left:\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\n del hole2start[holes[hole_pos - 1]]\n del holes[hole_pos - 1]\n hole_pos -= 1\n\n hole2start[size] = left\n if holes[hole_pos] != size:\n holes.add(size)\n\n barriers.remove(it)\n else: # If it's a check-hole query\n _, start, size = query\n hole_pos = holes.bisect_left(size)\n hole = holes[hole_pos]\n result.append(hole2start[hole] <= start - size)\n\n result.reverse() # Reverse the result to match the original query order\n\n return result","runtime":"4891"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n return get_results(queries)\n \nfrom bisect import bisect_left\n\ndef get_results(queries):\n main = []\n larg = []\n ans = []\n\n for q in queries:\n if q[0] == 1:\n ind = bisect_left(main, q[1])\n main.insert(ind, q[1])\n larg.insert(ind, q[1] if ind == 0 else max(larg[ind - 1], q[1] - main[ind - 1]))\n ind += 1\n while ind < len(main) and larg[ind] != (new_larg := max(larg[ind - 1], main[ind] - main[ind - 1])):\n larg[ind] = new_larg\n ind += 1\n else:\n ind = bisect_left(main, q[1])\n lim = q[1] if ind == 0 else (larg[ind - 1] if main[ind - 1] == q[1] else max(larg[ind - 1], q[1] - main[ind - 1]))\n ans.append(q[2] <= lim)\n\n return ans\n","runtime":"4891"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val);\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","runtime":"4978"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val);\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","runtime":"4978"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val);\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","runtime":"5064"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # keep track of the obstacles\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\n # say it lies between obstacle[i] and obstacle[i+1]\n\n from bisect import bisect_right, insort\n obstacles = [0]\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\n\n output = []\n for t, *rest in queries:\n #print(f\"{obstacles=} {largest_possible=}\")\n if t == 1:\n # insert into obstacles\n obs_pos = rest[0]\n idx = bisect_right(obstacles, obs_pos)\n if idx == len(obstacles):\n # largest obstacle\n prev_largest = largest_possible[-1]\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\n largest_possible.append(new_largest)\n insort(obstacles, obs_pos)\n else:\n # somewhere in between\n prev_largest = largest_possible[idx - 1]\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\n largest_possible.insert(idx, new_largest)\n insort(obstacles, obs_pos)\n for cur_idx in range(idx + 1, len(obstacles)):\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\n if largest_possible[cur_idx] > new_largest:\n largest_possible[cur_idx] = new_largest\n else:\n break\n #output.append(False)\n else:\n obs_pos = rest[0]\n size = rest[1]\n idx = bisect_right(obstacles, obs_pos)\n #print(f\"{obs_pos=} {size=} {idx=}\")\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\n output.append(possible >= size)\n\n return output \n\n\n\n\n\n\n ","runtime":"5064"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val)\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","runtime":"5151"},{"code":"from sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n gap = SortedList()\n gap.add((0, 0))\n curr = 0\n for x, y in pairwise(sl):\n if (g := y - x) > curr:\n gap.add((y, g))\n curr = g\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n g = after - before\n index = gap.bisect_left((x, 0))\n while index < len(gap) and gap[index][1] <= g:\n gap.pop(index)\n if gap[index - 1][1] < g:\n gap.add((after, g))\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n index = gap.bisect_right((before, math.inf)) - 1\n ans.append((x - before) >= sz or gap[index][1] >= sz)\n \n ans.reverse()\n return ans","runtime":"5151"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n gap = SortedList()\n gap.add((0, 0))\n curr = 0\n for x, y in pairwise(sl):\n if (g := y - x) > curr:\n gap.add((y, g))\n curr = g\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n g = after - before\n index = gap.bisect_left((x, 0))\n while index < len(gap) and gap[index][1] <= g:\n gap.pop(index)\n if gap[index - 1][1] < g:\n gap.add((after, g))\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n index = gap.bisect_right((before, math.inf)) - 1\n ans.append((x - before) >= sz or gap[index][1] >= sz)\n \n ans.reverse()\n return ans\n ","runtime":"5238"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n def find(x):\n r = len(obstacle)\n l = -1\n while r-l>1:\n med = (l+r)//2\n if obstacle[med]<=x:\n l = med\n elif x<obstacle[med]:\n r = med\n return l\n \n def maxsz(r):\n res = 0\n while r>=0:\n res = max(res, t[r])\n r = (r & (r+1)) - 1\n return res\n\n def modify(i, d):\n while i<n:\n t[i] = max(t[i],d)\n i = i | (i + 1)\n\n\n n = max(queries, key=lambda x: x[1])[1]+1\n t = [0]*(n+1)\n a = [0]*(n+1)\n obstacle = [0] + sorted([x for t, x, *sz in queries if t == 1]) + [n]\n m = len(obstacle)\n for i in range(1,m-1):\n a[obstacle[i]] = obstacle[i] - obstacle[i-1]\n modify(obstacle[i], a[obstacle[i]])\n ans =[]\n q = len(queries)\n for i in range(q-1,-1,-1):\n x = queries[i]\n if x[0] == 2:\n priv = obstacle[find(x[1])]\n sz = max(maxsz(priv),x[1]-priv)\n ans.append(sz>=x[2])\n else:\n l = find(x[1])\n nex = obstacle[l+1]\n a[nex] += a[x[1]]\n modify(nex,a[nex])\n del obstacle[l]\n return ans[::-1]","runtime":"5238"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5325"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5412"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5499"},{"code":"from sortedcontainers import SortedList\nfrom itertools import pairwise\n\n# the logic here is to perform the queries in reverse order\n# we use a BIT to store the ranges over which we can place a block\n# we use a SortedList to store the obstacles and the \"ends\" of this infinte line, which are\n# defined in the problem constraints\n\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.bit = [0 for _ in range(n+1)]\n\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.bit[i] = max(self.bit[i], x)\n i += i & -i\n\n def get(self, i):\n i += 1\n res = 0\n while i:\n res = max(self.bit[i], res)\n i -= i & -i\n return res\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(5 * 10**4, 3 * len(queries))\n t = BIT(n+1)\n sl = SortedList()\n sl.add(0)\n sl.add(n)\n\n for q in queries:\n if q[0] == 1:\n sl.add(q[1])\n\n for x, y in pairwise(sl):\n t.add(y, y - x)\n\n res = []\n for q in reversed(queries):\n if q[0] == 1:\n idx = sl.index(q[1])\n before = sl[idx - 1]\n after = sl[idx + 1]\n sl.remove(q[1])\n t.add(after, after - before)\n else:\n x, sz = q[1], q[2]\n idx = sl.bisect_right(x)\n before = sl[idx - 1]\n\n res.append(t.get(before) >= sz or x - before >= sz)\n\n return res[::-1]","runtime":"5586"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5672"},{"code":"\nfrom sortedcontainers import SortedList\nclass BIT:\n def __init__(self, size):\n self.bit = [0] * (size + 1)\n def update(self, pos, value):\n pos += 1\n while pos < len(self.bit):\n self.bit[pos] = max(self.bit[pos], value)\n pos += pos & -pos\n def pre_max(self, pos):\n pos += 1\n res = 0\n while pos > 0:\n res = max(res, self.bit[pos])\n pos -= pos & -pos\n return res\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n mx = max(q[1] for q in queries) + 1\n pos = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [mx] # mx prevent index out of range, there is no type 2 query on its right\n bit = BIT(len(pos))\n for i in range(1, len(pos)):\n i += 1\n bit.bit[i] = max(bit.bit[i], pos[i-1] - pos[i-2])\n p = i + (i & -i)\n if p < len(bit.bit):\n bit.bit[p] = max(bit.bit[p], bit.bit[i])\n\n sl = SortedList(pos)\n ans = []\n for q in reversed(queries):\n x = q[1]\n i = sl.bisect_left(x)\n left = sl[i-1]\n if q[0] == 1:\n sl.discard(x)\n right = sl[i]\n bit.update(bisect_left(pos, right), right - left)\n else:\n mx_gap = max(bit.pre_max(bisect_left(pos, left)), x - left)\n ans.append(mx_gap >= q[2])\n return ans[::-1]","runtime":"5759"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5759"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5846"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","runtime":"5846"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\n\nfrom sortedcontainers import SortedList\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10**4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n\n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n\n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n\n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n\n ans.reverse()\n return ans\n","runtime":"5933"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n blockends = [[0, 0]]\n res = []\n \n for query in queries:\n typeQ = query[0]\n xCoord = query[1]\n # binary search to find where the obstacle should be placed/where an obstacle might be\n lo = 0\n hi = len(blockends) - 1\n\n while lo < hi:\n mid = math.ceil((lo + hi)/2)\n wallLocation = blockends[mid][0]\n if wallLocation >= xCoord:\n hi = mid - 1\n else:\n lo = mid \n\n if typeQ == 1:\n # note the lo + 1'th index is where we should place the obstacle (since the lo-th index exits)\n blockends.insert(lo + 1, [query[1], max(blockends[lo][1], query[1] - blockends[lo][0])])\n lo += 1\n\n # updating all the obstacles to the right of the one we just placed\n while lo + 1 < len(blockends) and blockends[lo][1] < blockends[lo + 1][1] and blockends[lo + 1][0] - blockends[lo][0] < blockends[lo + 1][1]:\n blockends[lo + 1][1] = max(blockends[lo][1], blockends[lo + 1][0] - blockends[lo][0])\n lo += 1\n else:\n size = query[2]\n\n openSpace = max(query[1] - blockends[lo][0], blockends[lo][1])\n res.append(openSpace >= size)\n \n print(blockends)\n return res \n\n","runtime":"5933"},{"code":"class seg_tree():\n def __init__(self, length):\n n = 1\n while n < length: n <<= 1\n self.n = n\n self.x = [0]*n + [0]*length + [0]*(n-length)\n for i in range(n-1, 0, -1):\n self.x[i] = self.x[2*i]+self.x[2*i+1]\n \n def update(self, index, val):\n index += self.n\n self.x[index] = val\n while index > 0:\n index //= 2\n self.x[index] = max(self.x[index*2], self.x[index*2+1])\n \n def query(self, l, r):\n ans = []\n l += self.n\n r += self.n\n while l <= r:\n if l%2 == 1:\n ans.append(self.x[l])\n l += 1\n if r%2 == 0:\n ans.append(self.x[r])\n r -=1\n l, r = l//2, r//2\n return max(ans)\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = max([q[1] for q in queries])\n st = seg_tree(n+1)\n obstacles = [0]\n\n ans = []\n for i, q in enumerate(queries): \n loc = q[1]\n if q[0] == 1:\n idx = bisect.bisect_left(obstacles, loc)\n prev = obstacles[idx-1]\n st.update(loc, loc-prev)\n if idx < len(obstacles): \n nxt = obstacles[idx]\n st.update(nxt, nxt-loc)\n bisect.insort_left(obstacles, loc)\n else:\n idx = bisect.bisect_left(obstacles, loc)\n prev = obstacles[idx-1]\n maxx = max(loc-prev, st.query(0, prev))\n ans.append(q[2] <= maxx)\n return ans","runtime":"6020"},{"code":"class Ftree:\n def __init__(self, n):\n self.n = n\n self.t = [0 for _ in range(n)]\n\n def max(self, i):\n res = 0\n while i >= 0:\n res = max(res, self.t[i])\n i = (i & (i + 1)) - 1\n return res\n\n def update(self, i, v):\n while i < self.n:\n self.t[i] = max(self.t[i], v)\n i = (i | (i + 1))\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n from sortedcontainers import SortedList\n m = min(5 * 10**4, 3 * len(queries))\n sl = SortedList([0, m])\n for query in queries:\n if query[0] == 1:\n sl.add(query[1])\n bit = Ftree(m + 1)\n last = 0\n for l, r in pairwise(sl):\n bit.update(r, r - l)\n ans = []\n for query in reversed(queries):\n if query[0] == 1:\n v = sl.index(query[1])\n r = sl[v+1]\n l = sl[v-1]\n bit.update(r, r - l)\n sl.discard(sl[v])\n else:\n index = sl.bisect_right(query[1])\n before = sl[index - 1]\n val = bit.max(query[1])\n ans.append((val >= query[2]) or (query[1] - before >= query[2]) )\n # print(sl, bit.t, ans)\n return ans[::-1]","runtime":"6020"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","runtime":"6107"},{"code":"from sortedcontainers import SortedList\nfrom typing import List\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += self.lowbit(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= self.lowbit(i)\n return res\n\n @staticmethod\n def lowbit(i: int) -> int:\n return i & -i\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # Sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]\n\n","runtime":"6107"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def update(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.update(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.update(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","runtime":"6194"},{"code":"from sortedcontainers import SortedList\nfrom typing import List\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += self.lowbit(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= self.lowbit(i)\n return res\n\n @staticmethod\n def lowbit(i: int) -> int:\n return i & -i\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # Sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]\n\n\n","runtime":"6194"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","runtime":"6280"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: list[list[int]]) -> list[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","runtime":"6280"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: list[list[int]]) -> list[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","runtime":"6367"},{"code":"from sortedcontainers import SortedList\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n def maximize(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n])\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n for x1, x2 in itertools.pairwise(obstacles):\n tree.maximize(x2, x2 - x1)\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.maximize(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n return ans[::-1]","runtime":"6367"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n\n # Blocks along the axis\n axis = SortedList()\n\n # Range Max of intervals from 0 to each block\n itvl = SegTree(max(q[1] for q in queries))\n\n res = []\n axis.add(0)\n itvl.update(0,0)\n\n for q in queries:\n if q[0] == 1:\n ind = axis.bisect(q[1])\n if ind < len(axis):\n # Update the interval of the next block\n nxt = axis[ind]\n itvl.update(nxt, nxt-q[1])\n # Set the interval of the current block\n itvl.update(q[1], q[1] - axis[ind-1])\n # Add the current block on axis\n axis.add(q[1])\n else:\n # Find the previous block\n prv = axis[axis.bisect(q[1])-1]\n # Range query the max interval before prv\n mx = max(q[1]-prv, itvl.query(prv))\n\n res.append(q[2] <= mx)\n return res\n\nclass SegTree:\n\n def __init__(self, n: int):\n # self.n = 1 << n.bit_length()\n self.n = 2 ** (int(math.log2(n)) + 1)\n self.tree = [0] * (self.n*2)\n\n def update(self, ind: int, val: int):\n ind += self.n\n self.tree[ind] = val\n while ind > 1:\n ind //= 2\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\n \n def query(self, ind: int) -> int:\n ind += self.n\n res = self.tree[ind]\n while ind > 1:\n if ind%2 == 1:\n res = max(res, self.tree[ind-1])\n ind //= 2\n return res","runtime":"6454"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n\n # Blocks along the axis\n axis = SortedList()\n\n # Range Max of intervals from 0 to each block\n itvl = SegTree(max(q[1] for q in queries))\n\n res = []\n axis.add(0)\n itvl.update(0,0)\n\n for q in queries:\n if q[0] == 1:\n ind = axis.bisect(q[1])\n if ind < len(axis):\n # Update the interval of the next block\n nxt = axis[ind]\n itvl.update(nxt, nxt-q[1])\n # Set the interval of the current block\n itvl.update(q[1], q[1] - axis[ind-1])\n # Add the current block on axis\n axis.add(q[1])\n else:\n # Find the previous block\n prv = axis[axis.bisect(q[1])-1]\n # Range query the max interval before prv\n mx = max(q[1]-prv, itvl.query(prv))\n\n res.append(q[2] <= mx)\n return res\n\nclass SegTree:\n\n def __init__(self, n: int):\n self.n = 1 << n.bit_length()\n self.tree = [0] * (self.n*2)\n\n def update(self, ind: int, val: int):\n ind += self.n\n self.tree[ind] = val\n while ind > 1:\n ind //= 2\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\n \n def query(self, ind: int) -> int:\n ind += self.n\n res = self.tree[ind]\n while ind > 1:\n if ind%2 == 1:\n res = max(res, self.tree[ind-1])\n ind //= 2\n return res","runtime":"6454"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n\n # Blocks along the axis\n axis = SortedList()\n\n # Range Max of intervals from 0 to each block\n itvl = SegTree(max(q[1] for q in queries))\n\n res = []\n axis.add(0)\n itvl.update(0,0)\n\n for q in queries:\n if q[0] == 1:\n ind = axis.bisect(q[1])\n if ind < len(axis):\n # Update the interval of the next block\n nxt = axis[ind]\n itvl.update(nxt, nxt-q[1])\n # Set the interval of the current block\n itvl.update(q[1], q[1] - axis[ind-1])\n # Add the current block on axis\n axis.add(q[1])\n else:\n # Find the previous block\n prv = axis[axis.bisect(q[1])-1]\n # Range query the max interval before prv\n mx = max(q[1]-prv, itvl.query(prv))\n\n res.append(q[2] <= mx)\n return res\n\nclass SegTree:\n\n def __init__(self, n: int):\n self.n = 1 << n.bit_length()\n self.tree = [0] * (self.n*2)\n\n def update(self, ind: int, val: int):\n ind += self.n\n self.tree[ind] = val\n while ind > 1:\n ind //= 2\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\n \n def query(self, ind: int) -> int:\n ind += self.n\n res = self.tree[ind]\n while ind > 1:\n if ind%2 == 1:\n res = max(res, self.tree[ind-1])\n ind //= 2\n return res","runtime":"6541"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n deg2 = math.floor(math.log(max(x[1] for x in queries), 2)) + 1\n n = 2 ** deg2\n stsize = n * 2\n l = [0] * stsize # longest placement starting from the beginning of segment\n r = [0] * stsize # longest placement starting from the ending of segment\n m = [0] * stsize # longest placement overall in the segment\n\n # inital filling of the segment tree\n def fill(i=0, beg=0, size=n):\n l[i] = r[i] = m[i] = size\n if size > 1:\n li, ri = 2 * i + 1, 2 * i + 2\n hsize = size // 2\n fill(li, beg, hsize)\n fill(ri, beg + hsize, hsize)\n \n fill()\n\n # insert barrier operation\n def insert(x, i=0, beg=0, size=n):\n if size == 1:\n if x > beg:\n r[i] = 0\n else:\n l[i] = 0\n else:\n li, ri = 2 * i + 1, 2 * i + 2\n hsize = size // 2\n mid = beg + hsize\n if x <= mid:\n insert(x, li, beg, hsize)\n if x >= mid:\n insert(x, ri, mid, hsize)\n l[i] = l[li] + (l[ri] if l[li] == hsize else 0)\n r[i] = r[ri] + (r[li] if r[ri] == hsize else 0)\n m[i] = max(l[i], r[i], m[li], m[ri], r[li] + l[ri])\n\n # query\n # returns (left, max) \n # where `left` is max block size starting at the beginning of the segement (considering x constraint)\n # `max` is max block size overall in the chosen segment (considering x constraint)\n def get_max(x, i=0, beg=0, size=n):\n if size == 1:\n if x > beg:\n return l[i], m[i]\n else:\n return 0, 0\n li, ri = 2 * i + 1, 2 * i + 2\n hsize = size // 2\n mid = beg + hsize\n if x <= mid:\n return get_max(x, li, beg, hsize)\n lri, mr = get_max(x, ri, beg + hsize, hsize)\n lpart = l[li] + (lri if l[li] == hsize else 0)\n return lpart, max(m[li], mr, lpart, r[li] + lri)\n\n ret = []\n for q in queries:\n if q[0] == 1:\n insert(q[1])\n else:\n ret.append(get_max(q[1])[1] >= q[2])\n return ret","runtime":"6541"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n\n # Blocks along the axis\n axis = SortedList()\n\n # Range Max of intervals from 0 to each block\n itvl = SegTree(max(q[1] for q in queries))\n\n res = []\n axis.add(0)\n itvl.update(0,0)\n\n for q in queries:\n if q[0] == 1:\n ind = axis.bisect(q[1])\n if ind < len(axis):\n # Update the interval of the next block\n nxt = axis[ind]\n itvl.update(nxt, nxt-q[1])\n # Set the interval of the current block\n itvl.update(q[1], q[1] - axis[ind-1])\n # Add the current block on axis\n axis.add(q[1])\n else:\n # Find the previous block\n prv = axis[axis.bisect(q[1])-1]\n # Range query the max interval before prv\n mx = max(q[1]-prv, itvl.query(prv))\n\n res.append(q[2] <= mx)\n\n return res\n\nclass SegTree:\n\n def __init__(self, n: int):\n # self.n = 1 << n.bit_length()\n self.n = 2 ** (int(math.log2(n)) + 1)\n self.tree = [0] * (self.n*2 - 1)\n\n def update(self, ind: int, val: int):\n ind += self.n - 1\n self.tree[ind] = val\n while ind > 0:\n if ind % 2:\n ind //= 2\n else:\n ind //= 2\n ind -= 1\n self.tree[ind] = max(self.tree[ind*2+1], self.tree[ind*2+2])\n \n def query(self, ind: int) -> int:\n ind += self.n - 1\n res = self.tree[ind]\n while ind > 0:\n if ind%2 == 1: \n ind //= 2\n else:\n res = max(res, self.tree[ind-1])\n ind //= 2\n ind -= 1\n # res = max(res, self.tree[ind])\n return res","runtime":"6628"},{"code":"from typing import List\nfrom sortedcontainers import SortedList\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def add(self, i: int, val: int):\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += self.lowbit(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= self.lowbit(i)\n return res\n\n def lowbit(self, i: int) -> int:\n return i & -i\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n])\n\n for query in queries:\n if query[0] == 1:\n x = query[1]\n obstacles.add(x)\n\n x1 = obstacles[0]\n for i in range(1, len(obstacles)):\n x2 = obstacles[i]\n tree.add(x2, x2 - x1)\n x1 = x2\n\n for i in range(len(queries) - 1, -1, -1):\n query = queries[i]\n x = query[1]\n if query[0] == 1:\n next_idx = obstacles.bisect_right(x)\n prev_idx = obstacles.bisect_left(x) - 1\n if next_idx < len(obstacles):\n tree.add(obstacles[next_idx], obstacles[next_idx] - obstacles[prev_idx])\n obstacles.remove(x)\n else:\n sz = query[2]\n prev_idx = obstacles.bisect(x) - 1\n ans.append(tree.get(obstacles[prev_idx]) >= sz or x - obstacles[prev_idx] >= sz)\n\n ans.reverse()\n return ans\n\n# Example usage:\nsolution = Solution()\nqueries = [[2, 10, 2], [1, 10], [2, 9, 2], [1, 12], [2, 11, 2]]\nprint(solution.getResults(queries))\n","runtime":"6715"},{"code":"from sortedcontainers import SortedList\n\n\nclass SegmentTree:\n def __init__(self, size: int):\n self.size = size\n self.st = [0] * 2 * size\n\n def update(self, idx: int, val: int):\n idx += self.size\n self.st[idx] = val\n idx //= 2\n\n while idx > 0:\n self.st[idx] = max(self.st[2 * idx], self.st[2 * idx + 1])\n idx //= 2\n\n def query(self, left: int, right: int) -> int:\n left += self.size\n right += self.size\n max_val = -inf\n\n while left < right:\n if left & 1:\n max_val = max(max_val, self.st[left])\n left += 1\n\n left //= 2\n\n if right & 1:\n right -= 1\n max_val = max(max_val, self.st[right])\n\n right //= 2\n\n return max_val\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n X_MAX = min(5 * (10**4), 3 * len(queries))\n\n st = SegmentTree(X_MAX + 1)\n obstacles = SortedList([0, X_MAX])\n st.update(0, X_MAX)\n\n ans = []\n\n for query in queries:\n x = query[1]\n if query[0] == 1:\n idx = obstacles.bisect_left(x)\n prev_x = obstacles[idx - 1]\n st.update(prev_x, x - prev_x)\n st.update(x, obstacles[idx] - x)\n obstacles.add(x)\n else:\n sz = query[2]\n prev_x = obstacles[obstacles.bisect_right(x) - 1]\n max_in_range = st.query(0, prev_x)\n max_in_range = max(max_in_range, x - prev_x)\n ans.append(max_in_range >= sz)\n\n return ans\n","runtime":"6715"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n X = 1 + max(q[1] for q in queries)\n\n # build tree\n GAP = 0\n LEFT = 1\n RIGHT = 2\n tree = [[0, 0, 0] for _ in range(4 * X)]\n\n def maintain(i, l, r):\n this = tree[i]\n left = tree[2 * i]\n right = tree[2 * i + 1]\n\n # update leftmost and rightmost obstacle in this range\n this[LEFT] = left[LEFT] if left[LEFT] else right[LEFT]\n this[RIGHT] = right[RIGHT] if right[RIGHT] else left[RIGHT]\n\n # update biggest gap in this range\n leftcap = left[RIGHT] if left[RIGHT] else l\n rightcap = right[LEFT] if right[LEFT] else r\n this[GAP] = max(left[GAP], right[GAP], rightcap - leftcap)\n\n def construct(i, l, r):\n if l < r: # nothing to do for l == r initially\n m = (l + r) // 2\n construct(2 * i, l, m)\n construct(2 * i + 1, m + 1, r)\n maintain(i, l, r)\n \n construct(1, 0, X)\n\n def obstacle(i, l, r, x):\n if l == r:\n tree[i][LEFT] = tree[i][RIGHT] = x\n else:\n m = (l + r) // 2\n if x <= m:\n obstacle(2 * i, l, m, x)\n else:\n obstacle(2 * i + 1, m + 1, r, x)\n maintain(i, l, r)\n \n def gap_and_leftmost(i, l, r, x): # leftmost obstacle OR x\n if r == x:\n return tree[i][GAP], tree[i][LEFT] or x\n m = (l + r) // 2\n if x <= m:\n return gap_and_leftmost(2 * i, l, m, x)\n \n left = tree[2 * i]\n right_gap, right_left = gap_and_leftmost(2 * i + 1, m + 1, r, x)\n left_right = max(l, left[RIGHT])\n gap = max(left[GAP], right_gap, right_left - left_right)\n leftmost = left[LEFT] if left[LEFT] else right_left\n return gap, leftmost\n\n answers = []\n for q in queries:\n if q[0] == 1:\n obstacle(1, 0, X, q[1])\n else:\n gap, _ = gap_and_leftmost(1, 0, X, q[1])\n answers.append(q[2] <= gap)\n\n return answers","runtime":"6802"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n m = max(q[1] for q in queries) + 1\n t = [0] * (2 << m.bit_length())\n\n # 把 i 处的值改成 val\n def update(o, l, r, i, val):\n if l == r:\n t[o] = val\n return \n \n m = (l + r) // 2\n if i <= m:\n update(o * 2, l, m, i, val)\n else:\n update(o * 2 + 1, m + 1, r, i, val)\n t[o] = max(t[o * 2], t[o * 2 + 1])\n \n # 查询 [0,R] 中的最大值\n def query(o, l, r, R):\n if r <= R:\n return t[o]\n m = (l + r) // 2\n if R <= m:\n return query(o * 2, l, m, R)\n return max(t[o * 2], query(o * 2 + 1, m + 1, r, R))\n \n sl = SortedList([0, m]) # 哨兵\n ans = []\n for q in queries:\n x = q[1]\n i = sl.bisect_left(x)\n pre = sl[i - 1]\n if q[0] == 1:\n nxt = sl[i]\n sl.add(x)\n update(1, 0, m, x, x - pre)\n update(1, 0, m, nxt, nxt - x)\n else:\n max_gap = max(query(1, 0, m, pre), x - pre)\n ans.append(max_gap >= q[2])\n \n return ans","runtime":"6889"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n X = 1 + max(q[1] for q in queries)\n\n # built tree\n GAP = 0\n LEFT = 1\n RIGHT = 2\n tree = [[0, 0, 0] for _ in range(4 * X)]\n\n def maintain(i, l, r):\n this = tree[i]\n left = tree[2 * i]\n right = tree[2 * i + 1]\n\n # update leftmost and rightmost obstacle in this range\n this[LEFT] = left[LEFT] if left[LEFT] else right[LEFT]\n this[RIGHT] = right[RIGHT] if right[RIGHT] else left[RIGHT]\n\n # update biggest gap in this range\n leftcap = left[RIGHT] if left[RIGHT] else l\n rightcap = right[LEFT] if right[LEFT] else r\n this[GAP] = max(left[GAP], right[GAP], rightcap - leftcap)\n\n def construct(i, l, r):\n if l < r: # nothing to do for l == r initially\n m = (l + r) // 2\n construct(2 * i, l, m)\n construct(2 * i + 1, m + 1, r)\n maintain(i, l, r)\n \n construct(1, 0, X)\n\n def obstacle(i, l, r, x):\n if l == r:\n tree[i][LEFT] = tree[i][RIGHT] = x\n else:\n m = (l + r) // 2\n if x <= m:\n obstacle(2 * i, l, m, x)\n else:\n obstacle(2 * i + 1, m + 1, r, x)\n maintain(i, l, r)\n \n def gap_and_leftmost(i, l, r, x): # leftmost obstacle OR x\n if r == x:\n return tree[i][GAP], tree[i][LEFT] or x\n m = (l + r) // 2\n if x <= m:\n return gap_and_leftmost(2 * i, l, m, x)\n \n left = tree[2 * i]\n right_gap, right_left = gap_and_leftmost(2 * i + 1, m + 1, r, x)\n left_right = max(l, left[RIGHT])\n gap = max(left[GAP], right_gap, right_left - left_right)\n leftmost = left[LEFT] if left[LEFT] else right_left\n #print(f\"{i}: {left=}, {right_gap=}, {right_left=}, {left_right=}, {gap=}, {leftmost=}\")\n return gap, leftmost\n\n answers = []\n for q in queries:\n if q[0] == 1:\n obstacle(1, 0, X, q[1])\n else:\n gap, left = gap_and_leftmost(1, 0, X, q[1])\n print(gap, left)\n answers.append(q[2] <= gap)\n\n return answers","runtime":"6975"},{"code":"from numpy import array,arange\nfrom bisect import bisect_left,insort_left\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n result,obstacles,prev_obstacle_idx,index = [],[0],0,0\n arr = array([-1] * 50001)\n arr[0] = 1\n for q in queries:\n x = q[1]\n if len(obstacles) == 1:\n prev_obstacle_idx = obstacles[0]\n else:\n index = bisect_left(obstacles,x) \n if index > 0:\n prev_obstacle_idx = obstacles[index-1]\n if q[0] == 1:\n arr[x] = 1\n arr[prev_obstacle_idx+1:x] = arange(len(arr[prev_obstacle_idx+1:x])+1,1,-1)\n insort_left(obstacles,x)\n else:\n sz = q[2]\n dist = x - prev_obstacle_idx\n if prev_obstacle_idx == 0:\n prev_obstacle_idx = 1\n result.append(max(dist,arr[:prev_obstacle_idx].max()) >= sz) \n return result","runtime":"7062"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","runtime":"7149"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","runtime":"7236"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","runtime":"7323"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"7410"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"7497"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"7583"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","runtime":"7670"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"7757"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"7844"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","runtime":"7931"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res\n \n \n ","runtime":"8018"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n #[longest contineous length, leftmost continuous length, rightmost continuous length]\n self.l=min(50000, 3*len(queries))\n self.st=[[0,0,0,True] for i in range(4*self.l)]\n self.block=set()\n\n # index i on x-axis: segment[i,i+1]\n def up(self,i,l,r):\n L=i<<1\n R=L|1\n mid=(l+r)>>1\n if mid+1 not in self.block:\n lcl=max(self.st[L][0],self.st[R][0],self.st[L][2]+self.st[R][1])\n\n if self.st[L][3]:\n Lcl=self.st[L][1]+self.st[R][1]\n else:\n Lcl=self.st[L][1]\n\n if self.st[R][3]:\n Rcl=self.st[R][2]+self.st[L][2]\n else:\n Rcl=self.st[R][2]\n\n con=self.st[L][3]&self.st[R][3]\n else:\n lcl=max(self.st[L][0],self.st[R][0])\n Lcl=self.st[L][1]\n Rcl=self.st[R][2]\n con=False\n self.st[i]=[lcl,Lcl,Rcl,con]\n \n def down(self,i,jobi,l,r):\n mid=(l+r)>>1\n if jobi==mid+1:\n L=i<<1\n R=L|1\n self.st[i]=[max(self.st[L][0],self.st[R][0]),self.st[L][1],self.st[R][2],False]\n else:\n if jobi<=mid:\n down(self,i<<1,jobi,l,mid)\n else:\n down(self,1|(i<<1),jobi,mid+1,r)\n up(self,i,l,r)\n pass\n\n def build(self,l,r,i):\n if l==r:\n self.st[i]=[1,1,1,True]\n else:\n mid=(l+r)>>1\n build(self,l,mid,i<<1)\n build(self,mid+1,r,1|(i<<1))\n up(self,i,l,r)\n\n def query(self,i,jobl,jobr,l,r):\n if jobl<=l and r<=jobr:\n return (self.st[i][0],self.st[i][1],self.st[i][2],self.st[i][3])\n else:\n mid=(l+r)>>1\n if jobl<=mid:\n if mid+1<=jobr:\n lclL,LclL,RclL,conL=query(self,i<<1,jobl,jobr,l,mid)\n lclR,LclR,RclR,conR=query(self,1|(i<<1),jobl,jobr,mid+1,r)\n if mid+1 in self.block:\n return (max(lclL,lclR),LclL,RclR,False)\n else:\n lcl=max(lclL,lclR,RclL+LclR)\n\n if conL:\n Lcl=LclL+LclR\n else:\n Lcl=LclL\n\n if conR:\n Rcl=RclR+RclL\n else:\n Rcl=RclR\n \n con=conL&conR\n return (lcl,Lcl,Rcl,con)\n else:\n return query(self,i<<1,jobl,jobr,l,mid)\n else:\n return query(self,1|(i<<1),jobl,jobr,mid+1,r)\n\n build(self,0,self.l,1)\n #print(self.st)\n ans=[]\n\n for i in queries:\n if i[0]==1:\n self.block.add(i[1])\n down(self,1,i[1],0,self.l)\n else:\n a,b,c,d=query(self,1,0,i[1]-1,0,self.l)\n #print(a)\n ans.append(a>=i[2])\n return ans","runtime":"8105"},{"code":"class SegmentTree:\n def __init__(self, begin, end):\n self.begin = begin\n self.end = end\n self.mid = (begin + end) // 2\n self.left: SegmentTree = None\n self.right: SegmentTree = None\n self.left_blocked = False\n self.right_blocked = False\n self.max_left = end - begin # max length contains the left border\n self.max_right = end - begin # max length contains the right border\n self.max_mid = end - begin # max length among all children\n\n def insert(self, index):\n if index == self.begin:\n self.left_blocked = True\n self.max_left = 0\n elif index == self.end:\n self.right_blocked = True\n self.max_right = 0\n elif index >= self.end or index <= self.begin:\n return\n else:\n self.pushDown()\n\n if index <= self.mid:\n self.left.insert(index)\n if index >= self.mid:\n self.right.insert(index)\n\n self.popUp()\n\n def query(self, begin, end):\n if begin <= self.begin and end >= self.end:\n return self.max_left, self.max_mid, self.max_right\n elif self.left is None or self.right is None:\n res = min(end, self.end) - max(self.begin, begin)\n return res, res, res\n else:\n left_left = left_mid = left_right = right_left = right_mid = right_right = 0\n if begin <= self.mid:\n left_left, left_mid, left_right = self.left.query(begin, end)\n if end >= self.mid:\n right_left, right_mid, right_right = self.right.query(begin, end)\n if self.left.right_blocked != self.right.left_blocked:\n raise Exception\n mid_blocked = self.left.right_blocked\n left_max = (\n left_left + right_left) if not mid_blocked and left_right == self.mid - self.begin else left_left\n right_max = (\n right_right + left_right) if not mid_blocked and right_left == self.end - self.mid else right_right\n mid_max = max((left_right + right_left) if not mid_blocked else max(left_right, right_left), left_mid,\n right_mid, left_max, right_max)\n\n return left_max, mid_max, right_max\n\n def popUp(self):\n self.left_blocked = self.left.left_blocked or self.left_blocked\n self.right_blocked = self.right.right_blocked or self.right_blocked\n self.max_left = self.left.max_left + self.right.max_left \\\n if self.left.max_left == self.left.end - self.left.begin and not self.left.right_blocked \\\n else self.left.max_left\n self.max_right = self.right.max_right + self.left.max_right \\\n if self.right.max_right == self.right.end - self.right.begin and not self.right.left_blocked \\\n else self.right.max_right\n self.max_mid = max(\n (self.left.max_right + self.right.max_left) if not self.left.right_blocked else max(self.max_left,\n self.max_right),\n self.left.max_mid, self.right.max_mid)\n\n def pushDown(self):\n if self.left is None:\n self.left = SegmentTree(self.begin, self.mid)\n if self.right is None:\n self.right = SegmentTree(self.mid, self.end)\n\n\nclass Solution:\n def getResults(self, queries):\n root = SegmentTree(0, (int)(5E4 + 1)) # 初始化 root\n res = []\n for query in queries:\n if query[0] == 1: # 第一种操作\n root.insert(query[1]) # 加上 query[1] 这一块\n else: # 第二种操作\n res.append(max(root.query(0, query[1])) >= query[2]) # 查找 [0, query[1]] 的最大线段\n return res","runtime":"8191"},{"code":"from copy import deepcopy\nclass Node:\n def __init__(self, flag = True, node = None):\n if flag:\n self.left = None\n self.right = None\n self.lval = 0\n self.rval = 0\n self.bestval = 0\n self.connected = True\n else:\n self.left = node.left\n self.right = node.right\n self.lval = node.lval\n self.rval = node.rval\n self.bestval = node.bestval\n self.connected = node.connected\n \ndef Build(l,r, arr):\n if l == r:\n return Node()\n mid = (l+r)//2\n lnode = Build(l, mid, arr)\n rnode = Build(mid+1, r, arr)\n node = Node()\n node.left = lnode\n node.right = rnode\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n return node\n\ndef update(l,r,idx, node):\n if l > r:\n return\n mid = (l+r)//2\n if l == r == idx:\n node.connected = False\n node.lval = 0\n node.rval = 0\n node.bestval = 0\n return \n if l <= idx <= mid:\n update(l,mid, idx, node.left)\n elif mid+1 <= idx <= r:\n update(mid+1, r, idx, node.right)\n else:\n return\n lnode = node.left\n rnode = node.right\n if lnode.connected and rnode.connected:\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n elif lnode.connected:\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\n node.lval = lnode.bestval + rnode.lval+1\n node.rval = rnode.rval\n elif rnode.connected:\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\n node.lval = lnode.lval\n node.rval = lnode.rval + rnode.bestval+1\n else:\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\n node.lval = lnode.lval\n node.rval = rnode.rval\n node.connected = False\n\ndef query(l,r,idx, hnode):\n if l > r or idx < l:\n nnode = Node()\n nnode.bestval = -1\n nnode.lval = -1\n nnode.rval = -1\n return nnode\n mid = (l+r)//2\n if idx >= r:\n return Node(False, hnode)\n if l<=idx<=r:\n mid = (l+r)//2\n lnode = query(l, mid, idx, hnode.left)\n rnode = query(mid+1, r, idx, hnode.right)\n node = Node()\n if lnode.connected and rnode.connected:\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n elif lnode.connected:\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\n node.lval = lnode.bestval + rnode.lval+1\n node.rval = rnode.rval\n elif rnode.connected:\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\n node.lval = lnode.lval\n node.rval = lnode.rval + rnode.bestval+1\n else:\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\n node.lval = lnode.lval\n node.rval = rnode.rval\n node.connected = False\n return node\n\ndef ptrees(l,r,node):\n if l > r:\n return\n if l == r:\n return \n mid = (l+r)//2\n ptrees(l, mid, node.left)\n ptrees(mid+1, r, node.right)\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n ans = []\n arr = max([i[1] for i in queries])+1\n head = Build(0, arr-1, arr)\n for curr in queries:\n if curr[0] == 1:\n x = curr[1]\n temp = head\n update(0, arr-1, x, temp)\n else:\n x,sz = curr[1], curr[2]\n temp = head\n nnode = query(0, arr-1, x, temp)\n ans.append(nnode.bestval >= sz)\n # print(head.bestval)\n \n return ans","runtime":"8452"},{"code":"class SegmentTree:\n def __init__(self, data, operation=min):\n self.n = len(data)\n self.tree = [0]*self.n + list(data)\n self.operation = operation\n for i in range(self.n - 1, 0, -1):\n self.tree[i] = self.operation(self.tree[i << 1], self.tree[i << 1 | 1])\n\n def update(self, index, value):\n pos = index + self.n\n self.tree[pos] = value\n while pos > 1:\n pos >>= 1\n self.tree[pos] = self.operation(self.tree[pos << 1], self.tree[pos << 1 | 1])\n\n def __getitem__(self, key):\n if isinstance(key, slice):\n start = key.start if key.start is not None else 0\n stop = key.stop if key.stop is not None else self.n\n return self.query(start, stop)\n elif isinstance(key, int) and key < self.n:\n return self.tree[key+self.n]\n else:\n raise TypeError(f\"Value of {key} cannot be indexed.\")\n\n def query(self, left, right):\n result = self.tree[left + self.n]\n left += self.n + 1\n right += self.n\n while left < right:\n if left & 1:\n result = self.operation(result, self.tree[left])\n left += 1\n if right & 1:\n right -= 1\n result = self.operation(result, self.tree[right])\n left >>= 1\n right >>= 1\n return result\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n m = max([x[1] for x in queries])+2\n left = SegmentTree([0]*m, operation=max)\n lower = SegmentTree([0]*m, operation=max)\n upper = SegmentTree([float('inf')]*m, operation=min)\n ans = []\n for q in queries:\n if q[0] == 1:\n _, val = q\n\n v2 = upper[val+1:]\n if v2 != float('inf'):\n left.update(v2, v2-val)\n\n lower.update(val, val)\n upper.update(val, val)\n left.update(val, val-lower[:val])\n # print(val-lower[:val-1])\n\n else:\n _, x, sz = q\n cur = max(left[:x], x-lower[:x])\n ans.append(cur>=sz)\n # print(left[:x])\n # print(cur)\n # print(lower.tree[len(lower.tree) // 2 :])\n # print(upper.tree[len(lower.tree) // 2 :])\n # print('ans: ', left.tree[len(lower.tree) // 2 :])\n # print()\n return ans","runtime":"8539"},{"code":"from copy import deepcopy\nclass Node:\n def __init__(self, flag = True, node = None):\n if flag:\n self.left = None\n self.right = None\n self.lval = 0\n self.rval = 0\n self.bestval = 0\n self.connected = True\n else:\n self.left = node.left\n self.right = node.right\n self.lval = node.lval\n self.rval = node.rval\n self.bestval = node.bestval\n self.connected = node.connected\n \ndef Build(l,r, arr):\n if l == r:\n return Node()\n mid = (l+r)//2\n lnode = Build(l, mid, arr)\n rnode = Build(mid+1, r, arr)\n node = Node()\n node.left = lnode\n node.right = rnode\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n return node\n\ndef update(l,r,idx, node):\n if l > r:\n return\n mid = (l+r)//2\n if l == r == idx:\n node.connected = False\n node.lval = 0\n node.rval = 0\n node.bestval = 0\n return \n if l <= idx <= mid:\n update(l,mid, idx, node.left)\n elif mid+1 <= idx <= r:\n update(mid+1, r, idx, node.right)\n else:\n return\n lnode = node.left\n rnode = node.right\n if lnode.connected and rnode.connected:\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n elif lnode.connected:\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\n node.lval = lnode.bestval + rnode.lval+1\n node.rval = rnode.rval\n elif rnode.connected:\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\n node.lval = lnode.lval\n node.rval = lnode.rval + rnode.bestval+1\n else:\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\n node.lval = lnode.lval\n node.rval = rnode.rval\n node.connected = False\n\ndef query(l,r,idx, hnode):\n if l > r or idx < l:\n nnode = Node()\n nnode.bestval = -1\n nnode.lval = -1\n nnode.rval = -1\n return nnode\n mid = (l+r)//2\n if idx >= r:\n return Node(False, hnode)\n if l<=idx<=r:\n mid = (l+r)//2\n lnode = query(l, mid, idx, hnode.left)\n rnode = query(mid+1, r, idx, hnode.right)\n node = Node()\n if lnode.connected and rnode.connected:\n node.bestval = lnode.bestval + rnode.bestval+1\n node.lval = node.bestval\n node.rval = node.bestval\n elif lnode.connected:\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\n node.lval = lnode.bestval + rnode.lval+1\n node.rval = rnode.rval\n elif rnode.connected:\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\n node.lval = lnode.lval\n node.rval = lnode.rval + rnode.bestval+1\n else:\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\n node.lval = lnode.lval\n node.rval = rnode.rval\n node.connected = False\n return node\n\ndef ptrees(l,r,node):\n if l > r:\n return\n if l == r:\n return \n mid = (l+r)//2\n ptrees(l, mid, node.left)\n ptrees(mid+1, r, node.right)\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n ans = []\n arr = max([i[1] for i in queries])+1\n head = Build(0, arr-1, arr)\n for curr in queries:\n if curr[0] == 1:\n x = curr[1]\n temp = head\n update(0, arr-1, x, temp)\n else:\n x,sz = curr[1], curr[2]\n temp = head\n nnode = query(0, arr-1, x, temp)\n ans.append(nnode.bestval >= sz)\n # print(head.bestval)\n \n return ans","runtime":"8626"},{"code":"MAX = 10 ** 5\nINF = 10 ** 20\n\nclass SegmentTree:\n def __init__(self, n):\n self.n = n\n self.tree = [0] * (4 * n)\n self.lazy = [0] * (4 * n)\n\n def _build(self, start, end, node):\n if start == end:\n self.tree[node] = MAX\n else:\n mid = (start + end) // 2\n self._build(start, mid, 2 * node + 1)\n self._build(mid + 1, end, 2 * node + 2)\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\n\n def _update_range(self, start, end, l, r, value, node):\n if self.lazy[node] != 0:\n self.tree[node] = self.lazy[node]\n if start != end:\n self.lazy[2 * node + 1] = self.lazy[node]\n self.lazy[2 * node + 2] = self.lazy[node]\n self.lazy[node] = 0\n\n if start > end or start > r or end < l:\n return\n\n if start >= l and end <= r:\n self.tree[node] = value\n if start != end:\n self.lazy[2 * node + 1] = value\n self.lazy[2 * node + 2] = value\n return\n\n mid = (start + end) // 2\n self._update_range(start, mid, l, r, value, 2 * node + 1)\n self._update_range(mid + 1, end, l, r, value, 2 * node + 2)\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\n\n def build(self):\n self._build(0, self.n - 1, 0)\n\n def update_range(self, l, r, value):\n self._update_range(0, self.n - 1, l, r, value, 0)\n\n def _query_range(self, start, end, l, r, node):\n if start > end or start > r or end < l:\n return -INF\n\n if self.lazy[node] != 0:\n self.tree[node] = self.lazy[node]\n if start != end:\n self.lazy[2 * node + 1] = self.lazy[node]\n self.lazy[2 * node + 2] = self.lazy[node]\n self.lazy[node] = 0\n\n if start >= l and end <= r:\n return self.tree[node]\n\n mid = (start + end) // 2\n left_query = self._query_range(start, mid, l, r, 2 * node + 1)\n right_query = self._query_range(mid + 1, end, l, r, 2 * node + 2)\n return max(left_query, right_query)\n\n def query_range(self, l, r):\n return self._query_range(0, self.n - 1, l, r, 0)\n\n# st = SegmentTree(MAX)\n# st.update_range(prev + 1, x, x - prev)\n# st.update_range(x + 1, nxt, nxt - x)\n# st.query_range(0, p)\n\n\nfrom sortedcontainers import SortedList\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n st = SegmentTree(MAX)\n sl = SortedList()\n\n sl.add(0)\n sl.add(MAX)\n ans = []\n \n for row in queries:\n if len(row) == 2:\n _, x = row\n\n index = sl.bisect_left(x)\n nxt = sl[index]\n prev = sl[index - 1]\n\n sl.add(x)\n\n st.update_range(prev + 1, x, x - prev)\n st.update_range(x + 1, nxt, nxt - x)\n \n elif len(row) == 3:\n _, x, sz = row\n\n if sz > x:\n ans.append(False)\n continue\n\n index = sl.bisect_right(x) - 1\n p = sl[index]\n mx = 0\n mx = max(mx, x - p)\n\n if p != 0:\n mx = max(mx, st.query_range(0, p))\n\n ans.append(mx >= sz)\n\n return ans","runtime":"8713"},{"code":"MAX = 10 ** 5\nINF = 10 ** 20\n\nclass SegmentTree:\n def __init__(self, n):\n self.n = n\n self.tree = [0] * (4 * n)\n self.lazy = [0] * (4 * n)\n\n def _build(self, start, end, node):\n if start == end:\n self.tree[node] = MAX\n else:\n mid = (start + end) // 2\n self._build(start, mid, 2 * node + 1)\n self._build(mid + 1, end, 2 * node + 2)\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\n\n def _update_range(self, start, end, l, r, value, node):\n if self.lazy[node] != 0:\n self.tree[node] = self.lazy[node]\n if start != end:\n self.lazy[2 * node + 1] = self.lazy[node]\n self.lazy[2 * node + 2] = self.lazy[node]\n self.lazy[node] = 0\n\n if start > end or start > r or end < l:\n return\n\n if start >= l and end <= r:\n self.tree[node] = value\n if start != end:\n self.lazy[2 * node + 1] = value\n self.lazy[2 * node + 2] = value\n return\n\n mid = (start + end) // 2\n self._update_range(start, mid, l, r, value, 2 * node + 1)\n self._update_range(mid + 1, end, l, r, value, 2 * node + 2)\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\n\n def build(self):\n self._build(0, self.n - 1, 0)\n\n def update_range(self, l, r, value):\n self._update_range(0, self.n - 1, l, r, value, 0)\n\n def _query_range(self, start, end, l, r, node):\n if start > end or start > r or end < l:\n return -INF\n\n if self.lazy[node] != 0:\n self.tree[node] = self.lazy[node]\n if start != end:\n self.lazy[2 * node + 1] = self.lazy[node]\n self.lazy[2 * node + 2] = self.lazy[node]\n self.lazy[node] = 0\n\n if start >= l and end <= r:\n return self.tree[node]\n\n mid = (start + end) // 2\n left_query = self._query_range(start, mid, l, r, 2 * node + 1)\n right_query = self._query_range(mid + 1, end, l, r, 2 * node + 2)\n return max(left_query, right_query)\n\n def query_range(self, l, r):\n return self._query_range(0, self.n - 1, l, r, 0)\n\n# st = SegmentTree(MAX)\n# st.update_range(prev + 1, x, x - prev)\n# st.update_range(x + 1, nxt, nxt - x)\n# st.query_range(0, p)\n\n\nfrom sortedcontainers import SortedList\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n st = SegmentTree(MAX)\n sl = SortedList()\n\n sl.add(0)\n sl.add(MAX)\n ans = []\n \n for row in queries:\n if len(row) == 2:\n _, x = row\n\n index = sl.bisect_left(x)\n nxt = sl[index]\n prev = sl[index - 1]\n\n sl.add(x)\n\n st.update_range(prev + 1, x, x - prev)\n st.update_range(x + 1, nxt, nxt - x)\n \n elif len(row) == 3:\n _, x, sz = row\n\n if sz > x:\n ans.append(False)\n continue\n\n index = sl.bisect_right(x) - 1\n p = sl[index]\n mx = 0\n mx = max(mx, x - p)\n\n if p != 0:\n mx = max(mx, st.query_range(0, p))\n\n ans.append(mx >= sz)\n\n return ans","runtime":"8800"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n from sortedcontainers import SortedList\n\n def update(tree, i, ql, qr, idx, val):\n if ql == idx and idx == qr:\n tree[i] = val\n return val\n mid = (ql + qr) // 2\n if ql <= idx and idx <= mid:\n tree[i] = max(\n update(tree, 2 * i, ql, mid, idx, val),\n tree[2 * i + 1]\n )\n else:\n tree[i] = max(\n update(tree, 2 * i + 1, mid + 1, qr, idx, val), \n tree[2 * i]\n )\n return tree[i]\n \n def query(tree, i, ql, qr, l, r):\n if r < ql or l > qr:\n return 0\n elif l <= ql and qr <= r:\n return tree[i]\n else:\n mid = ql + (qr - ql) // 2\n return max(\n query(tree, 2 * i, ql, mid, l, r),\n query(tree, 2 * i + 1, mid + 1, qr, l, r)\n )\n\n print(f\"Operations: {queries}\")\n sl = SortedList([0])\n n = 1e5\n tree = [0] * int(4 * n)\n res = []\n for op in queries:\n # Builds an obstacle\n if op[0] == 1:\n i = sl.bisect_left(op[1])\n # Normal case\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, n-1, idx, op[1] - idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, n-1, idx, op[1] - idx)\n update(tree, 1, 0, n-1, op[1], sl[i] - op[1])\n sl.add(op[1])\n # Checks if obstacle can be built\n else:\n _, x, size = op\n i = sl.bisect_left(x)\n widest = x - sl[i-1]\n left = 0 if i == 1 else query(tree, 1, 0, n-1, 0, sl[i-1]-1)\n res.append(max(widest, left) >= size)\n \n return res\n\n ","runtime":"8886"},{"code":"from typing import List\nfrom sortedcontainers import SortedSet\n\nclass SegmentTree:\n def __init__(self, size):\n self.size = size\n self.tree = [0] * (2 * size)\n self.tree[size] = 1000000\n for i in range(size - 1, 0, -1):\n self.tree[i] = max(self.tree[i * 2], self.tree[i * 2 + 1])\n\n def update(self, idx, val):\n idx += self.size\n self.tree[idx] = val\n while idx > 1:\n idx //= 2\n self.tree[idx] = max(self.tree[2 * idx], self.tree[2 * idx + 1])\n\n def query(self, left, right):\n res = 0\n left += self.size\n right += self.size\n while left <= right:\n if left % 2 == 1:\n res = max(res, self.tree[left])\n left += 1\n if right % 2 == 0:\n res = max(res, self.tree[right])\n right -= 1\n left //= 2\n right //= 2\n return res\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n max_size = 50001\n segment_tree = SegmentTree(max_size)\n results = []\n obstacle_set = SortedSet([0, 1000000])\n \n for query in queries:\n if query[0] == 1:\n x = query[1]\n idx = obstacle_set.bisect_left(x)\n prev = obstacle_set[idx - 1]\n next = obstacle_set[idx] if idx < len(obstacle_set) else 1000000\n obstacle_set.add(x)\n segment_tree.update(prev, x - prev)\n segment_tree.update(x, next - x)\n elif query[0] == 2:\n x = query[1]\n sz = query[2]\n if sz > x:\n results.append(False)\n else:\n max_free = segment_tree.query(0, x - sz)\n results.append(max_free >= sz)\n \n return results\n","runtime":"8973"}],"string":"[\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n def beam_search(list_of_values, value):\\n start = -1\\n end = len(list_of_values)\\n while end - start > 1:\\n mid = (start + end) // 2\\n if list_of_values[mid] >= value:\\n end = mid\\n if list_of_values[mid] <= value:\\n start = mid\\n return start, end\\n \\n value_list = [0]\\n axis = []\\n for query in queries:\\n if query[0] == 1:\\n value_list.append(query[1])\\n else:\\n axis.append(True)\\n value_list = sorted(value_list)\\n axis_perimeter = len(axis)\\n mid = 0\\n search_weights = []\\n search_values = []\\n for i in range(len(value_list) - 1):\\n weight = value_list[i + 1] - value_list[i]\\n if weight > mid:\\n search_weights.append(weight)\\n search_values.append(value_list[i])\\n mid = weight\\n\\n query_len = len(queries)\\n\\n for q_i in range(len(queries)):\\n query = queries[query_len - 1 - q_i]\\n if query[0] == 1:\\n value = query[1]\\n i, i = beam_search(value_list, value) # these are equal in this case \\n v_s, v_e = beam_search(search_values, value_list[i - 1])\\n if i < len(value_list) - 1:\\n weight = value_list[i + 1] - value_list[i - 1]\\n w_s, w_e = beam_search(search_weights, weight)\\n del search_weights[v_e : w_s + 1]\\n del search_values[v_e : w_s + 1]\\n if v_s < w_s or v_s == w_s and v_e <= w_e:\\n search_weights.insert(v_e, weight)\\n search_values.insert(v_e, value_list[i - 1])\\n elif v_s == v_e:\\n del search_weights[v_e]\\n del search_values[v_e]\\n del value_list[i]\\n else:\\n axis_perimeter -= 1 \\n value = query[1]\\n weight = query[2]\\n i_s, i_e = beam_search(search_weights, weight)\\n if i_e == len(search_weights):\\n axis[axis_perimeter] = value - weight >= value_list[-1]\\n else:\\n axis[axis_perimeter] = value - weight >= search_values[i_e]\\n return axis\\n\",\n \"runtime\": \"4109\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n def bsearch(l, v):\\n b = -1\\n e = len(l)\\n while e - b > 1:\\n m = (b + e) // 2\\n if l[m] >= v:\\n e = m\\n if l[m] <= v:\\n b = m\\n return b, e\\n l = [0]\\n a = []\\n for q in queries:\\n if q[0] == 1:\\n l.append(q[1])\\n else:\\n a.append(True)\\n l = sorted(l)\\n p = len(a)\\n m = 0\\n sw = []\\n sv = []\\n for i in range(len(l) - 1):\\n w = l[i + 1] - l[i]\\n if w > m:\\n sw.append(w)\\n sv.append(l[i])\\n m = w\\n n = len(queries)\\n # print(l, sv, sw)\\n for j in range(len(queries)):\\n q = queries[n - 1 - j]\\n if q[0] == 1:\\n v = q[1]\\n i, i = bsearch(l, v)\\n vb, ve = bsearch(sv, l[i - 1])\\n if i < len(l) - 1:\\n w = l[i + 1] - l[i - 1]\\n wb, we = bsearch(sw, w)\\n # if wb == 7 and w == 12:\\n # print(v, i, vb, ve, sv)\\n # print('---', wb, we, sw)\\n del sw[ve: wb + 1]\\n del sv[ve: wb + 1]\\n if vb < wb or vb == wb and ve <= we:\\n sw.insert(ve, w)\\n sv.insert(ve, l[i - 1])\\n elif vb == ve:\\n del sw[ve]\\n del sv[ve]\\n del l[i]\\n else:\\n p -= 1\\n v = q[1]\\n w = q[2]\\n ib, ie = bsearch(sw, w)\\n # if p == 23272:\\n # print('====================', v, w, ib, ie, sv, sw)\\n if ie == len(sw):\\n a[p] = v - w >= l[-1]\\n else:\\n a[p] = v - w >= sv[ie]\\n return a\",\n \"runtime\": \"4109\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n def bsearch(l, v):\\n b = -1\\n e = len(l)\\n while e - b > 1:\\n m = (b + e) // 2\\n if l[m] >= v:\\n e = m\\n if l[m] <= v:\\n b = m\\n return b, e\\n l = [0]\\n a = []\\n for q in queries:\\n if q[0] == 1:\\n l.append(q[1])\\n else:\\n a.append(True)\\n l = sorted(l)\\n p = len(a)\\n m = 0\\n sw = []\\n sv = []\\n for i in range(len(l) - 1):\\n w = l[i + 1] - l[i]\\n if w > m:\\n sw.append(w)\\n sv.append(l[i])\\n m = w\\n n = len(queries)\\n # print(l, sv, sw)\\n for j in range(len(queries)):\\n q = queries[n - 1 - j]\\n if q[0] == 1:\\n v = q[1]\\n i, i = bsearch(l, v)\\n vb, ve = bsearch(sv, l[i - 1])\\n if i < len(l) - 1:\\n w = l[i + 1] - l[i - 1]\\n wb, we = bsearch(sw, w)\\n # if wb == 7 and w == 12:\\n # print(v, i, vb, ve, sv)\\n # print('---', wb, we, sw)\\n del sw[ve: wb + 1]\\n del sv[ve: wb + 1]\\n if vb < wb or vb == wb and ve <= we:\\n sw.insert(ve, w)\\n sv.insert(ve, l[i - 1])\\n elif vb == ve:\\n del sw[ve]\\n del sv[ve]\\n del l[i]\\n else:\\n p -= 1\\n v = q[1]\\n w = q[2]\\n ib, ie = bsearch(sw, w)\\n # if p == 23272:\\n # print('====================', v, w, ib, ie, sv, sw)\\n if ie == len(sw):\\n a[p] = v - w >= l[-1]\\n else:\\n a[p] = v - w >= sv[ie]\\n return a\",\n \"runtime\": \"4196\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # modified binary search to find boundary of value in value list range\\n def boundary_search(list_of_values, value):\\n start = -1\\n end = len(list_of_values)\\n while end - start > 1:\\n mid = (start + end) // 2\\n if list_of_values[mid] >= value:\\n end = mid\\n if list_of_values[mid] <= value:\\n start = mid\\n return start, end\\n \\n # value list starts at 0\\n value_list = [0]\\n # axis starts empty \\n axis = []\\n # iterate queries\\n # on type 1, place the obstacle in the value list \\n # on type 2, append true \\n for query in queries:\\n if query[0] == 1:\\n value_list.append(query[1])\\n else:\\n axis.append(True)\\n # sort the x values in ascending order of query type 1\\n value_list = sorted(value_list)\\n # determine your axial perimeter originally as the length of axis\\n # these are you type 2 that you need to consider, a perimeter of the number of options \\n axis_perimeter = len(axis)\\n # set max weight to 0\\n max_weight = 0\\n # set an array of search weights and values\\n search_weights = []\\n search_values = []\\n for i in range(len(value_list) - 1):\\n # get your weight current as the value list difference of one ahead and current\\n weight = value_list[i + 1] - value_list[i]\\n # if the weight is greater than the max_weight, append the weight and the ith value list of position\\n # then set max weight to the new weight \\n if weight > max_weight:\\n search_weights.append(weight)\\n search_values.append(value_list[i])\\n max_weight = weight\\n\\n # now get the length of your queries \\n query_len = len(queries)\\n # then, loop over and process it \\n for q_i in range(len(queries)):\\n # use the original query size less one, less the ith query position to get the current query\\n query = queries[query_len - 1 - q_i]\\n # if of type 1\\n if query[0] == 1:\\n # get the value \\n value = query[1]\\n # use the boundary search to get the start and end positions\\n i, i = boundary_search(value_list, value) # these are equal in this case \\n # get the value bounding as needed \\n v_s, v_e = boundary_search(search_values, value_list[i - 1])\\n # if the index is in range currently \\n if i < len(value_list) - 1:\\n # get the weight as the difference of boundary positions \\n weight = value_list[i + 1] - value_list[i - 1]\\n # use this to get the bounds of that weight \\n w_s, w_e = boundary_search(search_weights, weight)\\n # use this to remove segments from these sections\\n # this is an abstraction of a segment tree approach\\n del search_weights[v_e : w_s + 1]\\n del search_values[v_e : w_s + 1]\\n # if value start is lt weight start or they are equal and value end bounds \\n if v_s < w_s or (v_s == w_s and v_e <= w_e):\\n # then we need to reinsert at the value end position the weight and value respectively\\n search_weights.insert(v_e, weight)\\n search_values.insert(v_e, value_list[i - 1])\\n elif v_s == v_e:\\n # otherwise, if not in range, remove these end points\\n del search_weights[v_e]\\n del search_values[v_e]\\n # at end, remove an item from value list at index i \\n del value_list[i]\\n else:\\n # if not of type 1, reduce the perimeter by 1 for the number of options \\n axis_perimeter -= 1 \\n # get the value and weight \\n value = query[1]\\n weight = query[2]\\n # find the bounds that are acceptable \\n i_s, i_e = boundary_search(search_weights, weight)\\n # if the index ending is of matching length, \\n # at the axis perimeter, mark the relation of value and weight difference to your greatest positional obstacle \\n # otherwise, mark it in relation of value and weight difference to the values at index end boundary\\n if i_e == len(search_weights):\\n axis[axis_perimeter] = value - weight >= value_list[-1]\\n else:\\n axis[axis_perimeter] = value - weight >= search_values[i_e]\\n # when done your completed axis contains your answer \\n return axis\\n\",\n \"runtime\": \"4196\"\n },\n {\n \"code\": \"from typing import List\\nimport bisect\\n\\nclass BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n obstacles = [0]\\n n = min(5 * 10**4, len(queries) * 3)\\n obstacles.append(n)\\n \\n to_add = []\\n results = []\\n\\n for q in queries:\\n if q[0] == 1:\\n to_add.append(q[1])\\n \\n obstacles.extend(to_add)\\n obstacles = sorted(set(obstacles))\\n \\n bit = BIT(n + 1)\\n\\n for i in range(1, len(obstacles)):\\n bit.add(obstacles[i], obstacles[i] - obstacles[i - 1])\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n idx = bisect.bisect_left(obstacles, x)\\n if idx < len(obstacles) - 1:\\n after = obstacles[idx + 1]\\n else:\\n after = n\\n if idx > 0:\\n before = obstacles[idx - 1]\\n else:\\n before = 0\\n bit.add(after, after - before)\\n obstacles.pop(idx)\\n else:\\n _, x, sz = q\\n idx = bisect.bisect_right(obstacles, x)\\n before = obstacles[idx - 1]\\n results.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n results.reverse()\\n return results\\n\",\n \"runtime\": \"4283\"\n },\n {\n \"code\": \"from typing import List\\nimport bisect\\n\\nclass BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n obstacles = [0]\\n n = min(5 * 10**4, len(queries) * 3)\\n obstacles.append(n)\\n \\n to_add = []\\n results = []\\n\\n for q in queries:\\n if q[0] == 1:\\n to_add.append(q[1])\\n \\n obstacles.extend(to_add)\\n obstacles = sorted(set(obstacles))\\n \\n bit = BIT(n + 1)\\n\\n for i in range(1, len(obstacles)):\\n bit.add(obstacles[i], obstacles[i] - obstacles[i - 1])\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n idx = bisect.bisect_left(obstacles, x)\\n if idx < len(obstacles) - 1:\\n after = obstacles[idx + 1]\\n else:\\n after = n\\n if idx > 0:\\n before = obstacles[idx - 1]\\n else:\\n before = 0\\n bit.add(after, after - before)\\n obstacles.pop(idx)\\n else:\\n _, x, sz = q\\n idx = bisect.bisect_right(obstacles, x)\\n before = obstacles[idx - 1]\\n results.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n results.reverse()\\n return results\",\n \"runtime\": \"4543\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n barriers = SortedList()\\n barriers.add(0)\\n for query in queries:\\n if query[0] == 1:\\n it = query[1]\\n barriers.add(it)\\n holes = SortedList()\\n holes.add(float(\\\"inf\\\"))\\n hole2start = {float(\\\"inf\\\"): barriers[-1]}\\n for pos in range(len(barriers) - 1):\\n start = barriers[pos]\\n end = barriers[pos + 1]\\n size = end - start\\n if size:\\n pos = holes.bisect_left(size)\\n hole_size = holes[pos]\\n if hole2start[hole_size] > start:\\n if hole_size > size:\\n holes.add(size)\\n hole2start[size] = start\\n barriers.add(float(\\\"inf\\\"))\\n result = []\\n for query in reversed(queries):\\n if query[0] == 1:\\n it = query[1]\\n pos = barriers.bisect_left(it)\\n left = barriers[pos - 1]\\n right = barriers[pos + 1]\\n size = right - left\\n hole_pos = holes.bisect_left(size)\\n if hole2start[holes[hole_pos]] > left:\\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\\n del hole2start[holes[hole_pos - 1]]\\n del holes[hole_pos - 1]\\n hole_pos -= 1\\n hole2start[size] = left\\n if holes[hole_pos] != size:\\n holes.add(size)\\n barriers.remove(it)\\n else:\\n _, start, size = query\\n hole_pos = holes.bisect_left(size)\\n hole = holes[hole_pos]\\n result.append(hole2start[hole] <= start - size)\\n result.reverse()\\n return result\",\n \"runtime\": \"4630\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n barriers = SortedList()\\n barriers.add(0)\\n for query in queries:\\n if query[0] == 1:\\n it = query[1]\\n barriers.add(it)\\n holes = SortedList()\\n holes.add(float(\\\"inf\\\"))\\n hole2start = {float(\\\"inf\\\"): barriers[-1]}\\n for pos in range(len(barriers) - 1):\\n start = barriers[pos]\\n end = barriers[pos + 1]\\n size = end - start\\n if size:\\n pos = holes.bisect_left(size)\\n hole_size = holes[pos]\\n if hole2start[hole_size] > start:\\n if hole_size > size:\\n holes.add(size)\\n hole2start[size] = start\\n barriers.add(float(\\\"inf\\\"))\\n result = []\\n for query in reversed(queries):\\n if query[0] == 1:\\n it = query[1]\\n pos = barriers.bisect_left(it)\\n left = barriers[pos - 1]\\n right = barriers[pos + 1]\\n size = right - left\\n hole_pos = holes.bisect_left(size)\\n if hole2start[holes[hole_pos]] > left:\\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\\n del hole2start[holes[hole_pos - 1]]\\n del holes[hole_pos - 1]\\n hole_pos -= 1\\n hole2start[size] = left\\n if holes[hole_pos] != size:\\n holes.add(size)\\n barriers.remove(it)\\n else:\\n _, start, size = query\\n hole_pos = holes.bisect_left(size)\\n hole = holes[hole_pos]\\n result.append(hole2start[hole] <= start - size)\\n result.reverse()\\n return result\\n\",\n \"runtime\": \"4717\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n \\n\\n barriers = SortedList() # Sorted list to maintain barrier positions\\n barriers.add(0) # Add initial barrier at position 0\\n\\n # Process the add-barrier queries to populate the barriers list\\n for query in queries:\\n if query[0] == 1:\\n it = query[1]\\n barriers.add(it)\\n\\n holes = SortedList() # Sorted list to maintain hole sizes\\n holes.add(float('inf')) # Initialize with an infinitely large hole\\n hole2start = {float('inf'): barriers[-1]}\\n\\n # Calculate initial hole sizes based on the barriers\\n for pos in range(len(barriers) - 1):\\n start = barriers[pos]\\n end = barriers[pos + 1]\\n size = end - start\\n if size:\\n pos = holes.bisect_left(size)\\n hole_size = holes[pos]\\n if hole2start[hole_size] > start:\\n if hole_size > size:\\n holes.add(size)\\n hole2start[size] = start\\n\\n barriers.add(float('inf')) # Add an infinite barrier at the end\\n\\n result = []\\n # Process the queries in reverse order\\n for query in reversed(queries):\\n if query[0] == 1: # If it's an add-barrier query\\n it = query[1]\\n pos = barriers.bisect_left(it)\\n left = barriers[pos - 1]\\n right = barriers[pos + 1]\\n size = right - left\\n\\n hole_pos = holes.bisect_left(size)\\n if hole2start[holes[hole_pos]] > left:\\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\\n hole2start.pop(holes[hole_pos - 1])\\n holes.pop(hole_pos - 1)\\n hole_pos -= 1\\n\\n hole2start[size] = left\\n if holes[hole_pos] != size:\\n holes.add(size)\\n\\n barriers.remove(it)\\n else: # If it's a check-hole query\\n _, start, size = query\\n hole_pos = holes.bisect_left(size)\\n hole = holes[hole_pos]\\n result.append(hole2start[hole] <= start - size)\\n\\n result.reverse() # Reverse the result to match the original query order\\n\\n return result\",\n \"runtime\": \"4804\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n obsticals = dict()\\n obsticalss = []\\n result = []\\n for query in queries:\\n if query[0] == 1:\\n #obsticalss.append(query[1])\\n #obsticalss.sort()\\n if not len(obsticalss) < 3:\\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1])\\n obsticalss.insert(index, query[1])\\n else:\\n obsticalss.append(query[1])\\n obsticalss.sort()\\n index = obsticalss.index(query[1])\\n obsticals[query[1]] = max(query[1] - obsticalss[index-1], obsticals[obsticalss[index-1]]) if index != 0 else query[1]\\n for why in range(index+1, len(obsticalss)):\\n prev = obsticals[obsticalss[why]]\\n obsticals[obsticalss[why]] = max(obsticalss[why] - obsticalss[why-1], obsticals[obsticalss[why-1]])\\n if prev == obsticals[obsticalss[why]]:\\n break\\n else:\\n try:\\n if obsticals[query[1]] >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n except:\\n if not len(obsticalss) < 3:\\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1]) - 1\\n else:\\n ok = obsticalss[:]\\n ok.append(query[1])\\n ok.sort()\\n index = ok.index(query[1]) - 1\\n\\n if index == -1:\\n if query[1] >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n elif obsticals[obsticalss[index]] >= query[2] or (query[1] - obsticalss[index]) >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n return result\\n \\n def BinarySearchModified(self, arr, low, high, x):\\n while high - low > 1:\\n mid = low + (high - low)//2\\n if arr[mid] > x:\\n if arr[low] < x:\\n high = mid\\n else:\\n return low\\n else:\\n if arr[high] > x:\\n low = mid\\n else:\\n return high+1\\n return high\\n\",\n \"runtime\": \"4804\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n barriers = SortedList() # Sorted list to maintain barrier positions\\n barriers.add(0) # Add initial barrier at position 0\\n\\n # Process the add-barrier queries to populate the barriers list\\n for query in queries:\\n if query[0] == 1:\\n it = query[1]\\n barriers.add(it)\\n\\n holes = SortedList() # Sorted list to maintain hole sizes\\n holes.add(float('inf')) # Initialize with an infinitely large hole\\n hole2start = {float('inf'): barriers[-1]}\\n\\n # Calculate initial hole sizes based on the barriers\\n for pos in range(len(barriers) - 1):\\n start = barriers[pos]\\n end = barriers[pos + 1]\\n size = end - start\\n if size:\\n pos = holes.bisect_left(size)\\n hole_size = holes[pos]\\n if hole2start[hole_size] > start:\\n if hole_size > size:\\n holes.add(size)\\n hole2start[size] = start\\n\\n barriers.add(float('inf')) # Add an infinite barrier at the end\\n \\n result = []\\n # Process the queries in reverse order\\n for query in reversed(queries):\\n if query[0] == 1: # If it's an add-barrier query\\n it = query[1]\\n pos = barriers.bisect_left(it)\\n left = barriers[pos - 1]\\n right = barriers[pos + 1]\\n size = right - left\\n\\n hole_pos = holes.bisect_left(size)\\n if hole2start[holes[hole_pos]] > left:\\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\\n del hole2start[holes[hole_pos - 1]]\\n del holes[hole_pos - 1]\\n hole_pos -= 1\\n\\n hole2start[size] = left\\n if holes[hole_pos] != size:\\n holes.add(size)\\n\\n barriers.remove(it)\\n else: # If it's a check-hole query\\n _, start, size = query\\n hole_pos = holes.bisect_left(size)\\n hole = holes[hole_pos]\\n result.append(hole2start[hole] <= start - size)\\n\\n result.reverse() # Reverse the result to match the original query order\\n\\n return result\",\n \"runtime\": \"4891\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n return get_results(queries)\\n \\nfrom bisect import bisect_left\\n\\ndef get_results(queries):\\n main = []\\n larg = []\\n ans = []\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = bisect_left(main, q[1])\\n main.insert(ind, q[1])\\n larg.insert(ind, q[1] if ind == 0 else max(larg[ind - 1], q[1] - main[ind - 1]))\\n ind += 1\\n while ind < len(main) and larg[ind] != (new_larg := max(larg[ind - 1], main[ind] - main[ind - 1])):\\n larg[ind] = new_larg\\n ind += 1\\n else:\\n ind = bisect_left(main, q[1])\\n lim = q[1] if ind == 0 else (larg[ind - 1] if main[ind - 1] == q[1] else max(larg[ind - 1], q[1] - main[ind - 1]))\\n ans.append(q[2] <= lim)\\n\\n return ans\\n\",\n \"runtime\": \"4891\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val);\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"runtime\": \"4978\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val);\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"runtime\": \"4978\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val);\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"runtime\": \"5064\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # keep track of the obstacles\\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\\n # say it lies between obstacle[i] and obstacle[i+1]\\n\\n from bisect import bisect_right, insort\\n obstacles = [0]\\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\\n\\n output = []\\n for t, *rest in queries:\\n #print(f\\\"{obstacles=} {largest_possible=}\\\")\\n if t == 1:\\n # insert into obstacles\\n obs_pos = rest[0]\\n idx = bisect_right(obstacles, obs_pos)\\n if idx == len(obstacles):\\n # largest obstacle\\n prev_largest = largest_possible[-1]\\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\\n largest_possible.append(new_largest)\\n insort(obstacles, obs_pos)\\n else:\\n # somewhere in between\\n prev_largest = largest_possible[idx - 1]\\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\\n largest_possible.insert(idx, new_largest)\\n insort(obstacles, obs_pos)\\n for cur_idx in range(idx + 1, len(obstacles)):\\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\\n if largest_possible[cur_idx] > new_largest:\\n largest_possible[cur_idx] = new_largest\\n else:\\n break\\n #output.append(False)\\n else:\\n obs_pos = rest[0]\\n size = rest[1]\\n idx = bisect_right(obstacles, obs_pos)\\n #print(f\\\"{obs_pos=} {size=} {idx=}\\\")\\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\\n output.append(possible >= size)\\n\\n return output \\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"5064\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val)\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"runtime\": \"5151\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n gap = SortedList()\\n gap.add((0, 0))\\n curr = 0\\n for x, y in pairwise(sl):\\n if (g := y - x) > curr:\\n gap.add((y, g))\\n curr = g\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n g = after - before\\n index = gap.bisect_left((x, 0))\\n while index < len(gap) and gap[index][1] <= g:\\n gap.pop(index)\\n if gap[index - 1][1] < g:\\n gap.add((after, g))\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n index = gap.bisect_right((before, math.inf)) - 1\\n ans.append((x - before) >= sz or gap[index][1] >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5151\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n gap = SortedList()\\n gap.add((0, 0))\\n curr = 0\\n for x, y in pairwise(sl):\\n if (g := y - x) > curr:\\n gap.add((y, g))\\n curr = g\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n g = after - before\\n index = gap.bisect_left((x, 0))\\n while index < len(gap) and gap[index][1] <= g:\\n gap.pop(index)\\n if gap[index - 1][1] < g:\\n gap.add((after, g))\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n index = gap.bisect_right((before, math.inf)) - 1\\n ans.append((x - before) >= sz or gap[index][1] >= sz)\\n \\n ans.reverse()\\n return ans\\n \",\n \"runtime\": \"5238\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n def find(x):\\n r = len(obstacle)\\n l = -1\\n while r-l>1:\\n med = (l+r)//2\\n if obstacle[med]<=x:\\n l = med\\n elif x<obstacle[med]:\\n r = med\\n return l\\n \\n def maxsz(r):\\n res = 0\\n while r>=0:\\n res = max(res, t[r])\\n r = (r & (r+1)) - 1\\n return res\\n\\n def modify(i, d):\\n while i<n:\\n t[i] = max(t[i],d)\\n i = i | (i + 1)\\n\\n\\n n = max(queries, key=lambda x: x[1])[1]+1\\n t = [0]*(n+1)\\n a = [0]*(n+1)\\n obstacle = [0] + sorted([x for t, x, *sz in queries if t == 1]) + [n]\\n m = len(obstacle)\\n for i in range(1,m-1):\\n a[obstacle[i]] = obstacle[i] - obstacle[i-1]\\n modify(obstacle[i], a[obstacle[i]])\\n ans =[]\\n q = len(queries)\\n for i in range(q-1,-1,-1):\\n x = queries[i]\\n if x[0] == 2:\\n priv = obstacle[find(x[1])]\\n sz = max(maxsz(priv),x[1]-priv)\\n ans.append(sz>=x[2])\\n else:\\n l = find(x[1])\\n nex = obstacle[l+1]\\n a[nex] += a[x[1]]\\n modify(nex,a[nex])\\n del obstacle[l]\\n return ans[::-1]\",\n \"runtime\": \"5238\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5325\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5412\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5499\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nfrom itertools import pairwise\\n\\n# the logic here is to perform the queries in reverse order\\n# we use a BIT to store the ranges over which we can place a block\\n# we use a SortedList to store the obstacles and the \\\"ends\\\" of this infinte line, which are\\n# defined in the problem constraints\\n\\nclass BIT:\\n def __init__(self, n):\\n self.n = n\\n self.bit = [0 for _ in range(n+1)]\\n\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.bit[i] = max(self.bit[i], x)\\n i += i & -i\\n\\n def get(self, i):\\n i += 1\\n res = 0\\n while i:\\n res = max(self.bit[i], res)\\n i -= i & -i\\n return res\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(5 * 10**4, 3 * len(queries))\\n t = BIT(n+1)\\n sl = SortedList()\\n sl.add(0)\\n sl.add(n)\\n\\n for q in queries:\\n if q[0] == 1:\\n sl.add(q[1])\\n\\n for x, y in pairwise(sl):\\n t.add(y, y - x)\\n\\n res = []\\n for q in reversed(queries):\\n if q[0] == 1:\\n idx = sl.index(q[1])\\n before = sl[idx - 1]\\n after = sl[idx + 1]\\n sl.remove(q[1])\\n t.add(after, after - before)\\n else:\\n x, sz = q[1], q[2]\\n idx = sl.bisect_right(x)\\n before = sl[idx - 1]\\n\\n res.append(t.get(before) >= sz or x - before >= sz)\\n\\n return res[::-1]\",\n \"runtime\": \"5586\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5672\"\n },\n {\n \"code\": \"\\nfrom sortedcontainers import SortedList\\nclass BIT:\\n def __init__(self, size):\\n self.bit = [0] * (size + 1)\\n def update(self, pos, value):\\n pos += 1\\n while pos < len(self.bit):\\n self.bit[pos] = max(self.bit[pos], value)\\n pos += pos & -pos\\n def pre_max(self, pos):\\n pos += 1\\n res = 0\\n while pos > 0:\\n res = max(res, self.bit[pos])\\n pos -= pos & -pos\\n return res\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n mx = max(q[1] for q in queries) + 1\\n pos = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [mx] # mx prevent index out of range, there is no type 2 query on its right\\n bit = BIT(len(pos))\\n for i in range(1, len(pos)):\\n i += 1\\n bit.bit[i] = max(bit.bit[i], pos[i-1] - pos[i-2])\\n p = i + (i & -i)\\n if p < len(bit.bit):\\n bit.bit[p] = max(bit.bit[p], bit.bit[i])\\n\\n sl = SortedList(pos)\\n ans = []\\n for q in reversed(queries):\\n x = q[1]\\n i = sl.bisect_left(x)\\n left = sl[i-1]\\n if q[0] == 1:\\n sl.discard(x)\\n right = sl[i]\\n bit.update(bisect_left(pos, right), right - left)\\n else:\\n mx_gap = max(bit.pre_max(bisect_left(pos, left)), x - left)\\n ans.append(mx_gap >= q[2])\\n return ans[::-1]\",\n \"runtime\": \"5759\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5759\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5846\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"runtime\": \"5846\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\n\\nfrom sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10**4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n\\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n\\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n\\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n\\n ans.reverse()\\n return ans\\n\",\n \"runtime\": \"5933\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n blockends = [[0, 0]]\\n res = []\\n \\n for query in queries:\\n typeQ = query[0]\\n xCoord = query[1]\\n # binary search to find where the obstacle should be placed/where an obstacle might be\\n lo = 0\\n hi = len(blockends) - 1\\n\\n while lo < hi:\\n mid = math.ceil((lo + hi)/2)\\n wallLocation = blockends[mid][0]\\n if wallLocation >= xCoord:\\n hi = mid - 1\\n else:\\n lo = mid \\n\\n if typeQ == 1:\\n # note the lo + 1'th index is where we should place the obstacle (since the lo-th index exits)\\n blockends.insert(lo + 1, [query[1], max(blockends[lo][1], query[1] - blockends[lo][0])])\\n lo += 1\\n\\n # updating all the obstacles to the right of the one we just placed\\n while lo + 1 < len(blockends) and blockends[lo][1] < blockends[lo + 1][1] and blockends[lo + 1][0] - blockends[lo][0] < blockends[lo + 1][1]:\\n blockends[lo + 1][1] = max(blockends[lo][1], blockends[lo + 1][0] - blockends[lo][0])\\n lo += 1\\n else:\\n size = query[2]\\n\\n openSpace = max(query[1] - blockends[lo][0], blockends[lo][1])\\n res.append(openSpace >= size)\\n \\n print(blockends)\\n return res \\n\\n\",\n \"runtime\": \"5933\"\n },\n {\n \"code\": \"class seg_tree():\\n def __init__(self, length):\\n n = 1\\n while n < length: n <<= 1\\n self.n = n\\n self.x = [0]*n + [0]*length + [0]*(n-length)\\n for i in range(n-1, 0, -1):\\n self.x[i] = self.x[2*i]+self.x[2*i+1]\\n \\n def update(self, index, val):\\n index += self.n\\n self.x[index] = val\\n while index > 0:\\n index //= 2\\n self.x[index] = max(self.x[index*2], self.x[index*2+1])\\n \\n def query(self, l, r):\\n ans = []\\n l += self.n\\n r += self.n\\n while l <= r:\\n if l%2 == 1:\\n ans.append(self.x[l])\\n l += 1\\n if r%2 == 0:\\n ans.append(self.x[r])\\n r -=1\\n l, r = l//2, r//2\\n return max(ans)\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = max([q[1] for q in queries])\\n st = seg_tree(n+1)\\n obstacles = [0]\\n\\n ans = []\\n for i, q in enumerate(queries): \\n loc = q[1]\\n if q[0] == 1:\\n idx = bisect.bisect_left(obstacles, loc)\\n prev = obstacles[idx-1]\\n st.update(loc, loc-prev)\\n if idx < len(obstacles): \\n nxt = obstacles[idx]\\n st.update(nxt, nxt-loc)\\n bisect.insort_left(obstacles, loc)\\n else:\\n idx = bisect.bisect_left(obstacles, loc)\\n prev = obstacles[idx-1]\\n maxx = max(loc-prev, st.query(0, prev))\\n ans.append(q[2] <= maxx)\\n return ans\",\n \"runtime\": \"6020\"\n },\n {\n \"code\": \"class Ftree:\\n def __init__(self, n):\\n self.n = n\\n self.t = [0 for _ in range(n)]\\n\\n def max(self, i):\\n res = 0\\n while i >= 0:\\n res = max(res, self.t[i])\\n i = (i & (i + 1)) - 1\\n return res\\n\\n def update(self, i, v):\\n while i < self.n:\\n self.t[i] = max(self.t[i], v)\\n i = (i | (i + 1))\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n from sortedcontainers import SortedList\\n m = min(5 * 10**4, 3 * len(queries))\\n sl = SortedList([0, m])\\n for query in queries:\\n if query[0] == 1:\\n sl.add(query[1])\\n bit = Ftree(m + 1)\\n last = 0\\n for l, r in pairwise(sl):\\n bit.update(r, r - l)\\n ans = []\\n for query in reversed(queries):\\n if query[0] == 1:\\n v = sl.index(query[1])\\n r = sl[v+1]\\n l = sl[v-1]\\n bit.update(r, r - l)\\n sl.discard(sl[v])\\n else:\\n index = sl.bisect_right(query[1])\\n before = sl[index - 1]\\n val = bit.max(query[1])\\n ans.append((val >= query[2]) or (query[1] - before >= query[2]) )\\n # print(sl, bit.t, ans)\\n return ans[::-1]\",\n \"runtime\": \"6020\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"runtime\": \"6107\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nfrom typing import List\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += self.lowbit(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= self.lowbit(i)\\n return res\\n\\n @staticmethod\\n def lowbit(i: int) -> int:\\n return i & -i\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # Sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\\n\\n\",\n \"runtime\": \"6107\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def update(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.update(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.update(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"runtime\": \"6194\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nfrom typing import List\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += self.lowbit(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= self.lowbit(i)\\n return res\\n\\n @staticmethod\\n def lowbit(i: int) -> int:\\n return i & -i\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # Sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\\n\\n\\n\",\n \"runtime\": \"6194\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"runtime\": \"6280\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: list[list[int]]) -> list[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"runtime\": \"6280\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: list[list[int]]) -> list[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"runtime\": \"6367\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n def maximize(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n])\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.maximize(x2, x2 - x1)\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.maximize(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n return ans[::-1]\",\n \"runtime\": \"6367\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n\\n # Blocks along the axis\\n axis = SortedList()\\n\\n # Range Max of intervals from 0 to each block\\n itvl = SegTree(max(q[1] for q in queries))\\n\\n res = []\\n axis.add(0)\\n itvl.update(0,0)\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = axis.bisect(q[1])\\n if ind < len(axis):\\n # Update the interval of the next block\\n nxt = axis[ind]\\n itvl.update(nxt, nxt-q[1])\\n # Set the interval of the current block\\n itvl.update(q[1], q[1] - axis[ind-1])\\n # Add the current block on axis\\n axis.add(q[1])\\n else:\\n # Find the previous block\\n prv = axis[axis.bisect(q[1])-1]\\n # Range query the max interval before prv\\n mx = max(q[1]-prv, itvl.query(prv))\\n\\n res.append(q[2] <= mx)\\n return res\\n\\nclass SegTree:\\n\\n def __init__(self, n: int):\\n # self.n = 1 << n.bit_length()\\n self.n = 2 ** (int(math.log2(n)) + 1)\\n self.tree = [0] * (self.n*2)\\n\\n def update(self, ind: int, val: int):\\n ind += self.n\\n self.tree[ind] = val\\n while ind > 1:\\n ind //= 2\\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\\n \\n def query(self, ind: int) -> int:\\n ind += self.n\\n res = self.tree[ind]\\n while ind > 1:\\n if ind%2 == 1:\\n res = max(res, self.tree[ind-1])\\n ind //= 2\\n return res\",\n \"runtime\": \"6454\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n\\n # Blocks along the axis\\n axis = SortedList()\\n\\n # Range Max of intervals from 0 to each block\\n itvl = SegTree(max(q[1] for q in queries))\\n\\n res = []\\n axis.add(0)\\n itvl.update(0,0)\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = axis.bisect(q[1])\\n if ind < len(axis):\\n # Update the interval of the next block\\n nxt = axis[ind]\\n itvl.update(nxt, nxt-q[1])\\n # Set the interval of the current block\\n itvl.update(q[1], q[1] - axis[ind-1])\\n # Add the current block on axis\\n axis.add(q[1])\\n else:\\n # Find the previous block\\n prv = axis[axis.bisect(q[1])-1]\\n # Range query the max interval before prv\\n mx = max(q[1]-prv, itvl.query(prv))\\n\\n res.append(q[2] <= mx)\\n return res\\n\\nclass SegTree:\\n\\n def __init__(self, n: int):\\n self.n = 1 << n.bit_length()\\n self.tree = [0] * (self.n*2)\\n\\n def update(self, ind: int, val: int):\\n ind += self.n\\n self.tree[ind] = val\\n while ind > 1:\\n ind //= 2\\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\\n \\n def query(self, ind: int) -> int:\\n ind += self.n\\n res = self.tree[ind]\\n while ind > 1:\\n if ind%2 == 1:\\n res = max(res, self.tree[ind-1])\\n ind //= 2\\n return res\",\n \"runtime\": \"6454\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n\\n # Blocks along the axis\\n axis = SortedList()\\n\\n # Range Max of intervals from 0 to each block\\n itvl = SegTree(max(q[1] for q in queries))\\n\\n res = []\\n axis.add(0)\\n itvl.update(0,0)\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = axis.bisect(q[1])\\n if ind < len(axis):\\n # Update the interval of the next block\\n nxt = axis[ind]\\n itvl.update(nxt, nxt-q[1])\\n # Set the interval of the current block\\n itvl.update(q[1], q[1] - axis[ind-1])\\n # Add the current block on axis\\n axis.add(q[1])\\n else:\\n # Find the previous block\\n prv = axis[axis.bisect(q[1])-1]\\n # Range query the max interval before prv\\n mx = max(q[1]-prv, itvl.query(prv))\\n\\n res.append(q[2] <= mx)\\n return res\\n\\nclass SegTree:\\n\\n def __init__(self, n: int):\\n self.n = 1 << n.bit_length()\\n self.tree = [0] * (self.n*2)\\n\\n def update(self, ind: int, val: int):\\n ind += self.n\\n self.tree[ind] = val\\n while ind > 1:\\n ind //= 2\\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\\n \\n def query(self, ind: int) -> int:\\n ind += self.n\\n res = self.tree[ind]\\n while ind > 1:\\n if ind%2 == 1:\\n res = max(res, self.tree[ind-1])\\n ind //= 2\\n return res\",\n \"runtime\": \"6541\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n deg2 = math.floor(math.log(max(x[1] for x in queries), 2)) + 1\\n n = 2 ** deg2\\n stsize = n * 2\\n l = [0] * stsize # longest placement starting from the beginning of segment\\n r = [0] * stsize # longest placement starting from the ending of segment\\n m = [0] * stsize # longest placement overall in the segment\\n\\n # inital filling of the segment tree\\n def fill(i=0, beg=0, size=n):\\n l[i] = r[i] = m[i] = size\\n if size > 1:\\n li, ri = 2 * i + 1, 2 * i + 2\\n hsize = size // 2\\n fill(li, beg, hsize)\\n fill(ri, beg + hsize, hsize)\\n \\n fill()\\n\\n # insert barrier operation\\n def insert(x, i=0, beg=0, size=n):\\n if size == 1:\\n if x > beg:\\n r[i] = 0\\n else:\\n l[i] = 0\\n else:\\n li, ri = 2 * i + 1, 2 * i + 2\\n hsize = size // 2\\n mid = beg + hsize\\n if x <= mid:\\n insert(x, li, beg, hsize)\\n if x >= mid:\\n insert(x, ri, mid, hsize)\\n l[i] = l[li] + (l[ri] if l[li] == hsize else 0)\\n r[i] = r[ri] + (r[li] if r[ri] == hsize else 0)\\n m[i] = max(l[i], r[i], m[li], m[ri], r[li] + l[ri])\\n\\n # query\\n # returns (left, max) \\n # where `left` is max block size starting at the beginning of the segement (considering x constraint)\\n # `max` is max block size overall in the chosen segment (considering x constraint)\\n def get_max(x, i=0, beg=0, size=n):\\n if size == 1:\\n if x > beg:\\n return l[i], m[i]\\n else:\\n return 0, 0\\n li, ri = 2 * i + 1, 2 * i + 2\\n hsize = size // 2\\n mid = beg + hsize\\n if x <= mid:\\n return get_max(x, li, beg, hsize)\\n lri, mr = get_max(x, ri, beg + hsize, hsize)\\n lpart = l[li] + (lri if l[li] == hsize else 0)\\n return lpart, max(m[li], mr, lpart, r[li] + lri)\\n\\n ret = []\\n for q in queries:\\n if q[0] == 1:\\n insert(q[1])\\n else:\\n ret.append(get_max(q[1])[1] >= q[2])\\n return ret\",\n \"runtime\": \"6541\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n\\n # Blocks along the axis\\n axis = SortedList()\\n\\n # Range Max of intervals from 0 to each block\\n itvl = SegTree(max(q[1] for q in queries))\\n\\n res = []\\n axis.add(0)\\n itvl.update(0,0)\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = axis.bisect(q[1])\\n if ind < len(axis):\\n # Update the interval of the next block\\n nxt = axis[ind]\\n itvl.update(nxt, nxt-q[1])\\n # Set the interval of the current block\\n itvl.update(q[1], q[1] - axis[ind-1])\\n # Add the current block on axis\\n axis.add(q[1])\\n else:\\n # Find the previous block\\n prv = axis[axis.bisect(q[1])-1]\\n # Range query the max interval before prv\\n mx = max(q[1]-prv, itvl.query(prv))\\n\\n res.append(q[2] <= mx)\\n\\n return res\\n\\nclass SegTree:\\n\\n def __init__(self, n: int):\\n # self.n = 1 << n.bit_length()\\n self.n = 2 ** (int(math.log2(n)) + 1)\\n self.tree = [0] * (self.n*2 - 1)\\n\\n def update(self, ind: int, val: int):\\n ind += self.n - 1\\n self.tree[ind] = val\\n while ind > 0:\\n if ind % 2:\\n ind //= 2\\n else:\\n ind //= 2\\n ind -= 1\\n self.tree[ind] = max(self.tree[ind*2+1], self.tree[ind*2+2])\\n \\n def query(self, ind: int) -> int:\\n ind += self.n - 1\\n res = self.tree[ind]\\n while ind > 0:\\n if ind%2 == 1: \\n ind //= 2\\n else:\\n res = max(res, self.tree[ind-1])\\n ind //= 2\\n ind -= 1\\n # res = max(res, self.tree[ind])\\n return res\",\n \"runtime\": \"6628\"\n },\n {\n \"code\": \"from typing import List\\nfrom sortedcontainers import SortedList\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def add(self, i: int, val: int):\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += self.lowbit(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= self.lowbit(i)\\n return res\\n\\n def lowbit(self, i: int) -> int:\\n return i & -i\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n])\\n\\n for query in queries:\\n if query[0] == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n x1 = obstacles[0]\\n for i in range(1, len(obstacles)):\\n x2 = obstacles[i]\\n tree.add(x2, x2 - x1)\\n x1 = x2\\n\\n for i in range(len(queries) - 1, -1, -1):\\n query = queries[i]\\n x = query[1]\\n if query[0] == 1:\\n next_idx = obstacles.bisect_right(x)\\n prev_idx = obstacles.bisect_left(x) - 1\\n if next_idx < len(obstacles):\\n tree.add(obstacles[next_idx], obstacles[next_idx] - obstacles[prev_idx])\\n obstacles.remove(x)\\n else:\\n sz = query[2]\\n prev_idx = obstacles.bisect(x) - 1\\n ans.append(tree.get(obstacles[prev_idx]) >= sz or x - obstacles[prev_idx] >= sz)\\n\\n ans.reverse()\\n return ans\\n\\n# Example usage:\\nsolution = Solution()\\nqueries = [[2, 10, 2], [1, 10], [2, 9, 2], [1, 12], [2, 11, 2]]\\nprint(solution.getResults(queries))\\n\",\n \"runtime\": \"6715\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass SegmentTree:\\n def __init__(self, size: int):\\n self.size = size\\n self.st = [0] * 2 * size\\n\\n def update(self, idx: int, val: int):\\n idx += self.size\\n self.st[idx] = val\\n idx //= 2\\n\\n while idx > 0:\\n self.st[idx] = max(self.st[2 * idx], self.st[2 * idx + 1])\\n idx //= 2\\n\\n def query(self, left: int, right: int) -> int:\\n left += self.size\\n right += self.size\\n max_val = -inf\\n\\n while left < right:\\n if left & 1:\\n max_val = max(max_val, self.st[left])\\n left += 1\\n\\n left //= 2\\n\\n if right & 1:\\n right -= 1\\n max_val = max(max_val, self.st[right])\\n\\n right //= 2\\n\\n return max_val\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n X_MAX = min(5 * (10**4), 3 * len(queries))\\n\\n st = SegmentTree(X_MAX + 1)\\n obstacles = SortedList([0, X_MAX])\\n st.update(0, X_MAX)\\n\\n ans = []\\n\\n for query in queries:\\n x = query[1]\\n if query[0] == 1:\\n idx = obstacles.bisect_left(x)\\n prev_x = obstacles[idx - 1]\\n st.update(prev_x, x - prev_x)\\n st.update(x, obstacles[idx] - x)\\n obstacles.add(x)\\n else:\\n sz = query[2]\\n prev_x = obstacles[obstacles.bisect_right(x) - 1]\\n max_in_range = st.query(0, prev_x)\\n max_in_range = max(max_in_range, x - prev_x)\\n ans.append(max_in_range >= sz)\\n\\n return ans\\n\",\n \"runtime\": \"6715\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n X = 1 + max(q[1] for q in queries)\\n\\n # build tree\\n GAP = 0\\n LEFT = 1\\n RIGHT = 2\\n tree = [[0, 0, 0] for _ in range(4 * X)]\\n\\n def maintain(i, l, r):\\n this = tree[i]\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n\\n # update leftmost and rightmost obstacle in this range\\n this[LEFT] = left[LEFT] if left[LEFT] else right[LEFT]\\n this[RIGHT] = right[RIGHT] if right[RIGHT] else left[RIGHT]\\n\\n # update biggest gap in this range\\n leftcap = left[RIGHT] if left[RIGHT] else l\\n rightcap = right[LEFT] if right[LEFT] else r\\n this[GAP] = max(left[GAP], right[GAP], rightcap - leftcap)\\n\\n def construct(i, l, r):\\n if l < r: # nothing to do for l == r initially\\n m = (l + r) // 2\\n construct(2 * i, l, m)\\n construct(2 * i + 1, m + 1, r)\\n maintain(i, l, r)\\n \\n construct(1, 0, X)\\n\\n def obstacle(i, l, r, x):\\n if l == r:\\n tree[i][LEFT] = tree[i][RIGHT] = x\\n else:\\n m = (l + r) // 2\\n if x <= m:\\n obstacle(2 * i, l, m, x)\\n else:\\n obstacle(2 * i + 1, m + 1, r, x)\\n maintain(i, l, r)\\n \\n def gap_and_leftmost(i, l, r, x): # leftmost obstacle OR x\\n if r == x:\\n return tree[i][GAP], tree[i][LEFT] or x\\n m = (l + r) // 2\\n if x <= m:\\n return gap_and_leftmost(2 * i, l, m, x)\\n \\n left = tree[2 * i]\\n right_gap, right_left = gap_and_leftmost(2 * i + 1, m + 1, r, x)\\n left_right = max(l, left[RIGHT])\\n gap = max(left[GAP], right_gap, right_left - left_right)\\n leftmost = left[LEFT] if left[LEFT] else right_left\\n return gap, leftmost\\n\\n answers = []\\n for q in queries:\\n if q[0] == 1:\\n obstacle(1, 0, X, q[1])\\n else:\\n gap, _ = gap_and_leftmost(1, 0, X, q[1])\\n answers.append(q[2] <= gap)\\n\\n return answers\",\n \"runtime\": \"6802\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n m = max(q[1] for q in queries) + 1\\n t = [0] * (2 << m.bit_length())\\n\\n # 把 i 处的值改成 val\\n def update(o, l, r, i, val):\\n if l == r:\\n t[o] = val\\n return \\n \\n m = (l + r) // 2\\n if i <= m:\\n update(o * 2, l, m, i, val)\\n else:\\n update(o * 2 + 1, m + 1, r, i, val)\\n t[o] = max(t[o * 2], t[o * 2 + 1])\\n \\n # 查询 [0,R] 中的最大值\\n def query(o, l, r, R):\\n if r <= R:\\n return t[o]\\n m = (l + r) // 2\\n if R <= m:\\n return query(o * 2, l, m, R)\\n return max(t[o * 2], query(o * 2 + 1, m + 1, r, R))\\n \\n sl = SortedList([0, m]) # 哨兵\\n ans = []\\n for q in queries:\\n x = q[1]\\n i = sl.bisect_left(x)\\n pre = sl[i - 1]\\n if q[0] == 1:\\n nxt = sl[i]\\n sl.add(x)\\n update(1, 0, m, x, x - pre)\\n update(1, 0, m, nxt, nxt - x)\\n else:\\n max_gap = max(query(1, 0, m, pre), x - pre)\\n ans.append(max_gap >= q[2])\\n \\n return ans\",\n \"runtime\": \"6889\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n X = 1 + max(q[1] for q in queries)\\n\\n # built tree\\n GAP = 0\\n LEFT = 1\\n RIGHT = 2\\n tree = [[0, 0, 0] for _ in range(4 * X)]\\n\\n def maintain(i, l, r):\\n this = tree[i]\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n\\n # update leftmost and rightmost obstacle in this range\\n this[LEFT] = left[LEFT] if left[LEFT] else right[LEFT]\\n this[RIGHT] = right[RIGHT] if right[RIGHT] else left[RIGHT]\\n\\n # update biggest gap in this range\\n leftcap = left[RIGHT] if left[RIGHT] else l\\n rightcap = right[LEFT] if right[LEFT] else r\\n this[GAP] = max(left[GAP], right[GAP], rightcap - leftcap)\\n\\n def construct(i, l, r):\\n if l < r: # nothing to do for l == r initially\\n m = (l + r) // 2\\n construct(2 * i, l, m)\\n construct(2 * i + 1, m + 1, r)\\n maintain(i, l, r)\\n \\n construct(1, 0, X)\\n\\n def obstacle(i, l, r, x):\\n if l == r:\\n tree[i][LEFT] = tree[i][RIGHT] = x\\n else:\\n m = (l + r) // 2\\n if x <= m:\\n obstacle(2 * i, l, m, x)\\n else:\\n obstacle(2 * i + 1, m + 1, r, x)\\n maintain(i, l, r)\\n \\n def gap_and_leftmost(i, l, r, x): # leftmost obstacle OR x\\n if r == x:\\n return tree[i][GAP], tree[i][LEFT] or x\\n m = (l + r) // 2\\n if x <= m:\\n return gap_and_leftmost(2 * i, l, m, x)\\n \\n left = tree[2 * i]\\n right_gap, right_left = gap_and_leftmost(2 * i + 1, m + 1, r, x)\\n left_right = max(l, left[RIGHT])\\n gap = max(left[GAP], right_gap, right_left - left_right)\\n leftmost = left[LEFT] if left[LEFT] else right_left\\n #print(f\\\"{i}: {left=}, {right_gap=}, {right_left=}, {left_right=}, {gap=}, {leftmost=}\\\")\\n return gap, leftmost\\n\\n answers = []\\n for q in queries:\\n if q[0] == 1:\\n obstacle(1, 0, X, q[1])\\n else:\\n gap, left = gap_and_leftmost(1, 0, X, q[1])\\n print(gap, left)\\n answers.append(q[2] <= gap)\\n\\n return answers\",\n \"runtime\": \"6975\"\n },\n {\n \"code\": \"from numpy import array,arange\\nfrom bisect import bisect_left,insort_left\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n result,obstacles,prev_obstacle_idx,index = [],[0],0,0\\n arr = array([-1] * 50001)\\n arr[0] = 1\\n for q in queries:\\n x = q[1]\\n if len(obstacles) == 1:\\n prev_obstacle_idx = obstacles[0]\\n else:\\n index = bisect_left(obstacles,x) \\n if index > 0:\\n prev_obstacle_idx = obstacles[index-1]\\n if q[0] == 1:\\n arr[x] = 1\\n arr[prev_obstacle_idx+1:x] = arange(len(arr[prev_obstacle_idx+1:x])+1,1,-1)\\n insort_left(obstacles,x)\\n else:\\n sz = q[2]\\n dist = x - prev_obstacle_idx\\n if prev_obstacle_idx == 0:\\n prev_obstacle_idx = 1\\n result.append(max(dist,arr[:prev_obstacle_idx].max()) >= sz) \\n return result\",\n \"runtime\": \"7062\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"runtime\": \"7149\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"runtime\": \"7236\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"runtime\": \"7323\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"7410\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"7497\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"7583\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"runtime\": \"7670\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"7757\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"7844\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"runtime\": \"7931\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\\n \\n \\n \",\n \"runtime\": \"8018\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n #[longest contineous length, leftmost continuous length, rightmost continuous length]\\n self.l=min(50000, 3*len(queries))\\n self.st=[[0,0,0,True] for i in range(4*self.l)]\\n self.block=set()\\n\\n # index i on x-axis: segment[i,i+1]\\n def up(self,i,l,r):\\n L=i<<1\\n R=L|1\\n mid=(l+r)>>1\\n if mid+1 not in self.block:\\n lcl=max(self.st[L][0],self.st[R][0],self.st[L][2]+self.st[R][1])\\n\\n if self.st[L][3]:\\n Lcl=self.st[L][1]+self.st[R][1]\\n else:\\n Lcl=self.st[L][1]\\n\\n if self.st[R][3]:\\n Rcl=self.st[R][2]+self.st[L][2]\\n else:\\n Rcl=self.st[R][2]\\n\\n con=self.st[L][3]&self.st[R][3]\\n else:\\n lcl=max(self.st[L][0],self.st[R][0])\\n Lcl=self.st[L][1]\\n Rcl=self.st[R][2]\\n con=False\\n self.st[i]=[lcl,Lcl,Rcl,con]\\n \\n def down(self,i,jobi,l,r):\\n mid=(l+r)>>1\\n if jobi==mid+1:\\n L=i<<1\\n R=L|1\\n self.st[i]=[max(self.st[L][0],self.st[R][0]),self.st[L][1],self.st[R][2],False]\\n else:\\n if jobi<=mid:\\n down(self,i<<1,jobi,l,mid)\\n else:\\n down(self,1|(i<<1),jobi,mid+1,r)\\n up(self,i,l,r)\\n pass\\n\\n def build(self,l,r,i):\\n if l==r:\\n self.st[i]=[1,1,1,True]\\n else:\\n mid=(l+r)>>1\\n build(self,l,mid,i<<1)\\n build(self,mid+1,r,1|(i<<1))\\n up(self,i,l,r)\\n\\n def query(self,i,jobl,jobr,l,r):\\n if jobl<=l and r<=jobr:\\n return (self.st[i][0],self.st[i][1],self.st[i][2],self.st[i][3])\\n else:\\n mid=(l+r)>>1\\n if jobl<=mid:\\n if mid+1<=jobr:\\n lclL,LclL,RclL,conL=query(self,i<<1,jobl,jobr,l,mid)\\n lclR,LclR,RclR,conR=query(self,1|(i<<1),jobl,jobr,mid+1,r)\\n if mid+1 in self.block:\\n return (max(lclL,lclR),LclL,RclR,False)\\n else:\\n lcl=max(lclL,lclR,RclL+LclR)\\n\\n if conL:\\n Lcl=LclL+LclR\\n else:\\n Lcl=LclL\\n\\n if conR:\\n Rcl=RclR+RclL\\n else:\\n Rcl=RclR\\n \\n con=conL&conR\\n return (lcl,Lcl,Rcl,con)\\n else:\\n return query(self,i<<1,jobl,jobr,l,mid)\\n else:\\n return query(self,1|(i<<1),jobl,jobr,mid+1,r)\\n\\n build(self,0,self.l,1)\\n #print(self.st)\\n ans=[]\\n\\n for i in queries:\\n if i[0]==1:\\n self.block.add(i[1])\\n down(self,1,i[1],0,self.l)\\n else:\\n a,b,c,d=query(self,1,0,i[1]-1,0,self.l)\\n #print(a)\\n ans.append(a>=i[2])\\n return ans\",\n \"runtime\": \"8105\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, begin, end):\\n self.begin = begin\\n self.end = end\\n self.mid = (begin + end) // 2\\n self.left: SegmentTree = None\\n self.right: SegmentTree = None\\n self.left_blocked = False\\n self.right_blocked = False\\n self.max_left = end - begin # max length contains the left border\\n self.max_right = end - begin # max length contains the right border\\n self.max_mid = end - begin # max length among all children\\n\\n def insert(self, index):\\n if index == self.begin:\\n self.left_blocked = True\\n self.max_left = 0\\n elif index == self.end:\\n self.right_blocked = True\\n self.max_right = 0\\n elif index >= self.end or index <= self.begin:\\n return\\n else:\\n self.pushDown()\\n\\n if index <= self.mid:\\n self.left.insert(index)\\n if index >= self.mid:\\n self.right.insert(index)\\n\\n self.popUp()\\n\\n def query(self, begin, end):\\n if begin <= self.begin and end >= self.end:\\n return self.max_left, self.max_mid, self.max_right\\n elif self.left is None or self.right is None:\\n res = min(end, self.end) - max(self.begin, begin)\\n return res, res, res\\n else:\\n left_left = left_mid = left_right = right_left = right_mid = right_right = 0\\n if begin <= self.mid:\\n left_left, left_mid, left_right = self.left.query(begin, end)\\n if end >= self.mid:\\n right_left, right_mid, right_right = self.right.query(begin, end)\\n if self.left.right_blocked != self.right.left_blocked:\\n raise Exception\\n mid_blocked = self.left.right_blocked\\n left_max = (\\n left_left + right_left) if not mid_blocked and left_right == self.mid - self.begin else left_left\\n right_max = (\\n right_right + left_right) if not mid_blocked and right_left == self.end - self.mid else right_right\\n mid_max = max((left_right + right_left) if not mid_blocked else max(left_right, right_left), left_mid,\\n right_mid, left_max, right_max)\\n\\n return left_max, mid_max, right_max\\n\\n def popUp(self):\\n self.left_blocked = self.left.left_blocked or self.left_blocked\\n self.right_blocked = self.right.right_blocked or self.right_blocked\\n self.max_left = self.left.max_left + self.right.max_left \\\\\\n if self.left.max_left == self.left.end - self.left.begin and not self.left.right_blocked \\\\\\n else self.left.max_left\\n self.max_right = self.right.max_right + self.left.max_right \\\\\\n if self.right.max_right == self.right.end - self.right.begin and not self.right.left_blocked \\\\\\n else self.right.max_right\\n self.max_mid = max(\\n (self.left.max_right + self.right.max_left) if not self.left.right_blocked else max(self.max_left,\\n self.max_right),\\n self.left.max_mid, self.right.max_mid)\\n\\n def pushDown(self):\\n if self.left is None:\\n self.left = SegmentTree(self.begin, self.mid)\\n if self.right is None:\\n self.right = SegmentTree(self.mid, self.end)\\n\\n\\nclass Solution:\\n def getResults(self, queries):\\n root = SegmentTree(0, (int)(5E4 + 1)) # 初始化 root\\n res = []\\n for query in queries:\\n if query[0] == 1: # 第一种操作\\n root.insert(query[1]) # 加上 query[1] 这一块\\n else: # 第二种操作\\n res.append(max(root.query(0, query[1])) >= query[2]) # 查找 [0, query[1]] 的最大线段\\n return res\",\n \"runtime\": \"8191\"\n },\n {\n \"code\": \"from copy import deepcopy\\nclass Node:\\n def __init__(self, flag = True, node = None):\\n if flag:\\n self.left = None\\n self.right = None\\n self.lval = 0\\n self.rval = 0\\n self.bestval = 0\\n self.connected = True\\n else:\\n self.left = node.left\\n self.right = node.right\\n self.lval = node.lval\\n self.rval = node.rval\\n self.bestval = node.bestval\\n self.connected = node.connected\\n \\ndef Build(l,r, arr):\\n if l == r:\\n return Node()\\n mid = (l+r)//2\\n lnode = Build(l, mid, arr)\\n rnode = Build(mid+1, r, arr)\\n node = Node()\\n node.left = lnode\\n node.right = rnode\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n return node\\n\\ndef update(l,r,idx, node):\\n if l > r:\\n return\\n mid = (l+r)//2\\n if l == r == idx:\\n node.connected = False\\n node.lval = 0\\n node.rval = 0\\n node.bestval = 0\\n return \\n if l <= idx <= mid:\\n update(l,mid, idx, node.left)\\n elif mid+1 <= idx <= r:\\n update(mid+1, r, idx, node.right)\\n else:\\n return\\n lnode = node.left\\n rnode = node.right\\n if lnode.connected and rnode.connected:\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n elif lnode.connected:\\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\\n node.lval = lnode.bestval + rnode.lval+1\\n node.rval = rnode.rval\\n elif rnode.connected:\\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\\n node.lval = lnode.lval\\n node.rval = lnode.rval + rnode.bestval+1\\n else:\\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\\n node.lval = lnode.lval\\n node.rval = rnode.rval\\n node.connected = False\\n\\ndef query(l,r,idx, hnode):\\n if l > r or idx < l:\\n nnode = Node()\\n nnode.bestval = -1\\n nnode.lval = -1\\n nnode.rval = -1\\n return nnode\\n mid = (l+r)//2\\n if idx >= r:\\n return Node(False, hnode)\\n if l<=idx<=r:\\n mid = (l+r)//2\\n lnode = query(l, mid, idx, hnode.left)\\n rnode = query(mid+1, r, idx, hnode.right)\\n node = Node()\\n if lnode.connected and rnode.connected:\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n elif lnode.connected:\\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\\n node.lval = lnode.bestval + rnode.lval+1\\n node.rval = rnode.rval\\n elif rnode.connected:\\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\\n node.lval = lnode.lval\\n node.rval = lnode.rval + rnode.bestval+1\\n else:\\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\\n node.lval = lnode.lval\\n node.rval = rnode.rval\\n node.connected = False\\n return node\\n\\ndef ptrees(l,r,node):\\n if l > r:\\n return\\n if l == r:\\n return \\n mid = (l+r)//2\\n ptrees(l, mid, node.left)\\n ptrees(mid+1, r, node.right)\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n ans = []\\n arr = max([i[1] for i in queries])+1\\n head = Build(0, arr-1, arr)\\n for curr in queries:\\n if curr[0] == 1:\\n x = curr[1]\\n temp = head\\n update(0, arr-1, x, temp)\\n else:\\n x,sz = curr[1], curr[2]\\n temp = head\\n nnode = query(0, arr-1, x, temp)\\n ans.append(nnode.bestval >= sz)\\n # print(head.bestval)\\n \\n return ans\",\n \"runtime\": \"8452\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, data, operation=min):\\n self.n = len(data)\\n self.tree = [0]*self.n + list(data)\\n self.operation = operation\\n for i in range(self.n - 1, 0, -1):\\n self.tree[i] = self.operation(self.tree[i << 1], self.tree[i << 1 | 1])\\n\\n def update(self, index, value):\\n pos = index + self.n\\n self.tree[pos] = value\\n while pos > 1:\\n pos >>= 1\\n self.tree[pos] = self.operation(self.tree[pos << 1], self.tree[pos << 1 | 1])\\n\\n def __getitem__(self, key):\\n if isinstance(key, slice):\\n start = key.start if key.start is not None else 0\\n stop = key.stop if key.stop is not None else self.n\\n return self.query(start, stop)\\n elif isinstance(key, int) and key < self.n:\\n return self.tree[key+self.n]\\n else:\\n raise TypeError(f\\\"Value of {key} cannot be indexed.\\\")\\n\\n def query(self, left, right):\\n result = self.tree[left + self.n]\\n left += self.n + 1\\n right += self.n\\n while left < right:\\n if left & 1:\\n result = self.operation(result, self.tree[left])\\n left += 1\\n if right & 1:\\n right -= 1\\n result = self.operation(result, self.tree[right])\\n left >>= 1\\n right >>= 1\\n return result\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n m = max([x[1] for x in queries])+2\\n left = SegmentTree([0]*m, operation=max)\\n lower = SegmentTree([0]*m, operation=max)\\n upper = SegmentTree([float('inf')]*m, operation=min)\\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n _, val = q\\n\\n v2 = upper[val+1:]\\n if v2 != float('inf'):\\n left.update(v2, v2-val)\\n\\n lower.update(val, val)\\n upper.update(val, val)\\n left.update(val, val-lower[:val])\\n # print(val-lower[:val-1])\\n\\n else:\\n _, x, sz = q\\n cur = max(left[:x], x-lower[:x])\\n ans.append(cur>=sz)\\n # print(left[:x])\\n # print(cur)\\n # print(lower.tree[len(lower.tree) // 2 :])\\n # print(upper.tree[len(lower.tree) // 2 :])\\n # print('ans: ', left.tree[len(lower.tree) // 2 :])\\n # print()\\n return ans\",\n \"runtime\": \"8539\"\n },\n {\n \"code\": \"from copy import deepcopy\\nclass Node:\\n def __init__(self, flag = True, node = None):\\n if flag:\\n self.left = None\\n self.right = None\\n self.lval = 0\\n self.rval = 0\\n self.bestval = 0\\n self.connected = True\\n else:\\n self.left = node.left\\n self.right = node.right\\n self.lval = node.lval\\n self.rval = node.rval\\n self.bestval = node.bestval\\n self.connected = node.connected\\n \\ndef Build(l,r, arr):\\n if l == r:\\n return Node()\\n mid = (l+r)//2\\n lnode = Build(l, mid, arr)\\n rnode = Build(mid+1, r, arr)\\n node = Node()\\n node.left = lnode\\n node.right = rnode\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n return node\\n\\ndef update(l,r,idx, node):\\n if l > r:\\n return\\n mid = (l+r)//2\\n if l == r == idx:\\n node.connected = False\\n node.lval = 0\\n node.rval = 0\\n node.bestval = 0\\n return \\n if l <= idx <= mid:\\n update(l,mid, idx, node.left)\\n elif mid+1 <= idx <= r:\\n update(mid+1, r, idx, node.right)\\n else:\\n return\\n lnode = node.left\\n rnode = node.right\\n if lnode.connected and rnode.connected:\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n elif lnode.connected:\\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\\n node.lval = lnode.bestval + rnode.lval+1\\n node.rval = rnode.rval\\n elif rnode.connected:\\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\\n node.lval = lnode.lval\\n node.rval = lnode.rval + rnode.bestval+1\\n else:\\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\\n node.lval = lnode.lval\\n node.rval = rnode.rval\\n node.connected = False\\n\\ndef query(l,r,idx, hnode):\\n if l > r or idx < l:\\n nnode = Node()\\n nnode.bestval = -1\\n nnode.lval = -1\\n nnode.rval = -1\\n return nnode\\n mid = (l+r)//2\\n if idx >= r:\\n return Node(False, hnode)\\n if l<=idx<=r:\\n mid = (l+r)//2\\n lnode = query(l, mid, idx, hnode.left)\\n rnode = query(mid+1, r, idx, hnode.right)\\n node = Node()\\n if lnode.connected and rnode.connected:\\n node.bestval = lnode.bestval + rnode.bestval+1\\n node.lval = node.bestval\\n node.rval = node.bestval\\n elif lnode.connected:\\n node.bestval = max(lnode.bestval + rnode.lval+1, rnode.bestval)\\n node.lval = lnode.bestval + rnode.lval+1\\n node.rval = rnode.rval\\n elif rnode.connected:\\n node.bestval = max(lnode.bestval, lnode.rval + rnode.bestval+1)\\n node.lval = lnode.lval\\n node.rval = lnode.rval + rnode.bestval+1\\n else:\\n node.bestval = max(lnode.bestval, rnode.bestval, lnode.rval+rnode.lval+1)\\n node.lval = lnode.lval\\n node.rval = rnode.rval\\n node.connected = False\\n return node\\n\\ndef ptrees(l,r,node):\\n if l > r:\\n return\\n if l == r:\\n return \\n mid = (l+r)//2\\n ptrees(l, mid, node.left)\\n ptrees(mid+1, r, node.right)\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n ans = []\\n arr = max([i[1] for i in queries])+1\\n head = Build(0, arr-1, arr)\\n for curr in queries:\\n if curr[0] == 1:\\n x = curr[1]\\n temp = head\\n update(0, arr-1, x, temp)\\n else:\\n x,sz = curr[1], curr[2]\\n temp = head\\n nnode = query(0, arr-1, x, temp)\\n ans.append(nnode.bestval >= sz)\\n # print(head.bestval)\\n \\n return ans\",\n \"runtime\": \"8626\"\n },\n {\n \"code\": \"MAX = 10 ** 5\\nINF = 10 ** 20\\n\\nclass SegmentTree:\\n def __init__(self, n):\\n self.n = n\\n self.tree = [0] * (4 * n)\\n self.lazy = [0] * (4 * n)\\n\\n def _build(self, start, end, node):\\n if start == end:\\n self.tree[node] = MAX\\n else:\\n mid = (start + end) // 2\\n self._build(start, mid, 2 * node + 1)\\n self._build(mid + 1, end, 2 * node + 2)\\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\\n\\n def _update_range(self, start, end, l, r, value, node):\\n if self.lazy[node] != 0:\\n self.tree[node] = self.lazy[node]\\n if start != end:\\n self.lazy[2 * node + 1] = self.lazy[node]\\n self.lazy[2 * node + 2] = self.lazy[node]\\n self.lazy[node] = 0\\n\\n if start > end or start > r or end < l:\\n return\\n\\n if start >= l and end <= r:\\n self.tree[node] = value\\n if start != end:\\n self.lazy[2 * node + 1] = value\\n self.lazy[2 * node + 2] = value\\n return\\n\\n mid = (start + end) // 2\\n self._update_range(start, mid, l, r, value, 2 * node + 1)\\n self._update_range(mid + 1, end, l, r, value, 2 * node + 2)\\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\\n\\n def build(self):\\n self._build(0, self.n - 1, 0)\\n\\n def update_range(self, l, r, value):\\n self._update_range(0, self.n - 1, l, r, value, 0)\\n\\n def _query_range(self, start, end, l, r, node):\\n if start > end or start > r or end < l:\\n return -INF\\n\\n if self.lazy[node] != 0:\\n self.tree[node] = self.lazy[node]\\n if start != end:\\n self.lazy[2 * node + 1] = self.lazy[node]\\n self.lazy[2 * node + 2] = self.lazy[node]\\n self.lazy[node] = 0\\n\\n if start >= l and end <= r:\\n return self.tree[node]\\n\\n mid = (start + end) // 2\\n left_query = self._query_range(start, mid, l, r, 2 * node + 1)\\n right_query = self._query_range(mid + 1, end, l, r, 2 * node + 2)\\n return max(left_query, right_query)\\n\\n def query_range(self, l, r):\\n return self._query_range(0, self.n - 1, l, r, 0)\\n\\n# st = SegmentTree(MAX)\\n# st.update_range(prev + 1, x, x - prev)\\n# st.update_range(x + 1, nxt, nxt - x)\\n# st.query_range(0, p)\\n\\n\\nfrom sortedcontainers import SortedList\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n st = SegmentTree(MAX)\\n sl = SortedList()\\n\\n sl.add(0)\\n sl.add(MAX)\\n ans = []\\n \\n for row in queries:\\n if len(row) == 2:\\n _, x = row\\n\\n index = sl.bisect_left(x)\\n nxt = sl[index]\\n prev = sl[index - 1]\\n\\n sl.add(x)\\n\\n st.update_range(prev + 1, x, x - prev)\\n st.update_range(x + 1, nxt, nxt - x)\\n \\n elif len(row) == 3:\\n _, x, sz = row\\n\\n if sz > x:\\n ans.append(False)\\n continue\\n\\n index = sl.bisect_right(x) - 1\\n p = sl[index]\\n mx = 0\\n mx = max(mx, x - p)\\n\\n if p != 0:\\n mx = max(mx, st.query_range(0, p))\\n\\n ans.append(mx >= sz)\\n\\n return ans\",\n \"runtime\": \"8713\"\n },\n {\n \"code\": \"MAX = 10 ** 5\\nINF = 10 ** 20\\n\\nclass SegmentTree:\\n def __init__(self, n):\\n self.n = n\\n self.tree = [0] * (4 * n)\\n self.lazy = [0] * (4 * n)\\n\\n def _build(self, start, end, node):\\n if start == end:\\n self.tree[node] = MAX\\n else:\\n mid = (start + end) // 2\\n self._build(start, mid, 2 * node + 1)\\n self._build(mid + 1, end, 2 * node + 2)\\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\\n\\n def _update_range(self, start, end, l, r, value, node):\\n if self.lazy[node] != 0:\\n self.tree[node] = self.lazy[node]\\n if start != end:\\n self.lazy[2 * node + 1] = self.lazy[node]\\n self.lazy[2 * node + 2] = self.lazy[node]\\n self.lazy[node] = 0\\n\\n if start > end or start > r or end < l:\\n return\\n\\n if start >= l and end <= r:\\n self.tree[node] = value\\n if start != end:\\n self.lazy[2 * node + 1] = value\\n self.lazy[2 * node + 2] = value\\n return\\n\\n mid = (start + end) // 2\\n self._update_range(start, mid, l, r, value, 2 * node + 1)\\n self._update_range(mid + 1, end, l, r, value, 2 * node + 2)\\n self.tree[node] = max(self.tree[2 * node + 1], self.tree[2 * node + 2])\\n\\n def build(self):\\n self._build(0, self.n - 1, 0)\\n\\n def update_range(self, l, r, value):\\n self._update_range(0, self.n - 1, l, r, value, 0)\\n\\n def _query_range(self, start, end, l, r, node):\\n if start > end or start > r or end < l:\\n return -INF\\n\\n if self.lazy[node] != 0:\\n self.tree[node] = self.lazy[node]\\n if start != end:\\n self.lazy[2 * node + 1] = self.lazy[node]\\n self.lazy[2 * node + 2] = self.lazy[node]\\n self.lazy[node] = 0\\n\\n if start >= l and end <= r:\\n return self.tree[node]\\n\\n mid = (start + end) // 2\\n left_query = self._query_range(start, mid, l, r, 2 * node + 1)\\n right_query = self._query_range(mid + 1, end, l, r, 2 * node + 2)\\n return max(left_query, right_query)\\n\\n def query_range(self, l, r):\\n return self._query_range(0, self.n - 1, l, r, 0)\\n\\n# st = SegmentTree(MAX)\\n# st.update_range(prev + 1, x, x - prev)\\n# st.update_range(x + 1, nxt, nxt - x)\\n# st.query_range(0, p)\\n\\n\\nfrom sortedcontainers import SortedList\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n st = SegmentTree(MAX)\\n sl = SortedList()\\n\\n sl.add(0)\\n sl.add(MAX)\\n ans = []\\n \\n for row in queries:\\n if len(row) == 2:\\n _, x = row\\n\\n index = sl.bisect_left(x)\\n nxt = sl[index]\\n prev = sl[index - 1]\\n\\n sl.add(x)\\n\\n st.update_range(prev + 1, x, x - prev)\\n st.update_range(x + 1, nxt, nxt - x)\\n \\n elif len(row) == 3:\\n _, x, sz = row\\n\\n if sz > x:\\n ans.append(False)\\n continue\\n\\n index = sl.bisect_right(x) - 1\\n p = sl[index]\\n mx = 0\\n mx = max(mx, x - p)\\n\\n if p != 0:\\n mx = max(mx, st.query_range(0, p))\\n\\n ans.append(mx >= sz)\\n\\n return ans\",\n \"runtime\": \"8800\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n from sortedcontainers import SortedList\\n\\n def update(tree, i, ql, qr, idx, val):\\n if ql == idx and idx == qr:\\n tree[i] = val\\n return val\\n mid = (ql + qr) // 2\\n if ql <= idx and idx <= mid:\\n tree[i] = max(\\n update(tree, 2 * i, ql, mid, idx, val),\\n tree[2 * i + 1]\\n )\\n else:\\n tree[i] = max(\\n update(tree, 2 * i + 1, mid + 1, qr, idx, val), \\n tree[2 * i]\\n )\\n return tree[i]\\n \\n def query(tree, i, ql, qr, l, r):\\n if r < ql or l > qr:\\n return 0\\n elif l <= ql and qr <= r:\\n return tree[i]\\n else:\\n mid = ql + (qr - ql) // 2\\n return max(\\n query(tree, 2 * i, ql, mid, l, r),\\n query(tree, 2 * i + 1, mid + 1, qr, l, r)\\n )\\n\\n print(f\\\"Operations: {queries}\\\")\\n sl = SortedList([0])\\n n = 1e5\\n tree = [0] * int(4 * n)\\n res = []\\n for op in queries:\\n # Builds an obstacle\\n if op[0] == 1:\\n i = sl.bisect_left(op[1])\\n # Normal case\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, n-1, idx, op[1] - idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, n-1, idx, op[1] - idx)\\n update(tree, 1, 0, n-1, op[1], sl[i] - op[1])\\n sl.add(op[1])\\n # Checks if obstacle can be built\\n else:\\n _, x, size = op\\n i = sl.bisect_left(x)\\n widest = x - sl[i-1]\\n left = 0 if i == 1 else query(tree, 1, 0, n-1, 0, sl[i-1]-1)\\n res.append(max(widest, left) >= size)\\n \\n return res\\n\\n \",\n \"runtime\": \"8886\"\n },\n {\n \"code\": \"from typing import List\\nfrom sortedcontainers import SortedSet\\n\\nclass SegmentTree:\\n def __init__(self, size):\\n self.size = size\\n self.tree = [0] * (2 * size)\\n self.tree[size] = 1000000\\n for i in range(size - 1, 0, -1):\\n self.tree[i] = max(self.tree[i * 2], self.tree[i * 2 + 1])\\n\\n def update(self, idx, val):\\n idx += self.size\\n self.tree[idx] = val\\n while idx > 1:\\n idx //= 2\\n self.tree[idx] = max(self.tree[2 * idx], self.tree[2 * idx + 1])\\n\\n def query(self, left, right):\\n res = 0\\n left += self.size\\n right += self.size\\n while left <= right:\\n if left % 2 == 1:\\n res = max(res, self.tree[left])\\n left += 1\\n if right % 2 == 0:\\n res = max(res, self.tree[right])\\n right -= 1\\n left //= 2\\n right //= 2\\n return res\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n max_size = 50001\\n segment_tree = SegmentTree(max_size)\\n results = []\\n obstacle_set = SortedSet([0, 1000000])\\n \\n for query in queries:\\n if query[0] == 1:\\n x = query[1]\\n idx = obstacle_set.bisect_left(x)\\n prev = obstacle_set[idx - 1]\\n next = obstacle_set[idx] if idx < len(obstacle_set) else 1000000\\n obstacle_set.add(x)\\n segment_tree.update(prev, x - prev)\\n segment_tree.update(x, next - x)\\n elif query[0] == 2:\\n x = query[1]\\n sz = query[2]\\n if sz > x:\\n results.append(False)\\n else:\\n max_free = segment_tree.query(0, x - sz)\\n results.append(max_free >= sz)\\n \\n return results\\n\",\n \"runtime\": \"8973\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":72,"string":"72"},"mm_list":{"kind":"list like","value":[{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","memory":"86200"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","memory":"86400"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val);\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","memory":"86600"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val)\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","memory":"86600"},{"code":"class Solution: \n def getResults(self, queries: List[List[int]]) -> List[bool]:\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\n def bit_range(p, down=True):\n while p >= 0 and p < len(bit):\n yield p\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \n def get_max(p: int) -> int:\n return max(bit[i] for i in bit_range(p))\n def update(p, val):\n for idx in bit_range(p, False):\n bit[idx] = max(bit[idx], val);\n \n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\n for i, b in enumerate(blocks[1:]):\n update(b, b - blocks[i])\n for t, x, *sz in reversed(queries):\n p = bisect_left(blocks, x)\n if t == 1:\n if p + 1 < len(blocks):\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\n del blocks[p] # No difference if using sorted containers.\n else:\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\n return reversed(res)","memory":"86700"},{"code":"class BITree:\n def __init__(self, size):\n self.arr = [0 for _ in range(size+1)]\n \n def update(self, idx, x):\n idx += 1\n while idx < len(self.arr):\n self.arr[idx] = max(x, self.arr[idx])\n idx += idx & (-idx)\n \n def query(self, idx):\n idx += 1\n ans = 0\n while idx > 0:\n ans = max(ans, self.arr[idx])\n idx -= idx & (-idx)\n return ans\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(5 * 10 ** 4, len(queries) * 3)\n blocks = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [n]\n\n bit = BITree(n+1)\n for i in range(1, len(blocks)):\n bit.update(blocks[i], blocks[i] - blocks[i-1])\n\n ans = []\n for query in queries[::-1]:\n if query[0] == 1:\n idx = bisect.bisect_left(blocks, query[1])\n before = blocks[idx-1]\n after = blocks[idx+1]\n bit.update(after, after-before)\n blocks.pop(idx)\n else:\n _, x, size = query\n idx = bisect.bisect(blocks, x)\n before = blocks[idx-1]\n ans.append(bit.query(before) >= size or (x - before) >= size)\n return ans[::-1]\n ","memory":"86800"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n def bsearch(l, v):\n b = -1\n e = len(l)\n while e - b > 1:\n m = (b + e) // 2\n if l[m] >= v:\n e = m\n if l[m] <= v:\n b = m\n return b, e\n l = [0]\n a = []\n for q in queries:\n if q[0] == 1:\n l.append(q[1])\n else:\n a.append(True)\n l = sorted(l)\n p = len(a)\n m = 0\n sw = []\n sv = []\n for i in range(len(l) - 1):\n w = l[i + 1] - l[i]\n if w > m:\n sw.append(w)\n sv.append(l[i])\n m = w\n n = len(queries)\n # print(l, sv, sw)\n for j in range(len(queries)):\n q = queries[n - 1 - j]\n if q[0] == 1:\n v = q[1]\n i, i = bsearch(l, v)\n vb, ve = bsearch(sv, l[i - 1])\n if i < len(l) - 1:\n w = l[i + 1] - l[i - 1]\n wb, we = bsearch(sw, w)\n # if wb == 7 and w == 12:\n # print(v, i, vb, ve, sv)\n # print('---', wb, we, sw)\n del sw[ve: wb + 1]\n del sv[ve: wb + 1]\n if vb < wb or vb == wb and ve <= we:\n sw.insert(ve, w)\n sv.insert(ve, l[i - 1])\n elif vb == ve:\n del sw[ve]\n del sv[ve]\n del l[i]\n else:\n p -= 1\n v = q[1]\n w = q[2]\n ib, ie = bsearch(sw, w)\n # if p == 23272:\n # print('====================', v, w, ib, ie, sv, sw)\n if ie == len(sw):\n a[p] = v - w >= l[-1]\n else:\n a[p] = v - w >= sv[ie]\n return a","memory":"86900"},{"code":"class SegmentTree:\n def __init__(self, begin, end):\n self.begin = begin\n self.end = end\n self.mid = (begin + end) // 2\n self.left: SegmentTree = None\n self.right: SegmentTree = None\n self.left_blocked = False\n self.right_blocked = False\n self.max_left = end - begin # max length contains the left border\n self.max_right = end - begin # max length contains the right border\n self.max_mid = end - begin # max length among all children\n\n def insert(self, index):\n if index == self.begin:\n self.left_blocked = True\n self.max_left = 0\n elif index == self.end:\n self.right_blocked = True\n self.max_right = 0\n elif index >= self.end or index <= self.begin:\n return\n else:\n self.pushDown()\n\n if index <= self.mid:\n self.left.insert(index)\n if index >= self.mid:\n self.right.insert(index)\n\n self.popUp()\n\n def query(self, begin, end):\n if begin <= self.begin and end >= self.end:\n return self.max_left, self.max_mid, self.max_right\n elif self.left is None or self.right is None:\n res = min(end, self.end) - max(self.begin, begin)\n return res, res, res\n else:\n left_left = left_mid = left_right = right_left = right_mid = right_right = 0\n if begin <= self.mid:\n left_left, left_mid, left_right = self.left.query(begin, end)\n if end >= self.mid:\n right_left, right_mid, right_right = self.right.query(begin, end)\n if self.left.right_blocked != self.right.left_blocked:\n raise Exception\n mid_blocked = self.left.right_blocked\n left_max = (\n left_left + right_left) if not mid_blocked and left_right == self.mid - self.begin else left_left\n right_max = (\n right_right + left_right) if not mid_blocked and right_left == self.end - self.mid else right_right\n mid_max = max((left_right + right_left) if not mid_blocked else max(left_right, right_left), left_mid,\n right_mid, left_max, right_max)\n\n return left_max, mid_max, right_max\n\n def popUp(self):\n self.left_blocked = self.left.left_blocked or self.left_blocked\n self.right_blocked = self.right.right_blocked or self.right_blocked\n self.max_left = self.left.max_left + self.right.max_left \\\n if self.left.max_left == self.left.end - self.left.begin and not self.left.right_blocked \\\n else self.left.max_left\n self.max_right = self.right.max_right + self.left.max_right \\\n if self.right.max_right == self.right.end - self.right.begin and not self.right.left_blocked \\\n else self.right.max_right\n self.max_mid = max(\n (self.left.max_right + self.right.max_left) if not self.left.right_blocked else max(self.max_left,\n self.max_right),\n self.left.max_mid, self.right.max_mid)\n\n def pushDown(self):\n if self.left is None:\n self.left = SegmentTree(self.begin, self.mid)\n if self.right is None:\n self.right = SegmentTree(self.mid, self.end)\n\n\nclass Solution:\n def getResults(self, queries):\n root = SegmentTree(0, (int)(5E4 + 1)) # 初始化 root\n res = []\n for query in queries:\n if query[0] == 1: # 第一种操作\n root.insert(query[1]) # 加上 query[1] 这一块\n else: # 第二种操作\n res.append(max(root.query(0, query[1])) >= query[2]) # 查找 [0, query[1]] 的最大线段\n return res","memory":"87000"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # keep track of the obstacles\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\n # say it lies between obstacle[i] and obstacle[i+1]\n\n from bisect import bisect_right, insort\n obstacles = [0]\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\n\n output = []\n for t, *rest in queries:\n #print(f\"{obstacles=} {largest_possible=}\")\n if t == 1:\n # insert into obstacles\n obs_pos = rest[0]\n idx = bisect_right(obstacles, obs_pos)\n if idx == len(obstacles):\n # largest obstacle\n prev_largest = largest_possible[-1]\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\n largest_possible.append(new_largest)\n insort(obstacles, obs_pos)\n else:\n # somewhere in between\n prev_largest = largest_possible[idx - 1]\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\n largest_possible.insert(idx, new_largest)\n insort(obstacles, obs_pos)\n for cur_idx in range(idx + 1, len(obstacles)):\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\n if largest_possible[cur_idx] > new_largest:\n largest_possible[cur_idx] = new_largest\n else:\n break\n #output.append(False)\n else:\n obs_pos = rest[0]\n size = rest[1]\n idx = bisect_right(obstacles, obs_pos)\n #print(f\"{obs_pos=} {size=} {idx=}\")\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\n output.append(possible >= size)\n\n return output \n\n\n\n\n\n\n ","memory":"87200"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # keep track of the obstacles\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\n # say it lies between obstacle[i] and obstacle[i+1]\n\n from bisect import bisect_right, insort\n obstacles = [0]\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\n\n output = []\n for t, *rest in queries:\n #print(f\"{obstacles=} {largest_possible=}\")\n if t == 1:\n # insert into obstacles\n obs_pos = rest[0]\n idx = bisect_right(obstacles, obs_pos)\n if idx == len(obstacles):\n # largest obstacle\n prev_largest = largest_possible[-1]\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\n largest_possible.append(new_largest)\n insort(obstacles, obs_pos)\n else:\n # somewhere in between\n prev_largest = largest_possible[idx - 1]\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\n largest_possible.insert(idx, new_largest)\n insort(obstacles, obs_pos)\n for cur_idx in range(idx + 1, len(obstacles)):\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\n if largest_possible[cur_idx] > new_largest:\n largest_possible[cur_idx] = new_largest\n else:\n break\n #output.append(False)\n else:\n obs_pos = rest[0]\n size = rest[1]\n idx = bisect_right(obstacles, obs_pos)\n #print(f\"{obs_pos=} {size=} {idx=}\")\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\n output.append(possible >= size)\n\n return output \n\n\n\n\n\n\n ","memory":"87300"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # w[i] = [ wall location, largest gap to the left ]\n # Adding the zero wall means we do not have to worry about\n # this edge case.\n w = [[0, 0]]\n r = []\n for q in queries:\n # Binary search\n i = 0\n j = len(w) - 1\n while i < j:\n k = math.ceil((i+j)/2)\n # A block may touch an obstacle, therefore if a wall's\n # location is equal to x then we do not consider\n # it. We also do not need it for insertion as \"there\n # is no obstacle at distance x when the query is\n # asked\".\n if w[k][0] >= q[1]:\n j = k - 1\n else:\n i = k\n match q[0]:\n case 1:\n # Insert new wall\n w.insert(i + 1, [q[1], 0])\n # Update new wall with correct max gap value:\n # max of new gap and left wall max gap.\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\n i += 1\n # Wall to right must be checked\n if i + 1 < len(w):\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\n i += 1\n # Only subsequent walls to right that have larger\n # gaps than the current largest gap and do not use\n # the gap between themselves and previous need to\n # be updated. Once this is no long satisfied, no\n # walls to the right need to be updated.\n while i+1 < len(w) and w[i][1] < w[i+1][1] and w[i+1][0] - w[i][0] < w[i+1][1]:\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\n i += 1\n case 2:\n # Take max of gap between x and left wall and max\n # gap to left stored in w[left wall index].\n d = max(q[1] - w[i][0], w[i][1])\n r.append(d >= q[2])\n return r","memory":"87400"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","memory":"87500"},{"code":"class BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\nfrom sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans","memory":"87600"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # modified binary search to find boundary of value in value list range\n def boundary_search(list_of_values, value):\n start = -1\n end = len(list_of_values)\n while end - start > 1:\n mid = (start + end) // 2\n if list_of_values[mid] >= value:\n end = mid\n if list_of_values[mid] <= value:\n start = mid\n return start, end\n \n # value list starts at 0\n value_list = [0]\n # axis starts empty \n axis = []\n # iterate queries\n # on type 1, place the obstacle in the value list \n # on type 2, append true \n for query in queries:\n if query[0] == 1:\n value_list.append(query[1])\n else:\n axis.append(True)\n # sort the x values in ascending order of query type 1\n value_list = sorted(value_list)\n # determine your axial perimeter originally as the length of axis\n # these are you type 2 that you need to consider, a perimeter of the number of options \n axis_perimeter = len(axis)\n # set max weight to 0\n max_weight = 0\n # set an array of search weights and values\n search_weights = []\n search_values = []\n for i in range(len(value_list) - 1):\n # get your weight current as the value list difference of one ahead and current\n weight = value_list[i + 1] - value_list[i]\n # if the weight is greater than the max_weight, append the weight and the ith value list of position\n # then set max weight to the new weight \n if weight > max_weight:\n search_weights.append(weight)\n search_values.append(value_list[i])\n max_weight = weight\n\n # now get the length of your queries \n query_len = len(queries)\n # then, loop over and process it \n for q_i in range(len(queries)):\n # use the original query size less one, less the ith query position to get the current query\n query = queries[query_len - 1 - q_i]\n # if of type 1\n if query[0] == 1:\n # get the value \n value = query[1]\n # use the boundary search to get the start and end positions\n i, i = boundary_search(value_list, value) # these are equal in this case \n # get the value bounding as needed \n v_s, v_e = boundary_search(search_values, value_list[i - 1])\n # if the index is in range currently \n if i < len(value_list) - 1:\n # get the weight as the difference of boundary positions \n weight = value_list[i + 1] - value_list[i - 1]\n # use this to get the bounds of that weight \n w_s, w_e = boundary_search(search_weights, weight)\n # use this to remove segments from these sections\n # this is an abstraction of a segment tree approach\n del search_weights[v_e : w_s + 1]\n del search_values[v_e : w_s + 1]\n # if a or b and c in python evaluates as \n if v_s < w_s or (v_s == w_s and v_e <= w_e):\n search_weights.insert(v_e, weight)\n search_values.insert(v_e, value_list[i - 1])\n elif v_s == v_e:\n del search_weights[v_e]\n del search_values[v_e]\n del value_list[i]\n else:\n axis_perimeter -= 1 \n value = query[1]\n weight = query[2]\n i_s, i_e = boundary_search(search_weights, weight)\n if i_e == len(search_weights):\n axis[axis_perimeter] = value - weight >= value_list[-1]\n else:\n axis[axis_perimeter] = value - weight >= search_values[i_e]\n return axis\n","memory":"87900"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","memory":"88000"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","memory":"88100"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList([0])\n N = 5*(10**4)\n tree = [0]*(4*N)\n def query(tree,v,tl,tr,l,r):\n if r < tl or tr < l:\n return 0\n elif l<=tl and tr<=r:\n return tree[v]\n else:\n m = (tl+tr)//2\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\n def update(tree,v,tl,tr,idx,val):\n if tl==idx==tr:\n tree[v]=val\n return val\n mid = (tl+tr)//2 \n if tl<=idx<=mid:\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\n else:\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\n return tree[v] \n res = []\n for q in queries:\n if q[0] == 1:\n i = sl.bisect_left(q[1])\n if i == len(sl):\n idx = sl[-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n else:\n idx = sl[i-1]\n update(tree, 1, 0, N-1, idx, q[1]-idx)\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\n sl.add(q[1])\n else:\n _, x, sz = q\n i = sl.bisect_left(x)\n #print(\"sl, i\", sl, i)\n widest = x-sl[i-1]\n if i == 1:\n left = 0\n else:\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\n res.append(max(widest, left)>=sz)\n return res","memory":"88200"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n barriers = SortedList() # Sorted list to maintain barrier positions\n barriers.add(0) # Add initial barrier at position 0\n\n # Process the add-barrier queries to populate the barriers list\n for query in queries:\n if query[0] == 1:\n it = query[1]\n barriers.add(it)\n\n holes = SortedList() # Sorted list to maintain hole sizes\n holes.add(float('inf')) # Initialize with an infinitely large hole\n hole2start = {float('inf'): barriers[-1]}\n\n # Calculate initial hole sizes based on the barriers\n for pos in range(len(barriers) - 1):\n start = barriers[pos]\n end = barriers[pos + 1]\n size = end - start\n if size:\n pos = holes.bisect_left(size)\n hole_size = holes[pos]\n if hole2start[hole_size] > start:\n if hole_size > size:\n holes.add(size)\n hole2start[size] = start\n\n barriers.add(float('inf')) # Add an infinite barrier at the end\n \n result = []\n # Process the queries in reverse order\n for query in reversed(queries):\n if query[0] == 1: # If it's an add-barrier query\n it = query[1]\n pos = barriers.bisect_left(it)\n left = barriers[pos - 1]\n right = barriers[pos + 1]\n size = right - left\n\n hole_pos = holes.bisect_left(size)\n if hole2start[holes[hole_pos]] > left:\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\n del hole2start[holes[hole_pos - 1]]\n del holes[hole_pos - 1]\n hole_pos -= 1\n\n hole2start[size] = left\n if holes[hole_pos] != size:\n holes.add(size)\n\n barriers.remove(it)\n else: # If it's a check-hole query\n _, start, size = query\n hole_pos = holes.bisect_left(size)\n hole = holes[hole_pos]\n result.append(hole2start[hole] <= start - size)\n\n result.reverse() # Reverse the result to match the original query order\n\n return result","memory":"88200"},{"code":"# 3161. Block Placement Queries\n\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\nimport math\nfrom bisect import bisect_left, bisect_right\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\n\nT = TypeVar('T')\n\n\nclass SortedSet(Generic[T]):\n BUCKET_RATIO = 16\n SPLIT_RATIO = 24\n\n def __init__(self, a: Iterable[T] = []) -> None:\n \"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\"\n a = list(a)\n n = len(a)\n if any(a[i] > a[i + 1] for i in range(n - 1)):\n a.sort()\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\n a, b = [], a\n for x in b:\n if not a or a[-1] != x:\n a.append(x)\n n = self.size = len(a)\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\n\n def __iter__(self) -> Iterator[T]:\n for i in self.a:\n for j in i: yield j\n\n def __reversed__(self) -> Iterator[T]:\n for i in reversed(self.a):\n for j in reversed(i): yield j\n\n def __eq__(self, other) -> bool:\n return list(self) == list(other)\n\n def __len__(self) -> int:\n return self.size\n\n def __repr__(self) -> str:\n return \"SortedSet\" + str(self.a)\n\n def __str__(self) -> str:\n s = str(list(self))\n return \"{\" + s[1: len(s) - 1] + \"}\"\n\n def _position(self, x: T) -> Tuple[List[T], int, int]:\n \"return the bucket, index of the bucket and position in which x should be. self must not be empty.\"\n for i, a in enumerate(self.a):\n if x <= a[-1]: break\n return (a, i, bisect_left(a, x))\n\n def __contains__(self, x: T) -> bool:\n if self.size == 0: return False\n a, _, i = self._position(x)\n return i != len(a) and a[i] == x\n\n def add(self, x: T) -> bool:\n \"Add an element and return True if added. / O(√N)\"\n if self.size == 0:\n self.a = [[x]]\n self.size = 1\n return True\n a, b, i = self._position(x)\n if i != len(a) and a[i] == x: return False\n a.insert(i, x)\n self.size += 1\n if len(a) > len(self.a) * self.SPLIT_RATIO:\n mid = len(a) >> 1\n self.a[b:b + 1] = [a[:mid], a[mid:]]\n return True\n\n def _pop(self, a: List[T], b: int, i: int) -> T:\n ans = a.pop(i)\n self.size -= 1\n if not a: del self.a[b]\n return ans\n\n def discard(self, x: T) -> bool:\n \"Remove an element and return True if removed. / O(√N)\"\n if self.size == 0: return False\n a, b, i = self._position(x)\n if i == len(a) or a[i] != x: return False\n self._pop(a, b, i)\n return True\n\n def lt(self, x: T) -> Optional[T]:\n \"Find the largest element < x, or None if it doesn't exist.\"\n # Lower Bound\n for a in reversed(self.a):\n if a[0] < x:\n return a[bisect_left(a, x) - 1]\n\n def le(self, x: T) -> Optional[T]:\n \"Find the largest element <= x, or None if it doesn't exist.\"\n for a in reversed(self.a):\n if a[0] <= x:\n return a[bisect_right(a, x) - 1]\n\n def gt(self, x: T) -> Optional[T]:\n \"Find the smallest element > x, or None if it doesn't exist.\"\n # Upper bound\n for a in self.a:\n if a[-1] > x:\n return a[bisect_right(a, x)]\n\n def ge(self, x: T) -> Optional[T]:\n \"Find the smallest element >= x, or None if it doesn't exist.\"\n for a in self.a:\n if a[-1] >= x:\n return a[bisect_left(a, x)]\n\n def __getitem__(self, i: int) -> T:\n \"Return the i-th element.\"\n if i < 0:\n for a in reversed(self.a):\n i += len(a)\n if i >= 0: return a[i]\n else:\n for a in self.a:\n if i < len(a): return a[i]\n i -= len(a)\n raise IndexError\n\n def pop(self, i: int = -1) -> T:\n \"Pop and return the i-th element.\"\n if i < 0:\n for b, a in enumerate(reversed(self.a)):\n i += len(a)\n if i >= 0: return self._pop(a, ~b, i)\n else:\n for b, a in enumerate(self.a):\n if i < len(a): return self._pop(a, b, i)\n i -= len(a)\n raise IndexError\n\n def index(self, x: T) -> int:\n \"Count the number of elements < x.\"\n ans = 0\n for a in self.a:\n if a[-1] >= x:\n return ans + bisect_left(a, x)\n ans += len(a)\n return ans\n\n def index_right(self, x: T) -> int:\n \"Count the number of elements <= x.\"\n ans = 0\n for a in self.a:\n if a[-1] > x:\n return ans + bisect_right(a, x)\n ans += len(a)\n return ans\n\n\nclass SegmentTree:\n def __init__(self, size: int):\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\n self.size = size\n self.st = [0] * (4 * size)\n self.invalid = -100001\n\n def seg_op(self, left: int, right: int) -> int:\n return max(left, right)\n\n def update(self, place: int, val: int):\n self._update_(0, 0, self.size - 1, place, val)\n\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\n if low == high:\n if remove:\n self.st[index] = 0\n else:\n self.st[index] = val\n return\n mid = (low + high) // 2\n if low <= place <= mid:\n self._update_(2 * index + 1, low, mid, place, val, remove)\n else:\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\n\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\n\n def query(self, l_query: int, r_query: int):\n return self._query_(0, 0, self.size - 1, l_query, r_query)\n\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\n if low >= l_query and high <= r_query:\n return self.st[index]\n if high < l_query or low > r_query:\n return self.invalid\n mid = (low + high) // 2\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\n return self.seg_op(low_val, high_val)\n\n\nclass Solution:\n\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n result = []\n st = SegmentTree(50005)\n slist = SortedSet()\n slist.add(0)\n slist.add(50005)\n st.update(50004, 50005)\n\n for q in queries:\n if q[0] == 1:\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\n st.update(q[1] - 1, q[1] - l_bound)\n st.update(u_bound - 1, u_bound - q[1])\n slist.add(q[1])\n if q[0] == 2:\n if q[2] > q[1]:\n result.append(False)\n continue\n\n [_, pos, size] = q\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\n to_modify = []\n\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\n\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\n\n st.update(q[1] - 1, new_diff1)\n st.update(u_bound - 1, new_diff2)\n\n to_modify.append([q[1] - 1, prev_q1])\n to_modify.append([u_bound - 1, diff])\n\n q_res = st.query(0, q[1])\n result.append(q_res >= size)\n\n # undo\n for [place_, val_] in to_modify:\n st.update(place_, val_)\n\n return result\n\n","memory":"88300"},{"code":"# 3161. Block Placement Queries\n\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\nimport math\nfrom bisect import bisect_left, bisect_right\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\n\nT = TypeVar('T')\n\n\nclass SortedSet(Generic[T]):\n BUCKET_RATIO = 16\n SPLIT_RATIO = 24\n\n def __init__(self, a: Iterable[T] = []) -> None:\n \"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\"\n a = list(a)\n n = len(a)\n if any(a[i] > a[i + 1] for i in range(n - 1)):\n a.sort()\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\n a, b = [], a\n for x in b:\n if not a or a[-1] != x:\n a.append(x)\n n = self.size = len(a)\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\n\n def __iter__(self) -> Iterator[T]:\n for i in self.a:\n for j in i: yield j\n\n def __reversed__(self) -> Iterator[T]:\n for i in reversed(self.a):\n for j in reversed(i): yield j\n\n def __eq__(self, other) -> bool:\n return list(self) == list(other)\n\n def __len__(self) -> int:\n return self.size\n\n def __repr__(self) -> str:\n return \"SortedSet\" + str(self.a)\n\n def __str__(self) -> str:\n s = str(list(self))\n return \"{\" + s[1: len(s) - 1] + \"}\"\n\n def _position(self, x: T) -> Tuple[List[T], int, int]:\n \"return the bucket, index of the bucket and position in which x should be. self must not be empty.\"\n for i, a in enumerate(self.a):\n if x <= a[-1]: break\n return (a, i, bisect_left(a, x))\n\n def __contains__(self, x: T) -> bool:\n if self.size == 0: return False\n a, _, i = self._position(x)\n return i != len(a) and a[i] == x\n\n def add(self, x: T) -> bool:\n \"Add an element and return True if added. / O(√N)\"\n if self.size == 0:\n self.a = [[x]]\n self.size = 1\n return True\n a, b, i = self._position(x)\n if i != len(a) and a[i] == x: return False\n a.insert(i, x)\n self.size += 1\n if len(a) > len(self.a) * self.SPLIT_RATIO:\n mid = len(a) >> 1\n self.a[b:b + 1] = [a[:mid], a[mid:]]\n return True\n\n def _pop(self, a: List[T], b: int, i: int) -> T:\n ans = a.pop(i)\n self.size -= 1\n if not a: del self.a[b]\n return ans\n\n def discard(self, x: T) -> bool:\n \"Remove an element and return True if removed. / O(√N)\"\n if self.size == 0: return False\n a, b, i = self._position(x)\n if i == len(a) or a[i] != x: return False\n self._pop(a, b, i)\n return True\n\n def lt(self, x: T) -> Optional[T]:\n \"Find the largest element < x, or None if it doesn't exist.\"\n # Lower Bound\n for a in reversed(self.a):\n if a[0] < x:\n return a[bisect_left(a, x) - 1]\n\n def le(self, x: T) -> Optional[T]:\n \"Find the largest element <= x, or None if it doesn't exist.\"\n for a in reversed(self.a):\n if a[0] <= x:\n return a[bisect_right(a, x) - 1]\n\n def gt(self, x: T) -> Optional[T]:\n \"Find the smallest element > x, or None if it doesn't exist.\"\n # Upper bound\n for a in self.a:\n if a[-1] > x:\n return a[bisect_right(a, x)]\n\n def ge(self, x: T) -> Optional[T]:\n \"Find the smallest element >= x, or None if it doesn't exist.\"\n for a in self.a:\n if a[-1] >= x:\n return a[bisect_left(a, x)]\n\n def __getitem__(self, i: int) -> T:\n \"Return the i-th element.\"\n if i < 0:\n for a in reversed(self.a):\n i += len(a)\n if i >= 0: return a[i]\n else:\n for a in self.a:\n if i < len(a): return a[i]\n i -= len(a)\n raise IndexError\n\n def pop(self, i: int = -1) -> T:\n \"Pop and return the i-th element.\"\n if i < 0:\n for b, a in enumerate(reversed(self.a)):\n i += len(a)\n if i >= 0: return self._pop(a, ~b, i)\n else:\n for b, a in enumerate(self.a):\n if i < len(a): return self._pop(a, b, i)\n i -= len(a)\n raise IndexError\n\n def index(self, x: T) -> int:\n \"Count the number of elements < x.\"\n ans = 0\n for a in self.a:\n if a[-1] >= x:\n return ans + bisect_left(a, x)\n ans += len(a)\n return ans\n\n def index_right(self, x: T) -> int:\n \"Count the number of elements <= x.\"\n ans = 0\n for a in self.a:\n if a[-1] > x:\n return ans + bisect_right(a, x)\n ans += len(a)\n return ans\n\n\nclass SegmentTree:\n def __init__(self, size: int):\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\n self.size = size\n self.st = [0] * (4 * size)\n self.invalid = -100001\n\n def seg_op(self, left: int, right: int) -> int:\n return max(left, right)\n\n def update(self, place: int, val: int):\n self._update_(0, 0, self.size - 1, place, val)\n\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\n if low == high:\n if remove:\n self.st[index] = 0\n else:\n self.st[index] = val\n return\n mid = (low + high) // 2\n if low <= place <= mid:\n self._update_(2 * index + 1, low, mid, place, val, remove)\n else:\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\n\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\n\n def query(self, l_query: int, r_query: int):\n return self._query_(0, 0, self.size - 1, l_query, r_query)\n\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\n if low >= l_query and high <= r_query:\n return self.st[index]\n if high < l_query or low > r_query:\n return self.invalid\n mid = (low + high) // 2\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\n return self.seg_op(low_val, high_val)\n\n\nclass Solution:\n\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n result = []\n st = SegmentTree(50005)\n slist = SortedSet()\n slist.add(0)\n slist.add(50005)\n st.update(50004, 50005)\n\n for q in queries:\n if q[0] == 1:\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\n st.update(q[1] - 1, q[1] - l_bound)\n st.update(u_bound - 1, u_bound - q[1])\n slist.add(q[1])\n if q[0] == 2:\n if q[2] > q[1]:\n result.append(False)\n continue\n\n [_, pos, size] = q\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\n to_modify = []\n\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\n\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\n\n st.update(q[1] - 1, new_diff1)\n st.update(u_bound - 1, new_diff2)\n\n to_modify.append([q[1] - 1, prev_q1])\n to_modify.append([u_bound - 1, diff])\n\n q_res = st.query(0, q[1] - 1)\n result.append(q_res >= size)\n\n # undo\n for [place_, val_] in to_modify:\n st.update(place_, val_)\n\n return result\n\n","memory":"88300"},{"code":"# 3161. Block Placement Queries\n\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\nimport math\nfrom bisect import bisect_left, bisect_right\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\n\nT = TypeVar('T')\n\n\nclass SortedSet(Generic[T]):\n BUCKET_RATIO = 16\n SPLIT_RATIO = 24\n\n def __init__(self, a: Iterable[T] = []) -> None:\n \"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\"\n a = list(a)\n n = len(a)\n if any(a[i] > a[i + 1] for i in range(n - 1)):\n a.sort()\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\n a, b = [], a\n for x in b:\n if not a or a[-1] != x:\n a.append(x)\n n = self.size = len(a)\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\n\n def __iter__(self) -> Iterator[T]:\n for i in self.a:\n for j in i: yield j\n\n def __reversed__(self) -> Iterator[T]:\n for i in reversed(self.a):\n for j in reversed(i): yield j\n\n def __eq__(self, other) -> bool:\n return list(self) == list(other)\n\n def __len__(self) -> int:\n return self.size\n\n def __repr__(self) -> str:\n return \"SortedSet\" + str(self.a)\n\n def __str__(self) -> str:\n s = str(list(self))\n return \"{\" + s[1: len(s) - 1] + \"}\"\n\n def _position(self, x: T) -> Tuple[List[T], int, int]:\n \"return the bucket, index of the bucket and position in which x should be. self must not be empty.\"\n for i, a in enumerate(self.a):\n if x <= a[-1]: break\n return (a, i, bisect_left(a, x))\n\n def __contains__(self, x: T) -> bool:\n if self.size == 0: return False\n a, _, i = self._position(x)\n return i != len(a) and a[i] == x\n\n def add(self, x: T) -> bool:\n \"Add an element and return True if added. / O(√N)\"\n if self.size == 0:\n self.a = [[x]]\n self.size = 1\n return True\n a, b, i = self._position(x)\n if i != len(a) and a[i] == x: return False\n a.insert(i, x)\n self.size += 1\n if len(a) > len(self.a) * self.SPLIT_RATIO:\n mid = len(a) >> 1\n self.a[b:b + 1] = [a[:mid], a[mid:]]\n return True\n\n def _pop(self, a: List[T], b: int, i: int) -> T:\n ans = a.pop(i)\n self.size -= 1\n if not a: del self.a[b]\n return ans\n\n def discard(self, x: T) -> bool:\n \"Remove an element and return True if removed. / O(√N)\"\n if self.size == 0: return False\n a, b, i = self._position(x)\n if i == len(a) or a[i] != x: return False\n self._pop(a, b, i)\n return True\n\n def lt(self, x: T) -> Optional[T]:\n \"Find the largest element < x, or None if it doesn't exist.\"\n # Lower Bound\n for a in reversed(self.a):\n if a[0] < x:\n return a[bisect_left(a, x) - 1]\n\n def le(self, x: T) -> Optional[T]:\n \"Find the largest element <= x, or None if it doesn't exist.\"\n for a in reversed(self.a):\n if a[0] <= x:\n return a[bisect_right(a, x) - 1]\n\n def gt(self, x: T) -> Optional[T]:\n \"Find the smallest element > x, or None if it doesn't exist.\"\n # Upper bound\n for a in self.a:\n if a[-1] > x:\n return a[bisect_right(a, x)]\n\n def ge(self, x: T) -> Optional[T]:\n \"Find the smallest element >= x, or None if it doesn't exist.\"\n for a in self.a:\n if a[-1] >= x:\n return a[bisect_left(a, x)]\n\n def __getitem__(self, i: int) -> T:\n \"Return the i-th element.\"\n if i < 0:\n for a in reversed(self.a):\n i += len(a)\n if i >= 0: return a[i]\n else:\n for a in self.a:\n if i < len(a): return a[i]\n i -= len(a)\n raise IndexError\n\n def pop(self, i: int = -1) -> T:\n \"Pop and return the i-th element.\"\n if i < 0:\n for b, a in enumerate(reversed(self.a)):\n i += len(a)\n if i >= 0: return self._pop(a, ~b, i)\n else:\n for b, a in enumerate(self.a):\n if i < len(a): return self._pop(a, b, i)\n i -= len(a)\n raise IndexError\n\n def index(self, x: T) -> int:\n \"Count the number of elements < x.\"\n ans = 0\n for a in self.a:\n if a[-1] >= x:\n return ans + bisect_left(a, x)\n ans += len(a)\n return ans\n\n def index_right(self, x: T) -> int:\n \"Count the number of elements <= x.\"\n ans = 0\n for a in self.a:\n if a[-1] > x:\n return ans + bisect_right(a, x)\n ans += len(a)\n return ans\n\n\nclass SegmentTree:\n def __init__(self, size: int):\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\n self.size = size\n self.st = [0] * (4 * size)\n self.invalid = -100001\n\n def seg_op(self, left: int, right: int) -> int:\n return max(left, right)\n\n def update(self, place: int, val: int):\n self._update_(0, 0, self.size - 1, place, val)\n\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\n if low == high:\n if remove:\n self.st[index] = 0\n else:\n self.st[index] = val\n return\n mid = (low + high) // 2\n if low <= place <= mid:\n self._update_(2 * index + 1, low, mid, place, val, remove)\n else:\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\n\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\n\n def query(self, l_query: int, r_query: int):\n return self._query_(0, 0, self.size - 1, l_query, r_query)\n\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\n if low >= l_query and high <= r_query:\n return self.st[index]\n if high < l_query or low > r_query:\n return self.invalid\n mid = (low + high) // 2\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\n return self.seg_op(low_val, high_val)\n\n\nclass Solution:\n\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n result = []\n st = SegmentTree(50005)\n slist = SortedSet()\n slist.add(0)\n slist.add(50005)\n st.update(50004, 50005)\n\n for q in queries:\n if q[0] == 1:\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\n st.update(q[1] - 1, q[1] - l_bound)\n st.update(u_bound - 1, u_bound - q[1])\n slist.add(q[1])\n if q[0] == 2:\n if q[2] > q[1]:\n result.append(False)\n continue\n\n [_, pos, size] = q\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\n to_modify = []\n\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\n\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\n\n st.update(q[1] - 1, new_diff1)\n st.update(u_bound - 1, new_diff2)\n\n to_modify.append([q[1] - 1, prev_q1])\n to_modify.append([u_bound - 1, diff])\n\n q_res = st.query(0, q[1] - 1)\n result.append(q_res >= size)\n\n # undo\n for [place_, val_] in to_modify:\n st.update(place_, val_)\n\n return result\n\n","memory":"88400"},{"code":"\nfrom sortedcontainers import SortedList\nclass BIT:\n def __init__(self, size):\n self.bit = [0] * (size + 1)\n def update(self, pos, value):\n pos += 1\n while pos < len(self.bit):\n self.bit[pos] = max(self.bit[pos], value)\n pos += pos & -pos\n def pre_max(self, pos):\n pos += 1\n res = 0\n while pos > 0:\n res = max(res, self.bit[pos])\n pos -= pos & -pos\n return res\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n mx = max(q[1] for q in queries) + 1\n pos = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [mx] # mx prevent index out of range, there is no type 2 query on its right\n bit = BIT(len(pos))\n for i in range(1, len(pos)):\n i += 1\n bit.bit[i] = max(bit.bit[i], pos[i-1] - pos[i-2])\n p = i + (i & -i)\n if p < len(bit.bit):\n bit.bit[p] = max(bit.bit[p], bit.bit[i])\n\n sl = SortedList(pos)\n ans = []\n for q in reversed(queries):\n x = q[1]\n i = sl.bisect_left(x)\n left = sl[i-1]\n if q[0] == 1:\n sl.discard(x)\n right = sl[i]\n bit.update(bisect_left(pos, right), right - left)\n else:\n mx_gap = max(bit.pre_max(bisect_left(pos, left)), x - left)\n ans.append(mx_gap >= q[2])\n return ans[::-1]","memory":"88600"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n p = [0]+sorted(q[1] for q in queries if q[0]==1)+[50000]\n np = len(p)\n bit = [0]*np\n def pmax(x):\n r = 0\n while x>0:\n r = max(r,bit[x])\n x -= x&(-x)\n return r\n def modi(x,r):\n while x<np:\n bit[x] = max(bit[x],r)\n x += x&(-x)\n #\n def find_prev(i):\n if not alive[prev[i]]:\n prev[i] = find_prev(prev[i])\n return prev[i]\n alive = [True]*np\n prev = list(range(-1,np-1))\n inext = list(range(1,np+1))\n for i in range(1,np):\n modi(i,p[i]-p[i-1])\n ans = []\n for q in queries[::-1]:\n if q[0]==1: # remove obstacle\n x = q[1]\n i = bisect_left(p,x)\n alive[i] = False\n a,b = prev[i],inext[i]\n inext[a] = b; prev[b] = a\n modi(b,p[b]-p[a])\n else: # query\n x,sz = q[1],q[2]\n i = bisect_left(p,x)\n pi = find_prev(i)\n imax = max(pmax(pi), x-p[pi])\n ans.append(imax>=sz)\n #\n #\n return ans[::-1]","memory":"88700"},{"code":"from sortedcontainers import SortedList\nfrom itertools import pairwise\nimport math\nfrom typing import List\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n # Initialize a sorted list to keep track of the Wi-Fi hotspot positions\n hotspot_positions = SortedList()\n # Define the maximum range of the park\n park_length = min(5 * 10 ** 4, len(queries) * 3)\n hotspot_positions.add(0) # Add the start of the park (origin)\n hotspot_positions.add(park_length) # Add the end of the park\n\n results = []\n # Initialize a sorted list to track gaps between the Wi-Fi hotspots\n gaps = SortedList()\n gaps.add((0, 0)) # Initialize with a dummy gap\n largest_gap = 0\n\n # Process all type 1 queries (placing Wi-Fi hotspots)\n for query in queries:\n if query[0] == 1: # If it's a type 1 query, place the Wi-Fi hotspot\n hotspot_position = query[1]\n hotspot_positions.add(hotspot_position)\n \n # Calculate gaps between consecutive Wi-Fi hotspots\n for start, end in pairwise(hotspot_positions):\n current_gap = end - start # Calculate the gap between two hotspots\n if current_gap > largest_gap: # Only add gaps larger than the current largest gap\n gaps.add((end, current_gap))\n largest_gap = current_gap\n\n # Process the queries in reverse order to handle obstacle removals efficiently\n for query in reversed(queries):\n if query[0] == 1: # For type 1 query (remove a Wi-Fi hotspot)\n hotspot_position = query[1]\n index = hotspot_positions.index(hotspot_position)\n next_hotspot = hotspot_positions[index + 1] # The next hotspot on the right\n prev_hotspot = hotspot_positions[index - 1] # The previous hotspot on the left\n hotspot_positions.remove(hotspot_position) # Remove the current hotspot\n new_gap = next_hotspot - prev_hotspot # Calculate the new gap after removal\n index = gaps.bisect_left((hotspot_position, 0)) # Find the gap position\n \n # Remove smaller gaps and add the new larger gap\n while index < len(gaps) and gaps[index][1] <= new_gap:\n gaps.pop(index)\n if gaps[index - 1][1] < new_gap:\n gaps.add((next_hotspot, new_gap))\n else: # For type 2 query, check if a block of size `sz` can fit between [0, x]\n _, max_position, block_size = query\n index = hotspot_positions.bisect_right(max_position) # Find the next hotspot to the right\n prev_hotspot = hotspot_positions[index - 1] # Get the previous hotspot\n gap_index = gaps.bisect_right((prev_hotspot, math.inf)) - 1\n # Check if the block can fit based on available gap sizes\n results.append((max_position - prev_hotspot) >= block_size or gaps[gap_index][1] >= block_size)\n\n results.reverse() # Reverse the results to maintain the original query order\n return results\n","memory":"88800"},{"code":"from sortedcontainers import SortedList\n\n\nclass FenwickTree:\n def __init__(self, n: int):\n self.vals = [0] * (n + 1)\n\n def update(self, i: int, val: int) -> None:\n while i < len(self.vals):\n self.vals[i] = max(self.vals[i], val)\n i += FenwickTree.lowtree(i)\n\n def get(self, i: int) -> int:\n res = 0\n while i > 0:\n res = max(res, self.vals[i])\n i -= FenwickTree.lowtree(i)\n return res\n\n @staticmethod\n def lowtree(i: int) -> int:\n return i & -i\n\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n n = min(50000, len(queries) * 3)\n ans = []\n tree = FenwickTree(n + 1)\n obstacles = SortedList([0, n]) # sentinel values\n\n for query in queries:\n type = query[0]\n if type == 1:\n x = query[1]\n obstacles.add(x)\n\n for x1, x2 in itertools.pairwise(obstacles):\n tree.update(x2, x2 - x1)\n\n for query in reversed(queries):\n type = query[0]\n x = query[1]\n if type == 1:\n i = obstacles.index(x)\n next = obstacles[i + 1]\n prev = obstacles[i - 1]\n obstacles.remove(x)\n tree.update(next, next - prev)\n else:\n sz = query[2]\n i = obstacles.bisect_right(x)\n prev = obstacles[i - 1]\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\n\n return ans[::-1]","memory":"89000"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n\n # Blocks along the axis\n axis = SortedList()\n\n # Range Max of intervals from 0 to each block\n itvl = SegTree(max(q[1] for q in queries))\n\n res = []\n axis.add(0)\n itvl.update(0,0)\n\n for q in queries:\n if q[0] == 1:\n ind = axis.bisect(q[1])\n if ind < len(axis):\n # Update the interval of the next block\n nxt = axis[ind]\n itvl.update(nxt, nxt-q[1])\n # Set the interval of the current block\n itvl.update(q[1], q[1] - axis[ind-1])\n # Add the current block on axis\n axis.add(q[1])\n else:\n # Find the previous block\n prv = axis[axis.bisect(q[1])-1]\n # Range query the max interval before prv\n mx = max(q[1]-prv, itvl.query(prv))\n\n res.append(q[2] <= mx)\n return res\n\nclass SegTree:\n\n def __init__(self, n: int):\n self.n = 1 << n.bit_length()\n self.tree = [0] * (self.n*2)\n\n def update(self, ind: int, val: int):\n ind += self.n\n self.tree[ind] = val\n while ind > 1:\n ind //= 2\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\n \n def query(self, ind: int) -> int:\n ind += self.n\n res = self.tree[ind]\n while ind > 1:\n if ind%2 == 1:\n res = max(res, self.tree[ind-1])\n ind //= 2\n return res","memory":"89100"},{"code":"from sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n gap = SortedList()\n gap.add((0, 0))\n curr = 0\n for x, y in pairwise(sl):\n if (g := y - x) > curr:\n gap.add((y, g))\n curr = g\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n g = after - before\n index = gap.bisect_left((x, 0))\n while index < len(gap) and gap[index][1] <= g:\n gap.pop(index)\n if gap[index - 1][1] < g:\n gap.add((after, g))\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n index = gap.bisect_right((before, math.inf)) - 1\n ans.append((x - before) >= sz or gap[index][1] >= sz)\n \n ans.reverse()\n return ans","memory":"89200"},{"code":"from sortedcontainers import SortedList\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n gap = SortedList()\n gap.add((0, 0))\n curr = 0\n for x, y in pairwise(sl):\n if (g := y - x) > curr:\n gap.add((y, g))\n curr = g\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n g = after - before\n index = gap.bisect_left((x, 0))\n while index < len(gap) and gap[index][1] <= g:\n gap.pop(index)\n if gap[index - 1][1] < g:\n gap.add((after, g))\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n index = gap.bisect_right((before, math.inf)) - 1\n ans.append((x - before) >= sz or gap[index][1] >= sz)\n \n ans.reverse()\n return ans","memory":"89300"},{"code":"from sortedcontainers import SortedList\n\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.l = [0] * (n + 1)\n \n def add(self, i, x):\n i += 1\n while i <= self.n:\n self.l[i] = max(x, self.l[i])\n i += i & -i\n \n def query(self, i):\n i += 1\n ans = 0\n while i:\n ans = max(ans, self.l[i])\n i -= i & -i\n return ans\n\ndef pairwise(iterable):\n a, b = iter(iterable), iter(iterable)\n next(b, None)\n return zip(a, b)\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n sl = SortedList()\n n = min(5 * 10 ** 4, len(queries) * 3)\n sl.add(0)\n sl.add(n)\n \n ans = []\n for q in queries:\n if q[0] == 1:\n x = q[1]\n sl.add(x)\n \n bit = BIT(n + 1)\n for x, y in pairwise(sl):\n bit.add(y, y - x)\n \n for q in reversed(queries):\n if q[0] == 1:\n x = q[1]\n index = sl.index(x)\n after = sl[index + 1]\n before = sl[index - 1]\n sl.remove(x)\n bit.add(after, after - before)\n else:\n _, x, sz = q\n index = sl.bisect_right(x)\n before = sl[index - 1]\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\n \n ans.reverse()\n return ans\n","memory":"89400"},{"code":"class Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n obsticals = dict()\n obsticalss = []\n result = []\n for query in queries:\n if query[0] == 1:\n #obsticalss.append(query[1])\n #obsticalss.sort()\n if not len(obsticalss) < 3:\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1])\n obsticalss.insert(index, query[1])\n else:\n obsticalss.append(query[1])\n obsticalss.sort()\n index = obsticalss.index(query[1])\n obsticals[query[1]] = max(query[1] - obsticalss[index-1], obsticals[obsticalss[index-1]]) if index != 0 else query[1]\n for why in range(index+1, len(obsticalss)):\n prev = obsticals[obsticalss[why]]\n obsticals[obsticalss[why]] = max(obsticalss[why] - obsticalss[why-1], obsticals[obsticalss[why-1]])\n if prev == obsticals[obsticalss[why]]:\n break\n else:\n try:\n if obsticals[query[1]] >= query[2]:\n result.append(True)\n else:\n result.append(False)\n except:\n if not len(obsticalss) < 3:\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1]) - 1\n else:\n ok = obsticalss[:]\n ok.append(query[1])\n ok.sort()\n index = ok.index(query[1]) - 1\n\n if index == -1:\n if query[1] >= query[2]:\n result.append(True)\n else:\n result.append(False)\n elif obsticals[obsticalss[index]] >= query[2] or (query[1] - obsticalss[index]) >= query[2]:\n result.append(True)\n else:\n result.append(False)\n return result\n \n def BinarySearchModified(self, arr, low, high, x):\n while high - low > 1:\n mid = low + (high - low)//2\n if arr[mid] > x:\n if arr[low] < x:\n high = mid\n else:\n return low\n else:\n if arr[high] > x:\n low = mid\n else:\n return high+1\n return high\n","memory":"89500"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n axis = SortedList()\n intervals = SegTree(max(query[1] for query in queries))\n result = [] \n axis.add(0)\n intervals.update(0, 0)\n\n for block in queries: \n if block[0] == 1: \n index = axis.bisect(block[1])\n if index < len(axis):\n new_block = axis[index]\n intervals.update(new_block, new_block - block[1])\n intervals.update(block[1], block[1] - axis[index - 1])\n axis.add(block[1])\n else:\n previous_block = axis[axis.bisect(block[1]) - 1]\n query_max = max(block[1] - previous_block, intervals.query(previous_block))\n result.append(block[2] <= query_max)\n return result\n\nclass SegTree:\n def __init__(self, number_of_segments):\n self.number_of_segments = 1 << number_of_segments.bit_length()\n self.tree = [0] * (self.number_of_segments * 2)\n \n def update(self, index, value):\n index += self.number_of_segments\n self.tree[index] = value\n while index > 1 :\n index //= 2\n self.tree[index] = max(self.tree[index * 2], self.tree[index * 2 + 1])\n \n def query(self, index):\n index += self.number_of_segments\n result = self.tree[index]\n while index > 1 : \n if index % 2 == 1 :\n result = max(result, self.tree[index - 1])\n index //= 2 \n return result ","memory":"89600"},{"code":"class Ftree:\n def __init__(self, n):\n self.n = n\n self.t = [0 for _ in range(n)]\n\n def max(self, i):\n res = 0\n while i >= 0:\n res = max(res, self.t[i])\n i = (i & (i + 1)) - 1\n return res\n\n def update(self, i, v):\n while i < self.n:\n self.t[i] = max(self.t[i], v)\n i = (i | (i + 1))\n \nclass Solution:\n def getResults(self, queries: List[List[int]]) -> List[bool]:\n from sortedcontainers import SortedList\n m = min(5 * 10**4, 3 * len(queries))\n sl = SortedList([0, m])\n for query in queries:\n if query[0] == 1:\n sl.add(query[1])\n bit = Ftree(m + 1)\n last = 0\n for l, r in pairwise(sl):\n bit.update(r, r - l)\n ans = []\n for query in reversed(queries):\n if query[0] == 1:\n v = sl.index(query[1])\n r = sl[v+1]\n l = sl[v-1]\n bit.update(r, r - l)\n sl.discard(sl[v])\n else:\n index = sl.bisect_right(query[1])\n before = sl[index - 1]\n val = bit.max(query[1])\n ans.append((val >= query[2]) or (query[1] - before >= query[2]) )\n # print(sl, bit.t, ans)\n return ans[::-1]","memory":"89700"}],"string":"[\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"86200\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"86400\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val);\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"memory\": \"86600\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val)\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"memory\": \"86600\"\n },\n {\n \"code\": \"class Solution: \\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n bit, res = [0] * (min(50000, 3 * len(queries)) + 1), []\\n def bit_range(p, down=True):\\n while p >= 0 and p < len(bit):\\n yield p\\n p = (p & (p + 1)) - 1 if down else p | (p + 1) \\n def get_max(p: int) -> int:\\n return max(bit[i] for i in bit_range(p))\\n def update(p, val):\\n for idx in bit_range(p, False):\\n bit[idx] = max(bit[idx], val);\\n \\n blocks = [0] + sorted([x for t, x, *sz in queries if t == 1])\\n for i, b in enumerate(blocks[1:]):\\n update(b, b - blocks[i])\\n for t, x, *sz in reversed(queries):\\n p = bisect_left(blocks, x)\\n if t == 1:\\n if p + 1 < len(blocks):\\n update(blocks[p + 1], blocks[p + 1] - blocks[p - 1])\\n del blocks[p] # No difference if using sorted containers.\\n else:\\n res.append(x - blocks[p - 1] >= sz[0] or get_max(x) >= sz[0])\\n return reversed(res)\",\n \"memory\": \"86700\"\n },\n {\n \"code\": \"class BITree:\\n def __init__(self, size):\\n self.arr = [0 for _ in range(size+1)]\\n \\n def update(self, idx, x):\\n idx += 1\\n while idx < len(self.arr):\\n self.arr[idx] = max(x, self.arr[idx])\\n idx += idx & (-idx)\\n \\n def query(self, idx):\\n idx += 1\\n ans = 0\\n while idx > 0:\\n ans = max(ans, self.arr[idx])\\n idx -= idx & (-idx)\\n return ans\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n blocks = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [n]\\n\\n bit = BITree(n+1)\\n for i in range(1, len(blocks)):\\n bit.update(blocks[i], blocks[i] - blocks[i-1])\\n\\n ans = []\\n for query in queries[::-1]:\\n if query[0] == 1:\\n idx = bisect.bisect_left(blocks, query[1])\\n before = blocks[idx-1]\\n after = blocks[idx+1]\\n bit.update(after, after-before)\\n blocks.pop(idx)\\n else:\\n _, x, size = query\\n idx = bisect.bisect(blocks, x)\\n before = blocks[idx-1]\\n ans.append(bit.query(before) >= size or (x - before) >= size)\\n return ans[::-1]\\n \",\n \"memory\": \"86800\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n def bsearch(l, v):\\n b = -1\\n e = len(l)\\n while e - b > 1:\\n m = (b + e) // 2\\n if l[m] >= v:\\n e = m\\n if l[m] <= v:\\n b = m\\n return b, e\\n l = [0]\\n a = []\\n for q in queries:\\n if q[0] == 1:\\n l.append(q[1])\\n else:\\n a.append(True)\\n l = sorted(l)\\n p = len(a)\\n m = 0\\n sw = []\\n sv = []\\n for i in range(len(l) - 1):\\n w = l[i + 1] - l[i]\\n if w > m:\\n sw.append(w)\\n sv.append(l[i])\\n m = w\\n n = len(queries)\\n # print(l, sv, sw)\\n for j in range(len(queries)):\\n q = queries[n - 1 - j]\\n if q[0] == 1:\\n v = q[1]\\n i, i = bsearch(l, v)\\n vb, ve = bsearch(sv, l[i - 1])\\n if i < len(l) - 1:\\n w = l[i + 1] - l[i - 1]\\n wb, we = bsearch(sw, w)\\n # if wb == 7 and w == 12:\\n # print(v, i, vb, ve, sv)\\n # print('---', wb, we, sw)\\n del sw[ve: wb + 1]\\n del sv[ve: wb + 1]\\n if vb < wb or vb == wb and ve <= we:\\n sw.insert(ve, w)\\n sv.insert(ve, l[i - 1])\\n elif vb == ve:\\n del sw[ve]\\n del sv[ve]\\n del l[i]\\n else:\\n p -= 1\\n v = q[1]\\n w = q[2]\\n ib, ie = bsearch(sw, w)\\n # if p == 23272:\\n # print('====================', v, w, ib, ie, sv, sw)\\n if ie == len(sw):\\n a[p] = v - w >= l[-1]\\n else:\\n a[p] = v - w >= sv[ie]\\n return a\",\n \"memory\": \"86900\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, begin, end):\\n self.begin = begin\\n self.end = end\\n self.mid = (begin + end) // 2\\n self.left: SegmentTree = None\\n self.right: SegmentTree = None\\n self.left_blocked = False\\n self.right_blocked = False\\n self.max_left = end - begin # max length contains the left border\\n self.max_right = end - begin # max length contains the right border\\n self.max_mid = end - begin # max length among all children\\n\\n def insert(self, index):\\n if index == self.begin:\\n self.left_blocked = True\\n self.max_left = 0\\n elif index == self.end:\\n self.right_blocked = True\\n self.max_right = 0\\n elif index >= self.end or index <= self.begin:\\n return\\n else:\\n self.pushDown()\\n\\n if index <= self.mid:\\n self.left.insert(index)\\n if index >= self.mid:\\n self.right.insert(index)\\n\\n self.popUp()\\n\\n def query(self, begin, end):\\n if begin <= self.begin and end >= self.end:\\n return self.max_left, self.max_mid, self.max_right\\n elif self.left is None or self.right is None:\\n res = min(end, self.end) - max(self.begin, begin)\\n return res, res, res\\n else:\\n left_left = left_mid = left_right = right_left = right_mid = right_right = 0\\n if begin <= self.mid:\\n left_left, left_mid, left_right = self.left.query(begin, end)\\n if end >= self.mid:\\n right_left, right_mid, right_right = self.right.query(begin, end)\\n if self.left.right_blocked != self.right.left_blocked:\\n raise Exception\\n mid_blocked = self.left.right_blocked\\n left_max = (\\n left_left + right_left) if not mid_blocked and left_right == self.mid - self.begin else left_left\\n right_max = (\\n right_right + left_right) if not mid_blocked and right_left == self.end - self.mid else right_right\\n mid_max = max((left_right + right_left) if not mid_blocked else max(left_right, right_left), left_mid,\\n right_mid, left_max, right_max)\\n\\n return left_max, mid_max, right_max\\n\\n def popUp(self):\\n self.left_blocked = self.left.left_blocked or self.left_blocked\\n self.right_blocked = self.right.right_blocked or self.right_blocked\\n self.max_left = self.left.max_left + self.right.max_left \\\\\\n if self.left.max_left == self.left.end - self.left.begin and not self.left.right_blocked \\\\\\n else self.left.max_left\\n self.max_right = self.right.max_right + self.left.max_right \\\\\\n if self.right.max_right == self.right.end - self.right.begin and not self.right.left_blocked \\\\\\n else self.right.max_right\\n self.max_mid = max(\\n (self.left.max_right + self.right.max_left) if not self.left.right_blocked else max(self.max_left,\\n self.max_right),\\n self.left.max_mid, self.right.max_mid)\\n\\n def pushDown(self):\\n if self.left is None:\\n self.left = SegmentTree(self.begin, self.mid)\\n if self.right is None:\\n self.right = SegmentTree(self.mid, self.end)\\n\\n\\nclass Solution:\\n def getResults(self, queries):\\n root = SegmentTree(0, (int)(5E4 + 1)) # 初始化 root\\n res = []\\n for query in queries:\\n if query[0] == 1: # 第一种操作\\n root.insert(query[1]) # 加上 query[1] 这一块\\n else: # 第二种操作\\n res.append(max(root.query(0, query[1])) >= query[2]) # 查找 [0, query[1]] 的最大线段\\n return res\",\n \"memory\": \"87000\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # keep track of the obstacles\\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\\n # say it lies between obstacle[i] and obstacle[i+1]\\n\\n from bisect import bisect_right, insort\\n obstacles = [0]\\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\\n\\n output = []\\n for t, *rest in queries:\\n #print(f\\\"{obstacles=} {largest_possible=}\\\")\\n if t == 1:\\n # insert into obstacles\\n obs_pos = rest[0]\\n idx = bisect_right(obstacles, obs_pos)\\n if idx == len(obstacles):\\n # largest obstacle\\n prev_largest = largest_possible[-1]\\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\\n largest_possible.append(new_largest)\\n insort(obstacles, obs_pos)\\n else:\\n # somewhere in between\\n prev_largest = largest_possible[idx - 1]\\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\\n largest_possible.insert(idx, new_largest)\\n insort(obstacles, obs_pos)\\n for cur_idx in range(idx + 1, len(obstacles)):\\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\\n if largest_possible[cur_idx] > new_largest:\\n largest_possible[cur_idx] = new_largest\\n else:\\n break\\n #output.append(False)\\n else:\\n obs_pos = rest[0]\\n size = rest[1]\\n idx = bisect_right(obstacles, obs_pos)\\n #print(f\\\"{obs_pos=} {size=} {idx=}\\\")\\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\\n output.append(possible >= size)\\n\\n return output \\n\\n\\n\\n\\n\\n\\n \",\n \"memory\": \"87200\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # keep track of the obstacles\\n # given a type 2 query, perform binary search to find between which 2 obstacles it lies\\n # say it lies between obstacle[i] and obstacle[i+1]\\n\\n from bisect import bisect_right, insort\\n obstacles = [0]\\n largest_possible = [0] # largest_possible[idx] = size of largest possible hole before obstacle[i]\\n\\n output = []\\n for t, *rest in queries:\\n #print(f\\\"{obstacles=} {largest_possible=}\\\")\\n if t == 1:\\n # insert into obstacles\\n obs_pos = rest[0]\\n idx = bisect_right(obstacles, obs_pos)\\n if idx == len(obstacles):\\n # largest obstacle\\n prev_largest = largest_possible[-1]\\n new_largest = max(prev_largest, obs_pos - obstacles[-1])\\n largest_possible.append(new_largest)\\n insort(obstacles, obs_pos)\\n else:\\n # somewhere in between\\n prev_largest = largest_possible[idx - 1]\\n new_largest = max(prev_largest, obs_pos - obstacles[idx - 1])\\n new_largest_next = max(prev_largest, obstacles[idx] - obs_pos, obs_pos - obstacles[idx - 1])\\n largest_possible.insert(idx, new_largest)\\n insort(obstacles, obs_pos)\\n for cur_idx in range(idx + 1, len(obstacles)):\\n new_largest = max(largest_possible[cur_idx - 1], obstacles[cur_idx] - obstacles[cur_idx - 1])\\n if largest_possible[cur_idx] > new_largest:\\n largest_possible[cur_idx] = new_largest\\n else:\\n break\\n #output.append(False)\\n else:\\n obs_pos = rest[0]\\n size = rest[1]\\n idx = bisect_right(obstacles, obs_pos)\\n #print(f\\\"{obs_pos=} {size=} {idx=}\\\")\\n # obstacles[0: idx] <= obs_pos obstacles[idx:] > obs_pos\\n possible = max(largest_possible[idx - 1], obs_pos - obstacles[idx - 1])\\n output.append(possible >= size)\\n\\n return output \\n\\n\\n\\n\\n\\n\\n \",\n \"memory\": \"87300\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # w[i] = [ wall location, largest gap to the left ]\\n # Adding the zero wall means we do not have to worry about\\n # this edge case.\\n w = [[0, 0]]\\n r = []\\n for q in queries:\\n # Binary search\\n i = 0\\n j = len(w) - 1\\n while i < j:\\n k = math.ceil((i+j)/2)\\n # A block may touch an obstacle, therefore if a wall's\\n # location is equal to x then we do not consider\\n # it. We also do not need it for insertion as \\\"there\\n # is no obstacle at distance x when the query is\\n # asked\\\".\\n if w[k][0] >= q[1]:\\n j = k - 1\\n else:\\n i = k\\n match q[0]:\\n case 1:\\n # Insert new wall\\n w.insert(i + 1, [q[1], 0])\\n # Update new wall with correct max gap value:\\n # max of new gap and left wall max gap.\\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\\n i += 1\\n # Wall to right must be checked\\n if i + 1 < len(w):\\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\\n i += 1\\n # Only subsequent walls to right that have larger\\n # gaps than the current largest gap and do not use\\n # the gap between themselves and previous need to\\n # be updated. Once this is no long satisfied, no\\n # walls to the right need to be updated.\\n while i+1 < len(w) and w[i][1] < w[i+1][1] and w[i+1][0] - w[i][0] < w[i+1][1]:\\n w[i+1][1] = max(w[i][1], w[i+1][0] - w[i][0])\\n i += 1\\n case 2:\\n # Take max of gap between x and left wall and max\\n # gap to left stored in w[left wall index].\\n d = max(q[1] - w[i][0], w[i][1])\\n r.append(d >= q[2])\\n return r\",\n \"memory\": \"87400\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"87500\"\n },\n {\n \"code\": \"class BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\nfrom sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"87600\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # modified binary search to find boundary of value in value list range\\n def boundary_search(list_of_values, value):\\n start = -1\\n end = len(list_of_values)\\n while end - start > 1:\\n mid = (start + end) // 2\\n if list_of_values[mid] >= value:\\n end = mid\\n if list_of_values[mid] <= value:\\n start = mid\\n return start, end\\n \\n # value list starts at 0\\n value_list = [0]\\n # axis starts empty \\n axis = []\\n # iterate queries\\n # on type 1, place the obstacle in the value list \\n # on type 2, append true \\n for query in queries:\\n if query[0] == 1:\\n value_list.append(query[1])\\n else:\\n axis.append(True)\\n # sort the x values in ascending order of query type 1\\n value_list = sorted(value_list)\\n # determine your axial perimeter originally as the length of axis\\n # these are you type 2 that you need to consider, a perimeter of the number of options \\n axis_perimeter = len(axis)\\n # set max weight to 0\\n max_weight = 0\\n # set an array of search weights and values\\n search_weights = []\\n search_values = []\\n for i in range(len(value_list) - 1):\\n # get your weight current as the value list difference of one ahead and current\\n weight = value_list[i + 1] - value_list[i]\\n # if the weight is greater than the max_weight, append the weight and the ith value list of position\\n # then set max weight to the new weight \\n if weight > max_weight:\\n search_weights.append(weight)\\n search_values.append(value_list[i])\\n max_weight = weight\\n\\n # now get the length of your queries \\n query_len = len(queries)\\n # then, loop over and process it \\n for q_i in range(len(queries)):\\n # use the original query size less one, less the ith query position to get the current query\\n query = queries[query_len - 1 - q_i]\\n # if of type 1\\n if query[0] == 1:\\n # get the value \\n value = query[1]\\n # use the boundary search to get the start and end positions\\n i, i = boundary_search(value_list, value) # these are equal in this case \\n # get the value bounding as needed \\n v_s, v_e = boundary_search(search_values, value_list[i - 1])\\n # if the index is in range currently \\n if i < len(value_list) - 1:\\n # get the weight as the difference of boundary positions \\n weight = value_list[i + 1] - value_list[i - 1]\\n # use this to get the bounds of that weight \\n w_s, w_e = boundary_search(search_weights, weight)\\n # use this to remove segments from these sections\\n # this is an abstraction of a segment tree approach\\n del search_weights[v_e : w_s + 1]\\n del search_values[v_e : w_s + 1]\\n # if a or b and c in python evaluates as \\n if v_s < w_s or (v_s == w_s and v_e <= w_e):\\n search_weights.insert(v_e, weight)\\n search_values.insert(v_e, value_list[i - 1])\\n elif v_s == v_e:\\n del search_weights[v_e]\\n del search_values[v_e]\\n del value_list[i]\\n else:\\n axis_perimeter -= 1 \\n value = query[1]\\n weight = query[2]\\n i_s, i_e = boundary_search(search_weights, weight)\\n if i_e == len(search_weights):\\n axis[axis_perimeter] = value - weight >= value_list[-1]\\n else:\\n axis[axis_perimeter] = value - weight >= search_values[i_e]\\n return axis\\n\",\n \"memory\": \"87900\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"memory\": \"88000\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"memory\": \"88100\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList([0])\\n N = 5*(10**4)\\n tree = [0]*(4*N)\\n def query(tree,v,tl,tr,l,r):\\n if r < tl or tr < l:\\n return 0\\n elif l<=tl and tr<=r:\\n return tree[v]\\n else:\\n m = (tl+tr)//2\\n return max(query(tree,2*v,tl,m,l,r), query(tree,2*v+1,m+1,tr,l,r))\\n def update(tree,v,tl,tr,idx,val):\\n if tl==idx==tr:\\n tree[v]=val\\n return val\\n mid = (tl+tr)//2 \\n if tl<=idx<=mid:\\n tree[v]=max(update(tree,2*v,tl,mid,idx,val),tree[2*v+1])\\n else:\\n tree[v]=max(tree[2*v],update(tree,2*v+1,mid+1,tr,idx,val))\\n return tree[v] \\n res = []\\n for q in queries:\\n if q[0] == 1:\\n i = sl.bisect_left(q[1])\\n if i == len(sl):\\n idx = sl[-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n else:\\n idx = sl[i-1]\\n update(tree, 1, 0, N-1, idx, q[1]-idx)\\n update(tree, 1, 0, N-1, q[1], sl[i]-q[1])\\n sl.add(q[1])\\n else:\\n _, x, sz = q\\n i = sl.bisect_left(x)\\n #print(\\\"sl, i\\\", sl, i)\\n widest = x-sl[i-1]\\n if i == 1:\\n left = 0\\n else:\\n left = query(tree, 1, 0, N-1, 0, sl[i-1]-1)\\n res.append(max(widest, left)>=sz)\\n return res\",\n \"memory\": \"88200\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n barriers = SortedList() # Sorted list to maintain barrier positions\\n barriers.add(0) # Add initial barrier at position 0\\n\\n # Process the add-barrier queries to populate the barriers list\\n for query in queries:\\n if query[0] == 1:\\n it = query[1]\\n barriers.add(it)\\n\\n holes = SortedList() # Sorted list to maintain hole sizes\\n holes.add(float('inf')) # Initialize with an infinitely large hole\\n hole2start = {float('inf'): barriers[-1]}\\n\\n # Calculate initial hole sizes based on the barriers\\n for pos in range(len(barriers) - 1):\\n start = barriers[pos]\\n end = barriers[pos + 1]\\n size = end - start\\n if size:\\n pos = holes.bisect_left(size)\\n hole_size = holes[pos]\\n if hole2start[hole_size] > start:\\n if hole_size > size:\\n holes.add(size)\\n hole2start[size] = start\\n\\n barriers.add(float('inf')) # Add an infinite barrier at the end\\n \\n result = []\\n # Process the queries in reverse order\\n for query in reversed(queries):\\n if query[0] == 1: # If it's an add-barrier query\\n it = query[1]\\n pos = barriers.bisect_left(it)\\n left = barriers[pos - 1]\\n right = barriers[pos + 1]\\n size = right - left\\n\\n hole_pos = holes.bisect_left(size)\\n if hole2start[holes[hole_pos]] > left:\\n while hole_pos > 0 and hole2start[holes[hole_pos - 1]] > left:\\n del hole2start[holes[hole_pos - 1]]\\n del holes[hole_pos - 1]\\n hole_pos -= 1\\n\\n hole2start[size] = left\\n if holes[hole_pos] != size:\\n holes.add(size)\\n\\n barriers.remove(it)\\n else: # If it's a check-hole query\\n _, start, size = query\\n hole_pos = holes.bisect_left(size)\\n hole = holes[hole_pos]\\n result.append(hole2start[hole] <= start - size)\\n\\n result.reverse() # Reverse the result to match the original query order\\n\\n return result\",\n \"memory\": \"88200\"\n },\n {\n \"code\": \"# 3161. Block Placement Queries\\n\\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\\nimport math\\nfrom bisect import bisect_left, bisect_right\\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\\n\\nT = TypeVar('T')\\n\\n\\nclass SortedSet(Generic[T]):\\n BUCKET_RATIO = 16\\n SPLIT_RATIO = 24\\n\\n def __init__(self, a: Iterable[T] = []) -> None:\\n \\\"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\\\"\\n a = list(a)\\n n = len(a)\\n if any(a[i] > a[i + 1] for i in range(n - 1)):\\n a.sort()\\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\\n a, b = [], a\\n for x in b:\\n if not a or a[-1] != x:\\n a.append(x)\\n n = self.size = len(a)\\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\\n\\n def __iter__(self) -> Iterator[T]:\\n for i in self.a:\\n for j in i: yield j\\n\\n def __reversed__(self) -> Iterator[T]:\\n for i in reversed(self.a):\\n for j in reversed(i): yield j\\n\\n def __eq__(self, other) -> bool:\\n return list(self) == list(other)\\n\\n def __len__(self) -> int:\\n return self.size\\n\\n def __repr__(self) -> str:\\n return \\\"SortedSet\\\" + str(self.a)\\n\\n def __str__(self) -> str:\\n s = str(list(self))\\n return \\\"{\\\" + s[1: len(s) - 1] + \\\"}\\\"\\n\\n def _position(self, x: T) -> Tuple[List[T], int, int]:\\n \\\"return the bucket, index of the bucket and position in which x should be. self must not be empty.\\\"\\n for i, a in enumerate(self.a):\\n if x <= a[-1]: break\\n return (a, i, bisect_left(a, x))\\n\\n def __contains__(self, x: T) -> bool:\\n if self.size == 0: return False\\n a, _, i = self._position(x)\\n return i != len(a) and a[i] == x\\n\\n def add(self, x: T) -> bool:\\n \\\"Add an element and return True if added. / O(√N)\\\"\\n if self.size == 0:\\n self.a = [[x]]\\n self.size = 1\\n return True\\n a, b, i = self._position(x)\\n if i != len(a) and a[i] == x: return False\\n a.insert(i, x)\\n self.size += 1\\n if len(a) > len(self.a) * self.SPLIT_RATIO:\\n mid = len(a) >> 1\\n self.a[b:b + 1] = [a[:mid], a[mid:]]\\n return True\\n\\n def _pop(self, a: List[T], b: int, i: int) -> T:\\n ans = a.pop(i)\\n self.size -= 1\\n if not a: del self.a[b]\\n return ans\\n\\n def discard(self, x: T) -> bool:\\n \\\"Remove an element and return True if removed. / O(√N)\\\"\\n if self.size == 0: return False\\n a, b, i = self._position(x)\\n if i == len(a) or a[i] != x: return False\\n self._pop(a, b, i)\\n return True\\n\\n def lt(self, x: T) -> Optional[T]:\\n \\\"Find the largest element < x, or None if it doesn't exist.\\\"\\n # Lower Bound\\n for a in reversed(self.a):\\n if a[0] < x:\\n return a[bisect_left(a, x) - 1]\\n\\n def le(self, x: T) -> Optional[T]:\\n \\\"Find the largest element <= x, or None if it doesn't exist.\\\"\\n for a in reversed(self.a):\\n if a[0] <= x:\\n return a[bisect_right(a, x) - 1]\\n\\n def gt(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element > x, or None if it doesn't exist.\\\"\\n # Upper bound\\n for a in self.a:\\n if a[-1] > x:\\n return a[bisect_right(a, x)]\\n\\n def ge(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element >= x, or None if it doesn't exist.\\\"\\n for a in self.a:\\n if a[-1] >= x:\\n return a[bisect_left(a, x)]\\n\\n def __getitem__(self, i: int) -> T:\\n \\\"Return the i-th element.\\\"\\n if i < 0:\\n for a in reversed(self.a):\\n i += len(a)\\n if i >= 0: return a[i]\\n else:\\n for a in self.a:\\n if i < len(a): return a[i]\\n i -= len(a)\\n raise IndexError\\n\\n def pop(self, i: int = -1) -> T:\\n \\\"Pop and return the i-th element.\\\"\\n if i < 0:\\n for b, a in enumerate(reversed(self.a)):\\n i += len(a)\\n if i >= 0: return self._pop(a, ~b, i)\\n else:\\n for b, a in enumerate(self.a):\\n if i < len(a): return self._pop(a, b, i)\\n i -= len(a)\\n raise IndexError\\n\\n def index(self, x: T) -> int:\\n \\\"Count the number of elements < x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] >= x:\\n return ans + bisect_left(a, x)\\n ans += len(a)\\n return ans\\n\\n def index_right(self, x: T) -> int:\\n \\\"Count the number of elements <= x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] > x:\\n return ans + bisect_right(a, x)\\n ans += len(a)\\n return ans\\n\\n\\nclass SegmentTree:\\n def __init__(self, size: int):\\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\\n self.size = size\\n self.st = [0] * (4 * size)\\n self.invalid = -100001\\n\\n def seg_op(self, left: int, right: int) -> int:\\n return max(left, right)\\n\\n def update(self, place: int, val: int):\\n self._update_(0, 0, self.size - 1, place, val)\\n\\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\\n if low == high:\\n if remove:\\n self.st[index] = 0\\n else:\\n self.st[index] = val\\n return\\n mid = (low + high) // 2\\n if low <= place <= mid:\\n self._update_(2 * index + 1, low, mid, place, val, remove)\\n else:\\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\\n\\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\\n\\n def query(self, l_query: int, r_query: int):\\n return self._query_(0, 0, self.size - 1, l_query, r_query)\\n\\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\\n if low >= l_query and high <= r_query:\\n return self.st[index]\\n if high < l_query or low > r_query:\\n return self.invalid\\n mid = (low + high) // 2\\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\\n return self.seg_op(low_val, high_val)\\n\\n\\nclass Solution:\\n\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n result = []\\n st = SegmentTree(50005)\\n slist = SortedSet()\\n slist.add(0)\\n slist.add(50005)\\n st.update(50004, 50005)\\n\\n for q in queries:\\n if q[0] == 1:\\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\\n st.update(q[1] - 1, q[1] - l_bound)\\n st.update(u_bound - 1, u_bound - q[1])\\n slist.add(q[1])\\n if q[0] == 2:\\n if q[2] > q[1]:\\n result.append(False)\\n continue\\n\\n [_, pos, size] = q\\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\\n to_modify = []\\n\\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\\n\\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\\n\\n st.update(q[1] - 1, new_diff1)\\n st.update(u_bound - 1, new_diff2)\\n\\n to_modify.append([q[1] - 1, prev_q1])\\n to_modify.append([u_bound - 1, diff])\\n\\n q_res = st.query(0, q[1])\\n result.append(q_res >= size)\\n\\n # undo\\n for [place_, val_] in to_modify:\\n st.update(place_, val_)\\n\\n return result\\n\\n\",\n \"memory\": \"88300\"\n },\n {\n \"code\": \"# 3161. Block Placement Queries\\n\\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\\nimport math\\nfrom bisect import bisect_left, bisect_right\\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\\n\\nT = TypeVar('T')\\n\\n\\nclass SortedSet(Generic[T]):\\n BUCKET_RATIO = 16\\n SPLIT_RATIO = 24\\n\\n def __init__(self, a: Iterable[T] = []) -> None:\\n \\\"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\\\"\\n a = list(a)\\n n = len(a)\\n if any(a[i] > a[i + 1] for i in range(n - 1)):\\n a.sort()\\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\\n a, b = [], a\\n for x in b:\\n if not a or a[-1] != x:\\n a.append(x)\\n n = self.size = len(a)\\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\\n\\n def __iter__(self) -> Iterator[T]:\\n for i in self.a:\\n for j in i: yield j\\n\\n def __reversed__(self) -> Iterator[T]:\\n for i in reversed(self.a):\\n for j in reversed(i): yield j\\n\\n def __eq__(self, other) -> bool:\\n return list(self) == list(other)\\n\\n def __len__(self) -> int:\\n return self.size\\n\\n def __repr__(self) -> str:\\n return \\\"SortedSet\\\" + str(self.a)\\n\\n def __str__(self) -> str:\\n s = str(list(self))\\n return \\\"{\\\" + s[1: len(s) - 1] + \\\"}\\\"\\n\\n def _position(self, x: T) -> Tuple[List[T], int, int]:\\n \\\"return the bucket, index of the bucket and position in which x should be. self must not be empty.\\\"\\n for i, a in enumerate(self.a):\\n if x <= a[-1]: break\\n return (a, i, bisect_left(a, x))\\n\\n def __contains__(self, x: T) -> bool:\\n if self.size == 0: return False\\n a, _, i = self._position(x)\\n return i != len(a) and a[i] == x\\n\\n def add(self, x: T) -> bool:\\n \\\"Add an element and return True if added. / O(√N)\\\"\\n if self.size == 0:\\n self.a = [[x]]\\n self.size = 1\\n return True\\n a, b, i = self._position(x)\\n if i != len(a) and a[i] == x: return False\\n a.insert(i, x)\\n self.size += 1\\n if len(a) > len(self.a) * self.SPLIT_RATIO:\\n mid = len(a) >> 1\\n self.a[b:b + 1] = [a[:mid], a[mid:]]\\n return True\\n\\n def _pop(self, a: List[T], b: int, i: int) -> T:\\n ans = a.pop(i)\\n self.size -= 1\\n if not a: del self.a[b]\\n return ans\\n\\n def discard(self, x: T) -> bool:\\n \\\"Remove an element and return True if removed. / O(√N)\\\"\\n if self.size == 0: return False\\n a, b, i = self._position(x)\\n if i == len(a) or a[i] != x: return False\\n self._pop(a, b, i)\\n return True\\n\\n def lt(self, x: T) -> Optional[T]:\\n \\\"Find the largest element < x, or None if it doesn't exist.\\\"\\n # Lower Bound\\n for a in reversed(self.a):\\n if a[0] < x:\\n return a[bisect_left(a, x) - 1]\\n\\n def le(self, x: T) -> Optional[T]:\\n \\\"Find the largest element <= x, or None if it doesn't exist.\\\"\\n for a in reversed(self.a):\\n if a[0] <= x:\\n return a[bisect_right(a, x) - 1]\\n\\n def gt(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element > x, or None if it doesn't exist.\\\"\\n # Upper bound\\n for a in self.a:\\n if a[-1] > x:\\n return a[bisect_right(a, x)]\\n\\n def ge(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element >= x, or None if it doesn't exist.\\\"\\n for a in self.a:\\n if a[-1] >= x:\\n return a[bisect_left(a, x)]\\n\\n def __getitem__(self, i: int) -> T:\\n \\\"Return the i-th element.\\\"\\n if i < 0:\\n for a in reversed(self.a):\\n i += len(a)\\n if i >= 0: return a[i]\\n else:\\n for a in self.a:\\n if i < len(a): return a[i]\\n i -= len(a)\\n raise IndexError\\n\\n def pop(self, i: int = -1) -> T:\\n \\\"Pop and return the i-th element.\\\"\\n if i < 0:\\n for b, a in enumerate(reversed(self.a)):\\n i += len(a)\\n if i >= 0: return self._pop(a, ~b, i)\\n else:\\n for b, a in enumerate(self.a):\\n if i < len(a): return self._pop(a, b, i)\\n i -= len(a)\\n raise IndexError\\n\\n def index(self, x: T) -> int:\\n \\\"Count the number of elements < x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] >= x:\\n return ans + bisect_left(a, x)\\n ans += len(a)\\n return ans\\n\\n def index_right(self, x: T) -> int:\\n \\\"Count the number of elements <= x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] > x:\\n return ans + bisect_right(a, x)\\n ans += len(a)\\n return ans\\n\\n\\nclass SegmentTree:\\n def __init__(self, size: int):\\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\\n self.size = size\\n self.st = [0] * (4 * size)\\n self.invalid = -100001\\n\\n def seg_op(self, left: int, right: int) -> int:\\n return max(left, right)\\n\\n def update(self, place: int, val: int):\\n self._update_(0, 0, self.size - 1, place, val)\\n\\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\\n if low == high:\\n if remove:\\n self.st[index] = 0\\n else:\\n self.st[index] = val\\n return\\n mid = (low + high) // 2\\n if low <= place <= mid:\\n self._update_(2 * index + 1, low, mid, place, val, remove)\\n else:\\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\\n\\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\\n\\n def query(self, l_query: int, r_query: int):\\n return self._query_(0, 0, self.size - 1, l_query, r_query)\\n\\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\\n if low >= l_query and high <= r_query:\\n return self.st[index]\\n if high < l_query or low > r_query:\\n return self.invalid\\n mid = (low + high) // 2\\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\\n return self.seg_op(low_val, high_val)\\n\\n\\nclass Solution:\\n\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n result = []\\n st = SegmentTree(50005)\\n slist = SortedSet()\\n slist.add(0)\\n slist.add(50005)\\n st.update(50004, 50005)\\n\\n for q in queries:\\n if q[0] == 1:\\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\\n st.update(q[1] - 1, q[1] - l_bound)\\n st.update(u_bound - 1, u_bound - q[1])\\n slist.add(q[1])\\n if q[0] == 2:\\n if q[2] > q[1]:\\n result.append(False)\\n continue\\n\\n [_, pos, size] = q\\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\\n to_modify = []\\n\\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\\n\\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\\n\\n st.update(q[1] - 1, new_diff1)\\n st.update(u_bound - 1, new_diff2)\\n\\n to_modify.append([q[1] - 1, prev_q1])\\n to_modify.append([u_bound - 1, diff])\\n\\n q_res = st.query(0, q[1] - 1)\\n result.append(q_res >= size)\\n\\n # undo\\n for [place_, val_] in to_modify:\\n st.update(place_, val_)\\n\\n return result\\n\\n\",\n \"memory\": \"88300\"\n },\n {\n \"code\": \"# 3161. Block Placement Queries\\n\\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\\nimport math\\nfrom bisect import bisect_left, bisect_right\\nfrom typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional\\n\\nT = TypeVar('T')\\n\\n\\nclass SortedSet(Generic[T]):\\n BUCKET_RATIO = 16\\n SPLIT_RATIO = 24\\n\\n def __init__(self, a: Iterable[T] = []) -> None:\\n \\\"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\\\"\\n a = list(a)\\n n = len(a)\\n if any(a[i] > a[i + 1] for i in range(n - 1)):\\n a.sort()\\n if any(a[i] >= a[i + 1] for i in range(n - 1)):\\n a, b = [], a\\n for x in b:\\n if not a or a[-1] != x:\\n a.append(x)\\n n = self.size = len(a)\\n num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))\\n self.a = [a[n * i // num_bucket: n * (i + 1) // num_bucket] for i in range(num_bucket)]\\n\\n def __iter__(self) -> Iterator[T]:\\n for i in self.a:\\n for j in i: yield j\\n\\n def __reversed__(self) -> Iterator[T]:\\n for i in reversed(self.a):\\n for j in reversed(i): yield j\\n\\n def __eq__(self, other) -> bool:\\n return list(self) == list(other)\\n\\n def __len__(self) -> int:\\n return self.size\\n\\n def __repr__(self) -> str:\\n return \\\"SortedSet\\\" + str(self.a)\\n\\n def __str__(self) -> str:\\n s = str(list(self))\\n return \\\"{\\\" + s[1: len(s) - 1] + \\\"}\\\"\\n\\n def _position(self, x: T) -> Tuple[List[T], int, int]:\\n \\\"return the bucket, index of the bucket and position in which x should be. self must not be empty.\\\"\\n for i, a in enumerate(self.a):\\n if x <= a[-1]: break\\n return (a, i, bisect_left(a, x))\\n\\n def __contains__(self, x: T) -> bool:\\n if self.size == 0: return False\\n a, _, i = self._position(x)\\n return i != len(a) and a[i] == x\\n\\n def add(self, x: T) -> bool:\\n \\\"Add an element and return True if added. / O(√N)\\\"\\n if self.size == 0:\\n self.a = [[x]]\\n self.size = 1\\n return True\\n a, b, i = self._position(x)\\n if i != len(a) and a[i] == x: return False\\n a.insert(i, x)\\n self.size += 1\\n if len(a) > len(self.a) * self.SPLIT_RATIO:\\n mid = len(a) >> 1\\n self.a[b:b + 1] = [a[:mid], a[mid:]]\\n return True\\n\\n def _pop(self, a: List[T], b: int, i: int) -> T:\\n ans = a.pop(i)\\n self.size -= 1\\n if not a: del self.a[b]\\n return ans\\n\\n def discard(self, x: T) -> bool:\\n \\\"Remove an element and return True if removed. / O(√N)\\\"\\n if self.size == 0: return False\\n a, b, i = self._position(x)\\n if i == len(a) or a[i] != x: return False\\n self._pop(a, b, i)\\n return True\\n\\n def lt(self, x: T) -> Optional[T]:\\n \\\"Find the largest element < x, or None if it doesn't exist.\\\"\\n # Lower Bound\\n for a in reversed(self.a):\\n if a[0] < x:\\n return a[bisect_left(a, x) - 1]\\n\\n def le(self, x: T) -> Optional[T]:\\n \\\"Find the largest element <= x, or None if it doesn't exist.\\\"\\n for a in reversed(self.a):\\n if a[0] <= x:\\n return a[bisect_right(a, x) - 1]\\n\\n def gt(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element > x, or None if it doesn't exist.\\\"\\n # Upper bound\\n for a in self.a:\\n if a[-1] > x:\\n return a[bisect_right(a, x)]\\n\\n def ge(self, x: T) -> Optional[T]:\\n \\\"Find the smallest element >= x, or None if it doesn't exist.\\\"\\n for a in self.a:\\n if a[-1] >= x:\\n return a[bisect_left(a, x)]\\n\\n def __getitem__(self, i: int) -> T:\\n \\\"Return the i-th element.\\\"\\n if i < 0:\\n for a in reversed(self.a):\\n i += len(a)\\n if i >= 0: return a[i]\\n else:\\n for a in self.a:\\n if i < len(a): return a[i]\\n i -= len(a)\\n raise IndexError\\n\\n def pop(self, i: int = -1) -> T:\\n \\\"Pop and return the i-th element.\\\"\\n if i < 0:\\n for b, a in enumerate(reversed(self.a)):\\n i += len(a)\\n if i >= 0: return self._pop(a, ~b, i)\\n else:\\n for b, a in enumerate(self.a):\\n if i < len(a): return self._pop(a, b, i)\\n i -= len(a)\\n raise IndexError\\n\\n def index(self, x: T) -> int:\\n \\\"Count the number of elements < x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] >= x:\\n return ans + bisect_left(a, x)\\n ans += len(a)\\n return ans\\n\\n def index_right(self, x: T) -> int:\\n \\\"Count the number of elements <= x.\\\"\\n ans = 0\\n for a in self.a:\\n if a[-1] > x:\\n return ans + bisect_right(a, x)\\n ans += len(a)\\n return ans\\n\\n\\nclass SegmentTree:\\n def __init__(self, size: int):\\n # size = size of compressed map (= 1 + max_elem_of_compressed_map)\\n self.size = size\\n self.st = [0] * (4 * size)\\n self.invalid = -100001\\n\\n def seg_op(self, left: int, right: int) -> int:\\n return max(left, right)\\n\\n def update(self, place: int, val: int):\\n self._update_(0, 0, self.size - 1, place, val)\\n\\n def _update_(self, index: int, low: int, high: int, place: int, val: int, remove: bool = False):\\n if low == high:\\n if remove:\\n self.st[index] = 0\\n else:\\n self.st[index] = val\\n return\\n mid = (low + high) // 2\\n if low <= place <= mid:\\n self._update_(2 * index + 1, low, mid, place, val, remove)\\n else:\\n self._update_(2 * index + 2, mid + 1, high, place, val, remove)\\n\\n self.st[index] = self.seg_op(self.st[2 * index + 1], self.st[2 * index + 2])\\n\\n def query(self, l_query: int, r_query: int):\\n return self._query_(0, 0, self.size - 1, l_query, r_query)\\n\\n def _query_(self, index: int, low: int, high: int, l_query: int, r_query: int):\\n if low >= l_query and high <= r_query:\\n return self.st[index]\\n if high < l_query or low > r_query:\\n return self.invalid\\n mid = (low + high) // 2\\n low_val = self._query_(2 * index + 1, low, mid, l_query, r_query)\\n high_val = self._query_(2 * index + 2, mid + 1, high, l_query, r_query)\\n return self.seg_op(low_val, high_val)\\n\\n\\nclass Solution:\\n\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n result = []\\n st = SegmentTree(50005)\\n slist = SortedSet()\\n slist.add(0)\\n slist.add(50005)\\n st.update(50004, 50005)\\n\\n for q in queries:\\n if q[0] == 1:\\n l_bound, u_bound = slist.lt(q[1]), slist.gt(q[1])\\n st.update(q[1] - 1, q[1] - l_bound)\\n st.update(u_bound - 1, u_bound - q[1])\\n slist.add(q[1])\\n if q[0] == 2:\\n if q[2] > q[1]:\\n result.append(False)\\n continue\\n\\n [_, pos, size] = q\\n l_bound, u_bound = slist.lt(pos), slist.gt(pos)\\n to_modify = []\\n\\n prev_q1 = 0 if q[1] not in slist else st.query(q[1] - 1, q[1] - 1)\\n\\n diff = u_bound - (l_bound if q[1] not in slist else q[1])\\n new_diff1, new_diff2 = q[1] - l_bound, u_bound - q[1]\\n\\n st.update(q[1] - 1, new_diff1)\\n st.update(u_bound - 1, new_diff2)\\n\\n to_modify.append([q[1] - 1, prev_q1])\\n to_modify.append([u_bound - 1, diff])\\n\\n q_res = st.query(0, q[1] - 1)\\n result.append(q_res >= size)\\n\\n # undo\\n for [place_, val_] in to_modify:\\n st.update(place_, val_)\\n\\n return result\\n\\n\",\n \"memory\": \"88400\"\n },\n {\n \"code\": \"\\nfrom sortedcontainers import SortedList\\nclass BIT:\\n def __init__(self, size):\\n self.bit = [0] * (size + 1)\\n def update(self, pos, value):\\n pos += 1\\n while pos < len(self.bit):\\n self.bit[pos] = max(self.bit[pos], value)\\n pos += pos & -pos\\n def pre_max(self, pos):\\n pos += 1\\n res = 0\\n while pos > 0:\\n res = max(res, self.bit[pos])\\n pos -= pos & -pos\\n return res\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n mx = max(q[1] for q in queries) + 1\\n pos = [0] + sorted([q[1] for q in queries if q[0] == 1]) + [mx] # mx prevent index out of range, there is no type 2 query on its right\\n bit = BIT(len(pos))\\n for i in range(1, len(pos)):\\n i += 1\\n bit.bit[i] = max(bit.bit[i], pos[i-1] - pos[i-2])\\n p = i + (i & -i)\\n if p < len(bit.bit):\\n bit.bit[p] = max(bit.bit[p], bit.bit[i])\\n\\n sl = SortedList(pos)\\n ans = []\\n for q in reversed(queries):\\n x = q[1]\\n i = sl.bisect_left(x)\\n left = sl[i-1]\\n if q[0] == 1:\\n sl.discard(x)\\n right = sl[i]\\n bit.update(bisect_left(pos, right), right - left)\\n else:\\n mx_gap = max(bit.pre_max(bisect_left(pos, left)), x - left)\\n ans.append(mx_gap >= q[2])\\n return ans[::-1]\",\n \"memory\": \"88600\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n p = [0]+sorted(q[1] for q in queries if q[0]==1)+[50000]\\n np = len(p)\\n bit = [0]*np\\n def pmax(x):\\n r = 0\\n while x>0:\\n r = max(r,bit[x])\\n x -= x&(-x)\\n return r\\n def modi(x,r):\\n while x<np:\\n bit[x] = max(bit[x],r)\\n x += x&(-x)\\n #\\n def find_prev(i):\\n if not alive[prev[i]]:\\n prev[i] = find_prev(prev[i])\\n return prev[i]\\n alive = [True]*np\\n prev = list(range(-1,np-1))\\n inext = list(range(1,np+1))\\n for i in range(1,np):\\n modi(i,p[i]-p[i-1])\\n ans = []\\n for q in queries[::-1]:\\n if q[0]==1: # remove obstacle\\n x = q[1]\\n i = bisect_left(p,x)\\n alive[i] = False\\n a,b = prev[i],inext[i]\\n inext[a] = b; prev[b] = a\\n modi(b,p[b]-p[a])\\n else: # query\\n x,sz = q[1],q[2]\\n i = bisect_left(p,x)\\n pi = find_prev(i)\\n imax = max(pmax(pi), x-p[pi])\\n ans.append(imax>=sz)\\n #\\n #\\n return ans[::-1]\",\n \"memory\": \"88700\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nfrom itertools import pairwise\\nimport math\\nfrom typing import List\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n # Initialize a sorted list to keep track of the Wi-Fi hotspot positions\\n hotspot_positions = SortedList()\\n # Define the maximum range of the park\\n park_length = min(5 * 10 ** 4, len(queries) * 3)\\n hotspot_positions.add(0) # Add the start of the park (origin)\\n hotspot_positions.add(park_length) # Add the end of the park\\n\\n results = []\\n # Initialize a sorted list to track gaps between the Wi-Fi hotspots\\n gaps = SortedList()\\n gaps.add((0, 0)) # Initialize with a dummy gap\\n largest_gap = 0\\n\\n # Process all type 1 queries (placing Wi-Fi hotspots)\\n for query in queries:\\n if query[0] == 1: # If it's a type 1 query, place the Wi-Fi hotspot\\n hotspot_position = query[1]\\n hotspot_positions.add(hotspot_position)\\n \\n # Calculate gaps between consecutive Wi-Fi hotspots\\n for start, end in pairwise(hotspot_positions):\\n current_gap = end - start # Calculate the gap between two hotspots\\n if current_gap > largest_gap: # Only add gaps larger than the current largest gap\\n gaps.add((end, current_gap))\\n largest_gap = current_gap\\n\\n # Process the queries in reverse order to handle obstacle removals efficiently\\n for query in reversed(queries):\\n if query[0] == 1: # For type 1 query (remove a Wi-Fi hotspot)\\n hotspot_position = query[1]\\n index = hotspot_positions.index(hotspot_position)\\n next_hotspot = hotspot_positions[index + 1] # The next hotspot on the right\\n prev_hotspot = hotspot_positions[index - 1] # The previous hotspot on the left\\n hotspot_positions.remove(hotspot_position) # Remove the current hotspot\\n new_gap = next_hotspot - prev_hotspot # Calculate the new gap after removal\\n index = gaps.bisect_left((hotspot_position, 0)) # Find the gap position\\n \\n # Remove smaller gaps and add the new larger gap\\n while index < len(gaps) and gaps[index][1] <= new_gap:\\n gaps.pop(index)\\n if gaps[index - 1][1] < new_gap:\\n gaps.add((next_hotspot, new_gap))\\n else: # For type 2 query, check if a block of size `sz` can fit between [0, x]\\n _, max_position, block_size = query\\n index = hotspot_positions.bisect_right(max_position) # Find the next hotspot to the right\\n prev_hotspot = hotspot_positions[index - 1] # Get the previous hotspot\\n gap_index = gaps.bisect_right((prev_hotspot, math.inf)) - 1\\n # Check if the block can fit based on available gap sizes\\n results.append((max_position - prev_hotspot) >= block_size or gaps[gap_index][1] >= block_size)\\n\\n results.reverse() # Reverse the results to maintain the original query order\\n return results\\n\",\n \"memory\": \"88800\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass FenwickTree:\\n def __init__(self, n: int):\\n self.vals = [0] * (n + 1)\\n\\n def update(self, i: int, val: int) -> None:\\n while i < len(self.vals):\\n self.vals[i] = max(self.vals[i], val)\\n i += FenwickTree.lowtree(i)\\n\\n def get(self, i: int) -> int:\\n res = 0\\n while i > 0:\\n res = max(res, self.vals[i])\\n i -= FenwickTree.lowtree(i)\\n return res\\n\\n @staticmethod\\n def lowtree(i: int) -> int:\\n return i & -i\\n\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n n = min(50000, len(queries) * 3)\\n ans = []\\n tree = FenwickTree(n + 1)\\n obstacles = SortedList([0, n]) # sentinel values\\n\\n for query in queries:\\n type = query[0]\\n if type == 1:\\n x = query[1]\\n obstacles.add(x)\\n\\n for x1, x2 in itertools.pairwise(obstacles):\\n tree.update(x2, x2 - x1)\\n\\n for query in reversed(queries):\\n type = query[0]\\n x = query[1]\\n if type == 1:\\n i = obstacles.index(x)\\n next = obstacles[i + 1]\\n prev = obstacles[i - 1]\\n obstacles.remove(x)\\n tree.update(next, next - prev)\\n else:\\n sz = query[2]\\n i = obstacles.bisect_right(x)\\n prev = obstacles[i - 1]\\n ans.append(tree.get(prev) >= sz or x - prev >= sz)\\n\\n return ans[::-1]\",\n \"memory\": \"89000\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n\\n # Blocks along the axis\\n axis = SortedList()\\n\\n # Range Max of intervals from 0 to each block\\n itvl = SegTree(max(q[1] for q in queries))\\n\\n res = []\\n axis.add(0)\\n itvl.update(0,0)\\n\\n for q in queries:\\n if q[0] == 1:\\n ind = axis.bisect(q[1])\\n if ind < len(axis):\\n # Update the interval of the next block\\n nxt = axis[ind]\\n itvl.update(nxt, nxt-q[1])\\n # Set the interval of the current block\\n itvl.update(q[1], q[1] - axis[ind-1])\\n # Add the current block on axis\\n axis.add(q[1])\\n else:\\n # Find the previous block\\n prv = axis[axis.bisect(q[1])-1]\\n # Range query the max interval before prv\\n mx = max(q[1]-prv, itvl.query(prv))\\n\\n res.append(q[2] <= mx)\\n return res\\n\\nclass SegTree:\\n\\n def __init__(self, n: int):\\n self.n = 1 << n.bit_length()\\n self.tree = [0] * (self.n*2)\\n\\n def update(self, ind: int, val: int):\\n ind += self.n\\n self.tree[ind] = val\\n while ind > 1:\\n ind //= 2\\n self.tree[ind] = max(self.tree[ind*2], self.tree[ind*2+1])\\n \\n def query(self, ind: int) -> int:\\n ind += self.n\\n res = self.tree[ind]\\n while ind > 1:\\n if ind%2 == 1:\\n res = max(res, self.tree[ind-1])\\n ind //= 2\\n return res\",\n \"memory\": \"89100\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n gap = SortedList()\\n gap.add((0, 0))\\n curr = 0\\n for x, y in pairwise(sl):\\n if (g := y - x) > curr:\\n gap.add((y, g))\\n curr = g\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n g = after - before\\n index = gap.bisect_left((x, 0))\\n while index < len(gap) and gap[index][1] <= g:\\n gap.pop(index)\\n if gap[index - 1][1] < g:\\n gap.add((after, g))\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n index = gap.bisect_right((before, math.inf)) - 1\\n ans.append((x - before) >= sz or gap[index][1] >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"89200\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n gap = SortedList()\\n gap.add((0, 0))\\n curr = 0\\n for x, y in pairwise(sl):\\n if (g := y - x) > curr:\\n gap.add((y, g))\\n curr = g\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n g = after - before\\n index = gap.bisect_left((x, 0))\\n while index < len(gap) and gap[index][1] <= g:\\n gap.pop(index)\\n if gap[index - 1][1] < g:\\n gap.add((after, g))\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n index = gap.bisect_right((before, math.inf)) - 1\\n ans.append((x - before) >= sz or gap[index][1] >= sz)\\n \\n ans.reverse()\\n return ans\",\n \"memory\": \"89300\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass BIT:\\n def __init__(self, n):\\n self.n = n\\n self.l = [0] * (n + 1)\\n \\n def add(self, i, x):\\n i += 1\\n while i <= self.n:\\n self.l[i] = max(x, self.l[i])\\n i += i & -i\\n \\n def query(self, i):\\n i += 1\\n ans = 0\\n while i:\\n ans = max(ans, self.l[i])\\n i -= i & -i\\n return ans\\n\\ndef pairwise(iterable):\\n a, b = iter(iterable), iter(iterable)\\n next(b, None)\\n return zip(a, b)\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n sl = SortedList()\\n n = min(5 * 10 ** 4, len(queries) * 3)\\n sl.add(0)\\n sl.add(n)\\n \\n ans = []\\n for q in queries:\\n if q[0] == 1:\\n x = q[1]\\n sl.add(x)\\n \\n bit = BIT(n + 1)\\n for x, y in pairwise(sl):\\n bit.add(y, y - x)\\n \\n for q in reversed(queries):\\n if q[0] == 1:\\n x = q[1]\\n index = sl.index(x)\\n after = sl[index + 1]\\n before = sl[index - 1]\\n sl.remove(x)\\n bit.add(after, after - before)\\n else:\\n _, x, sz = q\\n index = sl.bisect_right(x)\\n before = sl[index - 1]\\n ans.append(bit.query(before) >= sz or (x - before) >= sz)\\n \\n ans.reverse()\\n return ans\\n\",\n \"memory\": \"89400\"\n },\n {\n \"code\": \"class Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n obsticals = dict()\\n obsticalss = []\\n result = []\\n for query in queries:\\n if query[0] == 1:\\n #obsticalss.append(query[1])\\n #obsticalss.sort()\\n if not len(obsticalss) < 3:\\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1])\\n obsticalss.insert(index, query[1])\\n else:\\n obsticalss.append(query[1])\\n obsticalss.sort()\\n index = obsticalss.index(query[1])\\n obsticals[query[1]] = max(query[1] - obsticalss[index-1], obsticals[obsticalss[index-1]]) if index != 0 else query[1]\\n for why in range(index+1, len(obsticalss)):\\n prev = obsticals[obsticalss[why]]\\n obsticals[obsticalss[why]] = max(obsticalss[why] - obsticalss[why-1], obsticals[obsticalss[why-1]])\\n if prev == obsticals[obsticalss[why]]:\\n break\\n else:\\n try:\\n if obsticals[query[1]] >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n except:\\n if not len(obsticalss) < 3:\\n index = self.BinarySearchModified(obsticalss, 0, len(obsticalss)-1, query[1]) - 1\\n else:\\n ok = obsticalss[:]\\n ok.append(query[1])\\n ok.sort()\\n index = ok.index(query[1]) - 1\\n\\n if index == -1:\\n if query[1] >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n elif obsticals[obsticalss[index]] >= query[2] or (query[1] - obsticalss[index]) >= query[2]:\\n result.append(True)\\n else:\\n result.append(False)\\n return result\\n \\n def BinarySearchModified(self, arr, low, high, x):\\n while high - low > 1:\\n mid = low + (high - low)//2\\n if arr[mid] > x:\\n if arr[low] < x:\\n high = mid\\n else:\\n return low\\n else:\\n if arr[high] > x:\\n low = mid\\n else:\\n return high+1\\n return high\\n\",\n \"memory\": \"89500\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n axis = SortedList()\\n intervals = SegTree(max(query[1] for query in queries))\\n result = [] \\n axis.add(0)\\n intervals.update(0, 0)\\n\\n for block in queries: \\n if block[0] == 1: \\n index = axis.bisect(block[1])\\n if index < len(axis):\\n new_block = axis[index]\\n intervals.update(new_block, new_block - block[1])\\n intervals.update(block[1], block[1] - axis[index - 1])\\n axis.add(block[1])\\n else:\\n previous_block = axis[axis.bisect(block[1]) - 1]\\n query_max = max(block[1] - previous_block, intervals.query(previous_block))\\n result.append(block[2] <= query_max)\\n return result\\n\\nclass SegTree:\\n def __init__(self, number_of_segments):\\n self.number_of_segments = 1 << number_of_segments.bit_length()\\n self.tree = [0] * (self.number_of_segments * 2)\\n \\n def update(self, index, value):\\n index += self.number_of_segments\\n self.tree[index] = value\\n while index > 1 :\\n index //= 2\\n self.tree[index] = max(self.tree[index * 2], self.tree[index * 2 + 1])\\n \\n def query(self, index):\\n index += self.number_of_segments\\n result = self.tree[index]\\n while index > 1 : \\n if index % 2 == 1 :\\n result = max(result, self.tree[index - 1])\\n index //= 2 \\n return result \",\n \"memory\": \"89600\"\n },\n {\n \"code\": \"class Ftree:\\n def __init__(self, n):\\n self.n = n\\n self.t = [0 for _ in range(n)]\\n\\n def max(self, i):\\n res = 0\\n while i >= 0:\\n res = max(res, self.t[i])\\n i = (i & (i + 1)) - 1\\n return res\\n\\n def update(self, i, v):\\n while i < self.n:\\n self.t[i] = max(self.t[i], v)\\n i = (i | (i + 1))\\n \\nclass Solution:\\n def getResults(self, queries: List[List[int]]) -> List[bool]:\\n from sortedcontainers import SortedList\\n m = min(5 * 10**4, 3 * len(queries))\\n sl = SortedList([0, m])\\n for query in queries:\\n if query[0] == 1:\\n sl.add(query[1])\\n bit = Ftree(m + 1)\\n last = 0\\n for l, r in pairwise(sl):\\n bit.update(r, r - l)\\n ans = []\\n for query in reversed(queries):\\n if query[0] == 1:\\n v = sl.index(query[1])\\n r = sl[v+1]\\n l = sl[v-1]\\n bit.update(r, r - l)\\n sl.discard(sl[v])\\n else:\\n index = sl.bisect_right(query[1])\\n before = sl[index - 1]\\n val = bit.max(query[1])\\n ans.append((val >= query[2]) or (query[1] - before >= query[2]) )\\n # print(sl, bit.t, ans)\\n return ans[::-1]\",\n \"memory\": \"89700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":32,"string":"32"}}},{"rowIdx":2447,"cells":{"question_id":{"kind":"number","value":3444,"string":"3,444"},"name":{"kind":"string","value":"find-the-number-of-good-pairs-ii"},"content":{"kind":"string","value":"<p>You are given 2 integer arrays <code>nums1</code> and <code>nums2</code> of lengths <code>n</code> and <code>m</code> respectively. You are also given a <strong>positive</strong> integer <code>k</code>.</p>\n\n<p>A pair <code>(i, j)</code> is called <strong>good</strong> if <code>nums1[i]</code> is divisible by <code>nums2[j] * k</code> (<code>0 <= i <= n - 1</code>, <code>0 <= j <= m - 1</code>).</p>\n\n<p>Return the total number of <strong>good</strong> pairs.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums1 = [1,3,4], nums2 = [1,3,4], k = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">5</span></p>\n\n<p><strong>Explanation:</strong></p>\nThe 5 good pairs are <code>(0, 0)</code>, <code>(1, 0)</code>, <code>(1, 1)</code>, <code>(2, 0)</code>, and <code>(2, 2)</code>.</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums1 = [1,2,4,12], nums2 = [2,4], k = 3</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The 2 good pairs are <code>(3, 0)</code> and <code>(3, 1)</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n, m <= 10<sup>5</sup></code></li>\n\t<li><code>1 <= nums1[i], nums2[j] <= 10<sup>6</sup></code></li>\n\t<li><code>1 <= k <= 10<sup>3</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":25.722809096667415,"string":"25.722809"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table"],"string":"[\n \"array\",\n \"hash-table\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"954\", 12.631899999999998], [\"1055\", 23.509899999999984], [\"1156\", 3.1581], [\"1257\", 5.263500000000001], [\"1357\", 10.526999999999996], [\"1458\", 2.1054], [\"1559\", 0.3509], [\"1660\", 0.3509], [\"1761\", 0.3509], [\"1862\", 0.3509], [\"1963\", 3.1581], [\"2063\", 0.7018], [\"2164\", 0.3509], [\"2265\", 0.3509], [\"2366\", 0.3509], [\"2467\", 0.3509], [\"2568\", 0.3509], [\"2669\", 0.3509], [\"2769\", 0.3509], [\"2870\", 0.3509], [\"2971\", 0.3509], [\"3072\", 0.3509], [\"3173\", 0.3509], [\"3274\", 0.3509], [\"3375\", 0.3509], [\"3475\", 0.3509], [\"3576\", 0.3509], [\"3677\", 0.3509], [\"3778\", 0.3509], [\"3879\", 0.3509], [\"3980\", 0.3509], [\"4081\", 0.3509], [\"4182\", 0.3509], [\"4282\", 0.7018], [\"4383\", 0.3509], [\"4484\", 0.3509], [\"4585\", 0.3509], [\"4686\", 0.3509], [\"4787\", 0.3509], [\"4888\", 0.3509], [\"4988\", 0.3509], [\"5089\", 0.3509], [\"5190\", 0.3509], [\"5291\", 0.3509], [\"5392\", 0.3509], [\"5493\", 0.3509], [\"5594\", 0.3509], [\"5694\", 0.3509], [\"5795\", 0.3509], [\"5896\", 0.3509], [\"5997\", 0.7018], [\"6098\", 0.7018], [\"6199\", 0.3509], [\"6300\", 0.3509], [\"6401\", 0.3509], [\"6501\", 0.3509], [\"6602\", 0.3509], [\"6703\", 0.3509], [\"6804\", 0.3509], [\"6905\", 0.3509], [\"7006\", 0.3509], [\"7107\", 0.3509], [\"7207\", 0.3509], [\"7308\", 0.3509], [\"7409\", 0.3509], [\"7510\", 0.3509], [\"7611\", 0.3509], [\"7712\", 0.3509], [\"7813\", 0.3509], [\"7913\", 0.3509], [\"8014\", 0.3509], [\"8115\", 0.3509], [\"8216\", 0.3509], [\"8317\", 1.4036], [\"8418\", 2.1054], [\"8519\", 1.7545], [\"8619\", 1.0527], [\"8720\", 2.4562999999999997], [\"8821\", 1.0527]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"38400\", 0.3509], [\"39700\", 0.3509], [\"40700\", 0.3509], [\"40800\", 0.3509], [\"41600\", 0.3509], [\"42300\", 1.0526], [\"42500\", 0.3509], [\"42600\", 1.0526], [\"42700\", 0.7018], [\"42800\", 5.9649], [\"42900\", 10.1754], [\"43000\", 4.2105], [\"43100\", 4.2105], [\"43200\", 9.1228], [\"43300\", 4.2105], [\"43400\", 5.2632], [\"43500\", 5.9649], [\"43600\", 1.7544], [\"43700\", 0.3509], [\"44100\", 0.7018], [\"44300\", 0.3509], [\"44400\", 0.3509], [\"44500\", 0.7018], [\"45600\", 0.7018], [\"48200\", 0.7018], [\"48300\", 0.3509], [\"48400\", 0.3509], [\"48500\", 0.3509], [\"49500\", 0.3509], [\"50700\", 0.3509], [\"51100\", 0.3509], [\"51900\", 0.3509], [\"52300\", 0.3509], [\"52800\", 0.3509], [\"52900\", 0.3509], [\"53800\", 0.3509], [\"54200\", 0.3509], [\"54900\", 0.3509], [\"55000\", 0.3509], [\"55100\", 0.7018], [\"55200\", 1.4035], [\"55300\", 0.3509], [\"55400\", 0.3509], [\"55500\", 0.7018], [\"57400\", 0.3509], [\"57500\", 0.3509], [\"61100\", 0.3509], [\"62500\", 0.3509], [\"62700\", 2.4561], [\"62800\", 5.9649], [\"62900\", 6.6667], [\"63000\", 1.4035], [\"63100\", 0.3509], [\"63800\", 0.7018], [\"63900\", 0.7018], [\"64000\", 0.3509], [\"64800\", 0.3509], [\"65300\", 0.3509], [\"65400\", 0.7018], [\"68100\", 0.3509], [\"71100\", 0.3509], [\"72800\", 0.7018], [\"72900\", 1.4035], [\"73000\", 0.7018], [\"73100\", 1.0526], [\"74100\", 0.3509], [\"78800\", 0.3509]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n n,m = len(nums1),len(nums2)\n imax = max(nums1)//k\n cnt = [0]*(imax+1)\n for i in range(n):\n if nums1[i]%k==0:\n cnt[nums1[i]//k] += 1\n total = 0\n for v,c in Counter(nums2).items():\n total += sum(cnt[v::v])*c\n return total","runtime":"954"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\n count2 = Counter(nums2)\n if len(nums1) == 0:\n return 0\n\n max_n1 = max(nums1)\n multiples_of_n2 = [0] * (max_n1 + 1)\n for n2, count in count2.items():\n # the worst case for this operation is if nums2 is [1, 2, 3, ...]\n # in this case, the following inner loop repeats approx. max_n1 / n2 times\n # summed over all n2, this is O(max_n1), because 1/2 + 1/3 + 1/4 + ... converges to a constant\n for product in range(n2, max_n1 + 1, n2):\n multiples_of_n2[product] += count\n return sum(multiples_of_n2[n1] for n1 in nums1)","runtime":"954"},{"code":"from collections import defaultdict\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n count = 0\n # use two dict to contain all num in num1 and num2\n hashmap1 = defaultdict(int)\n hashmap2 = defaultdict(int)\n\n # add all num in nums1 into hashmap1\n for num in nums1:\n hashmap1[num] += 1\n \n # add all num * k in nums2 into hashmap2\n for num in nums2:\n hashmap2[num * k] += 1\n \n # find the max value in nums1 to find loop bounds\n max_nums1 = max(nums1)\n\n # check for each key in hashmap2 if it can divide numbers in hashmap1\n for key2 in hashmap2:\n # try out every possible multiple of key2 until reach the upper bound\n multiple = key2\n while multiple <= max_nums1:\n if multiple in hashmap1:\n count += hashmap2[key2] * hashmap1[multiple]\n multiple += key2\n return count","runtime":"1055"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freqs = Counter(num*k for num in nums2)\n counts = [0]*(max(nums1)+1)\n\n for num, count in freqs.items():\n for mult in range(num,len(counts),num):\n counts[mult] += count\n return sum(counts[num] for num in nums1)\n","runtime":"1055"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n '''\n 1) Simplify the prob: what if K is 1?\n 2) What if there is no repetition?\n '''\n nums2_sorted = sorted([n*k for n in nums2])\n\n freq_num2 = Counter(nums2_sorted)\n freq_num1 = Counter(nums1)\n max_nums1 = max(nums1) + 1\n\n ans = 0\n for num2 in freq_num2.keys():\n for div in range(num2, max_nums1, num2):\n if div in freq_num1:\n ans += 1 * freq_num2[num2] * freq_num1[div]\n return ans\n ","runtime":"1156"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # pair is good if nums1[i] is divisible by nums2[j]*k\n \n nums2 = [num*k for num in nums2]\n nums1.sort()\n upperBound = max(nums1)\n ans = 0\n nums1_set = set(nums1)\n counter = Counter(nums1)\n \n for num2 in nums2:\n index = bisect.bisect_left(nums1, num2)\n \n if index == len(nums1):\n continue\n \n target = nums1[index]//num2 \n target = num2*target\n \n for x in range(target,upperBound+1,num2):\n if x in nums1_set:\n ans += counter[x]\n \n return ans\n \n \n \n ","runtime":"1156"},{"code":"class Solution:\n def numberOfPairs(self, num1: List[int], num2: List[int], k: int) -> int:\n num2 = [x*k for x in num2]\n c = Counter(num2)\n dct = {}\n maxi = max(num1)\n\n for num in c:\n snum = num\n while snum <= maxi:\n if snum in dct:\n dct[snum] += c[num]\n else:\n dct[snum] = c[num]\n\n snum += num\n\n count = 0\n for n1 in num1:\n if n1 in dct:\n count += dct[n1]\n\n return count\n\n \n\n\n\n ","runtime":"1257"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt1 = Counter(x // k for x in nums1 if x % k == 0)\n if not cnt1:\n return 0\n cnt2 = Counter(nums2)\n ans = 0\n mx = max(cnt1)\n for x, v in cnt2.items():\n s = sum(cnt1[y] for y in range(x, mx + 1, x))\n ans += s * v\n return ans","runtime":"1257"},{"code":"import functools\nclass Solution:\n def numberOfPairs(self, nn1: List[int], nn2: List[int], k: int) -> int:\n max_nums1 = max(nn1)\n cnt1 = collections.Counter(nn1)\n cnt2 = collections.Counter(nn2)\n res = 0\n for n, f in cnt2.items():\n mol = 1\n while mol * k * n <= max_nums1:\n res += cnt1[mol * k * n] * f\n mol += 1\n return res","runtime":"1357"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n count1 = Counter(nums1)\n count2 = Counter(nums2)\n max1 = max(count1.keys())\n res = 0\n for n in count2.keys():\n divisor = n * k\n multiplier = 1\n while divisor * multiplier <= max1:\n res += count2[n] * count1[divisor * multiplier]\n multiplier += 1\n return res","runtime":"1357"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n nums1 = list(map(lambda x: x//k, filter(lambda x: x%k == 0, nums1)))\n mx1 = max(nums1, default = 0) + 1\n\n ctr1 = defaultdict(int)\n ctr2 = Counter(nums2)\n \n for n2 in ctr2:\n for i in range(n2, mx1, n2):\n ctr1[i]+= ctr2[n2]\n\n return sum(map(lambda x: ctr1[x], nums1))","runtime":"1458"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n nums1 = list(map(lambda x: x//k, filter(lambda x: x%k == 0, nums1)))\n mx1 = max(nums1, default = 0) + 1\n\n ctr1 = defaultdict(int)\n ctr2 = Counter(nums2)\n \n for n2 in ctr2:\n for i in range(n2, mx1, n2):\n ctr1[i]+= ctr2[n2]\n\n return sum(map(lambda x: ctr1[x], nums1))","runtime":"1458"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n n, m = len(nums1), len(nums2)\n hash = defaultdict(int)\n\n for i in range(n):\n if(nums1[i] % k != 0):\n continue\n hash[nums1[i]/k] += 1\n \n ans = 0\n max_elem1, max_elem2 = max(nums1), max(nums2)\n dp = [-1] * (max_elem2 + 1)\n for j in range(m):\n if(dp[nums2[j]] == -1):\n dp[nums2[j]] = 0\n k = 1\n while(nums2[j]*k <= max_elem1):\n dp[nums2[j]] += hash[nums2[j] * k]\n k += 1\n \n ans += dp[nums2[j]]\n \n return ans","runtime":"1559"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n n, m = len(nums1), len(nums2)\n hash = defaultdict(int)\n\n for i in range(n):\n if(nums1[i] % k != 0):\n continue\n hash[nums1[i]/k] += 1\n \n ans = 0\n max_elem1, max_elem2 = max(nums1), max(nums2)\n dp = [-1] * (max_elem2 + 1)\n for j in range(m):\n if(dp[nums2[j]] == -1):\n dp[nums2[j]] = 0\n k = 1\n while(nums2[j]*k <= max_elem1):\n dp[nums2[j]] += hash[nums2[j] * k]\n k += 1\n \n ans += dp[nums2[j]]\n \n return ans","runtime":"1660"},{"code":"class Solution:\n def numberOfPairs(self, a: List[int], b: List[int], k: int) -> int:\n a,c,d,m=[*map(lambda x:x//k,filter(lambda x:x%k==0,a))],Counter(b),defaultdict(int),max([0,*a])+1;[setitem(d,i,d[i]+c[j])for j in c for i in range(j,m,j)];return sum(map(lambda x: d[x], a))\n","runtime":"1761"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = Counter([n // k for n in nums1 if n % k == 0])\n\n counts = Counter(nums2)\n\n res = 0\n for num, amt in nums1.items():\n pairs = 0\n for f in range(1, floor(sqrt(num) + 1)):\n if num % f:\n continue\n other = num // f\n pairs += counts[f]\n if other != f:\n pairs += counts[other]\n res += pairs * amt\n \n return res","runtime":"1862"},{"code":"class Trie:\n def __init__(self):\n self.conts = defaultdict(Trie)\n self.count = 0\n \n @cache\n def key_order(self):\n return sorted(self.conts.keys())\n \n def add(self, order):\n cur = self\n for num in order:\n cur.count += 1\n cur = cur.conts[num]\n cur.count += 1\n \n def matches(self, order, i=0):\n if i == len(order):\n return self.count\n \n res = 0\n \n for key in self.key_order():\n if key == order[i]:\n res += self.conts[key].matches(order, i + 1)\n elif key < order[i]:\n res += self.conts[key].matches(order, i)\n else:\n break\n\n return res\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = Counter([n // k for n in nums1 if n % k == 0])\n\n counts = Counter(nums2)\n\n res = 0\n for num, amt in nums1.items():\n pairs = 0\n for f in range(1, floor(sqrt(num) + 1)):\n if num % f:\n continue\n other = num // f\n pairs += counts[f]\n if other != f:\n pairs += counts[other]\n res += pairs * amt\n \n return res","runtime":"1963"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n map1 = defaultdict(int)\n map2 = defaultdict(int)\n\n for x in nums1:\n if x % k == 0:\n f = x // k\n map1[f] += 1\n\n for x in nums2:\n map2[x] += 1\n\n res = 0\n for x, y in map1.items():\n for i in range(1, int(math.sqrt(x)) + 1):\n if x % i == 0:\n cur = x // i\n if i in map2:\n res += map2[i] * y\n if cur != i and cur in map2:\n res += map2[cur] * y\n\n return res\n","runtime":"1963"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n ret = 0\n C1,C2 = collections.Counter(n//k for n in nums1 if n%k==0),collections.Counter(nums2)\n for n in C1:\n sq = int(n**0.5)\n if sq**2 == n:\n ret += C1[n]*C2[sq]\n else:\n sq += 1\n for d in range(1,sq):\n if n%d == 0:\n ret += C1[n]*(C2[d]+C2[n//d])\n return ret","runtime":"2063"},{"code":"class Solution:\n def factors(self, n: int):\n result = set()\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n result.add(i)\n result.add(n // i)\n return sorted(result) \n\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1_dict = {}\n for num in nums1:\n if num % k == 0:\n key = num // k\n nums1_dict[key] = nums1_dict.setdefault(key, 0) + 1\n nums2_dict = {}\n result = 0\n for num in nums2:\n if num in nums2_dict:\n nums2_dict[num] += 1\n else:\n nums2_dict[num] = 1\n for num, count in nums1_dict.items():\n factor = self.factors(num)\n for each in factor:\n if each in nums2_dict:\n result += nums2_dict[each] * count\n return result","runtime":"2063"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n targets = {}\n divisors = {}\n\n for n in nums1:\n if n % k == 0:\n temp = n // k\n if temp not in targets:\n targets[temp] = 0\n targets[temp] += 1\n\n for n in nums2:\n if n not in divisors:\n divisors[n] = 0\n divisors[n] += 1\n\n total = 0\n for t in targets:\n i = 1\n while i * i <= t:\n if t % i == 0:\n comp = t // i\n if i in divisors:\n total += targets[t] * divisors[i]\n if i != comp and comp in divisors:\n total += targets[t] * divisors[comp]\n i += 1\n return total","runtime":"2366"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [nums1[i]//k for i in range(len(nums1)) if nums1[i]%k==0]\n d = Counter(nums2)\n ans = 0\n d1 = Counter(nums1)\n for j in (d1):\n i = 1\n while i*i<=j:\n if j%i==0:\n ans += d[i]*d1[j]\n if j//i != i:\n ans += d[(j//i)]*d1[j]\n i += 1\n return ans","runtime":"2467"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n targets = {}\n divisors = {}\n\n for n in nums1:\n if n % k == 0:\n temp = n // k\n if temp not in targets:\n targets[temp] = 0\n targets[temp] += 1\n\n for n in nums2:\n if n not in divisors:\n divisors[n] = 0\n divisors[n] += 1\n\n total = 0\n for t in targets:\n i = 1\n while i * i <= t:\n if t % i == 0:\n comp = t // i\n if i in divisors:\n total += targets[t] * divisors[i]\n if i != comp and comp in divisors:\n total += targets[t] * divisors[comp]\n i += 1\n return total","runtime":"2568"},{"code":"import collections\nimport heapq\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\n d = collections.defaultdict(int)\n d1 = collections.Counter(nums1)\n d2 = collections.Counter(nums2)\n\n for k, v in d1.items():\n if k % n != 0:\n continue\n bound = int(sqrt(k))\n for i in range(1, bound + 1):\n if i*i == k:\n d[i] += v\n elif k % i == 0:\n d[i] += v\n d[k//i] += v\n \n count = 0\n for k, v in d2.items():\n if k*n in d.keys():\n count += v * d[k*n]\n return count\n\n ","runtime":"2669"},{"code":"import collections\nimport heapq\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\n d = collections.defaultdict(int)\n d1 = collections.Counter(nums1)\n d2 = collections.Counter(nums2)\n\n for k, v in d1.items():\n if k % n != 0:\n continue\n bound = int(sqrt(k))\n for i in range(1, bound + 1):\n if i*i == k:\n d[i] += v\n elif k % i == 0:\n d[i] += v\n d[k//i] += v\n \n count = 0\n for k, v in d2.items():\n if k*n in d.keys():\n count += v * d[k*n]\n return count\n\n ","runtime":"2769"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n def get_primes(max_n: int) -> list[int]:\n \n is_prime = [True if i%2 else False for i in range(max_n) ]\n is_prime[0] = False\n is_prime[1] = False\n is_prime[2] = True\n primes = [2]\n\n for i in range(3, len(is_prime), 2):\n if not is_prime[i]:\n continue\n primes.append(i)\n for x in range(3*i, max_n, 2*i):\n is_prime[x] = False\n return primes\n \n \n PRIMES = get_primes(1050)\n \n def get_all_factors(x: int) -> list[int]:\n if x == 1:\n return [1]\n start_x = x\n prime_facs_lists: list[list[int]] = []\n for prime in PRIMES:\n if x % prime == 0:\n pfacs = [1, prime]\n x = x//prime\n while x % prime == 0:\n x = x//prime\n pfacs.append(pfacs[-1] * prime)\n prime_facs_lists.append(pfacs)\n \n if prime*prime > x:\n break\n if x > 1:\n prime_facs_lists.append([1, x])\n return list(functools.reduce(operator.mul, y, 1) for y in itertools.product(*prime_facs_lists))\n \n \n div_counts = collections.Counter()\n \n for x in nums1:\n if x < k:\n continue\n div, rem = divmod(x, k)\n if rem != 0:\n continue\n\n div_counts.update(get_all_factors(div))\n \n ans = 0\n for y in nums2:\n ans += div_counts[y]\n return ans","runtime":"2870"},{"code":"\nfrom collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # count factors of numbers in nums1\n count = {}\n ans = 0\n nums1 = [x//k for x in nums1 if x%k == 0]\n nums1_map = Counter(nums1)\n nums2_map = Counter(nums2)\n for val, freq in nums1_map.items():\n i = 1\n while i * i <= val:\n if i * i == val:\n if i not in count:\n count[i] = 0\n count[i] += freq\n elif val%i == 0:\n if i not in count:\n count[i] = 0\n if val//i not in count:\n count[val//i] = 0\n count[i] += freq\n count[val//i] += freq\n i += 1\n for val, freq in nums2_map.items():\n \n if val in count:\n ans += count[val] * freq\n return ans","runtime":"2971"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n from collections import defaultdict\n import math\n\n # Step 1: Create a hash map for nums2[j] * k values\n divisor_count = defaultdict(int)\n for num2 in nums2:\n divisor = num2 * k\n divisor_count[divisor] += 1\n\n # Step 2: Count good pairs by checking divisibility\n good_pairs = 0\n\n nums1 = collections.Counter(nums1)\n for num1, val in nums1.items():\n # Find all divisors of num1\n sqrt_num1 = int(math.sqrt(num1))\n for i in range(1, sqrt_num1 + 1):\n if num1 % i == 0:\n # i is a divisor\n if i in divisor_count:\n good_pairs += divisor_count[i]*val\n # num1 // i is also a divisor, unless it's the same as i\n if i != num1 // i and num1 // i in divisor_count:\n good_pairs += divisor_count[num1 // i]*val\n\n return good_pairs\n\n \n \n \n ","runtime":"3072"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums2 = [k*n for n in nums2]\n \n n1c = collections.Counter(nums1)\n n2c = collections.Counter(nums2)\n \n res = 0\n \n for kn1, vn1 in n1c.items():\n ss = int(math.sqrt(kn1))\n \n for i in range(1, ss+1):\n if kn1%i==0:\n if i in n2c:\n res += vn1*n2c[i]\n \n comp = kn1//i\n \n if comp !=i and comp in n2c:\n res += vn1*n2c[comp]\n \n return res\n ","runtime":"3173"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n def find(n):\n factors=set()\n i=1\n while i*i<=n:\n if n%i==0:\n factors.add(i)\n factors.add(n//i)\n i+=1 \n return list(factors)\n f_factors=defaultdict(list)\n d=defaultdict(int)\n for i in range(len(nums1)):\n if nums1[i]%k==0:\n if nums1[i] not in f_factors:\n f_factors[nums1[i]]=find(nums1[i])\n for fac in f_factors[nums1[i]]:\n d[fac]+=1\n ans=0\n for i in nums2:\n ans+=d[i*k]\n return ans \n ","runtime":"3274"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n c1, c2 = collections.defaultdict(int), collections.defaultdict(int)\n for num in nums1:\n c1[num] += 1\n for num in nums2:\n c2[num * k] += 1\n\n res = 0\n\n for num in c1:\n sr = int(math.sqrt(num))\n for n in range(1, sr + 1):\n if num % n:\n continue\n res += c1[num] * c2[n]\n if n != num // n: # sqrt\n res += c1[num] * c2[num // n] \n\n return res\n","runtime":"3375"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = 0\n factors = collections.defaultdict(int)\n nums1ctr = collections.Counter(nums1)\n nums2ctr = collections.Counter(nums2)\n for n,amt in nums1ctr.items():\n if not n%k == 0:\n continue\n i = 1\n while i*i <= n:\n if(i*i == n):\n factors[i] += amt\n elif (n%i == 0):\n factors[i] += amt\n factors[n/i] += amt\n i += 1\n for n,amt in nums2ctr.items():\n cnt += (amt*factors[n*k])\n return cnt","runtime":"3475"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1D = {n:0 for n in nums1}\n for n in nums1:\n nums1D[n] +=1\n def find_factor(i):\n if i == 1: return [1]\n out = [] \n for f in range(1,int(i**0.5)+1): \n if i%f == 0:\n out.append(f)\n if i//f!=f:\n out.append(i//f)\n return out\n nums_factor = {}\n for n in nums1D:\n factors = find_factor(n)\n # print(n,factors)\n for f in factors:\n if f not in nums_factor:\n nums_factor[f] = 0\n nums_factor[f]+=nums1D[n]\n \n nums2D = {n*k:0 for n in nums2}\n for n in nums2:\n nums2D[n*k] +=1\n # print(nums2D,nums_factor)\n out = 0 \n for n in nums2D:\n if n in nums_factor:\n out += nums2D[n]*nums_factor[n]\n return out","runtime":"3576"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n # nums2 * k\n # check each num in nums2, count answer\n # for each num in nums1, we make table[factor] += 1\n \n table = defaultdict(int) #factor: number\n \n counter1 = Counter(nums1)\n \n def factors(num):\n res = []\n for x in range(1, isqrt(num) + 1):\n if num % x == 0:\n res.append(x)\n y = num // x\n if y != x:\n res.append(y)\n return res\n \n for num in counter1:\n for x in factors(num):\n table[x] += counter1[num]\n \n res = 0\n for num in nums2:\n num *= k\n res += table[num]\n \n return res\n \n \n \n ","runtime":"3677"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = Counter(nums2)\n res = 0\n cache = {}\n \n for num in nums1:\n if num%k!=0:\n continue\n if num in cache:\n res+=cache[num]\n continue\n \n cur = 0\n num = num / k\n \n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n cur += cnt[i]\n cur += cnt[num // i] if i!=num//i else 0\n cache[num*k] = cur\n # print(num, cur)\n res+=cur\n return res","runtime":"3778"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [y//k for y in filter(lambda x: x % k == 0, nums1)]\n nums2 = Counter(nums2)\n res = 0\n for num in nums1:\n for i in range(1, int(num**0.5)+1):\n if num % i == 0:\n if i in nums2:\n res += nums2[i]\n if num // i != i and num // i in nums2:\n res += nums2[num // i]\n return res","runtime":"3879"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [y//k for y in filter(lambda x: x % k == 0, nums1)]\n nums2 = Counter(nums2)\n res = 0\n for num in nums1:\n for i in range(1, int(num**0.5)+1):\n if num % i == 0:\n if i in nums2:\n res += nums2[i]\n if num // i != i and num // i in nums2:\n res += nums2[num // i]\n return res","runtime":"3980"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [el//k for el in nums1 if el % k == 0]\n dct = defaultdict(int)\n for el in nums2:\n dct[el]+=1\n res= 0\n def main(x):\n nonlocal res\n for i in range(1, math.floor(math.sqrt(x)) + 1):\n if x % i == 0:\n dv=x//i\n res += dct[i] + dct[dv]\n if i == dv:\n res -= dct[i]\n for x in nums1:\n main(x)\n return res","runtime":"4081"},{"code":"class Trie:\n def __init__(self):\n self.conts = defaultdict(Trie)\n self.count = 0\n \n @cache\n def key_order(self):\n return sorted(self.conts.keys())\n \n def add(self, order):\n cur = self\n for num in order:\n cur.count += 1\n cur = cur.conts[num]\n cur.count += 1\n \n def matches(self, order, i=0):\n if i == len(order):\n return self.count\n \n res = 0\n \n for key in self.key_order():\n if key == order[i]:\n res += self.conts[key].matches(order, i + 1)\n elif key < order[i]:\n res += self.conts[key].matches(order, i)\n else:\n break\n\n return res\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [n // k for n in nums1 if n % k == 0]\n\n counts = Counter(nums2)\n\n res = 0\n for num in nums1:\n for f in range(1, floor(sqrt(num) + 1)):\n if num % f:\n continue\n \n other = num // f\n res += counts[f]\n if other != f:\n res += counts[other]\n \n return res","runtime":"4182"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = defaultdict(int)\n for i in nums1:\n if i % k: continue\n i //= k\n for d in range(1, isqrt(i) + 1):\n if i % d: continue\n cnt[d] += 1\n if d * d < i:\n cnt[i // d] += 1\n res = 0\n for j in nums2:\n res += cnt[j]\n return res","runtime":"4282"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n\n counter = collections.defaultdict(int)\n for num in nums2:\n counter[num] +=1\n \n result = 0\n for num in nums1:\n if(num % k ==0):\n residue_num = num // k\n for factor in range(1, int(pow(residue_num, 0.5)) +1):\n if(residue_num % factor ==0):\n factor1 = factor\n factor2 = residue_num // factor\n result += counter[factor1]\n if(factor2 != factor1):\n result += counter[factor2]\n \n return result\n\n","runtime":"4383"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n # these three functions are from IterTools Recipes:\n # https://docs.python.org/3/library/itertools.html\n\n import contextlib\n\n def iter_index(iterable, value, start=0, stop=None):\n \"Return indices where a value occurs in a sequence or iterable.\"\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\n seq_index = getattr(iterable, 'index', None)\n if seq_index is None:\n iterator = islice(iterable, start, stop)\n for i, element in enumerate(iterator, start):\n if element is value or element == value:\n yield i\n else:\n stop = len(iterable) if stop is None else stop\n i = start\n with contextlib.suppress(ValueError):\n while True:\n yield (i := seq_index(value, i, stop))\n i += 1\n\n def sieve(n):\n \"Primes less than n.\"\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n if n > 2:\n yield 2\n data = bytearray((0, 1)) * (n // 2)\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n yield from iter_index(data, 1, start=3)\n\n def factor_cacheme(n):\n \"Prime factors of n.\"\n # factor(99) → 3 3 11\n # factor(1_000_000_000_000_007) → 47 59 360620266859\n # factor(1_000_000_000_000_403) → 1000000000000403\n for prime in sieve(math.isqrt(n) + 1):\n while not n % prime:\n yield prime\n n //= prime\n if n == 1:\n return\n if n > 1:\n yield n\n\n @cache\n def factor(n):\n return tuple(factor_cacheme(n))\n\n # we borrow some code from #3162:\n\n count1 = Counter(nums1)\n # print(f'{count1=}')\n count2 = Counter(nums2)\n # print(f'{count2=}')\n \n # @cache\n # nope. we need to roll our own cache, excluding \"depth\"\n CFFPP_cache = {}\n def composite_factors_from_prime_power(Prime: int, Power: int, depth=0) -> Set[int]:\n cache_index = (Prime, Power)\n if cache_index in CFFPP_cache:\n return CFFPP_cache[cache_index]\n margin = ' ' * depth\n # print(f'{margin}CFFPP({Prime},{Power})')\n answer = {1}\n if Power == 0:\n # print(f'{margin} {answer=}')\n CFFPP_cache[cache_index] = answer\n return answer\n CFFPP = composite_factors_from_prime_power(Prime, Power - 1, depth+1)\n answer = CFFPP | {\n A * Prime\n for A in CFFPP\n }\n # print(f'{margin} {answer=}')\n CFFPP_cache[cache_index] = answer\n return answer\n\n # @cache\n def composite_factors_from_primes(Primes: List[int], depth=0) -> Set[int]:\n margin = ' ' * depth\n # print(f'{margin}CFFP({Primes})')\n answer = {1}\n if not Primes:\n # print(f'{margin} {answer=}')\n return answer\n \n counts = Counter(Primes)\n # print(f'{margin} {counts=}')\n\n for Prime, Count in counts.items():\n # print(f'{margin} {Prime=} {Count=}')\n prime_powers = composite_factors_from_prime_power(Prime, Count, depth+1)\n # print(f'{margin} {prime_powers=}')\n answer = {\n A * B\n for A in answer\n for B in prime_powers\n }\n # print(f'{margin} {answer=}')\n \n return answer\n\n def factors_of(N: int) -> Set[int]:\n # print(f'factors_of({N})')\n\n F = factor(N)\n # print(f' {F=}')\n CF = composite_factors_from_primes(F)\n\n return CF\n\n hint1_F = Counter()\n for N, count in count2.items():\n hint1_F[N * k] += count\n # print(f'{hint1_F=}')\n hint1_F_set = set(hint1_F.keys())\n # print(f'{len(hint1_F_set)=}')\n\n answer = 0\n for N, count in sorted(count1.items()):\n # print(f'{N=} {count=}')\n factor_set = factors_of(N)\n intersect = factor_set & hint1_F_set\n # if intersect:\n # # print(f'{N=} {count=} F={len(factor_set)} &={len(intersect)}')\n for D in intersect:\n # print(f' {D=} {hint1_F[D]=}')\n answer += count * hint1_F[D]\n\n return answer\n","runtime":"4484"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n targets = {}\n divisors = {}\n\n for n in nums1:\n if n not in targets:\n targets[n] = 0\n targets[n] += 1\n\n for n in nums2:\n temp = n * k\n if temp not in divisors:\n divisors[temp] = 0\n divisors[temp] += 1\n \n total = 0\n for t in targets:\n i = 1\n while i * i <= t:\n if t % i == 0:\n comp = t // i\n if i in divisors:\n total += targets[t] * divisors[i]\n if i != comp and comp in divisors:\n total += targets[t] * divisors[comp]\n i += 1\n return total","runtime":"4585"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\n count2 = Counter(nums2)\n\n count = 0\n for n1 in nums1:\n for n2 in range(1, int(sqrt(n1)) + 1):\n if n1 % n2 == 0:\n count += count2[n2]\n big = n1 // n2\n if big != n2:\n count += count2[big]\n return count","runtime":"4686"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n targets = {}\n divisors = {}\n\n for n in nums1:\n if n not in targets:\n targets[n] = 0\n targets[n] += 1\n\n for n in nums2:\n temp = n * k\n if temp not in divisors:\n divisors[temp] = 0\n divisors[temp] += 1\n\n total = 0\n for t in targets:\n i = 1\n while i * i <= t:\n if t % i == 0:\n comp = t // i\n if i in divisors:\n total += targets[t] * divisors[i]\n if i != comp and comp in divisors:\n total += targets[t] * divisors[comp]\n i += 1\n return total","runtime":"4787"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n factors = defaultdict(int)\n\n for i in range(len(nums2)):\n factors[nums2[i]]+=1\n\n res = 0\n\n for i in range(len(nums1)):\n if nums1[i]%k == 0:\n temp = nums1[i]//k\n for j in range(1, int(math.sqrt(temp))+1):\n if temp%j == 0:\n res+=factors[j]\n if temp//j != j:\n res+=factors[temp//j]\n\n return res\n\n \n \n \n ","runtime":"4888"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n targets = {}\n divisors = {}\n\n for n in nums1:\n if n not in targets:\n targets[n] = 0\n targets[n] += 1\n\n for n in nums2:\n temp = n * k\n if temp not in divisors:\n divisors[temp] = 0\n divisors[temp] += 1\n \n print(divisors)\n total = 0\n for t in targets:\n i = 1\n while i * i <= t:\n if t % i == 0:\n comp = t // i\n if i in divisors:\n total += targets[t] * divisors[i]\n if i != comp and comp in divisors:\n total += targets[t] * divisors[comp]\n i += 1\n return total","runtime":"4988"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [num//k for num in nums1 if num%k == 0]\n d = defaultdict(int)\n #print(nums1)\n for num in nums1:\n iq = isqrt(num)\n for i in range(1, iq+1):\n if num%i == 0:\n d[i] += 1\n d[num//i] += 1\n if iq**2 == num:\n d[iq] -= 1\n\n #print(d)\n \n return sum(d[n] for n in nums2)\n ","runtime":"5089"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n d1 = defaultdict(int)\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n\n for c,f in c1.items():\n bound = int(sqrt(c))\n for i in range(1, bound+1):\n if i*i == c:\n d1[i] += f\n elif c % i == 0:\n d1[i] += f\n d1[c // i] += f\n\n res = 0\n for c,f in c2.items():\n res+= d1[c*k]*f\n return res","runtime":"5190"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\n count2 = Counter(nums2)\n keys2 = sorted(count2.keys())\n #print(count2)\n #print(nums1)\n #print(keys2)\n\n count = 0\n for n1 in nums1:\n for n2 in range(1, int(sqrt(n1)) + 1):\n if n1 % n2 == 0:\n #print(f\"{n1} divisible by {n2}\")\n count += count2[n2]\n big = n1 // n2\n if big != n2:\n count += count2[big]\n return count","runtime":"5291"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n d1 = defaultdict(int)\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n\n for c, f in c1.items():\n bound = int(sqrt(c))\n for i in range(1, bound + 1):\n if i * i == c:\n d1[i] += f\n elif c % i == 0:\n d1[i] += f\n d1[c // i] += f\n res = 0\n for c, f in c2.items():\n res += d1[c * k] * f\n return res","runtime":"5392"},{"code":"from typing import List\nimport bisect\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n factors = Counter(nums2)\n rst = 0\n nums = Counter(nums1)\n for num,val in nums.items():\n i = 1\n cnt = 0\n while (i*i <= num):\n if num % i != 0:\n i+=1\n continue\n n1 = i\n n2 = num//n1\n cnt += (factors[n1/k]+factors[n2/k])\n if n1 == n2:\n cnt -= factors[n1/k]\n i += 1\n cnt *= val\n rst += cnt\n\n return rst\n\n","runtime":"5493"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\n # this implies that a good pair is divisible by both k and by nums2[j]\n # we must only consider numbers divisible by k and for all other numbers\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\n # for some x that we can factor out\n\n freq = collections.defaultdict(int)\n for v in nums2:\n freq[v*k] += 1\n\n def isqrt(x: int) -> int:\n return int(x ** 0.5)\n\n def factor(x: int) -> List[int]:\n factors = []\n for i in range(1, isqrt(x) + 1):\n if x % i == 0:\n factors.append(i)\n return factors\n \n result = 0\n for x in nums1:\n if x % k != 0:\n continue\n for f in factor(x):\n result += freq[f]\n if x // f != f:\n result += freq[x // f]\n return result\n","runtime":"5594"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n def gd(n):\n d = set()\n for i in range(1, int(math.sqrt(n)) + 1):\n if n % i == 0:\n d.add(i)\n d.add(n//i)\n return d\n cnt = Counter()\n for n in nums1:\n if n % k == 0:\n a = gd(n//k)\n cnt.update(a)\n ans = 0\n for n in nums2:\n ans += cnt[n]\n return ans","runtime":"5694"},{"code":"from collections import defaultdict\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1FactorCount = defaultdict(lambda: 0)\n \n for num1 in nums1:\n summerize(num1, nums1FactorCount, k)\n\n count = 0\n for num2 in nums2:\n if num2 in nums1FactorCount.keys():\n count += nums1FactorCount[num2]\n\n return count\n\ndef summerize(num1, nums1FactorCount, k):\n if num1 % k != 0:\n return\n \n num1 = num1 // k\n for i in range(1, int(sqrt(num1)) + 1):\n\n if num1 % i == 0:\n nums1FactorCount[i] += 1\n \n residual = num1 // i\n if residual * residual > num1:\n nums1FactorCount[residual] += 1\n \n","runtime":"5795"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\n # if each divisor is in nums2\n nums2_counter = Counter(nums2)\n ans = 0\n\n for num in nums1:\n if num % k != 0:\n continue\n\n num //= k\n # find all divisors of num\n divisor = set([])\n end = ceil(sqrt(num))\n if end * end == num:\n end += 1\n for i in range(1, end):\n if num % i == 0:\n divisor.add(i)\n divisor.add(num//i)\n for div in divisor:\n ans += nums2_counter[div]\n \n return ans\n","runtime":"5896"},{"code":"from collections import defaultdict\n\nclass Solution:\n def numberOfPairs(self, nums1, nums2, k):\n freq1 = defaultdict(int)\n for num in nums1:\n freq1[num] += 1\n \n result = 0\n countDivisible = {}\n\n for num in nums2:\n product = num * k\n if product in countDivisible:\n result += countDivisible[product] \n continue\n\n currentCount = 0\n multiple = product\n while multiple <= 1000000:\n if multiple in freq1:\n currentCount += freq1[multiple]\n multiple += product\n\n countDivisible[product] = currentCount\n result += currentCount\n\n return result\n","runtime":"5997"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\n # if each divisor is in nums2\n nums2_counter = Counter(nums2)\n ans = 0\n\n for num in nums1:\n if num % k != 0:\n continue\n\n num //= k\n # find all divisors of num\n divisor = set([])\n end = ceil(sqrt(num))\n if end * end == num:\n end += 1\n for i in range(1, end):\n # if i > max(nums2):\n # break\n if num % i == 0:\n divisor.add(i)\n divisor.add(num//i)\n for div in divisor:\n ans += nums2_counter[div]\n \n return ans\n","runtime":"5997"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\n # if each divisor is in nums2\n nums2_counter = Counter(nums2)\n ans = 0\n max_nums2 = max(nums2)\n min_nums2 = min(nums2)\n\n for num in nums1:\n if num % k != 0:\n continue\n\n num //= k\n # find all divisors of num\n divisor = set([])\n end = ceil(sqrt(num))\n if end * end == num:\n end += 1\n for i in range(1, end):\n if num % i == 0:\n divisor.add(i)\n divisor.add(num//i)\n for div in divisor:\n ans += nums2_counter[div]\n \n return ans\n","runtime":"6098"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n \n def fact(num):\n ans = set()\n for i in range(1,int(num**(0.5))+1):\n if num % i == 0:\n ans.add(i)\n ans.add(num // i)\n return list(ans)\n \n dic = defaultdict(int)\n\n for num in nums1:\n if num % k == 0:\n all_fact = fact(num)\n for ele in all_fact:\n dic[ele] += 1\n \n count = 0\n \n for num in nums2:\n if num*k in dic:\n count += dic[num*k]\n return count\n\n\n \n\n\n \n ","runtime":"6098"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freq = {}\n freq1 = {}\n for num in nums1:\n freq1[num] = freq1.get(num,0)+1\n nums1 = set(nums1)\n for num in nums1:\n for i in range(1, 1 + int(math.sqrt(num))):\n if num%i==0:\n freq[i] = freq.get(i,0)+freq1[num]\n if num%i==0 and num//i !=i:\n freq[num//i] = freq.get(num//i,0)+freq1[num]\n \n count = 0\n # nums2 = set(nums2)\n # freq2 = {}\n # for num in nums2:\n # freq2[num] = freq2.get(num,0)+1\n for num in nums2:\n count+=(freq.get(num * k, 0) )\n return count","runtime":"6199"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n n = len(nums1)\n m = len(nums2)\n d2 = {}\n for i in range(m):\n t = k*nums2[i]\n if t in d2:\n d2[t]+=1\n else :\n d2[t]=1\n \n cnt = 0\n # Special case for 1:\n if 1 in d2:\n cnt+=n*d2[1]\n del d2[1]\n seen = {}\n for i in range(n):\n if nums1[i] in seen:\n cnt+=seen[nums1[i]]\n continue\n j = 2\n ad = []\n ad.append(nums1[i])\n while j*j<=nums1[i]:\n if nums1[i]%j==0:\n ad.append(j)\n if j*j < nums1[i]:\n ad.append(nums1[i]//j)\n j+=1\n t_cnt = 0\n for div in ad:\n if div in d2:\n t_cnt+=d2[div]\n cnt+=t_cnt\n seen[nums1[i]]=t_cnt\n return cnt","runtime":"6300"},{"code":"from math import floor\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n def getFactors(n):\n ret = []\n for i in range(1, floor(n**0.5)+1):\n x, y = divmod(n, i)\n if y == 0:\n ret.append(i)\n if i != x:\n ret.append(x)\n return ret\n\n ans = 0\n for k1, v1 in c1.items():\n for f in getFactors(k1):\n if f % k == 0:\n ans += c2[f // k] * v1\n return ans","runtime":"6401"},{"code":"\nfrom collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # count factors of numbers in nums1\n count = {}\n ans = 0\n nums1_map = Counter(nums1)\n nums2_map = Counter(nums2)\n for val, freq in nums1_map.items():\n i = 1\n while i * i <= val:\n if i * i == val:\n if i not in count:\n count[i] = 0\n count[i] += freq\n elif val%i == 0:\n if i not in count:\n count[i] = 0\n if val//i not in count:\n count[val//i] = 0\n count[i] += freq\n count[val//i] += freq\n i += 1\n for val, freq in nums2_map.items():\n factor = val * k\n if factor in count:\n ans += count[factor] * freq\n return ans","runtime":"6501"},{"code":"from collections import defaultdict\nclass Solution(object):\n def numberOfPairs(self, nums1, nums2, k):\n \"\"\"\n :type nums1: List[int]\n :type nums2: List[int]\n :type k: int\n :rtype: int\n \"\"\"\n s = defaultdict(int)\n for i in nums2:\n s[i*k]+=1 \n \n \n cnt = 0\n for i in nums1:\n sqr = int(i**0.5) \n for j in range(1,sqr+1):\n if i%j == 0:\n if j in s:\n cnt += s[j]\n # print(i,s[j])\n if i//j in s:\n cnt += s[i//j]\n # print(i,s[i//j])\n if i//j in s and sqr*sqr == i:\n cnt -= s[i//j]\n return cnt","runtime":"6602"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n memo = defaultdict(int)\n answer = 0\n for num in nums2:\n memo[num * k] += 1\n \n \n def get_pair_cnt(n):\n cnt = 0\n root = int(n ** 0.5)\n for i in range(1, root + 1):\n if not n % i:\n t = n // i\n cnt += memo[i]\n if t != i:\n cnt += memo[t]\n return cnt\n \n \n for num in nums1:\n answer += get_pair_cnt(num)\n \n return answer\n \n ","runtime":"6703"},{"code":"from collections import defaultdict\n\nclass Solution(object):\n def numberOfPairs(self, nums1, nums2, k):\n \"\"\"\n :type nums1: List[int]\n :type nums2: List[int]\n :type k: int\n :rtype: int\n \"\"\"\n s = defaultdict(int)\n for num in nums2:\n s[num * k] += 1\n \n cnt = 0\n for num in nums1:\n sqr = int(num ** 0.5)\n for j in range(1, sqr + 1):\n if num % j == 0:\n if j in s:\n cnt += s[j]\n if num // j in s and j != num // j:\n cnt += s[num // j]\n return cnt\n","runtime":"6804"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # num2k = [x*k for x in nums2]\n # nums1.sort()\n # num2k.sort()\n # for\n mp = defaultdict(int)\n for num in nums2:\n mp[num * k] += 1\n ans = 0\n\n for num in nums1:\n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n comp = num // i\n if i in mp:\n ans += mp[i]\n if comp !=i and comp in mp:\n ans += mp[comp]\n return ans","runtime":"6905"},{"code":"from collections import defaultdict\nimport math\nfrom typing import List\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n mp = defaultdict(int) \n for num in nums2:\n mp[num * k] += 1\n\n ans = 0\n\n for num in nums1:\n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n complement = num // i\n if i in mp:\n ans += mp[i]\n if complement != i and complement in mp:\n ans += mp[complement]\n return ans","runtime":"7006"},{"code":"# class Solution:\n# def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n# \"\"\"\n# n1 = [1,2,4,12]\n \n# n2 = [2,4]\n\n# k = 3\n\n# (n1 % k*n2) == 0\n\n# x * n1 = k * n2\n# \"\"\"\n# # ans = 0\n# # for i in range(len(nums1)):\n# # for j in range(len(nums2)):\n# # if nums1[i] % (k * nums2[j]) == 0:\n# # ans += 1\n# # return ans\n\n# temp = defaultdict(int)\n# for v in nums2:\n# temp[k*v] += 1\n \n# ans = 0\n# for i in range(len(nums1)):\n# if nums1[i]%k != 0:\n# continue\n# j = 1\n# while(j*j <= nums1[i]):\n# if nums1[i]%j != 0:\n# continue\n# f1 = j\n# f2 = nums1[i]//j\n# ans += temp[f1]\n# if f1 != f2:\n# ans += temp[f2]\n# j += 1\n \n# return ans\nfrom collections import defaultdict\nimport math\nfrom typing import List\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n mp = defaultdict(int) \n for num in nums2:\n mp[num * k] += 1\n\n ans = 0\n\n for num in nums1:\n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n complement = num // i\n if i in mp:\n ans += mp[i]\n if complement != i and complement in mp:\n ans += mp[complement]\n return ans","runtime":"7107"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n d = defaultdict(int)\n nums2 = [n * k for n in nums2]\n for n in nums1:\n for m in range(1, int(sqrt(n))+1):\n if n % m : continue\n v = n // m\n d[m] += 1\n d[v] += (1 if m != v else 0)\n res = sum([d[x] for x in nums2])\n return res\n\n\n\n\n ","runtime":"7207"},{"code":"class Solution:\n import math\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums2 = [num * k for num in nums2]\n hashMap = {}\n for num in nums2:\n if num in hashMap:\n hashMap[num] += 1\n else:\n hashMap[num] = 1\n res = 0\n for num in nums1:\n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n res += hashMap[i] if i in hashMap else 0\n res += hashMap[num//i] if (num//i in hashMap) and (num//i != i) else 0\n return res\n \n \n \n \n \n \n ","runtime":"7308"},{"code":"from collections import defaultdict\nfrom typing import List\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # Create a hashmap to store counts of nums2[j] * k\n divisor_count = defaultdict(int)\n \n # Populate the hashmap with counts of nums2[j] * k\n for num in nums2:\n divisor_count[num * k] += 1\n \n good_pairs = 0\n \n # For each number in nums1, find all its divisors and check against the hashmap\n for num in nums1:\n for j in range(1, int(num ** 0.5) + 1):\n if num % j == 0:\n # j is a divisor\n if j in divisor_count:\n good_pairs += divisor_count[j]\n # num // j is also a divisor if it's different from j\n if j != num // j and num // j in divisor_count:\n good_pairs += divisor_count[num // j]\n \n return good_pairs","runtime":"7409"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n from collections import defaultdict\n import math\n\n # Step 1: Create a hash map for nums2[j] * k values\n divisor_count = defaultdict(int)\n for num2 in nums2:\n divisor = num2 * k\n divisor_count[divisor] += 1\n\n # Step 2: Count good pairs by checking divisibility\n good_pairs = 0\n\n for num1 in nums1:\n # Find all divisors of num1\n sqrt_num1 = int(math.sqrt(num1))\n for i in range(1, sqrt_num1 + 1):\n if num1 % i == 0:\n # i is a divisor\n if i in divisor_count:\n good_pairs += divisor_count[i]\n # num1 // i is also a divisor, unless it's the same as i\n if i != num1 // i and num1 // i in divisor_count:\n good_pairs += divisor_count[num1 // i]\n\n return good_pairs\n\n \n \n \n ","runtime":"7510"},{"code":"class Solution:\n def numberOfPairs(self, nums1, nums2, k):\n dict1, count = defaultdict(int), 0 \n\n for i in nums2:\n dict1[i*k] += 1 \n\n def function(n):\n res = 0 \n\n for i in range(1,int(sqrt(n))+1):\n if n%i == 0:\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\n \n return res \n\n for i in nums1:\n count += function(i)\n\n return count ","runtime":"7611"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n def get_factors(n):\n res = set()\n curr = 1\n while curr <= sqrt(n):\n if n % curr == 0:\n res.add(curr)\n res.add(n // curr)\n curr += 1\n return res\n ans = 0\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n for n in c1:\n for factor in get_factors(n):\n if factor % k == 0:\n ans += c1[n] * c2[factor // k]\n return ans\n ","runtime":"7712"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n if num // potential_divisor in nums2_counter.keys():\n ans += nums2_counter[num // potential_divisor]\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\n ans += nums2_counter[potential_divisor]\n \n return ans","runtime":"7813"},{"code":"from collections import defaultdict, Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n for i, n in enumerate(nums2):\n nums2[i] *= k\n nums2Count = Counter(nums2)\n divisors = defaultdict(set)\n ret = 0\n for x in set(nums1):\n divisors[x].add(x)\n for i in range(1, int(x**0.5) + 1):\n if i in divisors[x]: continue\n else:\n y = x // i\n if (y * i) == x:\n divisors[x].add(y)\n divisors[x].add(i)\n retDict = defaultdict(int)\n for n in nums1:\n if n in retDict:\n ret += retDict[n]\n continue\n for d in divisors[n]:\n if d in nums2Count:\n ret += nums2Count[d]\n retDict[n] += nums2Count[d]\n return ret","runtime":"7913"},{"code":"class Solution:\n def numberOfPairs(self, nums1, nums2, k):\n dict1, count = defaultdict(int), 0 \n\n for i in nums2:\n dict1[i*k] += 1 \n\n def function(n):\n res = 0 \n\n for i in range(1,int(sqrt(n))+1):\n if n%i == 0:\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\n \n return res \n\n for i in nums1:\n count += function(i)\n\n return count ","runtime":"8014"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n if num // potential_divisor in nums2_counter.keys():\n ans += nums2_counter[num // potential_divisor]\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\n ans += nums2_counter[potential_divisor]\n \n return ans\n","runtime":"8115"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n\n hs = defaultdict(int)\n\n sm = 0\n for n in nums1:\n for j in range(1, int(n ** 0.5) + 1):\n\n if n % j == 0:\n hs[j] += 1\n\n if j * j != n:\n hs[n // j] += 1\n \n for n in nums2:\n if n * k in hs:\n sm += hs[n * k]\n\n return sm","runtime":"8519"},{"code":"import math\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n count = {}\n for num in nums2:\n if not num in count:\n count[num] = 1\n else:\n count[num] += 1\n \n ans = 0\n for num in nums1:\n if num % k != 0:\n continue\n num = num // k\n i = 1\n while i * i <= num:\n if num % i == 0:\n ans += count.get(i, 0)\n if i * i != num:\n ans += count.get(num // i, 0)\n i += 1\n return ans","runtime":"8519"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n complement_divisor: int = num // potential_divisor\n ans += nums2_counter[complement_divisor]\n if complement_divisor != potential_divisor:\n ans += nums2_counter[potential_divisor]\n \n return ans","runtime":"8619"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n complement_divisor: int = num // potential_divisor\n ans += nums2_counter[complement_divisor]\n if complement_divisor != potential_divisor:\n ans += nums2_counter[potential_divisor]\n \n return ans","runtime":"8619"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n factor_freq = defaultdict(int)\n for n in nums1:\n for i in range(1, int(sqrt(n)) + 1):\n if n % i == 0:\n factor_freq[i] += 1\n if n / i != i:\n factor_freq[n / i] += 1\n res = 0\n for n in nums2:\n if n * k in factor_freq:\n res += factor_freq[n*k]\n return res","runtime":"8720"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # # arr = []\n # # for i in nums2:\n # # arr.append(i*k)\n # # m = Counter(arr)\n # m = Counter(i*k for i in nums2)\n\n # def calc_factors(number, m):\n # res = []\n # # for i in range(1,number+1):\n # # print(i)\n # # if number%i == 0:\n # # res.append(i)\n # i = 1\n # # while i<=sqrt(number):\n # while i<=(number**0.5):\n # if number%i == 0:\n # res.append(m[i])\n # if number//i != i:\n # res.append(m[number//i])\n # i+=1\n # return res\n\n # ans = []\n # for i in nums1:\n # ans+=calc_factors(i,m)\n # return sum(ans)\n\n arr = []\n for i in nums1:\n if i%k == 0:\n arr.append(i//k)\n \n m = Counter(nums2)\n\n def factors(num,m):\n res = 0\n i = 1\n while i*i <= num:\n if num%i == 0:\n res+=m[i]\n if num//i != i:\n res+=m[num//i]\n i+=1\n return res\n\n ans = 0\n for i in arr:\n ans+=factors(i,m)\n return ans\n","runtime":"8720"},{"code":"class Solution:\n def __init__(self):\n self.dic = {}\n\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n def factors(x):\n for i in range(1, int(sqrt(x)) + 1):\n if x % i == 0:\n self.dic[i] = self.dic.get(i, 0) + 1\n if i != x // i: # Avoid counting the square root twice if x is a perfect square\n self.dic[x // i] = self.dic.get(x // i, 0) + 1\n return\n \n for i in nums1:\n factors(i)\n result=0\n for i in nums2:\n if i*k in self.dic:\n result+=self.dic[i*k]\n return result\n\n\n \n \n ","runtime":"8821"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1.sort()\n nums2.sort()\n\n d = Counter([n * k for n in nums2])\n res = 0\n\n for n in nums1:\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n res += d[i]\n if n // i != i:\n res += d[n // i]\n\n return res\n\n","runtime":"8821"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n n,m = len(nums1),len(nums2)\\n imax = max(nums1)//k\\n cnt = [0]*(imax+1)\\n for i in range(n):\\n if nums1[i]%k==0:\\n cnt[nums1[i]//k] += 1\\n total = 0\\n for v,c in Counter(nums2).items():\\n total += sum(cnt[v::v])*c\\n return total\",\n \"runtime\": \"954\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\\n count2 = Counter(nums2)\\n if len(nums1) == 0:\\n return 0\\n\\n max_n1 = max(nums1)\\n multiples_of_n2 = [0] * (max_n1 + 1)\\n for n2, count in count2.items():\\n # the worst case for this operation is if nums2 is [1, 2, 3, ...]\\n # in this case, the following inner loop repeats approx. max_n1 / n2 times\\n # summed over all n2, this is O(max_n1), because 1/2 + 1/3 + 1/4 + ... converges to a constant\\n for product in range(n2, max_n1 + 1, n2):\\n multiples_of_n2[product] += count\\n return sum(multiples_of_n2[n1] for n1 in nums1)\",\n \"runtime\": \"954\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n count = 0\\n # use two dict to contain all num in num1 and num2\\n hashmap1 = defaultdict(int)\\n hashmap2 = defaultdict(int)\\n\\n # add all num in nums1 into hashmap1\\n for num in nums1:\\n hashmap1[num] += 1\\n \\n # add all num * k in nums2 into hashmap2\\n for num in nums2:\\n hashmap2[num * k] += 1\\n \\n # find the max value in nums1 to find loop bounds\\n max_nums1 = max(nums1)\\n\\n # check for each key in hashmap2 if it can divide numbers in hashmap1\\n for key2 in hashmap2:\\n # try out every possible multiple of key2 until reach the upper bound\\n multiple = key2\\n while multiple <= max_nums1:\\n if multiple in hashmap1:\\n count += hashmap2[key2] * hashmap1[multiple]\\n multiple += key2\\n return count\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freqs = Counter(num*k for num in nums2)\\n counts = [0]*(max(nums1)+1)\\n\\n for num, count in freqs.items():\\n for mult in range(num,len(counts),num):\\n counts[mult] += count\\n return sum(counts[num] for num in nums1)\\n\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n '''\\n 1) Simplify the prob: what if K is 1?\\n 2) What if there is no repetition?\\n '''\\n nums2_sorted = sorted([n*k for n in nums2])\\n\\n freq_num2 = Counter(nums2_sorted)\\n freq_num1 = Counter(nums1)\\n max_nums1 = max(nums1) + 1\\n\\n ans = 0\\n for num2 in freq_num2.keys():\\n for div in range(num2, max_nums1, num2):\\n if div in freq_num1:\\n ans += 1 * freq_num2[num2] * freq_num1[div]\\n return ans\\n \",\n \"runtime\": \"1156\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # pair is good if nums1[i] is divisible by nums2[j]*k\\n \\n nums2 = [num*k for num in nums2]\\n nums1.sort()\\n upperBound = max(nums1)\\n ans = 0\\n nums1_set = set(nums1)\\n counter = Counter(nums1)\\n \\n for num2 in nums2:\\n index = bisect.bisect_left(nums1, num2)\\n \\n if index == len(nums1):\\n continue\\n \\n target = nums1[index]//num2 \\n target = num2*target\\n \\n for x in range(target,upperBound+1,num2):\\n if x in nums1_set:\\n ans += counter[x]\\n \\n return ans\\n \\n \\n \\n \",\n \"runtime\": \"1156\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, num1: List[int], num2: List[int], k: int) -> int:\\n num2 = [x*k for x in num2]\\n c = Counter(num2)\\n dct = {}\\n maxi = max(num1)\\n\\n for num in c:\\n snum = num\\n while snum <= maxi:\\n if snum in dct:\\n dct[snum] += c[num]\\n else:\\n dct[snum] = c[num]\\n\\n snum += num\\n\\n count = 0\\n for n1 in num1:\\n if n1 in dct:\\n count += dct[n1]\\n\\n return count\\n\\n \\n\\n\\n\\n \",\n \"runtime\": \"1257\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt1 = Counter(x // k for x in nums1 if x % k == 0)\\n if not cnt1:\\n return 0\\n cnt2 = Counter(nums2)\\n ans = 0\\n mx = max(cnt1)\\n for x, v in cnt2.items():\\n s = sum(cnt1[y] for y in range(x, mx + 1, x))\\n ans += s * v\\n return ans\",\n \"runtime\": \"1257\"\n },\n {\n \"code\": \"import functools\\nclass Solution:\\n def numberOfPairs(self, nn1: List[int], nn2: List[int], k: int) -> int:\\n max_nums1 = max(nn1)\\n cnt1 = collections.Counter(nn1)\\n cnt2 = collections.Counter(nn2)\\n res = 0\\n for n, f in cnt2.items():\\n mol = 1\\n while mol * k * n <= max_nums1:\\n res += cnt1[mol * k * n] * f\\n mol += 1\\n return res\",\n \"runtime\": \"1357\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n count1 = Counter(nums1)\\n count2 = Counter(nums2)\\n max1 = max(count1.keys())\\n res = 0\\n for n in count2.keys():\\n divisor = n * k\\n multiplier = 1\\n while divisor * multiplier <= max1:\\n res += count2[n] * count1[divisor * multiplier]\\n multiplier += 1\\n return res\",\n \"runtime\": \"1357\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n nums1 = list(map(lambda x: x//k, filter(lambda x: x%k == 0, nums1)))\\n mx1 = max(nums1, default = 0) + 1\\n\\n ctr1 = defaultdict(int)\\n ctr2 = Counter(nums2)\\n \\n for n2 in ctr2:\\n for i in range(n2, mx1, n2):\\n ctr1[i]+= ctr2[n2]\\n\\n return sum(map(lambda x: ctr1[x], nums1))\",\n \"runtime\": \"1458\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n nums1 = list(map(lambda x: x//k, filter(lambda x: x%k == 0, nums1)))\\n mx1 = max(nums1, default = 0) + 1\\n\\n ctr1 = defaultdict(int)\\n ctr2 = Counter(nums2)\\n \\n for n2 in ctr2:\\n for i in range(n2, mx1, n2):\\n ctr1[i]+= ctr2[n2]\\n\\n return sum(map(lambda x: ctr1[x], nums1))\",\n \"runtime\": \"1458\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n n, m = len(nums1), len(nums2)\\n hash = defaultdict(int)\\n\\n for i in range(n):\\n if(nums1[i] % k != 0):\\n continue\\n hash[nums1[i]/k] += 1\\n \\n ans = 0\\n max_elem1, max_elem2 = max(nums1), max(nums2)\\n dp = [-1] * (max_elem2 + 1)\\n for j in range(m):\\n if(dp[nums2[j]] == -1):\\n dp[nums2[j]] = 0\\n k = 1\\n while(nums2[j]*k <= max_elem1):\\n dp[nums2[j]] += hash[nums2[j] * k]\\n k += 1\\n \\n ans += dp[nums2[j]]\\n \\n return ans\",\n \"runtime\": \"1559\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n n, m = len(nums1), len(nums2)\\n hash = defaultdict(int)\\n\\n for i in range(n):\\n if(nums1[i] % k != 0):\\n continue\\n hash[nums1[i]/k] += 1\\n \\n ans = 0\\n max_elem1, max_elem2 = max(nums1), max(nums2)\\n dp = [-1] * (max_elem2 + 1)\\n for j in range(m):\\n if(dp[nums2[j]] == -1):\\n dp[nums2[j]] = 0\\n k = 1\\n while(nums2[j]*k <= max_elem1):\\n dp[nums2[j]] += hash[nums2[j] * k]\\n k += 1\\n \\n ans += dp[nums2[j]]\\n \\n return ans\",\n \"runtime\": \"1660\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, a: List[int], b: List[int], k: int) -> int:\\n a,c,d,m=[*map(lambda x:x//k,filter(lambda x:x%k==0,a))],Counter(b),defaultdict(int),max([0,*a])+1;[setitem(d,i,d[i]+c[j])for j in c for i in range(j,m,j)];return sum(map(lambda x: d[x], a))\\n\",\n \"runtime\": \"1761\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = Counter([n // k for n in nums1 if n % k == 0])\\n\\n counts = Counter(nums2)\\n\\n res = 0\\n for num, amt in nums1.items():\\n pairs = 0\\n for f in range(1, floor(sqrt(num) + 1)):\\n if num % f:\\n continue\\n other = num // f\\n pairs += counts[f]\\n if other != f:\\n pairs += counts[other]\\n res += pairs * amt\\n \\n return res\",\n \"runtime\": \"1862\"\n },\n {\n \"code\": \"class Trie:\\n def __init__(self):\\n self.conts = defaultdict(Trie)\\n self.count = 0\\n \\n @cache\\n def key_order(self):\\n return sorted(self.conts.keys())\\n \\n def add(self, order):\\n cur = self\\n for num in order:\\n cur.count += 1\\n cur = cur.conts[num]\\n cur.count += 1\\n \\n def matches(self, order, i=0):\\n if i == len(order):\\n return self.count\\n \\n res = 0\\n \\n for key in self.key_order():\\n if key == order[i]:\\n res += self.conts[key].matches(order, i + 1)\\n elif key < order[i]:\\n res += self.conts[key].matches(order, i)\\n else:\\n break\\n\\n return res\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = Counter([n // k for n in nums1 if n % k == 0])\\n\\n counts = Counter(nums2)\\n\\n res = 0\\n for num, amt in nums1.items():\\n pairs = 0\\n for f in range(1, floor(sqrt(num) + 1)):\\n if num % f:\\n continue\\n other = num // f\\n pairs += counts[f]\\n if other != f:\\n pairs += counts[other]\\n res += pairs * amt\\n \\n return res\",\n \"runtime\": \"1963\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n map1 = defaultdict(int)\\n map2 = defaultdict(int)\\n\\n for x in nums1:\\n if x % k == 0:\\n f = x // k\\n map1[f] += 1\\n\\n for x in nums2:\\n map2[x] += 1\\n\\n res = 0\\n for x, y in map1.items():\\n for i in range(1, int(math.sqrt(x)) + 1):\\n if x % i == 0:\\n cur = x // i\\n if i in map2:\\n res += map2[i] * y\\n if cur != i and cur in map2:\\n res += map2[cur] * y\\n\\n return res\\n\",\n \"runtime\": \"1963\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n ret = 0\\n C1,C2 = collections.Counter(n//k for n in nums1 if n%k==0),collections.Counter(nums2)\\n for n in C1:\\n sq = int(n**0.5)\\n if sq**2 == n:\\n ret += C1[n]*C2[sq]\\n else:\\n sq += 1\\n for d in range(1,sq):\\n if n%d == 0:\\n ret += C1[n]*(C2[d]+C2[n//d])\\n return ret\",\n \"runtime\": \"2063\"\n },\n {\n \"code\": \"class Solution:\\n def factors(self, n: int):\\n result = set()\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n result.add(i)\\n result.add(n // i)\\n return sorted(result) \\n\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1_dict = {}\\n for num in nums1:\\n if num % k == 0:\\n key = num // k\\n nums1_dict[key] = nums1_dict.setdefault(key, 0) + 1\\n nums2_dict = {}\\n result = 0\\n for num in nums2:\\n if num in nums2_dict:\\n nums2_dict[num] += 1\\n else:\\n nums2_dict[num] = 1\\n for num, count in nums1_dict.items():\\n factor = self.factors(num)\\n for each in factor:\\n if each in nums2_dict:\\n result += nums2_dict[each] * count\\n return result\",\n \"runtime\": \"2063\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n targets = {}\\n divisors = {}\\n\\n for n in nums1:\\n if n % k == 0:\\n temp = n // k\\n if temp not in targets:\\n targets[temp] = 0\\n targets[temp] += 1\\n\\n for n in nums2:\\n if n not in divisors:\\n divisors[n] = 0\\n divisors[n] += 1\\n\\n total = 0\\n for t in targets:\\n i = 1\\n while i * i <= t:\\n if t % i == 0:\\n comp = t // i\\n if i in divisors:\\n total += targets[t] * divisors[i]\\n if i != comp and comp in divisors:\\n total += targets[t] * divisors[comp]\\n i += 1\\n return total\",\n \"runtime\": \"2366\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [nums1[i]//k for i in range(len(nums1)) if nums1[i]%k==0]\\n d = Counter(nums2)\\n ans = 0\\n d1 = Counter(nums1)\\n for j in (d1):\\n i = 1\\n while i*i<=j:\\n if j%i==0:\\n ans += d[i]*d1[j]\\n if j//i != i:\\n ans += d[(j//i)]*d1[j]\\n i += 1\\n return ans\",\n \"runtime\": \"2467\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n targets = {}\\n divisors = {}\\n\\n for n in nums1:\\n if n % k == 0:\\n temp = n // k\\n if temp not in targets:\\n targets[temp] = 0\\n targets[temp] += 1\\n\\n for n in nums2:\\n if n not in divisors:\\n divisors[n] = 0\\n divisors[n] += 1\\n\\n total = 0\\n for t in targets:\\n i = 1\\n while i * i <= t:\\n if t % i == 0:\\n comp = t // i\\n if i in divisors:\\n total += targets[t] * divisors[i]\\n if i != comp and comp in divisors:\\n total += targets[t] * divisors[comp]\\n i += 1\\n return total\",\n \"runtime\": \"2568\"\n },\n {\n \"code\": \"import collections\\nimport heapq\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\\n d = collections.defaultdict(int)\\n d1 = collections.Counter(nums1)\\n d2 = collections.Counter(nums2)\\n\\n for k, v in d1.items():\\n if k % n != 0:\\n continue\\n bound = int(sqrt(k))\\n for i in range(1, bound + 1):\\n if i*i == k:\\n d[i] += v\\n elif k % i == 0:\\n d[i] += v\\n d[k//i] += v\\n \\n count = 0\\n for k, v in d2.items():\\n if k*n in d.keys():\\n count += v * d[k*n]\\n return count\\n\\n \",\n \"runtime\": \"2669\"\n },\n {\n \"code\": \"import collections\\nimport heapq\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\\n d = collections.defaultdict(int)\\n d1 = collections.Counter(nums1)\\n d2 = collections.Counter(nums2)\\n\\n for k, v in d1.items():\\n if k % n != 0:\\n continue\\n bound = int(sqrt(k))\\n for i in range(1, bound + 1):\\n if i*i == k:\\n d[i] += v\\n elif k % i == 0:\\n d[i] += v\\n d[k//i] += v\\n \\n count = 0\\n for k, v in d2.items():\\n if k*n in d.keys():\\n count += v * d[k*n]\\n return count\\n\\n \",\n \"runtime\": \"2769\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n def get_primes(max_n: int) -> list[int]:\\n \\n is_prime = [True if i%2 else False for i in range(max_n) ]\\n is_prime[0] = False\\n is_prime[1] = False\\n is_prime[2] = True\\n primes = [2]\\n\\n for i in range(3, len(is_prime), 2):\\n if not is_prime[i]:\\n continue\\n primes.append(i)\\n for x in range(3*i, max_n, 2*i):\\n is_prime[x] = False\\n return primes\\n \\n \\n PRIMES = get_primes(1050)\\n \\n def get_all_factors(x: int) -> list[int]:\\n if x == 1:\\n return [1]\\n start_x = x\\n prime_facs_lists: list[list[int]] = []\\n for prime in PRIMES:\\n if x % prime == 0:\\n pfacs = [1, prime]\\n x = x//prime\\n while x % prime == 0:\\n x = x//prime\\n pfacs.append(pfacs[-1] * prime)\\n prime_facs_lists.append(pfacs)\\n \\n if prime*prime > x:\\n break\\n if x > 1:\\n prime_facs_lists.append([1, x])\\n return list(functools.reduce(operator.mul, y, 1) for y in itertools.product(*prime_facs_lists))\\n \\n \\n div_counts = collections.Counter()\\n \\n for x in nums1:\\n if x < k:\\n continue\\n div, rem = divmod(x, k)\\n if rem != 0:\\n continue\\n\\n div_counts.update(get_all_factors(div))\\n \\n ans = 0\\n for y in nums2:\\n ans += div_counts[y]\\n return ans\",\n \"runtime\": \"2870\"\n },\n {\n \"code\": \"\\nfrom collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # count factors of numbers in nums1\\n count = {}\\n ans = 0\\n nums1 = [x//k for x in nums1 if x%k == 0]\\n nums1_map = Counter(nums1)\\n nums2_map = Counter(nums2)\\n for val, freq in nums1_map.items():\\n i = 1\\n while i * i <= val:\\n if i * i == val:\\n if i not in count:\\n count[i] = 0\\n count[i] += freq\\n elif val%i == 0:\\n if i not in count:\\n count[i] = 0\\n if val//i not in count:\\n count[val//i] = 0\\n count[i] += freq\\n count[val//i] += freq\\n i += 1\\n for val, freq in nums2_map.items():\\n \\n if val in count:\\n ans += count[val] * freq\\n return ans\",\n \"runtime\": \"2971\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n from collections import defaultdict\\n import math\\n\\n # Step 1: Create a hash map for nums2[j] * k values\\n divisor_count = defaultdict(int)\\n for num2 in nums2:\\n divisor = num2 * k\\n divisor_count[divisor] += 1\\n\\n # Step 2: Count good pairs by checking divisibility\\n good_pairs = 0\\n\\n nums1 = collections.Counter(nums1)\\n for num1, val in nums1.items():\\n # Find all divisors of num1\\n sqrt_num1 = int(math.sqrt(num1))\\n for i in range(1, sqrt_num1 + 1):\\n if num1 % i == 0:\\n # i is a divisor\\n if i in divisor_count:\\n good_pairs += divisor_count[i]*val\\n # num1 // i is also a divisor, unless it's the same as i\\n if i != num1 // i and num1 // i in divisor_count:\\n good_pairs += divisor_count[num1 // i]*val\\n\\n return good_pairs\\n\\n \\n \\n \\n \",\n \"runtime\": \"3072\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums2 = [k*n for n in nums2]\\n \\n n1c = collections.Counter(nums1)\\n n2c = collections.Counter(nums2)\\n \\n res = 0\\n \\n for kn1, vn1 in n1c.items():\\n ss = int(math.sqrt(kn1))\\n \\n for i in range(1, ss+1):\\n if kn1%i==0:\\n if i in n2c:\\n res += vn1*n2c[i]\\n \\n comp = kn1//i\\n \\n if comp !=i and comp in n2c:\\n res += vn1*n2c[comp]\\n \\n return res\\n \",\n \"runtime\": \"3173\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n def find(n):\\n factors=set()\\n i=1\\n while i*i<=n:\\n if n%i==0:\\n factors.add(i)\\n factors.add(n//i)\\n i+=1 \\n return list(factors)\\n f_factors=defaultdict(list)\\n d=defaultdict(int)\\n for i in range(len(nums1)):\\n if nums1[i]%k==0:\\n if nums1[i] not in f_factors:\\n f_factors[nums1[i]]=find(nums1[i])\\n for fac in f_factors[nums1[i]]:\\n d[fac]+=1\\n ans=0\\n for i in nums2:\\n ans+=d[i*k]\\n return ans \\n \",\n \"runtime\": \"3274\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n c1, c2 = collections.defaultdict(int), collections.defaultdict(int)\\n for num in nums1:\\n c1[num] += 1\\n for num in nums2:\\n c2[num * k] += 1\\n\\n res = 0\\n\\n for num in c1:\\n sr = int(math.sqrt(num))\\n for n in range(1, sr + 1):\\n if num % n:\\n continue\\n res += c1[num] * c2[n]\\n if n != num // n: # sqrt\\n res += c1[num] * c2[num // n] \\n\\n return res\\n\",\n \"runtime\": \"3375\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = 0\\n factors = collections.defaultdict(int)\\n nums1ctr = collections.Counter(nums1)\\n nums2ctr = collections.Counter(nums2)\\n for n,amt in nums1ctr.items():\\n if not n%k == 0:\\n continue\\n i = 1\\n while i*i <= n:\\n if(i*i == n):\\n factors[i] += amt\\n elif (n%i == 0):\\n factors[i] += amt\\n factors[n/i] += amt\\n i += 1\\n for n,amt in nums2ctr.items():\\n cnt += (amt*factors[n*k])\\n return cnt\",\n \"runtime\": \"3475\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1D = {n:0 for n in nums1}\\n for n in nums1:\\n nums1D[n] +=1\\n def find_factor(i):\\n if i == 1: return [1]\\n out = [] \\n for f in range(1,int(i**0.5)+1): \\n if i%f == 0:\\n out.append(f)\\n if i//f!=f:\\n out.append(i//f)\\n return out\\n nums_factor = {}\\n for n in nums1D:\\n factors = find_factor(n)\\n # print(n,factors)\\n for f in factors:\\n if f not in nums_factor:\\n nums_factor[f] = 0\\n nums_factor[f]+=nums1D[n]\\n \\n nums2D = {n*k:0 for n in nums2}\\n for n in nums2:\\n nums2D[n*k] +=1\\n # print(nums2D,nums_factor)\\n out = 0 \\n for n in nums2D:\\n if n in nums_factor:\\n out += nums2D[n]*nums_factor[n]\\n return out\",\n \"runtime\": \"3576\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n # nums2 * k\\n # check each num in nums2, count answer\\n # for each num in nums1, we make table[factor] += 1\\n \\n table = defaultdict(int) #factor: number\\n \\n counter1 = Counter(nums1)\\n \\n def factors(num):\\n res = []\\n for x in range(1, isqrt(num) + 1):\\n if num % x == 0:\\n res.append(x)\\n y = num // x\\n if y != x:\\n res.append(y)\\n return res\\n \\n for num in counter1:\\n for x in factors(num):\\n table[x] += counter1[num]\\n \\n res = 0\\n for num in nums2:\\n num *= k\\n res += table[num]\\n \\n return res\\n \\n \\n \\n \",\n \"runtime\": \"3677\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = Counter(nums2)\\n res = 0\\n cache = {}\\n \\n for num in nums1:\\n if num%k!=0:\\n continue\\n if num in cache:\\n res+=cache[num]\\n continue\\n \\n cur = 0\\n num = num / k\\n \\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n cur += cnt[i]\\n cur += cnt[num // i] if i!=num//i else 0\\n cache[num*k] = cur\\n # print(num, cur)\\n res+=cur\\n return res\",\n \"runtime\": \"3778\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [y//k for y in filter(lambda x: x % k == 0, nums1)]\\n nums2 = Counter(nums2)\\n res = 0\\n for num in nums1:\\n for i in range(1, int(num**0.5)+1):\\n if num % i == 0:\\n if i in nums2:\\n res += nums2[i]\\n if num // i != i and num // i in nums2:\\n res += nums2[num // i]\\n return res\",\n \"runtime\": \"3879\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [y//k for y in filter(lambda x: x % k == 0, nums1)]\\n nums2 = Counter(nums2)\\n res = 0\\n for num in nums1:\\n for i in range(1, int(num**0.5)+1):\\n if num % i == 0:\\n if i in nums2:\\n res += nums2[i]\\n if num // i != i and num // i in nums2:\\n res += nums2[num // i]\\n return res\",\n \"runtime\": \"3980\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [el//k for el in nums1 if el % k == 0]\\n dct = defaultdict(int)\\n for el in nums2:\\n dct[el]+=1\\n res= 0\\n def main(x):\\n nonlocal res\\n for i in range(1, math.floor(math.sqrt(x)) + 1):\\n if x % i == 0:\\n dv=x//i\\n res += dct[i] + dct[dv]\\n if i == dv:\\n res -= dct[i]\\n for x in nums1:\\n main(x)\\n return res\",\n \"runtime\": \"4081\"\n },\n {\n \"code\": \"class Trie:\\n def __init__(self):\\n self.conts = defaultdict(Trie)\\n self.count = 0\\n \\n @cache\\n def key_order(self):\\n return sorted(self.conts.keys())\\n \\n def add(self, order):\\n cur = self\\n for num in order:\\n cur.count += 1\\n cur = cur.conts[num]\\n cur.count += 1\\n \\n def matches(self, order, i=0):\\n if i == len(order):\\n return self.count\\n \\n res = 0\\n \\n for key in self.key_order():\\n if key == order[i]:\\n res += self.conts[key].matches(order, i + 1)\\n elif key < order[i]:\\n res += self.conts[key].matches(order, i)\\n else:\\n break\\n\\n return res\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [n // k for n in nums1 if n % k == 0]\\n\\n counts = Counter(nums2)\\n\\n res = 0\\n for num in nums1:\\n for f in range(1, floor(sqrt(num) + 1)):\\n if num % f:\\n continue\\n \\n other = num // f\\n res += counts[f]\\n if other != f:\\n res += counts[other]\\n \\n return res\",\n \"runtime\": \"4182\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = defaultdict(int)\\n for i in nums1:\\n if i % k: continue\\n i //= k\\n for d in range(1, isqrt(i) + 1):\\n if i % d: continue\\n cnt[d] += 1\\n if d * d < i:\\n cnt[i // d] += 1\\n res = 0\\n for j in nums2:\\n res += cnt[j]\\n return res\",\n \"runtime\": \"4282\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n\\n counter = collections.defaultdict(int)\\n for num in nums2:\\n counter[num] +=1\\n \\n result = 0\\n for num in nums1:\\n if(num % k ==0):\\n residue_num = num // k\\n for factor in range(1, int(pow(residue_num, 0.5)) +1):\\n if(residue_num % factor ==0):\\n factor1 = factor\\n factor2 = residue_num // factor\\n result += counter[factor1]\\n if(factor2 != factor1):\\n result += counter[factor2]\\n \\n return result\\n\\n\",\n \"runtime\": \"4383\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n # these three functions are from IterTools Recipes:\\n # https://docs.python.org/3/library/itertools.html\\n\\n import contextlib\\n\\n def iter_index(iterable, value, start=0, stop=None):\\n \\\"Return indices where a value occurs in a sequence or iterable.\\\"\\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\\n seq_index = getattr(iterable, 'index', None)\\n if seq_index is None:\\n iterator = islice(iterable, start, stop)\\n for i, element in enumerate(iterator, start):\\n if element is value or element == value:\\n yield i\\n else:\\n stop = len(iterable) if stop is None else stop\\n i = start\\n with contextlib.suppress(ValueError):\\n while True:\\n yield (i := seq_index(value, i, stop))\\n i += 1\\n\\n def sieve(n):\\n \\\"Primes less than n.\\\"\\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\\n if n > 2:\\n yield 2\\n data = bytearray((0, 1)) * (n // 2)\\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\\n yield from iter_index(data, 1, start=3)\\n\\n def factor_cacheme(n):\\n \\\"Prime factors of n.\\\"\\n # factor(99) → 3 3 11\\n # factor(1_000_000_000_000_007) → 47 59 360620266859\\n # factor(1_000_000_000_000_403) → 1000000000000403\\n for prime in sieve(math.isqrt(n) + 1):\\n while not n % prime:\\n yield prime\\n n //= prime\\n if n == 1:\\n return\\n if n > 1:\\n yield n\\n\\n @cache\\n def factor(n):\\n return tuple(factor_cacheme(n))\\n\\n # we borrow some code from #3162:\\n\\n count1 = Counter(nums1)\\n # print(f'{count1=}')\\n count2 = Counter(nums2)\\n # print(f'{count2=}')\\n \\n # @cache\\n # nope. we need to roll our own cache, excluding \\\"depth\\\"\\n CFFPP_cache = {}\\n def composite_factors_from_prime_power(Prime: int, Power: int, depth=0) -> Set[int]:\\n cache_index = (Prime, Power)\\n if cache_index in CFFPP_cache:\\n return CFFPP_cache[cache_index]\\n margin = ' ' * depth\\n # print(f'{margin}CFFPP({Prime},{Power})')\\n answer = {1}\\n if Power == 0:\\n # print(f'{margin} {answer=}')\\n CFFPP_cache[cache_index] = answer\\n return answer\\n CFFPP = composite_factors_from_prime_power(Prime, Power - 1, depth+1)\\n answer = CFFPP | {\\n A * Prime\\n for A in CFFPP\\n }\\n # print(f'{margin} {answer=}')\\n CFFPP_cache[cache_index] = answer\\n return answer\\n\\n # @cache\\n def composite_factors_from_primes(Primes: List[int], depth=0) -> Set[int]:\\n margin = ' ' * depth\\n # print(f'{margin}CFFP({Primes})')\\n answer = {1}\\n if not Primes:\\n # print(f'{margin} {answer=}')\\n return answer\\n \\n counts = Counter(Primes)\\n # print(f'{margin} {counts=}')\\n\\n for Prime, Count in counts.items():\\n # print(f'{margin} {Prime=} {Count=}')\\n prime_powers = composite_factors_from_prime_power(Prime, Count, depth+1)\\n # print(f'{margin} {prime_powers=}')\\n answer = {\\n A * B\\n for A in answer\\n for B in prime_powers\\n }\\n # print(f'{margin} {answer=}')\\n \\n return answer\\n\\n def factors_of(N: int) -> Set[int]:\\n # print(f'factors_of({N})')\\n\\n F = factor(N)\\n # print(f' {F=}')\\n CF = composite_factors_from_primes(F)\\n\\n return CF\\n\\n hint1_F = Counter()\\n for N, count in count2.items():\\n hint1_F[N * k] += count\\n # print(f'{hint1_F=}')\\n hint1_F_set = set(hint1_F.keys())\\n # print(f'{len(hint1_F_set)=}')\\n\\n answer = 0\\n for N, count in sorted(count1.items()):\\n # print(f'{N=} {count=}')\\n factor_set = factors_of(N)\\n intersect = factor_set & hint1_F_set\\n # if intersect:\\n # # print(f'{N=} {count=} F={len(factor_set)} &={len(intersect)}')\\n for D in intersect:\\n # print(f' {D=} {hint1_F[D]=}')\\n answer += count * hint1_F[D]\\n\\n return answer\\n\",\n \"runtime\": \"4484\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n targets = {}\\n divisors = {}\\n\\n for n in nums1:\\n if n not in targets:\\n targets[n] = 0\\n targets[n] += 1\\n\\n for n in nums2:\\n temp = n * k\\n if temp not in divisors:\\n divisors[temp] = 0\\n divisors[temp] += 1\\n \\n total = 0\\n for t in targets:\\n i = 1\\n while i * i <= t:\\n if t % i == 0:\\n comp = t // i\\n if i in divisors:\\n total += targets[t] * divisors[i]\\n if i != comp and comp in divisors:\\n total += targets[t] * divisors[comp]\\n i += 1\\n return total\",\n \"runtime\": \"4585\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\\n count2 = Counter(nums2)\\n\\n count = 0\\n for n1 in nums1:\\n for n2 in range(1, int(sqrt(n1)) + 1):\\n if n1 % n2 == 0:\\n count += count2[n2]\\n big = n1 // n2\\n if big != n2:\\n count += count2[big]\\n return count\",\n \"runtime\": \"4686\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n targets = {}\\n divisors = {}\\n\\n for n in nums1:\\n if n not in targets:\\n targets[n] = 0\\n targets[n] += 1\\n\\n for n in nums2:\\n temp = n * k\\n if temp not in divisors:\\n divisors[temp] = 0\\n divisors[temp] += 1\\n\\n total = 0\\n for t in targets:\\n i = 1\\n while i * i <= t:\\n if t % i == 0:\\n comp = t // i\\n if i in divisors:\\n total += targets[t] * divisors[i]\\n if i != comp and comp in divisors:\\n total += targets[t] * divisors[comp]\\n i += 1\\n return total\",\n \"runtime\": \"4787\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n factors = defaultdict(int)\\n\\n for i in range(len(nums2)):\\n factors[nums2[i]]+=1\\n\\n res = 0\\n\\n for i in range(len(nums1)):\\n if nums1[i]%k == 0:\\n temp = nums1[i]//k\\n for j in range(1, int(math.sqrt(temp))+1):\\n if temp%j == 0:\\n res+=factors[j]\\n if temp//j != j:\\n res+=factors[temp//j]\\n\\n return res\\n\\n \\n \\n \\n \",\n \"runtime\": \"4888\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n targets = {}\\n divisors = {}\\n\\n for n in nums1:\\n if n not in targets:\\n targets[n] = 0\\n targets[n] += 1\\n\\n for n in nums2:\\n temp = n * k\\n if temp not in divisors:\\n divisors[temp] = 0\\n divisors[temp] += 1\\n \\n print(divisors)\\n total = 0\\n for t in targets:\\n i = 1\\n while i * i <= t:\\n if t % i == 0:\\n comp = t // i\\n if i in divisors:\\n total += targets[t] * divisors[i]\\n if i != comp and comp in divisors:\\n total += targets[t] * divisors[comp]\\n i += 1\\n return total\",\n \"runtime\": \"4988\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [num//k for num in nums1 if num%k == 0]\\n d = defaultdict(int)\\n #print(nums1)\\n for num in nums1:\\n iq = isqrt(num)\\n for i in range(1, iq+1):\\n if num%i == 0:\\n d[i] += 1\\n d[num//i] += 1\\n if iq**2 == num:\\n d[iq] -= 1\\n\\n #print(d)\\n \\n return sum(d[n] for n in nums2)\\n \",\n \"runtime\": \"5089\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n d1 = defaultdict(int)\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n\\n for c,f in c1.items():\\n bound = int(sqrt(c))\\n for i in range(1, bound+1):\\n if i*i == c:\\n d1[i] += f\\n elif c % i == 0:\\n d1[i] += f\\n d1[c // i] += f\\n\\n res = 0\\n for c,f in c2.items():\\n res+= d1[c*k]*f\\n return res\",\n \"runtime\": \"5190\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\\n count2 = Counter(nums2)\\n keys2 = sorted(count2.keys())\\n #print(count2)\\n #print(nums1)\\n #print(keys2)\\n\\n count = 0\\n for n1 in nums1:\\n for n2 in range(1, int(sqrt(n1)) + 1):\\n if n1 % n2 == 0:\\n #print(f\\\"{n1} divisible by {n2}\\\")\\n count += count2[n2]\\n big = n1 // n2\\n if big != n2:\\n count += count2[big]\\n return count\",\n \"runtime\": \"5291\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n d1 = defaultdict(int)\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n\\n for c, f in c1.items():\\n bound = int(sqrt(c))\\n for i in range(1, bound + 1):\\n if i * i == c:\\n d1[i] += f\\n elif c % i == 0:\\n d1[i] += f\\n d1[c // i] += f\\n res = 0\\n for c, f in c2.items():\\n res += d1[c * k] * f\\n return res\",\n \"runtime\": \"5392\"\n },\n {\n \"code\": \"from typing import List\\nimport bisect\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n factors = Counter(nums2)\\n rst = 0\\n nums = Counter(nums1)\\n for num,val in nums.items():\\n i = 1\\n cnt = 0\\n while (i*i <= num):\\n if num % i != 0:\\n i+=1\\n continue\\n n1 = i\\n n2 = num//n1\\n cnt += (factors[n1/k]+factors[n2/k])\\n if n1 == n2:\\n cnt -= factors[n1/k]\\n i += 1\\n cnt *= val\\n rst += cnt\\n\\n return rst\\n\\n\",\n \"runtime\": \"5493\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\\n # this implies that a good pair is divisible by both k and by nums2[j]\\n # we must only consider numbers divisible by k and for all other numbers\\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\\n # for some x that we can factor out\\n\\n freq = collections.defaultdict(int)\\n for v in nums2:\\n freq[v*k] += 1\\n\\n def isqrt(x: int) -> int:\\n return int(x ** 0.5)\\n\\n def factor(x: int) -> List[int]:\\n factors = []\\n for i in range(1, isqrt(x) + 1):\\n if x % i == 0:\\n factors.append(i)\\n return factors\\n \\n result = 0\\n for x in nums1:\\n if x % k != 0:\\n continue\\n for f in factor(x):\\n result += freq[f]\\n if x // f != f:\\n result += freq[x // f]\\n return result\\n\",\n \"runtime\": \"5594\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n def gd(n):\\n d = set()\\n for i in range(1, int(math.sqrt(n)) + 1):\\n if n % i == 0:\\n d.add(i)\\n d.add(n//i)\\n return d\\n cnt = Counter()\\n for n in nums1:\\n if n % k == 0:\\n a = gd(n//k)\\n cnt.update(a)\\n ans = 0\\n for n in nums2:\\n ans += cnt[n]\\n return ans\",\n \"runtime\": \"5694\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1FactorCount = defaultdict(lambda: 0)\\n \\n for num1 in nums1:\\n summerize(num1, nums1FactorCount, k)\\n\\n count = 0\\n for num2 in nums2:\\n if num2 in nums1FactorCount.keys():\\n count += nums1FactorCount[num2]\\n\\n return count\\n\\ndef summerize(num1, nums1FactorCount, k):\\n if num1 % k != 0:\\n return\\n \\n num1 = num1 // k\\n for i in range(1, int(sqrt(num1)) + 1):\\n\\n if num1 % i == 0:\\n nums1FactorCount[i] += 1\\n \\n residual = num1 // i\\n if residual * residual > num1:\\n nums1FactorCount[residual] += 1\\n \\n\",\n \"runtime\": \"5795\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\\n # if each divisor is in nums2\\n nums2_counter = Counter(nums2)\\n ans = 0\\n\\n for num in nums1:\\n if num % k != 0:\\n continue\\n\\n num //= k\\n # find all divisors of num\\n divisor = set([])\\n end = ceil(sqrt(num))\\n if end * end == num:\\n end += 1\\n for i in range(1, end):\\n if num % i == 0:\\n divisor.add(i)\\n divisor.add(num//i)\\n for div in divisor:\\n ans += nums2_counter[div]\\n \\n return ans\\n\",\n \"runtime\": \"5896\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def numberOfPairs(self, nums1, nums2, k):\\n freq1 = defaultdict(int)\\n for num in nums1:\\n freq1[num] += 1\\n \\n result = 0\\n countDivisible = {}\\n\\n for num in nums2:\\n product = num * k\\n if product in countDivisible:\\n result += countDivisible[product] \\n continue\\n\\n currentCount = 0\\n multiple = product\\n while multiple <= 1000000:\\n if multiple in freq1:\\n currentCount += freq1[multiple]\\n multiple += product\\n\\n countDivisible[product] = currentCount\\n result += currentCount\\n\\n return result\\n\",\n \"runtime\": \"5997\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\\n # if each divisor is in nums2\\n nums2_counter = Counter(nums2)\\n ans = 0\\n\\n for num in nums1:\\n if num % k != 0:\\n continue\\n\\n num //= k\\n # find all divisors of num\\n divisor = set([])\\n end = ceil(sqrt(num))\\n if end * end == num:\\n end += 1\\n for i in range(1, end):\\n # if i > max(nums2):\\n # break\\n if num % i == 0:\\n divisor.add(i)\\n divisor.add(num//i)\\n for div in divisor:\\n ans += nums2_counter[div]\\n \\n return ans\\n\",\n \"runtime\": \"5997\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # nums1[i] % (nums2[j]*k) == 0 -> nums1[i] % nums2[j] == 0\\n # for each nums1[i], find all its divisor O(sqrt(nums1[i])), add check\\n # if each divisor is in nums2\\n nums2_counter = Counter(nums2)\\n ans = 0\\n max_nums2 = max(nums2)\\n min_nums2 = min(nums2)\\n\\n for num in nums1:\\n if num % k != 0:\\n continue\\n\\n num //= k\\n # find all divisors of num\\n divisor = set([])\\n end = ceil(sqrt(num))\\n if end * end == num:\\n end += 1\\n for i in range(1, end):\\n if num % i == 0:\\n divisor.add(i)\\n divisor.add(num//i)\\n for div in divisor:\\n ans += nums2_counter[div]\\n \\n return ans\\n\",\n \"runtime\": \"6098\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n \\n def fact(num):\\n ans = set()\\n for i in range(1,int(num**(0.5))+1):\\n if num % i == 0:\\n ans.add(i)\\n ans.add(num // i)\\n return list(ans)\\n \\n dic = defaultdict(int)\\n\\n for num in nums1:\\n if num % k == 0:\\n all_fact = fact(num)\\n for ele in all_fact:\\n dic[ele] += 1\\n \\n count = 0\\n \\n for num in nums2:\\n if num*k in dic:\\n count += dic[num*k]\\n return count\\n\\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"6098\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freq = {}\\n freq1 = {}\\n for num in nums1:\\n freq1[num] = freq1.get(num,0)+1\\n nums1 = set(nums1)\\n for num in nums1:\\n for i in range(1, 1 + int(math.sqrt(num))):\\n if num%i==0:\\n freq[i] = freq.get(i,0)+freq1[num]\\n if num%i==0 and num//i !=i:\\n freq[num//i] = freq.get(num//i,0)+freq1[num]\\n \\n count = 0\\n # nums2 = set(nums2)\\n # freq2 = {}\\n # for num in nums2:\\n # freq2[num] = freq2.get(num,0)+1\\n for num in nums2:\\n count+=(freq.get(num * k, 0) )\\n return count\",\n \"runtime\": \"6199\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n n = len(nums1)\\n m = len(nums2)\\n d2 = {}\\n for i in range(m):\\n t = k*nums2[i]\\n if t in d2:\\n d2[t]+=1\\n else :\\n d2[t]=1\\n \\n cnt = 0\\n # Special case for 1:\\n if 1 in d2:\\n cnt+=n*d2[1]\\n del d2[1]\\n seen = {}\\n for i in range(n):\\n if nums1[i] in seen:\\n cnt+=seen[nums1[i]]\\n continue\\n j = 2\\n ad = []\\n ad.append(nums1[i])\\n while j*j<=nums1[i]:\\n if nums1[i]%j==0:\\n ad.append(j)\\n if j*j < nums1[i]:\\n ad.append(nums1[i]//j)\\n j+=1\\n t_cnt = 0\\n for div in ad:\\n if div in d2:\\n t_cnt+=d2[div]\\n cnt+=t_cnt\\n seen[nums1[i]]=t_cnt\\n return cnt\",\n \"runtime\": \"6300\"\n },\n {\n \"code\": \"from math import floor\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n def getFactors(n):\\n ret = []\\n for i in range(1, floor(n**0.5)+1):\\n x, y = divmod(n, i)\\n if y == 0:\\n ret.append(i)\\n if i != x:\\n ret.append(x)\\n return ret\\n\\n ans = 0\\n for k1, v1 in c1.items():\\n for f in getFactors(k1):\\n if f % k == 0:\\n ans += c2[f // k] * v1\\n return ans\",\n \"runtime\": \"6401\"\n },\n {\n \"code\": \"\\nfrom collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # count factors of numbers in nums1\\n count = {}\\n ans = 0\\n nums1_map = Counter(nums1)\\n nums2_map = Counter(nums2)\\n for val, freq in nums1_map.items():\\n i = 1\\n while i * i <= val:\\n if i * i == val:\\n if i not in count:\\n count[i] = 0\\n count[i] += freq\\n elif val%i == 0:\\n if i not in count:\\n count[i] = 0\\n if val//i not in count:\\n count[val//i] = 0\\n count[i] += freq\\n count[val//i] += freq\\n i += 1\\n for val, freq in nums2_map.items():\\n factor = val * k\\n if factor in count:\\n ans += count[factor] * freq\\n return ans\",\n \"runtime\": \"6501\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution(object):\\n def numberOfPairs(self, nums1, nums2, k):\\n \\\"\\\"\\\"\\n :type nums1: List[int]\\n :type nums2: List[int]\\n :type k: int\\n :rtype: int\\n \\\"\\\"\\\"\\n s = defaultdict(int)\\n for i in nums2:\\n s[i*k]+=1 \\n \\n \\n cnt = 0\\n for i in nums1:\\n sqr = int(i**0.5) \\n for j in range(1,sqr+1):\\n if i%j == 0:\\n if j in s:\\n cnt += s[j]\\n # print(i,s[j])\\n if i//j in s:\\n cnt += s[i//j]\\n # print(i,s[i//j])\\n if i//j in s and sqr*sqr == i:\\n cnt -= s[i//j]\\n return cnt\",\n \"runtime\": \"6602\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n memo = defaultdict(int)\\n answer = 0\\n for num in nums2:\\n memo[num * k] += 1\\n \\n \\n def get_pair_cnt(n):\\n cnt = 0\\n root = int(n ** 0.5)\\n for i in range(1, root + 1):\\n if not n % i:\\n t = n // i\\n cnt += memo[i]\\n if t != i:\\n cnt += memo[t]\\n return cnt\\n \\n \\n for num in nums1:\\n answer += get_pair_cnt(num)\\n \\n return answer\\n \\n \",\n \"runtime\": \"6703\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution(object):\\n def numberOfPairs(self, nums1, nums2, k):\\n \\\"\\\"\\\"\\n :type nums1: List[int]\\n :type nums2: List[int]\\n :type k: int\\n :rtype: int\\n \\\"\\\"\\\"\\n s = defaultdict(int)\\n for num in nums2:\\n s[num * k] += 1\\n \\n cnt = 0\\n for num in nums1:\\n sqr = int(num ** 0.5)\\n for j in range(1, sqr + 1):\\n if num % j == 0:\\n if j in s:\\n cnt += s[j]\\n if num // j in s and j != num // j:\\n cnt += s[num // j]\\n return cnt\\n\",\n \"runtime\": \"6804\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # num2k = [x*k for x in nums2]\\n # nums1.sort()\\n # num2k.sort()\\n # for\\n mp = defaultdict(int)\\n for num in nums2:\\n mp[num * k] += 1\\n ans = 0\\n\\n for num in nums1:\\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n comp = num // i\\n if i in mp:\\n ans += mp[i]\\n if comp !=i and comp in mp:\\n ans += mp[comp]\\n return ans\",\n \"runtime\": \"6905\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nfrom typing import List\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n mp = defaultdict(int) \\n for num in nums2:\\n mp[num * k] += 1\\n\\n ans = 0\\n\\n for num in nums1:\\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n complement = num // i\\n if i in mp:\\n ans += mp[i]\\n if complement != i and complement in mp:\\n ans += mp[complement]\\n return ans\",\n \"runtime\": \"7006\"\n },\n {\n \"code\": \"# class Solution:\\n# def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n# \\\"\\\"\\\"\\n# n1 = [1,2,4,12]\\n \\n# n2 = [2,4]\\n\\n# k = 3\\n\\n# (n1 % k*n2) == 0\\n\\n# x * n1 = k * n2\\n# \\\"\\\"\\\"\\n# # ans = 0\\n# # for i in range(len(nums1)):\\n# # for j in range(len(nums2)):\\n# # if nums1[i] % (k * nums2[j]) == 0:\\n# # ans += 1\\n# # return ans\\n\\n# temp = defaultdict(int)\\n# for v in nums2:\\n# temp[k*v] += 1\\n \\n# ans = 0\\n# for i in range(len(nums1)):\\n# if nums1[i]%k != 0:\\n# continue\\n# j = 1\\n# while(j*j <= nums1[i]):\\n# if nums1[i]%j != 0:\\n# continue\\n# f1 = j\\n# f2 = nums1[i]//j\\n# ans += temp[f1]\\n# if f1 != f2:\\n# ans += temp[f2]\\n# j += 1\\n \\n# return ans\\nfrom collections import defaultdict\\nimport math\\nfrom typing import List\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n mp = defaultdict(int) \\n for num in nums2:\\n mp[num * k] += 1\\n\\n ans = 0\\n\\n for num in nums1:\\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n complement = num // i\\n if i in mp:\\n ans += mp[i]\\n if complement != i and complement in mp:\\n ans += mp[complement]\\n return ans\",\n \"runtime\": \"7107\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n d = defaultdict(int)\\n nums2 = [n * k for n in nums2]\\n for n in nums1:\\n for m in range(1, int(sqrt(n))+1):\\n if n % m : continue\\n v = n // m\\n d[m] += 1\\n d[v] += (1 if m != v else 0)\\n res = sum([d[x] for x in nums2])\\n return res\\n\\n\\n\\n\\n \",\n \"runtime\": \"7207\"\n },\n {\n \"code\": \"class Solution:\\n import math\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums2 = [num * k for num in nums2]\\n hashMap = {}\\n for num in nums2:\\n if num in hashMap:\\n hashMap[num] += 1\\n else:\\n hashMap[num] = 1\\n res = 0\\n for num in nums1:\\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n res += hashMap[i] if i in hashMap else 0\\n res += hashMap[num//i] if (num//i in hashMap) and (num//i != i) else 0\\n return res\\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"7308\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom typing import List\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # Create a hashmap to store counts of nums2[j] * k\\n divisor_count = defaultdict(int)\\n \\n # Populate the hashmap with counts of nums2[j] * k\\n for num in nums2:\\n divisor_count[num * k] += 1\\n \\n good_pairs = 0\\n \\n # For each number in nums1, find all its divisors and check against the hashmap\\n for num in nums1:\\n for j in range(1, int(num ** 0.5) + 1):\\n if num % j == 0:\\n # j is a divisor\\n if j in divisor_count:\\n good_pairs += divisor_count[j]\\n # num // j is also a divisor if it's different from j\\n if j != num // j and num // j in divisor_count:\\n good_pairs += divisor_count[num // j]\\n \\n return good_pairs\",\n \"runtime\": \"7409\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n from collections import defaultdict\\n import math\\n\\n # Step 1: Create a hash map for nums2[j] * k values\\n divisor_count = defaultdict(int)\\n for num2 in nums2:\\n divisor = num2 * k\\n divisor_count[divisor] += 1\\n\\n # Step 2: Count good pairs by checking divisibility\\n good_pairs = 0\\n\\n for num1 in nums1:\\n # Find all divisors of num1\\n sqrt_num1 = int(math.sqrt(num1))\\n for i in range(1, sqrt_num1 + 1):\\n if num1 % i == 0:\\n # i is a divisor\\n if i in divisor_count:\\n good_pairs += divisor_count[i]\\n # num1 // i is also a divisor, unless it's the same as i\\n if i != num1 // i and num1 // i in divisor_count:\\n good_pairs += divisor_count[num1 // i]\\n\\n return good_pairs\\n\\n \\n \\n \\n \",\n \"runtime\": \"7510\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1, nums2, k):\\n dict1, count = defaultdict(int), 0 \\n\\n for i in nums2:\\n dict1[i*k] += 1 \\n\\n def function(n):\\n res = 0 \\n\\n for i in range(1,int(sqrt(n))+1):\\n if n%i == 0:\\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\\n \\n return res \\n\\n for i in nums1:\\n count += function(i)\\n\\n return count \",\n \"runtime\": \"7611\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n def get_factors(n):\\n res = set()\\n curr = 1\\n while curr <= sqrt(n):\\n if n % curr == 0:\\n res.add(curr)\\n res.add(n // curr)\\n curr += 1\\n return res\\n ans = 0\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n for n in c1:\\n for factor in get_factors(n):\\n if factor % k == 0:\\n ans += c1[n] * c2[factor // k]\\n return ans\\n \",\n \"runtime\": \"7712\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n if num // potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[num // potential_divisor]\\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"runtime\": \"7813\"\n },\n {\n \"code\": \"from collections import defaultdict, Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n for i, n in enumerate(nums2):\\n nums2[i] *= k\\n nums2Count = Counter(nums2)\\n divisors = defaultdict(set)\\n ret = 0\\n for x in set(nums1):\\n divisors[x].add(x)\\n for i in range(1, int(x**0.5) + 1):\\n if i in divisors[x]: continue\\n else:\\n y = x // i\\n if (y * i) == x:\\n divisors[x].add(y)\\n divisors[x].add(i)\\n retDict = defaultdict(int)\\n for n in nums1:\\n if n in retDict:\\n ret += retDict[n]\\n continue\\n for d in divisors[n]:\\n if d in nums2Count:\\n ret += nums2Count[d]\\n retDict[n] += nums2Count[d]\\n return ret\",\n \"runtime\": \"7913\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1, nums2, k):\\n dict1, count = defaultdict(int), 0 \\n\\n for i in nums2:\\n dict1[i*k] += 1 \\n\\n def function(n):\\n res = 0 \\n\\n for i in range(1,int(sqrt(n))+1):\\n if n%i == 0:\\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\\n \\n return res \\n\\n for i in nums1:\\n count += function(i)\\n\\n return count \",\n \"runtime\": \"8014\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n if num // potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[num // potential_divisor]\\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\\n\",\n \"runtime\": \"8115\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n\\n hs = defaultdict(int)\\n\\n sm = 0\\n for n in nums1:\\n for j in range(1, int(n ** 0.5) + 1):\\n\\n if n % j == 0:\\n hs[j] += 1\\n\\n if j * j != n:\\n hs[n // j] += 1\\n \\n for n in nums2:\\n if n * k in hs:\\n sm += hs[n * k]\\n\\n return sm\",\n \"runtime\": \"8519\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n count = {}\\n for num in nums2:\\n if not num in count:\\n count[num] = 1\\n else:\\n count[num] += 1\\n \\n ans = 0\\n for num in nums1:\\n if num % k != 0:\\n continue\\n num = num // k\\n i = 1\\n while i * i <= num:\\n if num % i == 0:\\n ans += count.get(i, 0)\\n if i * i != num:\\n ans += count.get(num // i, 0)\\n i += 1\\n return ans\",\n \"runtime\": \"8519\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n complement_divisor: int = num // potential_divisor\\n ans += nums2_counter[complement_divisor]\\n if complement_divisor != potential_divisor:\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"runtime\": \"8619\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n complement_divisor: int = num // potential_divisor\\n ans += nums2_counter[complement_divisor]\\n if complement_divisor != potential_divisor:\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"runtime\": \"8619\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n factor_freq = defaultdict(int)\\n for n in nums1:\\n for i in range(1, int(sqrt(n)) + 1):\\n if n % i == 0:\\n factor_freq[i] += 1\\n if n / i != i:\\n factor_freq[n / i] += 1\\n res = 0\\n for n in nums2:\\n if n * k in factor_freq:\\n res += factor_freq[n*k]\\n return res\",\n \"runtime\": \"8720\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # # arr = []\\n # # for i in nums2:\\n # # arr.append(i*k)\\n # # m = Counter(arr)\\n # m = Counter(i*k for i in nums2)\\n\\n # def calc_factors(number, m):\\n # res = []\\n # # for i in range(1,number+1):\\n # # print(i)\\n # # if number%i == 0:\\n # # res.append(i)\\n # i = 1\\n # # while i<=sqrt(number):\\n # while i<=(number**0.5):\\n # if number%i == 0:\\n # res.append(m[i])\\n # if number//i != i:\\n # res.append(m[number//i])\\n # i+=1\\n # return res\\n\\n # ans = []\\n # for i in nums1:\\n # ans+=calc_factors(i,m)\\n # return sum(ans)\\n\\n arr = []\\n for i in nums1:\\n if i%k == 0:\\n arr.append(i//k)\\n \\n m = Counter(nums2)\\n\\n def factors(num,m):\\n res = 0\\n i = 1\\n while i*i <= num:\\n if num%i == 0:\\n res+=m[i]\\n if num//i != i:\\n res+=m[num//i]\\n i+=1\\n return res\\n\\n ans = 0\\n for i in arr:\\n ans+=factors(i,m)\\n return ans\\n\",\n \"runtime\": \"8720\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.dic = {}\\n\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n def factors(x):\\n for i in range(1, int(sqrt(x)) + 1):\\n if x % i == 0:\\n self.dic[i] = self.dic.get(i, 0) + 1\\n if i != x // i: # Avoid counting the square root twice if x is a perfect square\\n self.dic[x // i] = self.dic.get(x // i, 0) + 1\\n return\\n \\n for i in nums1:\\n factors(i)\\n result=0\\n for i in nums2:\\n if i*k in self.dic:\\n result+=self.dic[i*k]\\n return result\\n\\n\\n \\n \\n \",\n \"runtime\": \"8821\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1.sort()\\n nums2.sort()\\n\\n d = Counter([n * k for n in nums2])\\n res = 0\\n\\n for n in nums1:\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n res += d[i]\\n if n // i != i:\\n res += d[n // i]\\n\\n return res\\n\\n\",\n \"runtime\": \"8821\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":88,"string":"88"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n counter = Counter(nums1)\n minimum = min(nums1)\n maximum = max(nums1)\n result = 0\n for num in nums2:\n base = num * k\n multiply = 1 + (minimum - 1) // base\n while base * multiply <= maximum:\n target = base * multiply\n if target in counter:\n result += counter[target]\n\n multiply += 1\n\n return result","memory":"38400"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # pair is good if nums1[i] is divisible by nums2[j]*k\n \n nums2 = [num*k for num in nums2]\n nums1.sort()\n upperBound = max(nums1)\n ans = 0\n nums1_set = set(nums1)\n counter = Counter(nums1)\n \n for num2 in nums2:\n index = bisect.bisect_left(nums1, num2)\n \n if index == len(nums1):\n continue\n \n target = nums1[index]//num2 \n target = num2*target\n \n for x in range(target,upperBound+1,num2):\n if x in nums1_set:\n ans += counter[x]\n \n return ans\n \n \n \n ","memory":"39700"},{"code":"from collections import defaultdict\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1FactorCount = defaultdict(lambda: 0)\n \n for num1 in nums1:\n summerize(num1, nums1FactorCount, k)\n\n count = 0\n for num2 in nums2:\n if num2 in nums1FactorCount.keys():\n count += nums1FactorCount[num2]\n\n return count\n\ndef summerize(num1, nums1FactorCount, k):\n if num1 % k != 0:\n return\n \n num1 = num1 // k\n for i in range(1, int(sqrt(num1)) + 1):\n\n if num1 % i == 0:\n nums1FactorCount[i] += 1\n \n residual = num1 // i\n if residual * residual > num1:\n nums1FactorCount[residual] += 1\n \n","memory":"40700"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n def gd(n):\n d = set()\n for i in range(1, int(math.sqrt(n)) + 1):\n if n % i == 0:\n d.add(i)\n d.add(n//i)\n return d\n cnt = Counter()\n for n in nums1:\n if n % k == 0:\n a = gd(n//k)\n cnt.update(a)\n ans = 0\n for n in nums2:\n ans += cnt[n]\n return ans","memory":"40800"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n hm = defaultdict(lambda : 0)\n\n def find_factors(num): \n for i in range(1, int(math.sqrt(num)) + 1): \n if num % i == 0: \n # print(num, i)\n if i != num // i: \n hm[i] += 1 \n hm[num//i] += 1\n else:\n hm[i] += 1\n\n for num in nums1: \n find_factors(num)\n # print(hm)\n ret = 0\n for num in nums2: \n if num * k in hm: \n ret += hm[num * k]\n\n return ret\n\n","memory":"41600"},{"code":"from collections import defaultdict\nimport math\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n \n def fact(num):\n ans = set()\n for i in range(1,int(num**(0.5))+1):\n if num % i == 0:\n ans.add(i)\n ans.add(num // i)\n return list(ans)\n \n dic = defaultdict(int)\n\n for num in nums1:\n if num % k == 0:\n all_fact = fact(num)\n for ele in all_fact:\n dic[ele] += 1\n \n count = 0\n \n for num in nums2:\n if num*k in dic:\n count += dic[num*k]\n return count\n\n\n \n\n\n \n ","memory":"42300"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1D = {n:0 for n in nums1} \n nums2D = {n*k:0 for n in nums2}\n for n in nums1:\n nums1D[n] +=1 \n for n in nums2:\n nums2D[n*k] +=1 \n max_num1 = max(nums1)+1\n out = 0\n for n in nums2D:\n for i in range(n,max_num1,n):\n if i in nums1D:\n out+=nums1D[i]*nums2D[n]\n return out","memory":"42500"},{"code":"import functools\nclass Solution:\n def numberOfPairs(self, nn1: List[int], nn2: List[int], k: int) -> int:\n max_nums1 = max(nn1)\n cnt1 = collections.Counter(nn1)\n cnt2 = collections.Counter(nn2)\n res = 0\n for n, f in cnt2.items():\n mol = 1\n while mol * k * n <= max_nums1:\n res += cnt1[mol * k * n] * f\n mol += 1\n return res","memory":"42600"},{"code":"class Solution3:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n a_nums2=Counter(nums2)\n c=0\n \n for i in nums1:\n for j in a_nums2.keys():\n if i%(j*k)==0:\n c+=a_nums2[j]\n return c\nclass Solution2:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n a=Counter(nums1)\n b=Counter(nums2)\n c=0\n for i in a:\n if i*k in b:\n c+=a[i]*b[i*k]\n return c\n\n\nclass Solution1:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n multiplied_counts = Counter(num * k for num in nums2)\n count = 0\n for num in nums1:\n for key in multiplied_counts:\n if num % key == 0:\n count += multiplied_counts[key]\n \n return count\n\nclass Solution0:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n a= defaultdict(int)\n \n for num in nums2:\n a[num * k] += 1\n \n count = 0\n for num in nums1:\n \n for div in a:\n if num % div == 0:\n count += a[div]\n \n return count\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n max_num1 = max(nums1)\n res = 0\n nums_1 = Counter(nums1)\n nums_2 = Counter(nums2)\n for num2 in nums_2:\n mul = 1\n while num2 * k * mul <= max_num1:\n res += nums_2[num2] * nums_1[num2 * k * mul]\n mul += 1\n return res\n\n ","memory":"42700"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n freq1 = Counter(x//k for x in nums1 if x%k == 0)\n\n if not freq1:\n return 0\n\n freq2 = Counter(nums2)\n\n res = 0\n maxMultiple = max(freq1)\n\n for num2, count in freq2.items():\n cur = sum(freq1[y] for y in range(num2, maxMultiple+1, num2))\n res += cur * count\n \n return res\n\n\n\n \n \n","memory":"42800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n max_num = max(nums1)\n counter1 = Counter(nums1)\n counter2 = Counter(nums2)\n count = 0\n\n for num in counter2:\n mul = 1\n while num * mul * k <= max_num:\n count += counter2[num] * counter1[num * mul * k]\n mul += 1\n return count","memory":"42900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n def get_factors(n):\n res = set()\n curr = 1\n while curr <= sqrt(n):\n if n % curr == 0:\n res.add(curr)\n res.add(n // curr)\n curr += 1\n return res\n ans = 0\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n for n in c1:\n for factor in get_factors(n):\n if factor % k == 0:\n ans += c1[n] * c2[factor // k]\n return ans\n ","memory":"43000"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n ret = 0\n C1,C2 = collections.Counter(n//k for n in nums1 if n%k==0),collections.Counter(nums2)\n for n in C1:\n sq = int(n**0.5)\n if sq**2 == n:\n ret += C1[n]*C2[sq]\n else:\n sq += 1\n for d in range(1,sq):\n if n%d == 0:\n ret += C1[n]*(C2[d]+C2[n//d])\n return ret","memory":"43100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n\n\n def get_factors(n):\n factors = set()\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n factors.add(i)\n factors.add(n // i)\n return factors\n\n\n factor_map = defaultdict(int)\n \n # Precompute factors of nums1 and store in factor_map\n for num in nums1:\n # Get all factors of num\n factors = get_factors(num)\n # Increment count for each factor\n for factor in factors:\n factor_map[factor] += 1\n \n count = 0\n \n # Now check each number in nums2\n for num in nums2:\n target = num * k\n # Check if target divides any of the factors in nums1\n if target in factor_map:\n count += factor_map[target]\n \n return count\n\n ","memory":"43200"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n hash2 = {}\n for i in range(len(nums2)):\n hash2[nums2[i]*k] = 1 + hash2.get(nums2[i]*k, 0)\n \n # print(hash2)\n goodPairs = 0\n for j in range(len(nums1)):\n # if( nums1[j] % k == 0 ):\n sr = int(sqrt(nums1[j]))\n for i in range(1,sr+1):\n # print(i)\n # print(k*i)\n # print(nums1[j])\n if( nums1[j] % i == 0):\n # print(\"la\")\n goodPairs += hash2.get(i, 0)\n if( i != nums1[j]/i):\n # print(\"ba\")\n goodPairs += hash2.get(nums1[j] / i, 0)\n # print(goodPairs)\n return goodPairs\n","memory":"43300"},{"code":"from collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n counter2 = Counter(nums2)\n counter1 = Counter(nums1)\n \n set1 = set(counter1.keys())\n max1 = max(set1)\n ans = 0\n for num2 in counter2.keys():\n \n for i in range(max1//(num2*k)+1):\n num1 = num2*k*i\n if num1 in set1:\n ans += counter2[num2] * counter1[num1]\n return ans\n \n# counter1 = Counter(nums1)\n \n# # for num in counter1:\n# # if num % k != 0: counter1[num] = 0\n# # counter1 = dict(sorted(counter1.items()))\n \n# counter2 = Counter(nums2)\n# counter2 = dict(sorted(counter2.items()))\n# minNum2 = min(nums2)\n \n# cnt = 0\n# for num1, cnt1 in counter1.items():\n# if cnt1 == 0:\n# continue\n# if num1 < minNum2: continue\n# for num2, cnt2 in counter2.items():\n# if num2 > num1: break\n# if num1 % (num2 * k) == 0:\n# cnt += cnt1 * cnt2\n# return cnt","memory":"43400"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = Counter(nums2)\n res = 0\n cache = {}\n \n for num in nums1:\n if num%k!=0:\n continue\n if num in cache:\n res+=cache[num]\n continue\n \n cur = 0\n num = num / k\n \n for i in range(1, int(math.sqrt(num)) + 1):\n if num % i == 0:\n cur += cnt[i]\n cur += cnt[num // i] if i!=num//i else 0\n cache[num*k] = cur\n # print(num, cur)\n res+=cur\n return res","memory":"43500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n hashmap = {}\n for n in nums1:\n for i in range(1,int(sqrt(n))+1):\n if n%i==0:\n if i not in hashmap:\n hashmap[i] =1 \n else:\n hashmap[i] +=1\n if i!=n//i:\n if n//i not in hashmap:\n hashmap[n//i] =1 \n else:\n hashmap[n//i] +=1 \n \n ans =0\n for i in nums2:\n if k*i in hashmap:\n ans = ans + hashmap[k*i]\n return ans","memory":"43600"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n\n hs = defaultdict(int)\n\n sm = 0\n for n in nums1:\n for j in range(1, int(n ** 0.5) + 1):\n\n if n % j == 0:\n hs[j] += 1\n\n if j * j != n:\n hs[n // j] += 1\n \n for n in nums2:\n if n * k in hs:\n sm += hs[n * k]\n\n return sm","memory":"43700"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n complement_divisor: int = num // potential_divisor\n if complement_divisor in nums2_counter.keys():\n ans += nums2_counter[complement_divisor]\n if complement_divisor != potential_divisor and potential_divisor in nums2_counter.keys():\n ans += nums2_counter[potential_divisor]\n \n return ans","memory":"44100"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n if num // potential_divisor in nums2_counter.keys():\n ans += nums2_counter[num // potential_divisor]\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\n ans += nums2_counter[potential_divisor]\n \n return ans","memory":"44100"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n if num // potential_divisor in nums2_counter.keys():\n ans += nums2_counter[num // potential_divisor]\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\n ans += nums2_counter[potential_divisor]\n \n return ans\n","memory":"44300"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freq = {}\n freq1 = {}\n for num in nums1:\n freq1[num] = freq1.get(num,0)+1\n nums1 = set(nums1)\n for num in nums1:\n for i in range(1, 1 + int(math.sqrt(num))):\n if num%i==0:\n freq[i] = freq.get(i,0)+freq1[num]\n if num%i==0 and num//i !=i:\n freq[num//i] = freq.get(num//i,0)+freq1[num]\n \n count = 0\n # nums2 = set(nums2)\n # freq2 = {}\n # for num in nums2:\n # freq2[num] = freq2.get(num,0)+1\n for num in nums2:\n count+=(freq.get(num * k, 0) )\n return count","memory":"44400"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n complement_divisor: int = num // potential_divisor\n ans += nums2_counter[complement_divisor]\n if complement_divisor != potential_divisor:\n ans += nums2_counter[potential_divisor]\n \n return ans","memory":"44500"},{"code":"import bisect # noqa\nimport heapq # noqa\nimport math # noqa\nimport statistics # noqa\nimport sys\nfrom bisect import bisect_left as lower_bound\nfrom bisect import bisect_right as upper_bound\nfrom collections import Counter, defaultdict, deque # noqa\nfrom datetime import datetime # noqa\nfrom fractions import Fraction # noqa\nfrom functools import lru_cache # noqa\nfrom itertools import ( # noqa\n permutations, combinations # difference is that order matters for permutations but not for combinations\n)\nfrom typing import List, Optional # noqa\n\n# allow big recursion\nsys.setrecursionlimit(10**5)\n\n# Magic no recursion\nfrom types import GeneratorType # noqa\ndef bootstrap(f, stack=[]): # noqa\n def wrappedfunc(*args, **kwargs):\n if stack:\n return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n else:\n stack.pop()\n if not stack:\n break\n to = stack[-1].send(to)\n return to\n\n return wrappedfunc\n\ndef partitions(partitions_n: int):\n partitions_a = [0 for _ in range(partitions_n + 1)]\n k_ = 1\n y_ = partitions_n - 1\n while k_ != 0:\n x_ = partitions_a[k_ - 1] + 1\n k_ -= 1\n while 2 * x_ <= y_:\n partitions_a[k_] = x_\n y_ -= x_\n k_ += 1\n l_ = k_ + 1\n while x_ <= y_:\n partitions_a[k_] = x_\n partitions_a[l_] = y_\n yield partitions_a[: k_ + 2]\n x_ += 1\n y_ -= 1\n partitions_a[k_] = x_ + y_\n y_ = x_ + y_ - 1\n yield partitions_a[: k_ + 1]\n\ndef get_lps(string: str) -> list[int]:\n lps: list[int] = [0] * len(string)\n length: int = 0\n i: int = 1\n while i < len(string):\n if string[i] == string[length]:\n length += 1\n lps[i] = length\n i += 1\n else:\n if length != 0:\n length = lps[length - 1]\n else:\n lps[i] = 0\n i += 1\n return lps\n\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\n hash_prefixes: list[int] = [0] * (n + 1)\n powers: list[int] = [1] * (n + 1)\n for i in range(1, n + 1):\n powers[i] = (powers[i - 1] * p) % mod\n for i in range(n):\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\"a\") + 1)) % mod\n return hash_prefixes, powers\n\ndef gen_suffix_array(s_: str) -> list[int]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n return p\n\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\n count: list[int] = [0 for _ in range(len(p_))]\n for x in p_:\n count[c_[x]] += 1\n new_p: list[int] = p_.copy()\n pos: list[int] = [0 for _ in range(len(p_))]\n for i in range(1, len(p_)):\n pos[i] = pos[i-1] + count[i-1]\n for x in p_:\n new_p[pos[c_[x]]] = x\n pos[c_[x]] += 1\n\n return new_p\n s_ += \"$\"\n n: int = len(s_)\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\n a.sort(key=lambda x: x[0])\n p: list[int] = [a[i][1] for i in range(n)]\n c: list[int] = [0] * n\n c[p[0]] = 0\n for i in range(1, n):\n if a[i][0] == a[i-1][0]:\n c[p[i]] = c[p[i-1]]\n else:\n c[p[i]] = c[p[i-1]] + 1\n k: int = 1\n while (1 << k) <= 2*n:\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\n p = radix_sort(p, c)\n\n c_new: list[int] = [0] * n\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\n for i in range(1, n):\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\n if prev == curr:\n c_new[p[i]] = c_new[p[i-1]]\n else:\n c_new[p[i]] = c_new[p[i-1]] + 1\n prev = curr\n c = c_new\n k += 1\n if c_new[p[n-1]] == n - 1:\n break\n\n lcp: list[int] = [0] * (n-1)\n k: int = 0\n for i in range(n-1):\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \n # compare it to.\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\n # pi is never 0 because the suffix at 0 is $\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\n while s_[i+k] == s_[j+k]:\n k += 1\n lcp[pi-1] = k\n k = max(k-1, 0)\n\n return p, lcp\n\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\n\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\n max_n = min(max_n, mod - 1)\n\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\n fact[0] = 1\n for i in range(max_n):\n fact[i + 1] = fact[i] * (i + 1) % mod\n\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\n for i in reversed(range(max_n)):\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\n\n def nCr_mod(n, r):\n res = 1\n while n or r:\n a, b = n % mod, r % mod\n if a < b:\n return 0\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\n n //= mod\n r //= mod\n return res\n\n return nCr_mod\n\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\n # k inclusive, n inclusive\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\n\nclass FenwickTree:\n def __init__(self, x):\n bit = self.bit = list(x)\n size = self.size = len(bit)\n for i in range(size):\n j = i | (i + 1)\n if j < size:\n bit[j] += bit[i]\n\n def update(self, idx, x):\n \"\"\"updates bit[idx] += x\"\"\"\n while idx < self.size:\n self.bit[idx] += x\n idx |= idx + 1\n\n def __call__(self, end):\n \"\"\"calc sum(bit[:end])\"\"\"\n x = 0\n while end:\n x += self.bit[end - 1]\n end &= end - 1\n return x\n\n def find_kth(self, k):\n \"\"\"Find largest idx such that sum(bit[:idx]) <= k\"\"\"\n idx = -1\n for d in reversed(range(self.size.bit_length())):\n right_idx = idx + (1 << d)\n if right_idx < self.size and self.bit[right_idx] <= k:\n idx = right_idx\n k -= self.bit[idx]\n return idx + 1, k\n\nclass SortedList:\n block_size = 700\n\n def __init__(self, iterable=()):\n self.macro = []\n self.micros = [[]]\n self.micro_size = [0]\n self.fenwick = FenwickTree([0])\n self.size = 0\n for item in iterable:\n self.insert(item)\n\n def insert(self, x):\n i = lower_bound(self.macro, x)\n j = upper_bound(self.micros[i], x)\n self.micros[i].insert(j, x)\n self.size += 1\n self.micro_size[i] += 1\n self.fenwick.update(i, 1)\n if len(self.micros[i]) >= self.block_size:\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\n self.fenwick = FenwickTree(self.micro_size)\n self.macro.insert(i, self.micros[i + 1][0])\n\n def pop(self, k=-1):\n i, j = self._find_kth(k)\n self.size -= 1\n self.micro_size[i] -= 1\n self.fenwick.update(i, -1)\n return self.micros[i].pop(j)\n\n def __getitem__(self, k):\n i, j = self._find_kth(k)\n return self.micros[i][j]\n\n def count(self, x):\n return self.upper_bound(x) - self.lower_bound(x)\n\n def __contains__(self, x):\n return self.count(x) > 0\n\n def lower_bound(self, x):\n i = lower_bound(self.macro, x)\n return self.fenwick(i) + lower_bound(self.micros[i], x)\n\n def upper_bound(self, x):\n i = upper_bound(self.macro, x)\n return self.fenwick(i) + upper_bound(self.micros[i], x)\n\n def _find_kth(self, k):\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\n\n def __len__(self):\n return self.size\n\n def __iter__(self):\n return (x for micro in self.micros for x in micro)\n\n def __repr__(self):\n return str(list(self))\n\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\n # nums2_count: Counter = Counter(nums2)\n # nums2 = list(sorted(set(nums2)))\n # num: int\n # for num in nums2:\n # i: int = 1\n # while k * num * i <= max(nums1):\n # sieve[k * num * i] += nums2_count[num]\n # i += 1\n # \n # ans: int = 0\n # for num in nums1:\n # ans += sieve[num]\n \n nums2 = [nums2[i] * k for i in range(len(nums2))]\n nums2_counter: Counter = Counter(nums2)\n \n ans: int = 0\n for num in nums1:\n for potential_divisor in range(1, int(num**0.5) + 1):\n if num % potential_divisor == 0:\n complement_divisor: int = num // potential_divisor\n ans += nums2_counter[complement_divisor]\n if complement_divisor != potential_divisor:\n ans += nums2_counter[potential_divisor]\n \n return ans","memory":"44500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n factorcount=collections.defaultdict(int)\n for i in range(len(nums1)):\n for j in range(1,int(sqrt(nums1[i]))+1):\n if nums1[i]%j==0:\n factorcount[j]+=1\n if (nums1[i]//j)!=(j):\n factorcount[nums1[i]//j]+=1\n nums2=[num*k for num in nums2]\n count=0\n print(factorcount,nums2)\n for num in nums2:\n if num in factorcount:\n count+=factorcount[num]\n return count","memory":"45600"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n factorcount=collections.defaultdict(int)\n for i in range(len(nums1)):\n for j in range(1,int(sqrt(nums1[i]))+1):\n if nums1[i]%j==0:\n factorcount[j]+=1\n if (nums1[i]//j)!=(j):\n factorcount[nums1[i]//j]+=1\n nums2=[num*k for num in nums2]\n count=0\n print(factorcount,nums2)\n for num in nums2:\n if num in factorcount:\n count+=factorcount[num]\n return count","memory":"45600"},{"code":"from collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [i//k for i in nums1 if i % k == 0]\n oc1, nums1 = Counter(nums1), sorted(list(set(nums1)))\n oc2, nums2 = Counter(nums2), sorted(list(set(nums2)))\n # print(nums1, nums2)\n re = 0\n for i in nums1:\n for j in range(1, int(sqrt(i)) + 1):\n if i % j == 0:\n re += oc1[i] * oc2[j]\n if i//j != j:\n re += oc1[i] * oc2[i//j]\n return re\n ","memory":"48200"},{"code":"from collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n count = 0\n nums1_count = Counter(nums1)\n nums2_count = Counter(nums2)\n factors = {}\n for i in nums1_count.keys():\n if i % k != 0:\n continue\n for j in range(1, math.floor(math.sqrt(i)) + 1):\n if i % j == 0:\n factors[j] = factors.get(j, 0) + nums1_count[i]\n # factors.setdefault(j, 0) += 1\n if i // j != j:\n factors[i // j] = factors.get(i // j, 0) + nums1_count[i]\n # factors.setdefault(i // j, 0) += 1\n print(factors)\n for j in nums2_count.keys():\n count += factors.get(j * k, 0) * nums2_count[j]\n return count","memory":"48300"},{"code":"import collections\nimport heapq\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\n d = collections.defaultdict(int)\n d1 = collections.Counter(nums1)\n d2 = collections.Counter(nums2)\n\n for k, v in d1.items():\n if k % n != 0:\n continue\n bound = int(sqrt(k))\n for i in range(1, bound + 1):\n if i*i == k:\n d[i] += v\n elif k % i == 0:\n d[i] += v\n d[k//i] += v\n \n count = 0\n for k, v in d2.items():\n if k*n in d.keys():\n count += v * d[k*n]\n return count\n\n ","memory":"48400"},{"code":"import collections\nimport heapq\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\n d = collections.defaultdict(int)\n d1 = collections.Counter(nums1)\n d2 = collections.Counter(nums2)\n\n for k, v in d1.items():\n if k % n != 0:\n continue\n bound = int(sqrt(k))\n for i in range(1, bound + 1):\n if i*i == k:\n d[i] += v\n elif k % i == 0:\n d[i] += v\n d[k//i] += v\n \n count = 0\n for k, v in d2.items():\n if k*n in d.keys():\n count += v * d[k*n]\n return count\n\n ","memory":"48500"},{"code":"\nfrom collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # count factors of numbers in nums1\n count = {}\n ans = 0\n nums1_map = Counter(nums1)\n nums2_map = Counter(nums2)\n for val, freq in nums1_map.items():\n i = 1\n while i * i <= val:\n if i * i == val:\n if i not in count:\n count[i] = 0\n count[i] += freq\n elif val%i == 0:\n if i not in count:\n count[i] = 0\n if val//i not in count:\n count[val//i] = 0\n count[i] += freq\n count[val//i] += freq\n i += 1\n for val, freq in nums2_map.items():\n factor = val * k\n if factor in count:\n ans += count[factor] * freq\n return ans","memory":"49500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n\n counter = collections.defaultdict(int)\n for num in nums2:\n counter[num] +=1\n \n result = 0\n for num in nums1:\n if(num % k ==0):\n residue_num = num // k\n for factor in range(1, int(pow(residue_num, 0.5)) +1):\n if(residue_num % factor ==0):\n factor1 = factor\n factor2 = residue_num // factor\n result += counter[factor1]\n if(factor2 != factor1):\n result += counter[factor2]\n \n return result\n\n","memory":"50700"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freq = Counter(num*k for num in nums2)\n mx1 = max(nums1)\n numbers1 = [0]*(mx1+1)\n for i in nums1:\n numbers1[i] += 1\n ans = 0\n for i, cnt in freq.items():\n f = 1\n while f*i<=mx1:\n ans += numbers1[f*i]*(cnt)\n f += 1\n return ans\n ","memory":"51100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n factors = defaultdict(int)\n\n for i in range(len(nums2)):\n factors[nums2[i]]+=1\n\n res = 0\n\n for i in range(len(nums1)):\n if nums1[i]%k == 0:\n temp = nums1[i]//k\n for j in range(1, int(math.sqrt(temp))+1):\n if temp%j == 0:\n res+=factors[j]\n if temp//j != j:\n res+=factors[temp//j]\n\n return res\n\n \n \n \n ","memory":"51900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = defaultdict(int)\n for i in nums1:\n if i % k: continue\n i //= k\n for d in range(1, isqrt(i) + 1):\n if i % d: continue\n cnt[d] += 1\n if d * d < i:\n cnt[i // d] += 1\n res = 0\n for j in nums2:\n res += cnt[j]\n return res","memory":"52300"},{"code":"\nfrom collections import Counter\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # count factors of numbers in nums1\n count = {}\n ans = 0\n nums1 = [x//k for x in nums1 if x%k == 0]\n nums1_map = Counter(nums1)\n nums2_map = Counter(nums2)\n for val, freq in nums1_map.items():\n i = 1\n while i * i <= val:\n if i * i == val:\n if i not in count:\n count[i] = 0\n count[i] += freq\n elif val%i == 0:\n if i not in count:\n count[i] = 0\n if val//i not in count:\n count[val//i] = 0\n count[i] += freq\n count[val//i] += freq\n i += 1\n for val, freq in nums2_map.items():\n \n if val in count:\n ans += count[val] * freq\n return ans","memory":"52800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1D = {n:0 for n in nums1}\n for n in nums1:\n nums1D[n] +=1\n def find_factor(i):\n if i == 1: return [1]\n out = [] \n for f in range(1,int(i**0.5)+1): \n if i%f == 0:\n out.append(f)\n if i//f!=f:\n out.append(i//f)\n return out\n nums_factor = {}\n for n in nums1D:\n factors = find_factor(n)\n # print(n,factors)\n for f in factors:\n if f not in nums_factor:\n nums_factor[f] = 0\n nums_factor[f]+=nums1D[n]\n \n nums2D = {n*k:0 for n in nums2}\n for n in nums2:\n nums2D[n*k] +=1\n # print(nums2D,nums_factor)\n out = 0 \n for n in nums2D:\n if n in nums_factor:\n out += nums2D[n]*nums_factor[n]\n return out","memory":"52900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [el//k for el in nums1 if el % k == 0]\n dct = defaultdict(int)\n for el in nums2:\n dct[el]+=1\n res= 0\n def main(x):\n nonlocal res\n for i in range(1, math.floor(math.sqrt(x)) + 1):\n if x % i == 0:\n dv=x//i\n res += dct[i] + dct[dv]\n if i == dv:\n res -= dct[i]\n for x in nums1:\n main(x)\n return res","memory":"53800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\n # this implies that a good pair is divisible by both k and by nums2[j]\n # we must only consider numbers divisible by k and for all other numbers\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\n # for some x that we can factor out\n\n freq = collections.defaultdict(int)\n for v in nums2:\n freq[v*k] += 1\n\n def isqrt(x: int) -> int:\n return int(x ** 0.5)\n\n def factor(x: int) -> List[int]:\n factors = []\n for i in range(1, isqrt(x) + 1):\n if x % i == 0:\n factors.append(i)\n return factors\n \n result = 0\n for x in nums1:\n if x % k != 0:\n continue\n for f in factor(x):\n result += freq[f]\n if x // f != f:\n result += freq[x // f]\n return result\n","memory":"54200"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\n # this implies that a good pair is divisible by both k and by nums2[j]\n # we must only consider numbers divisible by k and for all other numbers\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\n # for some x that we can factor out\n\n freq = collections.defaultdict(int)\n for v in nums2:\n freq[v*k] += 1\n\n def isqrt(x: int) -> int:\n return int(x ** 0.5)\n\n def factor(x: int) -> List[int]:\n factors = []\n for i in range(1, isqrt(x) + 1):\n if x % i == 0:\n factors.append(i)\n return factors\n \n result = 0\n for x in nums1:\n for f in factor(x):\n result += freq[f]\n if x // f != f:\n result += freq[x // f]\n return result\n","memory":"54900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # if x < k, x % k is not 0 for sure, \n # 24 % 12 \n # 12 = 3 * 4 = 3 * 2 * 2 \n # 12 is divisible by 3 or 2 or 4 \n # count of potential divisors for nums2\n freq_divisors = defaultdict(int)\n for num2 in nums2:\n freq_divisors[num2 * k] += 1\n\n ans = 0\n for num in nums1: # find all the divisors for this num and see how many are there in freq_divisors\n for i in range(1, int(sqrt(num))+ 1):\n if num % i == 0: # it's a possible divisor\n ans += freq_divisors[i]\n if i != num//i:\n ans += freq_divisors[num//i]\n return ans","memory":"55000"},{"code":"class Solution:\n def numberOfPairs(self, nums1, nums2, k):\n dict1, count = defaultdict(int), 0 \n\n for i in nums2:\n dict1[i*k] += 1 \n\n def function(n):\n res = 0 \n\n for i in range(1,int(sqrt(n))+1):\n if n%i == 0:\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\n \n return res \n\n for i in nums1:\n count += function(i)\n\n return count ","memory":"55100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n count = defaultdict(int)\n for n in nums2:\n count[n*k]+=1\n print (count)\n\n ans = 0 \n def divisorsCount(n) : \n res = 0\n for i in range(1,int(sqrt(n))+1):\n if n%i==0:\n res+=count[i]+(count[n//i] if n//i!=i else 0)\n return res\n \n for n in nums1:\n ans+=divisorsCount(n)\n \n return ans\n\n# class Solution:\n# def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n# pair = 0 \n \n# for i in range(len(nums1)):\n# for j in range(len(nums2)):\n# current = nums2[j]*k\n# if nums1[i]% (nums2[j]*k)==0:\n# pair = pair+1\n# return pair\n \n'''\n[1,3,4]\n[1,3,4]\n1\n\n\n'''","memory":"55200"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n memo = defaultdict(int)\n answer = 0\n for num in nums2:\n memo[num * k] += 1\n \n \n def get_pair_cnt(n):\n cnt = 0\n root = int(n ** 0.5)\n for i in range(1, root + 1):\n if not n % i:\n t = n // i\n cnt += memo[i]\n if t != i:\n cnt += memo[t]\n return cnt\n \n \n for num in nums1:\n answer += get_pair_cnt(num)\n \n return answer\n \n ","memory":"55300"},{"code":"#nums[i] // nums[j] * k\n#we can remember nums1 / k: frequency[nums1 / k]\n\ndef get_divisors(n):\n divisors = set()\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n divisors.add(i)\n divisors.add(n // i)\n return divisors\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n divisor_count = defaultdict(int)\n good_pairs = 0\n\n for num in nums1:\n divisors = get_divisors(num)\n for d in divisors:\n divisor_count[d] += 1\n \n for num in nums2:\n good_pairs += divisor_count[num * k]\n \n return good_pairs","memory":"55400"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n def get_factors(x):\n factors = set([])\n pause = int(math.sqrt(x))\n for i in range(1, 1+pause):\n if x%i==0:\n factors.add(i)\n factors.add(x//i)\n return factors\n\n nums2 = [k*x for x in nums2]\n counter = defaultdict(int)\n\n for num in nums2:\n counter[num]+=1\n \n ans = 0\n\n for num in nums1:\n factors = get_factors(num)\n for factor in factors:\n ans+=counter[factor]\n return ans\n ","memory":"55500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n c1, c2 = collections.defaultdict(int), collections.defaultdict(int)\n for num in nums1:\n c1[num] += 1\n for num in nums2:\n c2[num * k] += 1\n\n res = 0\n\n for num in c1:\n sr = int(math.sqrt(num))\n for n in range(1, sr + 1):\n if num % n:\n continue\n res += c1[num] * c2[n]\n if n != num // n: # sqrt\n res += c1[num] * c2[num // n] \n\n return res\n","memory":"57400"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \n # nums2 * k\n # check each num in nums2, count answer\n # for each num in nums1, we make table[factor] += 1\n \n table = defaultdict(int) #factor: number\n \n counter1 = Counter(nums1)\n \n def factors(num):\n res = []\n for x in range(1, isqrt(num) + 1):\n if num % x == 0:\n res.append(x)\n y = num // x\n if y != x:\n res.append(y)\n return res\n \n for num in counter1:\n for x in factors(num):\n table[x] += counter1[num]\n \n res = 0\n for num in nums2:\n num *= k\n res += table[num]\n \n return res\n \n \n \n ","memory":"57500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n cnt = 0\n factors = collections.defaultdict(int)\n nums1ctr = collections.Counter(nums1)\n nums2ctr = collections.Counter(nums2)\n for n,amt in nums1ctr.items():\n if not n%k == 0:\n continue\n i = 1\n while i*i <= n:\n if(i*i == n):\n factors[i] += amt\n elif (n%i == 0):\n factors[i] += amt\n factors[n/i] += amt\n i += 1\n for n,amt in nums2ctr.items():\n cnt += (amt*factors[n*k])\n return cnt","memory":"61100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n d1 = defaultdict(int)\n c1 = Counter(nums1)\n c2 = Counter(nums2)\n\n for c, f in c1.items():\n bound = int(sqrt(c))\n for i in range(1, bound + 1):\n if i * i == c:\n d1[i] += f\n elif c % i == 0:\n d1[i] += f\n d1[c // i] += f\n res = 0\n for c, f in c2.items():\n res += d1[c * k] * f\n return res","memory":"62500"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n res = 0\n freq = defaultdict(int)\n for n in nums2:\n freq[n * k] += 1\n counts = [0] * (max(nums1) + 1)\n for n, cnt in freq.items():\n for m in range(n, len(counts), n):\n counts[m] += cnt\n return sum(counts[n] for n in nums1)","memory":"62700"},{"code":"# Data Structure: Counter for frequencies, array to store counts of multiples\n# Algorithm: Process nums2 to count the occurrences of multiples of nums2[j] * k, and use an array to accumulate counts for valid multiples in nums1\n\n# Short Intuition:\n# We are searching for pairs where nums1[i] is divisible by nums2[j] * k. Instead of checking each pair, we first calculate how often each multiple appears in nums1 and then sum up the valid counts.\n\n# Detailed Intuition:\n# - We first count how many multiples of each number from nums2 * k appear in nums1.\n# - For each element in nums2 multiplied by k, we track how many of its multiples are in nums1.\n# - Instead of directly checking for pairs, we count multiples using an array and sum over these counts for efficiency.\n\n# Pseudo Code:\n# 1. Use a Counter to store frequencies of nums2 * k.\n# 2. Initialize a counts array to track the frequency of each multiple for nums1.\n# 3. For each number in nums2 * k, update the counts for all multiples of that number.\n# 4. Finally, sum the counts for each element in nums1 to get the total number of good pairs.\n\nfrom typing import List\nfrom collections import Counter\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # Step 1: Create a frequency counter for nums2 elements multiplied by k\n freqs = Counter(num * k for num in nums2)\n \n # Step 2: Initialize a counts array to track counts for multiples\n max_value = max(nums1) # Find the maximum value in nums1\n counts = [0] * (max_value + 1)\n\n print(freqs)\n # Step 3: For each number in freqs, update counts for all multiples of that number\n for num, count in freqs.items():\n for multiplier in range(num, len(counts), num):\n counts[multiplier] += count\n\n # Step 4: Return the total number of good pairs by summing counts for all elements in nums1\n return sum(counts[num] for num in nums1)\n\n# Time Complexity: O(n log n), where n is the length of the largest number in nums1.\n# Explanation: The time complexity is bounded by the harmonic series when summing over multiples for each value in nums2.\n\n# Space Complexity: O(n), where n is the length of the largest number in nums1.\n# Explanation: We use a counts array to track the number of valid multiples in nums1.\n","memory":"63000"},{"code":"from collections import Counter\n\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n dp = [0] * (max(nums1) + 1)\n f = Counter(nums2)\n print(len(nums1))\n print(len(nums2))\n # print(f)\n for n, freq in f.items():\n i = n * k\n while i < len(dp):\n dp[i] += freq\n i += n * k\n \n tot = 0\n c2 = Counter(nums1)\n for n, freq in c2.items():\n tot += dp[n] * freq\n \n return tot","memory":"63100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n M = max(nums1) + 1\n y_counts = [0 for _ in range(M)]\n for y, y_count in collections.Counter(nums2).items():\n for i in range(y*k, M, y*k):\n y_counts[i] += y_count\n return sum(\n y_counts[x] * x_count\n for x, x_count in collections.Counter(nums1).items()\n )","memory":"63800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n M = max(nums1) + 1\n y_counts = [0 for _ in range(M)]\n for y, y_count in collections.Counter(nums2).items():\n for i in range(y*k, M, y*k):\n y_counts[i] += y_count\n return sum(\n y_counts[x] * x_count\n for x, x_count in collections.Counter(nums1).items()\n )","memory":"63800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n maxnums1: int = max(nums1)\n \n sieve: list[int] = [0 for _ in range(maxnums1 + 1)]\n nums2_count: Counter = Counter(nums2)\n nums2 = list(sorted(set(nums2)))\n num: int\n for num in nums2:\n i: int = 1\n while k * num * i <= maxnums1:\n sieve[k * num * i] += nums2_count[num]\n i += 1\n\n ans: int = 0\n for num in nums1:\n ans += sieve[num]\n \n return ans\n","memory":"63900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n M = max(nums1) + 1\n y_counts = [0 for _ in range(M)]\n for y, y_count in collections.Counter(nums2).items():\n for i in range(y*k, M, y*k):\n y_counts[i] += y_count\n return sum(\n y_counts[x] * x_count\n for x, x_count in collections.Counter(nums1).items()\n )","memory":"64000"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n M = max(nums1) + 1\n y_counts = [0 for _ in range(M)]\n for y, y_count in collections.Counter(nums2).items():\n i = 1\n while i * y * k < M:\n y_counts[i * y * k] += y_count\n i += 1\n return sum(\n y_counts[x] * x_count\n for x, x_count in collections.Counter(nums1).items()\n )","memory":"64800"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n numsp = Counter(num*k for num in nums2)\n counts = [0] * (max(nums1)+1)\n n_num = len(counts)\n for num, count in numsp.items():\n for mult in range(num, n_num, num):\n counts[mult] += count\n return sum((counts[num] for num in nums1))\n","memory":"65300"},{"code":"class Solution:\n def numberOfPairs(self, L1: List[int], L2: List[int], k: int) -> int:\n M=[0]*(max(L1)+1)\n dic={}\n for j in range (0,len(L2)):\n count=L2[j]*k\n dic[count]=dic.get(count,0)+1\n for x in dic:\n count=dic[x]\n for k in range (x,len(M),x):\n M[k]=M[k]+count\n ans=0\n for j in range (0,len(L1)):\n ans=ans+M[L1[j]]\n return ans","memory":"65400"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\n count2 = Counter(nums2)\n if len(nums1) == 0:\n return 0\n\n max_n1 = max(nums1)\n multiples_of_n2 = [0] * (max_n1 + 1)\n for n2, count in count2.items():\n # the worst case for this operation is if nums2 is [1, 2, 3, ...]\n # in this case, the following inner loop repeats approx. max_n1 / n2 times\n # summed over all n2, this is O(max_n1), because 1/2 + 1/3 + 1/4 + ... converges to a constant\n for product in range(n2, max_n1 + 1, n2):\n multiples_of_n2[product] += count\n return sum(multiples_of_n2[n1] for n1 in nums1)","memory":"68100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n def find(n):\n factors=set()\n i=1\n while i*i<=n:\n if n%i==0:\n factors.add(i)\n factors.add(n//i)\n i+=1 \n return list(factors)\n f_factors=defaultdict(list)\n d=defaultdict(int)\n for i in range(len(nums1)):\n if nums1[i]%k==0:\n if nums1[i] not in f_factors:\n f_factors[nums1[i]]=find(nums1[i])\n for fac in f_factors[nums1[i]]:\n d[fac]+=1\n ans=0\n for i in nums2:\n ans+=d[i*k]\n return ans \n ","memory":"71100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n \"\"\"\n time: O(n + nlogn)\n n = max(nums1)\n nlogn: worst case-> n + n/2 + n/3 + ... + 1\n \"\"\"\n freq = defaultdict(int)\n for n in nums2:\n freq[n * k] += 1\n counts = [0] * (max(nums1) + 1)\n for n, cnt in freq.items():\n for multiplier in range(n, len(counts), n):\n counts[multiplier] += cnt\n return sum(counts[n] for n in nums1)","memory":"72800"},{"code":"\"\"\"\nMultiply everything in nums by k\nHow many number is nums1 is multiple of value in nums 2\n\nidea, for each number, multiple by multiple of value in nums2\nand add freq into the count\n\nthen go through nums1 to add all freqs in the counter\n\"\"\"\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freqs = Counter(num * k for num in nums2)\n counts = [0] * (max(nums1)+1)\n\n \"\"\"\n freq\n 6 -> 1\n 12 -> 1\n \"\"\"\n for num, count in freqs.items():\n for multiplier in range(num, len(counts), num):\n counts[multiplier] += count\n \n return sum(counts[num] for num in nums1)","memory":"72900"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n # factorcount=collections.defaultdict(int)\n # for i in range(len(nums1)):\n # for j in range(1,int(sqrt(nums1[i]))+1):\n # if nums1[i]%j==0:\n # factorcount[j]+=1\n # if (nums1[i]//j)!=(j):\n # factorcount[nums1[i]//j]+=1\n # count=0\n # for num in nums2:\n # if num*k in factorcount:\n # count+=factorcount[num*k]\n # return count\n count2=Counter([num*k for num in nums2])\n arr=[0]*(max(nums1)+1)\n for num,count in count2.items():\n for mul in range(num,len(arr),num):\n arr[mul]+=count\n return sum([arr[num] for num in nums1])","memory":"73000"},{"code":"import bisect\nclass Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freq = Counter([n*k for n in nums2])\n counts = [0]*(max(nums1)+1)\n for den, count in freq.items():\n for num in range(den , len(counts), den):\n counts[num] += count\n return sum([counts[n] for n in nums1])\n ","memory":"73100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n\n # these three functions are from IterTools Recipes:\n # https://docs.python.org/3/library/itertools.html\n\n import contextlib\n\n def iter_index(iterable, value, start=0, stop=None):\n \"Return indices where a value occurs in a sequence or iterable.\"\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\n seq_index = getattr(iterable, 'index', None)\n if seq_index is None:\n iterator = islice(iterable, start, stop)\n for i, element in enumerate(iterator, start):\n if element is value or element == value:\n yield i\n else:\n stop = len(iterable) if stop is None else stop\n i = start\n with contextlib.suppress(ValueError):\n while True:\n yield (i := seq_index(value, i, stop))\n i += 1\n\n def sieve(n):\n \"Primes less than n.\"\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n if n > 2:\n yield 2\n data = bytearray((0, 1)) * (n // 2)\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n yield from iter_index(data, 1, start=3)\n\n def factor_cacheme(n):\n \"Prime factors of n.\"\n # factor(99) → 3 3 11\n # factor(1_000_000_000_000_007) → 47 59 360620266859\n # factor(1_000_000_000_000_403) → 1000000000000403\n for prime in sieve(math.isqrt(n) + 1):\n while not n % prime:\n yield prime\n n //= prime\n if n == 1:\n return\n if n > 1:\n yield n\n\n @cache\n def factor(n):\n return tuple(factor_cacheme(n))\n\n # we borrow some code from #3162:\n\n count1 = Counter(nums1)\n # print(f'{count1=}')\n count2 = Counter(nums2)\n # print(f'{count2=}')\n \n # @cache\n # nope. we need to roll our own cache, excluding \"depth\"\n CFFPP_cache = {}\n def composite_factors_from_prime_power(Prime: int, Power: int, depth=0) -> Set[int]:\n cache_index = (Prime, Power)\n if cache_index in CFFPP_cache:\n return CFFPP_cache[cache_index]\n margin = ' ' * depth\n # print(f'{margin}CFFPP({Prime},{Power})')\n answer = {1}\n if Power == 0:\n # print(f'{margin} {answer=}')\n CFFPP_cache[cache_index] = answer\n return answer\n CFFPP = composite_factors_from_prime_power(Prime, Power - 1, depth+1)\n answer = CFFPP | {\n A * Prime\n for A in CFFPP\n }\n # print(f'{margin} {answer=}')\n CFFPP_cache[cache_index] = answer\n return answer\n\n # @cache\n def composite_factors_from_primes(Primes: List[int], depth=0) -> Set[int]:\n margin = ' ' * depth\n # print(f'{margin}CFFP({Primes})')\n answer = {1}\n if not Primes:\n # print(f'{margin} {answer=}')\n return answer\n \n counts = Counter(Primes)\n # print(f'{margin} {counts=}')\n\n for Prime, Count in counts.items():\n # print(f'{margin} {Prime=} {Count=}')\n prime_powers = composite_factors_from_prime_power(Prime, Count, depth+1)\n # print(f'{margin} {prime_powers=}')\n answer = {\n A * B\n for A in answer\n for B in prime_powers\n }\n # print(f'{margin} {answer=}')\n \n return answer\n\n def factors_of(N: int) -> Set[int]:\n # print(f'factors_of({N})')\n\n F = factor(N)\n # print(f' {F=}')\n CF = composite_factors_from_primes(F)\n\n return CF\n\n hint1_F = Counter()\n for N, count in count2.items():\n hint1_F[N * k] += count\n # print(f'{hint1_F=}')\n hint1_F_set = set(hint1_F.keys())\n # print(f'{len(hint1_F_set)=}')\n\n answer = 0\n for N, count in sorted(count1.items()):\n # print(f'{N=} {count=}')\n factor_set = factors_of(N)\n intersect = factor_set & hint1_F_set\n # if intersect:\n # # print(f'{N=} {count=} F={len(factor_set)} &={len(intersect)}')\n for D in intersect:\n # print(f' {D=} {hint1_F[D]=}')\n answer += count * hint1_F[D]\n\n return answer\n","memory":"74100"},{"code":"class Solution:\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\n freqs = Counter(num * k for num in nums2)\n count = [0] * (max(nums1)+1)\n for num, cnt in freqs.items():\n for mul in range(num, len(count), num):\n count[mul] += cnt\n print(count)\n return sum(count[num] for num in nums1)","memory":"78800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n counter = Counter(nums1)\\n minimum = min(nums1)\\n maximum = max(nums1)\\n result = 0\\n for num in nums2:\\n base = num * k\\n multiply = 1 + (minimum - 1) // base\\n while base * multiply <= maximum:\\n target = base * multiply\\n if target in counter:\\n result += counter[target]\\n\\n multiply += 1\\n\\n return result\",\n \"memory\": \"38400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # pair is good if nums1[i] is divisible by nums2[j]*k\\n \\n nums2 = [num*k for num in nums2]\\n nums1.sort()\\n upperBound = max(nums1)\\n ans = 0\\n nums1_set = set(nums1)\\n counter = Counter(nums1)\\n \\n for num2 in nums2:\\n index = bisect.bisect_left(nums1, num2)\\n \\n if index == len(nums1):\\n continue\\n \\n target = nums1[index]//num2 \\n target = num2*target\\n \\n for x in range(target,upperBound+1,num2):\\n if x in nums1_set:\\n ans += counter[x]\\n \\n return ans\\n \\n \\n \\n \",\n \"memory\": \"39700\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1FactorCount = defaultdict(lambda: 0)\\n \\n for num1 in nums1:\\n summerize(num1, nums1FactorCount, k)\\n\\n count = 0\\n for num2 in nums2:\\n if num2 in nums1FactorCount.keys():\\n count += nums1FactorCount[num2]\\n\\n return count\\n\\ndef summerize(num1, nums1FactorCount, k):\\n if num1 % k != 0:\\n return\\n \\n num1 = num1 // k\\n for i in range(1, int(sqrt(num1)) + 1):\\n\\n if num1 % i == 0:\\n nums1FactorCount[i] += 1\\n \\n residual = num1 // i\\n if residual * residual > num1:\\n nums1FactorCount[residual] += 1\\n \\n\",\n \"memory\": \"40700\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n def gd(n):\\n d = set()\\n for i in range(1, int(math.sqrt(n)) + 1):\\n if n % i == 0:\\n d.add(i)\\n d.add(n//i)\\n return d\\n cnt = Counter()\\n for n in nums1:\\n if n % k == 0:\\n a = gd(n//k)\\n cnt.update(a)\\n ans = 0\\n for n in nums2:\\n ans += cnt[n]\\n return ans\",\n \"memory\": \"40800\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n hm = defaultdict(lambda : 0)\\n\\n def find_factors(num): \\n for i in range(1, int(math.sqrt(num)) + 1): \\n if num % i == 0: \\n # print(num, i)\\n if i != num // i: \\n hm[i] += 1 \\n hm[num//i] += 1\\n else:\\n hm[i] += 1\\n\\n for num in nums1: \\n find_factors(num)\\n # print(hm)\\n ret = 0\\n for num in nums2: \\n if num * k in hm: \\n ret += hm[num * k]\\n\\n return ret\\n\\n\",\n \"memory\": \"41600\"\n },\n {\n \"code\": \"from collections import defaultdict\\nimport math\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n \\n def fact(num):\\n ans = set()\\n for i in range(1,int(num**(0.5))+1):\\n if num % i == 0:\\n ans.add(i)\\n ans.add(num // i)\\n return list(ans)\\n \\n dic = defaultdict(int)\\n\\n for num in nums1:\\n if num % k == 0:\\n all_fact = fact(num)\\n for ele in all_fact:\\n dic[ele] += 1\\n \\n count = 0\\n \\n for num in nums2:\\n if num*k in dic:\\n count += dic[num*k]\\n return count\\n\\n\\n \\n\\n\\n \\n \",\n \"memory\": \"42300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1D = {n:0 for n in nums1} \\n nums2D = {n*k:0 for n in nums2}\\n for n in nums1:\\n nums1D[n] +=1 \\n for n in nums2:\\n nums2D[n*k] +=1 \\n max_num1 = max(nums1)+1\\n out = 0\\n for n in nums2D:\\n for i in range(n,max_num1,n):\\n if i in nums1D:\\n out+=nums1D[i]*nums2D[n]\\n return out\",\n \"memory\": \"42500\"\n },\n {\n \"code\": \"import functools\\nclass Solution:\\n def numberOfPairs(self, nn1: List[int], nn2: List[int], k: int) -> int:\\n max_nums1 = max(nn1)\\n cnt1 = collections.Counter(nn1)\\n cnt2 = collections.Counter(nn2)\\n res = 0\\n for n, f in cnt2.items():\\n mol = 1\\n while mol * k * n <= max_nums1:\\n res += cnt1[mol * k * n] * f\\n mol += 1\\n return res\",\n \"memory\": \"42600\"\n },\n {\n \"code\": \"class Solution3:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n a_nums2=Counter(nums2)\\n c=0\\n \\n for i in nums1:\\n for j in a_nums2.keys():\\n if i%(j*k)==0:\\n c+=a_nums2[j]\\n return c\\nclass Solution2:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n a=Counter(nums1)\\n b=Counter(nums2)\\n c=0\\n for i in a:\\n if i*k in b:\\n c+=a[i]*b[i*k]\\n return c\\n\\n\\nclass Solution1:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n multiplied_counts = Counter(num * k for num in nums2)\\n count = 0\\n for num in nums1:\\n for key in multiplied_counts:\\n if num % key == 0:\\n count += multiplied_counts[key]\\n \\n return count\\n\\nclass Solution0:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n a= defaultdict(int)\\n \\n for num in nums2:\\n a[num * k] += 1\\n \\n count = 0\\n for num in nums1:\\n \\n for div in a:\\n if num % div == 0:\\n count += a[div]\\n \\n return count\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n max_num1 = max(nums1)\\n res = 0\\n nums_1 = Counter(nums1)\\n nums_2 = Counter(nums2)\\n for num2 in nums_2:\\n mul = 1\\n while num2 * k * mul <= max_num1:\\n res += nums_2[num2] * nums_1[num2 * k * mul]\\n mul += 1\\n return res\\n\\n \",\n \"memory\": \"42700\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n freq1 = Counter(x//k for x in nums1 if x%k == 0)\\n\\n if not freq1:\\n return 0\\n\\n freq2 = Counter(nums2)\\n\\n res = 0\\n maxMultiple = max(freq1)\\n\\n for num2, count in freq2.items():\\n cur = sum(freq1[y] for y in range(num2, maxMultiple+1, num2))\\n res += cur * count\\n \\n return res\\n\\n\\n\\n \\n \\n\",\n \"memory\": \"42800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n max_num = max(nums1)\\n counter1 = Counter(nums1)\\n counter2 = Counter(nums2)\\n count = 0\\n\\n for num in counter2:\\n mul = 1\\n while num * mul * k <= max_num:\\n count += counter2[num] * counter1[num * mul * k]\\n mul += 1\\n return count\",\n \"memory\": \"42900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n def get_factors(n):\\n res = set()\\n curr = 1\\n while curr <= sqrt(n):\\n if n % curr == 0:\\n res.add(curr)\\n res.add(n // curr)\\n curr += 1\\n return res\\n ans = 0\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n for n in c1:\\n for factor in get_factors(n):\\n if factor % k == 0:\\n ans += c1[n] * c2[factor // k]\\n return ans\\n \",\n \"memory\": \"43000\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n ret = 0\\n C1,C2 = collections.Counter(n//k for n in nums1 if n%k==0),collections.Counter(nums2)\\n for n in C1:\\n sq = int(n**0.5)\\n if sq**2 == n:\\n ret += C1[n]*C2[sq]\\n else:\\n sq += 1\\n for d in range(1,sq):\\n if n%d == 0:\\n ret += C1[n]*(C2[d]+C2[n//d])\\n return ret\",\n \"memory\": \"43100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n\\n\\n def get_factors(n):\\n factors = set()\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n factors.add(i)\\n factors.add(n // i)\\n return factors\\n\\n\\n factor_map = defaultdict(int)\\n \\n # Precompute factors of nums1 and store in factor_map\\n for num in nums1:\\n # Get all factors of num\\n factors = get_factors(num)\\n # Increment count for each factor\\n for factor in factors:\\n factor_map[factor] += 1\\n \\n count = 0\\n \\n # Now check each number in nums2\\n for num in nums2:\\n target = num * k\\n # Check if target divides any of the factors in nums1\\n if target in factor_map:\\n count += factor_map[target]\\n \\n return count\\n\\n \",\n \"memory\": \"43200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n hash2 = {}\\n for i in range(len(nums2)):\\n hash2[nums2[i]*k] = 1 + hash2.get(nums2[i]*k, 0)\\n \\n # print(hash2)\\n goodPairs = 0\\n for j in range(len(nums1)):\\n # if( nums1[j] % k == 0 ):\\n sr = int(sqrt(nums1[j]))\\n for i in range(1,sr+1):\\n # print(i)\\n # print(k*i)\\n # print(nums1[j])\\n if( nums1[j] % i == 0):\\n # print(\\\"la\\\")\\n goodPairs += hash2.get(i, 0)\\n if( i != nums1[j]/i):\\n # print(\\\"ba\\\")\\n goodPairs += hash2.get(nums1[j] / i, 0)\\n # print(goodPairs)\\n return goodPairs\\n\",\n \"memory\": \"43300\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n counter2 = Counter(nums2)\\n counter1 = Counter(nums1)\\n \\n set1 = set(counter1.keys())\\n max1 = max(set1)\\n ans = 0\\n for num2 in counter2.keys():\\n \\n for i in range(max1//(num2*k)+1):\\n num1 = num2*k*i\\n if num1 in set1:\\n ans += counter2[num2] * counter1[num1]\\n return ans\\n \\n# counter1 = Counter(nums1)\\n \\n# # for num in counter1:\\n# # if num % k != 0: counter1[num] = 0\\n# # counter1 = dict(sorted(counter1.items()))\\n \\n# counter2 = Counter(nums2)\\n# counter2 = dict(sorted(counter2.items()))\\n# minNum2 = min(nums2)\\n \\n# cnt = 0\\n# for num1, cnt1 in counter1.items():\\n# if cnt1 == 0:\\n# continue\\n# if num1 < minNum2: continue\\n# for num2, cnt2 in counter2.items():\\n# if num2 > num1: break\\n# if num1 % (num2 * k) == 0:\\n# cnt += cnt1 * cnt2\\n# return cnt\",\n \"memory\": \"43400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = Counter(nums2)\\n res = 0\\n cache = {}\\n \\n for num in nums1:\\n if num%k!=0:\\n continue\\n if num in cache:\\n res+=cache[num]\\n continue\\n \\n cur = 0\\n num = num / k\\n \\n for i in range(1, int(math.sqrt(num)) + 1):\\n if num % i == 0:\\n cur += cnt[i]\\n cur += cnt[num // i] if i!=num//i else 0\\n cache[num*k] = cur\\n # print(num, cur)\\n res+=cur\\n return res\",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n hashmap = {}\\n for n in nums1:\\n for i in range(1,int(sqrt(n))+1):\\n if n%i==0:\\n if i not in hashmap:\\n hashmap[i] =1 \\n else:\\n hashmap[i] +=1\\n if i!=n//i:\\n if n//i not in hashmap:\\n hashmap[n//i] =1 \\n else:\\n hashmap[n//i] +=1 \\n \\n ans =0\\n for i in nums2:\\n if k*i in hashmap:\\n ans = ans + hashmap[k*i]\\n return ans\",\n \"memory\": \"43600\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n\\n hs = defaultdict(int)\\n\\n sm = 0\\n for n in nums1:\\n for j in range(1, int(n ** 0.5) + 1):\\n\\n if n % j == 0:\\n hs[j] += 1\\n\\n if j * j != n:\\n hs[n // j] += 1\\n \\n for n in nums2:\\n if n * k in hs:\\n sm += hs[n * k]\\n\\n return sm\",\n \"memory\": \"43700\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n complement_divisor: int = num // potential_divisor\\n if complement_divisor in nums2_counter.keys():\\n ans += nums2_counter[complement_divisor]\\n if complement_divisor != potential_divisor and potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"memory\": \"44100\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n if num // potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[num // potential_divisor]\\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"memory\": \"44100\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n if num // potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[num // potential_divisor]\\n if potential_divisor ** 2 != num and potential_divisor in nums2_counter.keys():\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\\n\",\n \"memory\": \"44300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freq = {}\\n freq1 = {}\\n for num in nums1:\\n freq1[num] = freq1.get(num,0)+1\\n nums1 = set(nums1)\\n for num in nums1:\\n for i in range(1, 1 + int(math.sqrt(num))):\\n if num%i==0:\\n freq[i] = freq.get(i,0)+freq1[num]\\n if num%i==0 and num//i !=i:\\n freq[num//i] = freq.get(num//i,0)+freq1[num]\\n \\n count = 0\\n # nums2 = set(nums2)\\n # freq2 = {}\\n # for num in nums2:\\n # freq2[num] = freq2.get(num,0)+1\\n for num in nums2:\\n count+=(freq.get(num * k, 0) )\\n return count\",\n \"memory\": \"44400\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n complement_divisor: int = num // potential_divisor\\n ans += nums2_counter[complement_divisor]\\n if complement_divisor != potential_divisor:\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"memory\": \"44500\"\n },\n {\n \"code\": \"import bisect # noqa\\nimport heapq # noqa\\nimport math # noqa\\nimport statistics # noqa\\nimport sys\\nfrom bisect import bisect_left as lower_bound\\nfrom bisect import bisect_right as upper_bound\\nfrom collections import Counter, defaultdict, deque # noqa\\nfrom datetime import datetime # noqa\\nfrom fractions import Fraction # noqa\\nfrom functools import lru_cache # noqa\\nfrom itertools import ( # noqa\\n permutations, combinations # difference is that order matters for permutations but not for combinations\\n)\\nfrom typing import List, Optional # noqa\\n\\n# allow big recursion\\nsys.setrecursionlimit(10**5)\\n\\n# Magic no recursion\\nfrom types import GeneratorType # noqa\\ndef bootstrap(f, stack=[]): # noqa\\n def wrappedfunc(*args, **kwargs):\\n if stack:\\n return f(*args, **kwargs)\\n to = f(*args, **kwargs)\\n while True:\\n if type(to) is GeneratorType:\\n stack.append(to)\\n to = next(to)\\n else:\\n stack.pop()\\n if not stack:\\n break\\n to = stack[-1].send(to)\\n return to\\n\\n return wrappedfunc\\n\\ndef partitions(partitions_n: int):\\n partitions_a = [0 for _ in range(partitions_n + 1)]\\n k_ = 1\\n y_ = partitions_n - 1\\n while k_ != 0:\\n x_ = partitions_a[k_ - 1] + 1\\n k_ -= 1\\n while 2 * x_ <= y_:\\n partitions_a[k_] = x_\\n y_ -= x_\\n k_ += 1\\n l_ = k_ + 1\\n while x_ <= y_:\\n partitions_a[k_] = x_\\n partitions_a[l_] = y_\\n yield partitions_a[: k_ + 2]\\n x_ += 1\\n y_ -= 1\\n partitions_a[k_] = x_ + y_\\n y_ = x_ + y_ - 1\\n yield partitions_a[: k_ + 1]\\n\\ndef get_lps(string: str) -> list[int]:\\n lps: list[int] = [0] * len(string)\\n length: int = 0\\n i: int = 1\\n while i < len(string):\\n if string[i] == string[length]:\\n length += 1\\n lps[i] = length\\n i += 1\\n else:\\n if length != 0:\\n length = lps[length - 1]\\n else:\\n lps[i] = 0\\n i += 1\\n return lps\\n\\ndef create_string_hash(string: str, n: int, p: int, mod: int) -> tuple[list[int], list[int]]:\\n hash_prefixes: list[int] = [0] * (n + 1)\\n powers: list[int] = [1] * (n + 1)\\n for i in range(1, n + 1):\\n powers[i] = (powers[i - 1] * p) % mod\\n for i in range(n):\\n hash_prefixes[i + 1] = (hash_prefixes[i] * p + (ord(string[i]) - ord(\\\"a\\\") + 1)) % mod\\n return hash_prefixes, powers\\n\\ndef gen_suffix_array(s_: str) -> list[int]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n return p\\n\\ndef gen_suffix_array_and_lcp(s_: str) -> tuple[list[int], list[int]]:\\n def radix_sort(p_: list[int], c_: list[int]) -> list[int]:\\n count: list[int] = [0 for _ in range(len(p_))]\\n for x in p_:\\n count[c_[x]] += 1\\n new_p: list[int] = p_.copy()\\n pos: list[int] = [0 for _ in range(len(p_))]\\n for i in range(1, len(p_)):\\n pos[i] = pos[i-1] + count[i-1]\\n for x in p_:\\n new_p[pos[c_[x]]] = x\\n pos[c_[x]] += 1\\n\\n return new_p\\n s_ += \\\"$\\\"\\n n: int = len(s_)\\n a: list[tuple[str, int]] = [(s_[i], i) for i in range(n)]\\n a.sort(key=lambda x: x[0])\\n p: list[int] = [a[i][1] for i in range(n)]\\n c: list[int] = [0] * n\\n c[p[0]] = 0\\n for i in range(1, n):\\n if a[i][0] == a[i-1][0]:\\n c[p[i]] = c[p[i-1]]\\n else:\\n c[p[i]] = c[p[i-1]] + 1\\n k: int = 1\\n while (1 << k) <= 2*n:\\n p = [(p[i] - (1 << (k-1))) % n for i in range(n)]\\n p = radix_sort(p, c)\\n\\n c_new: list[int] = [0] * n\\n prev: tuple[int, int] = (c[p[0]], c[(p[0] + (1 << (k-1))) % n])\\n for i in range(1, n):\\n curr: tuple[int, int] = (c[p[i]], c[(p[i] + (1 << (k-1))) % n])\\n if prev == curr:\\n c_new[p[i]] = c_new[p[i-1]]\\n else:\\n c_new[p[i]] = c_new[p[i-1]] + 1\\n prev = curr\\n c = c_new\\n k += 1\\n if c_new[p[n-1]] == n - 1:\\n break\\n\\n lcp: list[int] = [0] * (n-1)\\n k: int = 0\\n for i in range(n-1):\\n # i => where do we start (in the string) this suffix. we never start the suffix at n-1.\\n # because the suffix at n-1 is $ and it is the first of the suffix array so we don't have a previous suffix to \\n # compare it to.\\n pi: int = c[i] # pi => position of the suffix i in the suffix array.\\n # pi is never 0 because the suffix at 0 is $\\n j: int = p[pi - 1] # j => where does the previous (in the suffix array) suffix start (in the string).\\n while s_[i+k] == s_[j+k]:\\n k += 1\\n lcp[pi-1] = k\\n k = max(k-1, 0)\\n\\n return p, lcp\\n\\ndef get_hash(hash_prefixes: list[int], powers: list[int], mod: int, i: int, j: int) -> int:\\n return (hash_prefixes[j] - hash_prefixes[i] * powers[j - i]) % mod\\n\\ndef make_nCr_mod(max_n: int, mod: int = 10**9+7):\\n max_n = min(max_n, mod - 1)\\n\\n fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)\\n fact[0] = 1\\n for i in range(max_n):\\n fact[i + 1] = fact[i] * (i + 1) % mod\\n\\n inv_fact[-1] = pow(fact[-1], mod - 2, mod)\\n for i in reversed(range(max_n)):\\n inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod\\n\\n def nCr_mod(n, r):\\n res = 1\\n while n or r:\\n a, b = n % mod, r % mod\\n if a < b:\\n return 0\\n res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod\\n n //= mod\\n r //= mod\\n return res\\n\\n return nCr_mod\\n\\ndef sum_from_k_to_n(k_: int, n_: int) -> int:\\n # k inclusive, n inclusive\\n return (n_ * (n_ + 1) - k_ * (k_ - 1)) // 2\\n\\nclass FenwickTree:\\n def __init__(self, x):\\n bit = self.bit = list(x)\\n size = self.size = len(bit)\\n for i in range(size):\\n j = i | (i + 1)\\n if j < size:\\n bit[j] += bit[i]\\n\\n def update(self, idx, x):\\n \\\"\\\"\\\"updates bit[idx] += x\\\"\\\"\\\"\\n while idx < self.size:\\n self.bit[idx] += x\\n idx |= idx + 1\\n\\n def __call__(self, end):\\n \\\"\\\"\\\"calc sum(bit[:end])\\\"\\\"\\\"\\n x = 0\\n while end:\\n x += self.bit[end - 1]\\n end &= end - 1\\n return x\\n\\n def find_kth(self, k):\\n \\\"\\\"\\\"Find largest idx such that sum(bit[:idx]) <= k\\\"\\\"\\\"\\n idx = -1\\n for d in reversed(range(self.size.bit_length())):\\n right_idx = idx + (1 << d)\\n if right_idx < self.size and self.bit[right_idx] <= k:\\n idx = right_idx\\n k -= self.bit[idx]\\n return idx + 1, k\\n\\nclass SortedList:\\n block_size = 700\\n\\n def __init__(self, iterable=()):\\n self.macro = []\\n self.micros = [[]]\\n self.micro_size = [0]\\n self.fenwick = FenwickTree([0])\\n self.size = 0\\n for item in iterable:\\n self.insert(item)\\n\\n def insert(self, x):\\n i = lower_bound(self.macro, x)\\n j = upper_bound(self.micros[i], x)\\n self.micros[i].insert(j, x)\\n self.size += 1\\n self.micro_size[i] += 1\\n self.fenwick.update(i, 1)\\n if len(self.micros[i]) >= self.block_size:\\n self.micros[i:i + 1] = self.micros[i][:self.block_size >> 1], self.micros[i][self.block_size >> 1:]\\n self.micro_size[i:i + 1] = self.block_size >> 1, self.block_size >> 1\\n self.fenwick = FenwickTree(self.micro_size)\\n self.macro.insert(i, self.micros[i + 1][0])\\n\\n def pop(self, k=-1):\\n i, j = self._find_kth(k)\\n self.size -= 1\\n self.micro_size[i] -= 1\\n self.fenwick.update(i, -1)\\n return self.micros[i].pop(j)\\n\\n def __getitem__(self, k):\\n i, j = self._find_kth(k)\\n return self.micros[i][j]\\n\\n def count(self, x):\\n return self.upper_bound(x) - self.lower_bound(x)\\n\\n def __contains__(self, x):\\n return self.count(x) > 0\\n\\n def lower_bound(self, x):\\n i = lower_bound(self.macro, x)\\n return self.fenwick(i) + lower_bound(self.micros[i], x)\\n\\n def upper_bound(self, x):\\n i = upper_bound(self.macro, x)\\n return self.fenwick(i) + upper_bound(self.micros[i], x)\\n\\n def _find_kth(self, k):\\n return self.fenwick.find_kth(k + self.size if k < 0 else k)\\n\\n def __len__(self):\\n return self.size\\n\\n def __iter__(self):\\n return (x for micro in self.micros for x in micro)\\n\\n def __repr__(self):\\n return str(list(self))\\n\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # sieve: list[int] = [0 for _ in range(max(nums1) + 1)]\\n # nums2_count: Counter = Counter(nums2)\\n # nums2 = list(sorted(set(nums2)))\\n # num: int\\n # for num in nums2:\\n # i: int = 1\\n # while k * num * i <= max(nums1):\\n # sieve[k * num * i] += nums2_count[num]\\n # i += 1\\n # \\n # ans: int = 0\\n # for num in nums1:\\n # ans += sieve[num]\\n \\n nums2 = [nums2[i] * k for i in range(len(nums2))]\\n nums2_counter: Counter = Counter(nums2)\\n \\n ans: int = 0\\n for num in nums1:\\n for potential_divisor in range(1, int(num**0.5) + 1):\\n if num % potential_divisor == 0:\\n complement_divisor: int = num // potential_divisor\\n ans += nums2_counter[complement_divisor]\\n if complement_divisor != potential_divisor:\\n ans += nums2_counter[potential_divisor]\\n \\n return ans\",\n \"memory\": \"44500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n factorcount=collections.defaultdict(int)\\n for i in range(len(nums1)):\\n for j in range(1,int(sqrt(nums1[i]))+1):\\n if nums1[i]%j==0:\\n factorcount[j]+=1\\n if (nums1[i]//j)!=(j):\\n factorcount[nums1[i]//j]+=1\\n nums2=[num*k for num in nums2]\\n count=0\\n print(factorcount,nums2)\\n for num in nums2:\\n if num in factorcount:\\n count+=factorcount[num]\\n return count\",\n \"memory\": \"45600\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n factorcount=collections.defaultdict(int)\\n for i in range(len(nums1)):\\n for j in range(1,int(sqrt(nums1[i]))+1):\\n if nums1[i]%j==0:\\n factorcount[j]+=1\\n if (nums1[i]//j)!=(j):\\n factorcount[nums1[i]//j]+=1\\n nums2=[num*k for num in nums2]\\n count=0\\n print(factorcount,nums2)\\n for num in nums2:\\n if num in factorcount:\\n count+=factorcount[num]\\n return count\",\n \"memory\": \"45600\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [i//k for i in nums1 if i % k == 0]\\n oc1, nums1 = Counter(nums1), sorted(list(set(nums1)))\\n oc2, nums2 = Counter(nums2), sorted(list(set(nums2)))\\n # print(nums1, nums2)\\n re = 0\\n for i in nums1:\\n for j in range(1, int(sqrt(i)) + 1):\\n if i % j == 0:\\n re += oc1[i] * oc2[j]\\n if i//j != j:\\n re += oc1[i] * oc2[i//j]\\n return re\\n \",\n \"memory\": \"48200\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n count = 0\\n nums1_count = Counter(nums1)\\n nums2_count = Counter(nums2)\\n factors = {}\\n for i in nums1_count.keys():\\n if i % k != 0:\\n continue\\n for j in range(1, math.floor(math.sqrt(i)) + 1):\\n if i % j == 0:\\n factors[j] = factors.get(j, 0) + nums1_count[i]\\n # factors.setdefault(j, 0) += 1\\n if i // j != j:\\n factors[i // j] = factors.get(i // j, 0) + nums1_count[i]\\n # factors.setdefault(i // j, 0) += 1\\n print(factors)\\n for j in nums2_count.keys():\\n count += factors.get(j * k, 0) * nums2_count[j]\\n return count\",\n \"memory\": \"48300\"\n },\n {\n \"code\": \"import collections\\nimport heapq\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\\n d = collections.defaultdict(int)\\n d1 = collections.Counter(nums1)\\n d2 = collections.Counter(nums2)\\n\\n for k, v in d1.items():\\n if k % n != 0:\\n continue\\n bound = int(sqrt(k))\\n for i in range(1, bound + 1):\\n if i*i == k:\\n d[i] += v\\n elif k % i == 0:\\n d[i] += v\\n d[k//i] += v\\n \\n count = 0\\n for k, v in d2.items():\\n if k*n in d.keys():\\n count += v * d[k*n]\\n return count\\n\\n \",\n \"memory\": \"48400\"\n },\n {\n \"code\": \"import collections\\nimport heapq\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], n: int) -> int:\\n d = collections.defaultdict(int)\\n d1 = collections.Counter(nums1)\\n d2 = collections.Counter(nums2)\\n\\n for k, v in d1.items():\\n if k % n != 0:\\n continue\\n bound = int(sqrt(k))\\n for i in range(1, bound + 1):\\n if i*i == k:\\n d[i] += v\\n elif k % i == 0:\\n d[i] += v\\n d[k//i] += v\\n \\n count = 0\\n for k, v in d2.items():\\n if k*n in d.keys():\\n count += v * d[k*n]\\n return count\\n\\n \",\n \"memory\": \"48500\"\n },\n {\n \"code\": \"\\nfrom collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # count factors of numbers in nums1\\n count = {}\\n ans = 0\\n nums1_map = Counter(nums1)\\n nums2_map = Counter(nums2)\\n for val, freq in nums1_map.items():\\n i = 1\\n while i * i <= val:\\n if i * i == val:\\n if i not in count:\\n count[i] = 0\\n count[i] += freq\\n elif val%i == 0:\\n if i not in count:\\n count[i] = 0\\n if val//i not in count:\\n count[val//i] = 0\\n count[i] += freq\\n count[val//i] += freq\\n i += 1\\n for val, freq in nums2_map.items():\\n factor = val * k\\n if factor in count:\\n ans += count[factor] * freq\\n return ans\",\n \"memory\": \"49500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n\\n counter = collections.defaultdict(int)\\n for num in nums2:\\n counter[num] +=1\\n \\n result = 0\\n for num in nums1:\\n if(num % k ==0):\\n residue_num = num // k\\n for factor in range(1, int(pow(residue_num, 0.5)) +1):\\n if(residue_num % factor ==0):\\n factor1 = factor\\n factor2 = residue_num // factor\\n result += counter[factor1]\\n if(factor2 != factor1):\\n result += counter[factor2]\\n \\n return result\\n\\n\",\n \"memory\": \"50700\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freq = Counter(num*k for num in nums2)\\n mx1 = max(nums1)\\n numbers1 = [0]*(mx1+1)\\n for i in nums1:\\n numbers1[i] += 1\\n ans = 0\\n for i, cnt in freq.items():\\n f = 1\\n while f*i<=mx1:\\n ans += numbers1[f*i]*(cnt)\\n f += 1\\n return ans\\n \",\n \"memory\": \"51100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n factors = defaultdict(int)\\n\\n for i in range(len(nums2)):\\n factors[nums2[i]]+=1\\n\\n res = 0\\n\\n for i in range(len(nums1)):\\n if nums1[i]%k == 0:\\n temp = nums1[i]//k\\n for j in range(1, int(math.sqrt(temp))+1):\\n if temp%j == 0:\\n res+=factors[j]\\n if temp//j != j:\\n res+=factors[temp//j]\\n\\n return res\\n\\n \\n \\n \\n \",\n \"memory\": \"51900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = defaultdict(int)\\n for i in nums1:\\n if i % k: continue\\n i //= k\\n for d in range(1, isqrt(i) + 1):\\n if i % d: continue\\n cnt[d] += 1\\n if d * d < i:\\n cnt[i // d] += 1\\n res = 0\\n for j in nums2:\\n res += cnt[j]\\n return res\",\n \"memory\": \"52300\"\n },\n {\n \"code\": \"\\nfrom collections import Counter\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # count factors of numbers in nums1\\n count = {}\\n ans = 0\\n nums1 = [x//k for x in nums1 if x%k == 0]\\n nums1_map = Counter(nums1)\\n nums2_map = Counter(nums2)\\n for val, freq in nums1_map.items():\\n i = 1\\n while i * i <= val:\\n if i * i == val:\\n if i not in count:\\n count[i] = 0\\n count[i] += freq\\n elif val%i == 0:\\n if i not in count:\\n count[i] = 0\\n if val//i not in count:\\n count[val//i] = 0\\n count[i] += freq\\n count[val//i] += freq\\n i += 1\\n for val, freq in nums2_map.items():\\n \\n if val in count:\\n ans += count[val] * freq\\n return ans\",\n \"memory\": \"52800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1D = {n:0 for n in nums1}\\n for n in nums1:\\n nums1D[n] +=1\\n def find_factor(i):\\n if i == 1: return [1]\\n out = [] \\n for f in range(1,int(i**0.5)+1): \\n if i%f == 0:\\n out.append(f)\\n if i//f!=f:\\n out.append(i//f)\\n return out\\n nums_factor = {}\\n for n in nums1D:\\n factors = find_factor(n)\\n # print(n,factors)\\n for f in factors:\\n if f not in nums_factor:\\n nums_factor[f] = 0\\n nums_factor[f]+=nums1D[n]\\n \\n nums2D = {n*k:0 for n in nums2}\\n for n in nums2:\\n nums2D[n*k] +=1\\n # print(nums2D,nums_factor)\\n out = 0 \\n for n in nums2D:\\n if n in nums_factor:\\n out += nums2D[n]*nums_factor[n]\\n return out\",\n \"memory\": \"52900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [el//k for el in nums1 if el % k == 0]\\n dct = defaultdict(int)\\n for el in nums2:\\n dct[el]+=1\\n res= 0\\n def main(x):\\n nonlocal res\\n for i in range(1, math.floor(math.sqrt(x)) + 1):\\n if x % i == 0:\\n dv=x//i\\n res += dct[i] + dct[dv]\\n if i == dv:\\n res -= dct[i]\\n for x in nums1:\\n main(x)\\n return res\",\n \"memory\": \"53800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\\n # this implies that a good pair is divisible by both k and by nums2[j]\\n # we must only consider numbers divisible by k and for all other numbers\\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\\n # for some x that we can factor out\\n\\n freq = collections.defaultdict(int)\\n for v in nums2:\\n freq[v*k] += 1\\n\\n def isqrt(x: int) -> int:\\n return int(x ** 0.5)\\n\\n def factor(x: int) -> List[int]:\\n factors = []\\n for i in range(1, isqrt(x) + 1):\\n if x % i == 0:\\n factors.append(i)\\n return factors\\n \\n result = 0\\n for x in nums1:\\n if x % k != 0:\\n continue\\n for f in factor(x):\\n result += freq[f]\\n if x // f != f:\\n result += freq[x // f]\\n return result\\n\",\n \"memory\": \"54200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # a pair (i, j) is good if nums1[i] is divisible by num2[j] * k\\n # this implies that a good pair is divisible by both k and by nums2[j]\\n # we must only consider numbers divisible by k and for all other numbers\\n # if nums[j] is divisible by nums[l] then the pair (i, j) also can form pairs\\n # (i, l) since nums1[i] % (nums2[j] * k) == 0 ==> nums1[i] % (num2[l] * x * k) == 0\\n # for some x that we can factor out\\n\\n freq = collections.defaultdict(int)\\n for v in nums2:\\n freq[v*k] += 1\\n\\n def isqrt(x: int) -> int:\\n return int(x ** 0.5)\\n\\n def factor(x: int) -> List[int]:\\n factors = []\\n for i in range(1, isqrt(x) + 1):\\n if x % i == 0:\\n factors.append(i)\\n return factors\\n \\n result = 0\\n for x in nums1:\\n for f in factor(x):\\n result += freq[f]\\n if x // f != f:\\n result += freq[x // f]\\n return result\\n\",\n \"memory\": \"54900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # if x < k, x % k is not 0 for sure, \\n # 24 % 12 \\n # 12 = 3 * 4 = 3 * 2 * 2 \\n # 12 is divisible by 3 or 2 or 4 \\n # count of potential divisors for nums2\\n freq_divisors = defaultdict(int)\\n for num2 in nums2:\\n freq_divisors[num2 * k] += 1\\n\\n ans = 0\\n for num in nums1: # find all the divisors for this num and see how many are there in freq_divisors\\n for i in range(1, int(sqrt(num))+ 1):\\n if num % i == 0: # it's a possible divisor\\n ans += freq_divisors[i]\\n if i != num//i:\\n ans += freq_divisors[num//i]\\n return ans\",\n \"memory\": \"55000\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1, nums2, k):\\n dict1, count = defaultdict(int), 0 \\n\\n for i in nums2:\\n dict1[i*k] += 1 \\n\\n def function(n):\\n res = 0 \\n\\n for i in range(1,int(sqrt(n))+1):\\n if n%i == 0:\\n res += dict1[i] + (dict1[n//i] if n//i != i else 0)\\n \\n return res \\n\\n for i in nums1:\\n count += function(i)\\n\\n return count \",\n \"memory\": \"55100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n count = defaultdict(int)\\n for n in nums2:\\n count[n*k]+=1\\n print (count)\\n\\n ans = 0 \\n def divisorsCount(n) : \\n res = 0\\n for i in range(1,int(sqrt(n))+1):\\n if n%i==0:\\n res+=count[i]+(count[n//i] if n//i!=i else 0)\\n return res\\n \\n for n in nums1:\\n ans+=divisorsCount(n)\\n \\n return ans\\n\\n# class Solution:\\n# def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n# pair = 0 \\n \\n# for i in range(len(nums1)):\\n# for j in range(len(nums2)):\\n# current = nums2[j]*k\\n# if nums1[i]% (nums2[j]*k)==0:\\n# pair = pair+1\\n# return pair\\n \\n'''\\n[1,3,4]\\n[1,3,4]\\n1\\n\\n\\n'''\",\n \"memory\": \"55200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n memo = defaultdict(int)\\n answer = 0\\n for num in nums2:\\n memo[num * k] += 1\\n \\n \\n def get_pair_cnt(n):\\n cnt = 0\\n root = int(n ** 0.5)\\n for i in range(1, root + 1):\\n if not n % i:\\n t = n // i\\n cnt += memo[i]\\n if t != i:\\n cnt += memo[t]\\n return cnt\\n \\n \\n for num in nums1:\\n answer += get_pair_cnt(num)\\n \\n return answer\\n \\n \",\n \"memory\": \"55300\"\n },\n {\n \"code\": \"#nums[i] // nums[j] * k\\n#we can remember nums1 / k: frequency[nums1 / k]\\n\\ndef get_divisors(n):\\n divisors = set()\\n for i in range(1, int(n**0.5) + 1):\\n if n % i == 0:\\n divisors.add(i)\\n divisors.add(n // i)\\n return divisors\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n divisor_count = defaultdict(int)\\n good_pairs = 0\\n\\n for num in nums1:\\n divisors = get_divisors(num)\\n for d in divisors:\\n divisor_count[d] += 1\\n \\n for num in nums2:\\n good_pairs += divisor_count[num * k]\\n \\n return good_pairs\",\n \"memory\": \"55400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n def get_factors(x):\\n factors = set([])\\n pause = int(math.sqrt(x))\\n for i in range(1, 1+pause):\\n if x%i==0:\\n factors.add(i)\\n factors.add(x//i)\\n return factors\\n\\n nums2 = [k*x for x in nums2]\\n counter = defaultdict(int)\\n\\n for num in nums2:\\n counter[num]+=1\\n \\n ans = 0\\n\\n for num in nums1:\\n factors = get_factors(num)\\n for factor in factors:\\n ans+=counter[factor]\\n return ans\\n \",\n \"memory\": \"55500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n c1, c2 = collections.defaultdict(int), collections.defaultdict(int)\\n for num in nums1:\\n c1[num] += 1\\n for num in nums2:\\n c2[num * k] += 1\\n\\n res = 0\\n\\n for num in c1:\\n sr = int(math.sqrt(num))\\n for n in range(1, sr + 1):\\n if num % n:\\n continue\\n res += c1[num] * c2[n]\\n if n != num // n: # sqrt\\n res += c1[num] * c2[num // n] \\n\\n return res\\n\",\n \"memory\": \"57400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\n # nums2 * k\\n # check each num in nums2, count answer\\n # for each num in nums1, we make table[factor] += 1\\n \\n table = defaultdict(int) #factor: number\\n \\n counter1 = Counter(nums1)\\n \\n def factors(num):\\n res = []\\n for x in range(1, isqrt(num) + 1):\\n if num % x == 0:\\n res.append(x)\\n y = num // x\\n if y != x:\\n res.append(y)\\n return res\\n \\n for num in counter1:\\n for x in factors(num):\\n table[x] += counter1[num]\\n \\n res = 0\\n for num in nums2:\\n num *= k\\n res += table[num]\\n \\n return res\\n \\n \\n \\n \",\n \"memory\": \"57500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n cnt = 0\\n factors = collections.defaultdict(int)\\n nums1ctr = collections.Counter(nums1)\\n nums2ctr = collections.Counter(nums2)\\n for n,amt in nums1ctr.items():\\n if not n%k == 0:\\n continue\\n i = 1\\n while i*i <= n:\\n if(i*i == n):\\n factors[i] += amt\\n elif (n%i == 0):\\n factors[i] += amt\\n factors[n/i] += amt\\n i += 1\\n for n,amt in nums2ctr.items():\\n cnt += (amt*factors[n*k])\\n return cnt\",\n \"memory\": \"61100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n d1 = defaultdict(int)\\n c1 = Counter(nums1)\\n c2 = Counter(nums2)\\n\\n for c, f in c1.items():\\n bound = int(sqrt(c))\\n for i in range(1, bound + 1):\\n if i * i == c:\\n d1[i] += f\\n elif c % i == 0:\\n d1[i] += f\\n d1[c // i] += f\\n res = 0\\n for c, f in c2.items():\\n res += d1[c * k] * f\\n return res\",\n \"memory\": \"62500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n res = 0\\n freq = defaultdict(int)\\n for n in nums2:\\n freq[n * k] += 1\\n counts = [0] * (max(nums1) + 1)\\n for n, cnt in freq.items():\\n for m in range(n, len(counts), n):\\n counts[m] += cnt\\n return sum(counts[n] for n in nums1)\",\n \"memory\": \"62700\"\n },\n {\n \"code\": \"# Data Structure: Counter for frequencies, array to store counts of multiples\\n# Algorithm: Process nums2 to count the occurrences of multiples of nums2[j] * k, and use an array to accumulate counts for valid multiples in nums1\\n\\n# Short Intuition:\\n# We are searching for pairs where nums1[i] is divisible by nums2[j] * k. Instead of checking each pair, we first calculate how often each multiple appears in nums1 and then sum up the valid counts.\\n\\n# Detailed Intuition:\\n# - We first count how many multiples of each number from nums2 * k appear in nums1.\\n# - For each element in nums2 multiplied by k, we track how many of its multiples are in nums1.\\n# - Instead of directly checking for pairs, we count multiples using an array and sum over these counts for efficiency.\\n\\n# Pseudo Code:\\n# 1. Use a Counter to store frequencies of nums2 * k.\\n# 2. Initialize a counts array to track the frequency of each multiple for nums1.\\n# 3. For each number in nums2 * k, update the counts for all multiples of that number.\\n# 4. Finally, sum the counts for each element in nums1 to get the total number of good pairs.\\n\\nfrom typing import List\\nfrom collections import Counter\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # Step 1: Create a frequency counter for nums2 elements multiplied by k\\n freqs = Counter(num * k for num in nums2)\\n \\n # Step 2: Initialize a counts array to track counts for multiples\\n max_value = max(nums1) # Find the maximum value in nums1\\n counts = [0] * (max_value + 1)\\n\\n print(freqs)\\n # Step 3: For each number in freqs, update counts for all multiples of that number\\n for num, count in freqs.items():\\n for multiplier in range(num, len(counts), num):\\n counts[multiplier] += count\\n\\n # Step 4: Return the total number of good pairs by summing counts for all elements in nums1\\n return sum(counts[num] for num in nums1)\\n\\n# Time Complexity: O(n log n), where n is the length of the largest number in nums1.\\n# Explanation: The time complexity is bounded by the harmonic series when summing over multiples for each value in nums2.\\n\\n# Space Complexity: O(n), where n is the length of the largest number in nums1.\\n# Explanation: We use a counts array to track the number of valid multiples in nums1.\\n\",\n \"memory\": \"63000\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n dp = [0] * (max(nums1) + 1)\\n f = Counter(nums2)\\n print(len(nums1))\\n print(len(nums2))\\n # print(f)\\n for n, freq in f.items():\\n i = n * k\\n while i < len(dp):\\n dp[i] += freq\\n i += n * k\\n \\n tot = 0\\n c2 = Counter(nums1)\\n for n, freq in c2.items():\\n tot += dp[n] * freq\\n \\n return tot\",\n \"memory\": \"63100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n M = max(nums1) + 1\\n y_counts = [0 for _ in range(M)]\\n for y, y_count in collections.Counter(nums2).items():\\n for i in range(y*k, M, y*k):\\n y_counts[i] += y_count\\n return sum(\\n y_counts[x] * x_count\\n for x, x_count in collections.Counter(nums1).items()\\n )\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n M = max(nums1) + 1\\n y_counts = [0 for _ in range(M)]\\n for y, y_count in collections.Counter(nums2).items():\\n for i in range(y*k, M, y*k):\\n y_counts[i] += y_count\\n return sum(\\n y_counts[x] * x_count\\n for x, x_count in collections.Counter(nums1).items()\\n )\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n maxnums1: int = max(nums1)\\n \\n sieve: list[int] = [0 for _ in range(maxnums1 + 1)]\\n nums2_count: Counter = Counter(nums2)\\n nums2 = list(sorted(set(nums2)))\\n num: int\\n for num in nums2:\\n i: int = 1\\n while k * num * i <= maxnums1:\\n sieve[k * num * i] += nums2_count[num]\\n i += 1\\n\\n ans: int = 0\\n for num in nums1:\\n ans += sieve[num]\\n \\n return ans\\n\",\n \"memory\": \"63900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n M = max(nums1) + 1\\n y_counts = [0 for _ in range(M)]\\n for y, y_count in collections.Counter(nums2).items():\\n for i in range(y*k, M, y*k):\\n y_counts[i] += y_count\\n return sum(\\n y_counts[x] * x_count\\n for x, x_count in collections.Counter(nums1).items()\\n )\",\n \"memory\": \"64000\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n M = max(nums1) + 1\\n y_counts = [0 for _ in range(M)]\\n for y, y_count in collections.Counter(nums2).items():\\n i = 1\\n while i * y * k < M:\\n y_counts[i * y * k] += y_count\\n i += 1\\n return sum(\\n y_counts[x] * x_count\\n for x, x_count in collections.Counter(nums1).items()\\n )\",\n \"memory\": \"64800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n numsp = Counter(num*k for num in nums2)\\n counts = [0] * (max(nums1)+1)\\n n_num = len(counts)\\n for num, count in numsp.items():\\n for mult in range(num, n_num, num):\\n counts[mult] += count\\n return sum((counts[num] for num in nums1))\\n\",\n \"memory\": \"65300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, L1: List[int], L2: List[int], k: int) -> int:\\n M=[0]*(max(L1)+1)\\n dic={}\\n for j in range (0,len(L2)):\\n count=L2[j]*k\\n dic[count]=dic.get(count,0)+1\\n for x in dic:\\n count=dic[x]\\n for k in range (x,len(M),x):\\n M[k]=M[k]+count\\n ans=0\\n for j in range (0,len(L1)):\\n ans=ans+M[L1[j]]\\n return ans\",\n \"memory\": \"65400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n nums1 = [n1 // k for n1 in nums1 if n1 % k == 0]\\n count2 = Counter(nums2)\\n if len(nums1) == 0:\\n return 0\\n\\n max_n1 = max(nums1)\\n multiples_of_n2 = [0] * (max_n1 + 1)\\n for n2, count in count2.items():\\n # the worst case for this operation is if nums2 is [1, 2, 3, ...]\\n # in this case, the following inner loop repeats approx. max_n1 / n2 times\\n # summed over all n2, this is O(max_n1), because 1/2 + 1/3 + 1/4 + ... converges to a constant\\n for product in range(n2, max_n1 + 1, n2):\\n multiples_of_n2[product] += count\\n return sum(multiples_of_n2[n1] for n1 in nums1)\",\n \"memory\": \"68100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n def find(n):\\n factors=set()\\n i=1\\n while i*i<=n:\\n if n%i==0:\\n factors.add(i)\\n factors.add(n//i)\\n i+=1 \\n return list(factors)\\n f_factors=defaultdict(list)\\n d=defaultdict(int)\\n for i in range(len(nums1)):\\n if nums1[i]%k==0:\\n if nums1[i] not in f_factors:\\n f_factors[nums1[i]]=find(nums1[i])\\n for fac in f_factors[nums1[i]]:\\n d[fac]+=1\\n ans=0\\n for i in nums2:\\n ans+=d[i*k]\\n return ans \\n \",\n \"memory\": \"71100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n time: O(n + nlogn)\\n n = max(nums1)\\n nlogn: worst case-> n + n/2 + n/3 + ... + 1\\n \\\"\\\"\\\"\\n freq = defaultdict(int)\\n for n in nums2:\\n freq[n * k] += 1\\n counts = [0] * (max(nums1) + 1)\\n for n, cnt in freq.items():\\n for multiplier in range(n, len(counts), n):\\n counts[multiplier] += cnt\\n return sum(counts[n] for n in nums1)\",\n \"memory\": \"72800\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nMultiply everything in nums by k\\nHow many number is nums1 is multiple of value in nums 2\\n\\nidea, for each number, multiple by multiple of value in nums2\\nand add freq into the count\\n\\nthen go through nums1 to add all freqs in the counter\\n\\\"\\\"\\\"\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freqs = Counter(num * k for num in nums2)\\n counts = [0] * (max(nums1)+1)\\n\\n \\\"\\\"\\\"\\n freq\\n 6 -> 1\\n 12 -> 1\\n \\\"\\\"\\\"\\n for num, count in freqs.items():\\n for multiplier in range(num, len(counts), num):\\n counts[multiplier] += count\\n \\n return sum(counts[num] for num in nums1)\",\n \"memory\": \"72900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n # factorcount=collections.defaultdict(int)\\n # for i in range(len(nums1)):\\n # for j in range(1,int(sqrt(nums1[i]))+1):\\n # if nums1[i]%j==0:\\n # factorcount[j]+=1\\n # if (nums1[i]//j)!=(j):\\n # factorcount[nums1[i]//j]+=1\\n # count=0\\n # for num in nums2:\\n # if num*k in factorcount:\\n # count+=factorcount[num*k]\\n # return count\\n count2=Counter([num*k for num in nums2])\\n arr=[0]*(max(nums1)+1)\\n for num,count in count2.items():\\n for mul in range(num,len(arr),num):\\n arr[mul]+=count\\n return sum([arr[num] for num in nums1])\",\n \"memory\": \"73000\"\n },\n {\n \"code\": \"import bisect\\nclass Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freq = Counter([n*k for n in nums2])\\n counts = [0]*(max(nums1)+1)\\n for den, count in freq.items():\\n for num in range(den , len(counts), den):\\n counts[num] += count\\n return sum([counts[n] for n in nums1])\\n \",\n \"memory\": \"73100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n\\n # these three functions are from IterTools Recipes:\\n # https://docs.python.org/3/library/itertools.html\\n\\n import contextlib\\n\\n def iter_index(iterable, value, start=0, stop=None):\\n \\\"Return indices where a value occurs in a sequence or iterable.\\\"\\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\\n seq_index = getattr(iterable, 'index', None)\\n if seq_index is None:\\n iterator = islice(iterable, start, stop)\\n for i, element in enumerate(iterator, start):\\n if element is value or element == value:\\n yield i\\n else:\\n stop = len(iterable) if stop is None else stop\\n i = start\\n with contextlib.suppress(ValueError):\\n while True:\\n yield (i := seq_index(value, i, stop))\\n i += 1\\n\\n def sieve(n):\\n \\\"Primes less than n.\\\"\\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\\n if n > 2:\\n yield 2\\n data = bytearray((0, 1)) * (n // 2)\\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\\n yield from iter_index(data, 1, start=3)\\n\\n def factor_cacheme(n):\\n \\\"Prime factors of n.\\\"\\n # factor(99) → 3 3 11\\n # factor(1_000_000_000_000_007) → 47 59 360620266859\\n # factor(1_000_000_000_000_403) → 1000000000000403\\n for prime in sieve(math.isqrt(n) + 1):\\n while not n % prime:\\n yield prime\\n n //= prime\\n if n == 1:\\n return\\n if n > 1:\\n yield n\\n\\n @cache\\n def factor(n):\\n return tuple(factor_cacheme(n))\\n\\n # we borrow some code from #3162:\\n\\n count1 = Counter(nums1)\\n # print(f'{count1=}')\\n count2 = Counter(nums2)\\n # print(f'{count2=}')\\n \\n # @cache\\n # nope. we need to roll our own cache, excluding \\\"depth\\\"\\n CFFPP_cache = {}\\n def composite_factors_from_prime_power(Prime: int, Power: int, depth=0) -> Set[int]:\\n cache_index = (Prime, Power)\\n if cache_index in CFFPP_cache:\\n return CFFPP_cache[cache_index]\\n margin = ' ' * depth\\n # print(f'{margin}CFFPP({Prime},{Power})')\\n answer = {1}\\n if Power == 0:\\n # print(f'{margin} {answer=}')\\n CFFPP_cache[cache_index] = answer\\n return answer\\n CFFPP = composite_factors_from_prime_power(Prime, Power - 1, depth+1)\\n answer = CFFPP | {\\n A * Prime\\n for A in CFFPP\\n }\\n # print(f'{margin} {answer=}')\\n CFFPP_cache[cache_index] = answer\\n return answer\\n\\n # @cache\\n def composite_factors_from_primes(Primes: List[int], depth=0) -> Set[int]:\\n margin = ' ' * depth\\n # print(f'{margin}CFFP({Primes})')\\n answer = {1}\\n if not Primes:\\n # print(f'{margin} {answer=}')\\n return answer\\n \\n counts = Counter(Primes)\\n # print(f'{margin} {counts=}')\\n\\n for Prime, Count in counts.items():\\n # print(f'{margin} {Prime=} {Count=}')\\n prime_powers = composite_factors_from_prime_power(Prime, Count, depth+1)\\n # print(f'{margin} {prime_powers=}')\\n answer = {\\n A * B\\n for A in answer\\n for B in prime_powers\\n }\\n # print(f'{margin} {answer=}')\\n \\n return answer\\n\\n def factors_of(N: int) -> Set[int]:\\n # print(f'factors_of({N})')\\n\\n F = factor(N)\\n # print(f' {F=}')\\n CF = composite_factors_from_primes(F)\\n\\n return CF\\n\\n hint1_F = Counter()\\n for N, count in count2.items():\\n hint1_F[N * k] += count\\n # print(f'{hint1_F=}')\\n hint1_F_set = set(hint1_F.keys())\\n # print(f'{len(hint1_F_set)=}')\\n\\n answer = 0\\n for N, count in sorted(count1.items()):\\n # print(f'{N=} {count=}')\\n factor_set = factors_of(N)\\n intersect = factor_set & hint1_F_set\\n # if intersect:\\n # # print(f'{N=} {count=} F={len(factor_set)} &={len(intersect)}')\\n for D in intersect:\\n # print(f' {D=} {hint1_F[D]=}')\\n answer += count * hint1_F[D]\\n\\n return answer\\n\",\n \"memory\": \"74100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:\\n freqs = Counter(num * k for num in nums2)\\n count = [0] * (max(nums1)+1)\\n for num, cnt in freqs.items():\\n for mul in range(num, len(count), num):\\n count[mul] += cnt\\n print(count)\\n return sum(count[num] for num in nums1)\",\n \"memory\": \"78800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":69,"string":"69"}}},{"rowIdx":2448,"cells":{"question_id":{"kind":"number","value":3423,"string":"3,423"},"name":{"kind":"string","value":"maximum-sum-of-subsequence-with-non-adjacent-elements"},"content":{"kind":"string","value":"<p>You are given an array <code>nums</code> consisting of integers. You are also given a 2D array <code>queries</code>, where <code>queries[i] = [pos<sub>i</sub>, x<sub>i</sub>]</code>.</p>\n\n<p>For query <code>i</code>, we first set <code>nums[pos<sub>i</sub>]</code> equal to <code>x<sub>i</sub></code>, then we calculate the answer to query <code>i</code> which is the <strong>maximum</strong> sum of a <span data-keyword=\"subsequence-array\">subsequence</span> of <code>nums</code> where <strong>no two adjacent elements are selected</strong>.</p>\n\n<p>Return the <em>sum</em> of the answers to all queries.</p>\n\n<p>Since the final answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>\n\n<p>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [3,5,9], queries = [[1,-2],[0,-3]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">21</span></p>\n\n<p><strong>Explanation:</strong><br />\nAfter the 1<sup>st</sup> query, <code>nums = [3,-2,9]</code> and the maximum sum of a subsequence with non-adjacent elements is <code>3 + 9 = 12</code>.<br />\nAfter the 2<sup>nd</sup> query, <code>nums = [-3,-2,9]</code> and the maximum sum of a subsequence with non-adjacent elements is 9.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [0,-1], queries = [[0,-5]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">0</span></p>\n\n<p><strong>Explanation:</strong><br />\nAfter the 1<sup>st</sup> query, <code>nums = [-5,-1]</code> and the maximum sum of a subsequence with non-adjacent elements is 0 (choosing an empty subsequence).</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 5 * 10<sup>4</sup></code></li>\n\t<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>\n\t<li><code>1 <= queries.length <= 5 * 10<sup>4</sup></code></li>\n\t<li><code>queries[i] == [pos<sub>i</sub>, x<sub>i</sub>]</code></li>\n\t<li><code>0 <= pos<sub>i</sub> <= nums.length - 1</code></li>\n\t<li><code>-10<sup>5</sup> <= x<sub>i</sub> <= 10<sup>5</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":16.96471863323921,"string":"16.964719"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","divide-and-conquer","dynamic-programming","segment-tree"],"string":"[\n \"array\",\n \"divide-and-conquer\",\n \"dynamic-programming\",\n \"segment-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"3679\", 1.2048], [\"3680\", 1.2048], [\"3783\", 1.2048], [\"4072\", 1.2048], [\"4078\", 1.2048], [\"4085\", 1.2048], [\"4151\", 1.2048], [\"4156\", 1.2048], [\"4180\", 1.2048], [\"4293\", 1.2048], [\"4303\", 1.2048], [\"4413\", 1.2048], [\"4522\", 1.2048], [\"4531\", 1.2048], [\"4606\", 1.2048], [\"4620\", 1.2048], [\"4638\", 1.2048], [\"4660\", 1.2048], [\"4664\", 1.2048], [\"4675\", 1.2048], [\"4685\", 1.2048], [\"4692\", 1.2048], [\"4693\", 1.2048], [\"4701\", 1.2048], [\"4718\", 1.2048], [\"4748\", 1.2048], [\"4760\", 1.2048], [\"4768\", 1.2048], [\"4769\", 1.2048], [\"4785\", 1.2048], [\"4831\", 1.2048], [\"4834\", 1.2048], [\"4858\", 1.2048], [\"4861\", 1.2048], [\"4877\", 1.2048], [\"4878\", 1.2048], [\"4884\", 1.2048], [\"4925\", 1.2048], [\"4982\", 1.2048], [\"5015\", 1.2048], [\"5016\", 1.2048], [\"5028\", 1.2048], [\"5042\", 1.2048], [\"5100\", 1.2048], [\"5111\", 1.2048], [\"5138\", 1.2048], [\"5149\", 1.2048], [\"5241\", 1.2048], [\"5498\", 1.2048], [\"5516\", 1.2048], [\"5536\", 1.2048], [\"5654\", 1.2048], [\"6641\", 1.2048], [\"6847\", 1.2048], [\"7007\", 1.2048], [\"7036\", 1.2048], [\"7064\", 1.2048], [\"7067\", 1.2048], [\"7076\", 1.2048], [\"7101\", 1.2048], [\"7124\", 1.2048], [\"7207\", 1.2048], [\"7216\", 1.2048], [\"7523\", 1.2048], [\"7727\", 1.2048], [\"7739\", 1.2048], [\"7749\", 1.2048], [\"7927\", 1.2048], [\"8339\", 1.2048], [\"8407\", 1.2048], [\"8572\", 1.2048], [\"8620\", 1.2048], [\"8747\", 1.2048], [\"8818\", 1.2048], [\"8841\", 1.2048], [\"8843\", 1.2048], [\"9031\", 1.2048], [\"9053\", 1.2048]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"43400\", 1.2048], [\"43500\", 2.4096], [\"43900\", 1.2048], [\"44000\", 3.6145], [\"44100\", 1.2048], [\"44600\", 1.2048], [\"44800\", 1.2048], [\"46700\", 2.4096], [\"46800\", 2.4096], [\"46900\", 2.4096], [\"47000\", 3.6145], [\"47300\", 1.2048], [\"47800\", 3.6145], [\"49000\", 3.6145], [\"50700\", 1.2048], [\"51400\", 1.2048], [\"51500\", 1.2048], [\"51900\", 1.2048], [\"52200\", 1.2048], [\"53400\", 1.2048], [\"54100\", 1.2048], [\"54400\", 1.2048], [\"54600\", 2.4096], [\"54800\", 1.2048], [\"56700\", 1.2048], [\"57000\", 1.2048], [\"57200\", 1.2048], [\"57500\", 1.2048], [\"58700\", 1.2048], [\"59100\", 1.2048], [\"59200\", 1.2048], [\"59300\", 1.2048], [\"59400\", 3.6145], [\"59500\", 1.2048], [\"59600\", 2.4096], [\"61300\", 2.4096], [\"62200\", 1.2048], [\"63100\", 1.2048], [\"63600\", 1.2048], [\"63700\", 3.6145], [\"63800\", 2.4096], [\"63900\", 4.8193], [\"64000\", 1.2048], [\"75200\", 2.4096], [\"77400\", 1.2048], [\"77500\", 1.2048], [\"78800\", 2.4096], [\"88400\", 1.2048], [\"88500\", 2.4096], [\"90200\", 1.2048]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n class node:\n def __init__(self,num,val):\n self.range_left=num\n self.range_right=num+1\n self.full_v=max(val,0)\n self.nleft_v=0\n self.nright_v=0\n self.nboth_v=0\n\n @classmethod\n def grow(cls,range_left,range_right):\n if range_right-range_left==1:\n return node(range_left,nums[range_left])\n root=node(0,0)\n root.range_left=range_left\n root.range_right=range_right\n mid=(range_left+range_right)//2\n root.left=cls.grow(range_left,mid)\n root.right=cls.grow(mid,range_right)\n root.left.parent=root\n root.right.parent=root\n root.parent=None\n root.merge()\n return root\n \n def merge(self):\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\n\n def seek(self,n):\n if self.range_left==n and self.range_right==n+1:\n return self\n mid=(self.range_left+self.range_right)//2\n if n<mid:\n return self.left.seek(n)\n else:\n return self.right.seek(n)\n \n def update_leaf(self,v):\n self.full_v=max(v,0)\n t=self.parent\n while t:\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\n t.merge()\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\n break\n t=t.parent\n \n root=node.grow(0,len(nums))\n root.parent=None\n sums=0\n for i in queries:\n nd=root.seek(i[0])\n nd.update_leaf(i[1])\n sums+=root.full_v\n sums%=(10**9+7)\n return sums\n\n\n","runtime":"3679"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n class node:\n def __init__(self,num,val):\n self.range_left=num\n self.range_right=num+1\n self.full_v=max(val,0)\n self.nleft_v=0\n self.nright_v=0\n self.nboth_v=0\n\n @classmethod\n def grow(cls,range_left,range_right):\n if range_right-range_left==1:\n return node(range_left,nums[range_left])\n root=node(0,0)\n root.range_left=range_left\n root.range_right=range_right\n mid=(range_left+range_right)//2\n root.left=cls.grow(range_left,mid)\n root.right=cls.grow(mid,range_right)\n root.left.parent=root\n root.right.parent=root\n root.parent=None\n root.merge()\n return root\n \n def merge(self):\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\n\n def seek(self,n):\n if self.range_left==n and self.range_right==n+1:\n return self\n mid=(self.range_left+self.range_right)//2\n if n<mid:\n return self.left.seek(n)\n else:\n return self.right.seek(n)\n \n def update_leaf(self,v):\n self.full_v=max(v,0)\n t=self.parent\n while t:\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\n t.merge()\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\n break\n t=t.parent\n \n root=node.grow(0,len(nums))\n root.parent=None\n sums=0\n for i in queries:\n nd=root.seek(i[0])\n nd.update_leaf(i[1])\n sums+=root.full_v\n sums%=(10**9+7)\n return sums\n\n","runtime":"3680"},{"code":"class Node:\n def __init__(self,start,end):\n self.l = start\n self.r = end\n self.n = end-start+1\n self.left = None\n self.right = None\n \n self.all = 0\n self.left_loo = 0\n self.right_loo = 0\n self.both_loo = 0\n \nclass QueryTree:\n def __init__(self,nums):\n self.nums = nums\n self.root = self.build(0, len(nums)-1)\n self.calc(self.root)\n \n def build(self,start,end):\n if start == end:\n return Node(start,end)\n \n mid = (start+end)//2\n root = Node(start,end)\n root.left = self.build(start,mid)\n root.right = self.build(mid+1,end)\n return root\n \n def calc(self,node):\n if node is None:\n return \n \n if node.n == 1:\n node.all = max(self.nums[node.l],0)\n node.left_loo = 0\n node.right_loo = 0\n node.both_loo = 0\n return\n \n # node has at least two children\n self.calc(node.left)\n self.calc(node.right)\n \n node.all = max(node.left.all + node.right.left_loo, \n node.left.right_loo + node.right.all)\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\n node.left.both_loo + node.right.all)\n node.right_loo = max(node.left.all + node.right.both_loo,\n node.left.right_loo + node.right.right_loo)\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\n node.left.both_loo + node.right.right_loo) \n \n def query(self):\n return self.root.all\n \n def update(self,i,x):\n self.nums[i] = x\n self.recalc(self.root,i)\n \n def recalc(self,node,i):\n if node is None:\n return \n \n if node.n == 1:\n if node.l == i:\n node.all = max(self.nums[i],0)\n return \n \n if (i < node.l) or (i > node.r):\n return \n \n if i <= node.left.r:\n self.recalc(node.left,i)\n if i >= node.right.l:\n self.recalc(node.right,i)\n \n node.all = max(node.left.all + node.right.left_loo, \n node.left.right_loo + node.right.all)\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\n node.left.both_loo + node.right.all)\n node.right_loo = max(node.left.all + node.right.both_loo,\n node.left.right_loo + node.right.right_loo)\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\n node.left.both_loo + node.right.right_loo) \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n ans = []\n qt = QueryTree(nums)\n for i,x in queries:\n qt.update(i,x)\n ans.append(qt.query())\n return sum(ans) % (10 ** 9 + 7)","runtime":"3783"},{"code":"class Tree:\n def __init__(self, l, r):\n self.l = l\n self.r = r\n self.lt = None\n self.rt = None\n\n self.noExc = 0\n self.lExc = 0\n self.rExc = 0\n self.bothExc = 0\n\n\n @staticmethod\n def build(l, r, nums):\n tree = Tree(l, r)\n if l == r:\n tree.noExc = nums[l]\n return tree\n\n mid = l + (r-l)//2\n tree.lt = Tree.build(l, mid, nums)\n tree.rt = Tree.build(mid+1, r, nums)\n tree.updateSsq()\n return tree\n\n def update(self, idx, val):\n if self.l == self.r:\n self.noExc = max(val, 0)\n return\n\n mid = self.l + (self.r-self.l)//2\n\n if idx <= mid:\n self.lt.update(idx, val)\n else:\n self.rt.update(idx, val)\n\n self.updateSsq()\n\n def updateSsq(self):\n self.noExc = max(self.lt.noExc + self.rt.lExc, self.lt.rExc + self.rt.noExc)\n self.lExc = max(self.lt.lExc + self.rt.lExc, self.lt.bothExc + self.rt.noExc)\n self.rExc = max(self.lt.noExc + self.rt.bothExc, self.lt.rExc + self.rt.rExc)\n self.bothExc = max(self.lt.lExc + self.rt.bothExc, self.lt.bothExc + self.rt.rExc)\n # print(self.noExc, self.lExc, self.rExc, self.noExc)\n \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n n = len(nums)\n MOD = 10**9 + 7\n\n tree = Tree.build(0, n-1, nums)\n # print(tree.noExc)\n ans = 0\n for idx, val in queries:\n tree.update(idx, val)\n # print(tree.noExc)\n ans += tree.noExc % MOD\n\n return ans % MOD\n\n# |----| + |-| |----|\n# or |---| |-| + |---| \n# all = max(l [] + r (], l [) + r[])\n# (] = max(l (] + r(], l () + r[])\n# [) = max(l [) + r[), l [] + r())\n# () = max(l (] + r(), l() + r[))\n","runtime":"4072"},{"code":"modulus = 1000000007\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = Tree(0, len(nums), nums)\n result = 0\n for i, value in queries:\n tree.change(i, value)\n result = (result + tree.max) % modulus\n return result\n\nclass Tree:\n def __init__(self, start, end, nums):\n self.start = start\n self.end = end\n\n if end - start == 1:\n self.max_without_start = 0\n self.max_without_end = 0\n self.max_without_either = 0\n self.max = max(0, nums[start])\n else:\n mid = (start + end) // 2\n self.left = Tree(start, mid, nums)\n self.right = Tree(mid, end, nums)\n self.update()\n\n def change(self, i, value):\n if self.end - self.start == 1:\n self.max = max(0, value)\n return\n if i < (self.start + self.end) // 2:\n self.left.change(i, value)\n else:\n self.right.change(i, value)\n self.update()\n\n def update(self):\n self.max_without_start = max(\n self.left.max_without_start + self.right.max_without_start,\n self.left.max_without_either + self.right.max\n ) % modulus\n self.max_without_end = max(\n self.left.max_without_end + self.right.max_without_end,\n self.left.max + self.right.max_without_either\n ) % modulus\n self.max_without_either = max(\n self.left.max_without_start + self.right.max_without_either,\n self.left.max_without_either + self.right.max_without_end\n ) % modulus\n self.max = max(\n self.left.max_without_end + self.right.max,\n self.left.max + self.right.max_without_start\n ) % modulus","runtime":"4078"},{"code":"import typing\n\n\nclass SegTree:\n def __init__(\n self,\n op: typing.Callable[[typing.Any, typing.Any], typing.Any],\n e: typing.Any,\n v: typing.Union[int, typing.List[typing.Any]],\n ) -> None:\n self._op = op\n self._e = e\n\n if isinstance(v, int):\n v = [e] * v\n\n self._n = len(v)\n self._log = self._ceil_pow2(self._n)\n self._size = 1 << self._log\n self._d = [e] * (2 * self._size)\n\n for i in range(self._n):\n self._d[self._size + i] = v[i]\n for i in range(self._size - 1, 0, -1):\n self._update(i)\n\n def set(self, p: int, x: typing.Any) -> None:\n assert 0 <= p < self._n\n\n p += self._size\n self._d[p] = x\n for i in range(1, self._log + 1):\n self._update(p >> i)\n\n def get(self, p: int) -> typing.Any:\n assert 0 <= p < self._n\n\n return self._d[p + self._size]\n\n def prod(self, left: int, right: int) -> typing.Any:\n assert 0 <= left <= right <= self._n\n sml = self._e\n smr = self._e\n left += self._size\n right += self._size\n\n while left < right:\n if left & 1:\n sml = self._op(sml, self._d[left])\n left += 1\n if right & 1:\n right -= 1\n smr = self._op(self._d[right], smr)\n left >>= 1\n right >>= 1\n\n return self._op(sml, smr)\n\n def all_prod(self) -> typing.Any:\n return self._d[1]\n\n def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int:\n assert 0 <= left <= self._n\n assert f(self._e)\n\n if left == self._n:\n return self._n\n\n left += self._size\n sm = self._e\n\n first = True\n while first or (left & -left) != left:\n first = False\n while left % 2 == 0:\n left >>= 1\n if not f(self._op(sm, self._d[left])):\n while left < self._size:\n left *= 2\n if f(self._op(sm, self._d[left])):\n sm = self._op(sm, self._d[left])\n left += 1\n return left - self._size\n sm = self._op(sm, self._d[left])\n left += 1\n\n return self._n\n\n def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int:\n assert 0 <= right <= self._n\n assert f(self._e)\n\n if right == 0:\n return 0\n\n right += self._size\n sm = self._e\n\n first = True\n while first or (right & -right) != right:\n first = False\n right -= 1\n while right > 1 and right % 2:\n right >>= 1\n if not f(self._op(self._d[right], sm)):\n while right < self._size:\n right = 2 * right + 1\n if f(self._op(self._d[right], sm)):\n sm = self._op(self._d[right], sm)\n right -= 1\n return right + 1 - self._size\n sm = self._op(self._d[right], sm)\n\n return 0\n\n def _update(self, k: int) -> None:\n self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])\n\n @staticmethod\n def _ceil_pow2(n: int) -> int:\n x = 0\n while (1 << x) < n:\n x += 1\n\n return x\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n\n def op(x, y) -> int:\n left_max_without_start, left_max_without_end, left_max_without_either, left_max = x\n right_max_without_start, right_max_without_end, right_max_without_either, right_max = y\n\n return (\n max(left_max_without_start + right_max_without_start, left_max_without_either + right_max) % MOD,\n max(left_max_without_end + right_max_without_end, left_max + right_max_without_either) % MOD,\n max(left_max_without_start + right_max_without_either, left_max_without_either + right_max_without_end) % MOD,\n max(left_max_without_end + right_max, left_max + right_max_without_start) % MOD,\n )\n\n e = (0, 0, 0, 0)\n nodes = [(0, 0, 0, max(num, 0)) for num in nums]\n seg_tree = SegTree(op, e, nodes)\n\n ans = 0\n for pos, x in queries:\n seg_tree.set(pos, (0, 0, 0, max(0, x)))\n _, _, _, v = seg_tree.all_prod()\n ans += v % MOD\n return ans % MOD\n\n","runtime":"4085"},{"code":"class SegTree:\n def __init__(self, nums):\n self.n = len(nums)\n self.tree = [None] * (4 * self.n)\n self.build(nums, 0, 0, self.n - 1)\n \n def build(self, nums, node, start, end):\n if start == end:\n self.tree[node] = (max(0, nums[start]), 0, 0, 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n self.build(nums, left_child, start, mid)\n self.build(nums, right_child, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n \n def merge(self, left, right):\n include = max(left[2] + right[0], left[0] + right[1])\n exclude_l = max(left[3] + right[0], left[1] + right[1])\n exclude_r = max(left[2] + right[2], left[0] + right[3])\n exclude_both = max(left[3] + right[2], left[1] + right[3])\n return (include, exclude_l, exclude_r, exclude_both)\n \n def update(self, idx, value, node, start, end):\n if start == end:\n self.tree[node] = (max(0, value), 0, 0, 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n if start <= idx <= mid:\n self.update(idx, value, left_child, start, mid)\n else:\n self.update(idx, value, right_child, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n \n def query(self):\n return self.tree[0][0]\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n\n segtree = SegTree(nums)\n \n MOD = 10 ** 9 + 7\n \n res = 0\n for pos, val in queries:\n segtree.update(pos, val, 0, 0, segtree.n - 1)\n \n #segtree.print_tree()\n #print(segtree.query())\n \n res = (res + segtree.query()) % MOD\n \n return res\n ","runtime":"4151"},{"code":"class SegTree:\n def __init__(self, nums):\n self.n = len(nums)\n self.tree = [0] * (4 * self.n)\n self.build(nums, 0, 0, self.n - 1)\n \n def build(self, nums, node, start, end):\n if start == end:\n self.tree[node] = (max(nums[start], 0), 0, 0, 0)\n \n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n self.build(nums, left, start, mid)\n self.build(nums, right, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\n \n def merge(self, left, right):\n include = max(left[2] + right[0], left[0] + right[1])\n ex_l = max(left[1] + right[1], left[3] + right[0])\n ex_r = max(left[2] + right[2], left[0] + right[3])\n ex_both = max(left[3] + right[2], left[1] + right[3])\n return (include, ex_l, ex_r, ex_both)\n \n def update(self, idx, value, node, start, end):\n if start == end:\n self.tree[node] = (max(0, value), 0, 0, 0)\n \n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n if start <= idx <= mid:\n self.update(idx, value, left, start, mid)\n else:\n self.update(idx, value, right, mid + 1, end)\n\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\n return\n \n def query(self):\n return self.tree[0][0]\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n segtree = SegTree(nums)\n mod = 10 ** 9 + 7\n\n ans = 0\n for pos, val in queries:\n segtree.update(pos, val, 0, 0, segtree.n - 1)\n\n ans = (ans + segtree.query()) % mod\n\n return ans","runtime":"4156"},{"code":"class SegTree: \n\n def __init__(self, arr: List[int]):\n self.n = n = len(arr)\n self.tree = [0]*(4*n)\n self._build(arr, 0, 0, n)\n \n def _op(self, left, right): \n lv, ls, le, lse = left\n rv, rs, re, rse = right \n ov = max(le+rv, lv+rs)\n os = max(ls+rs, lse+rv)\n oe = max(le+re, lv+rse)\n ose = max(lse+re, ls+rse)\n return (ov, os, oe, ose)\n\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\n else:\n mid = lo + hi >> 1\n self._build(arr, 2*k+1, lo, mid)\n self._build(arr, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\n if not hi: hi = self.n\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\n else: \n mid = lo + hi >> 1\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\n else: self.update(i, x, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \n if not hi: hi = self.n\n if qhi <= lo or hi <= qlo: return inf # no overlap \n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \n mid = lo + hi >> 1 # partial overlap \n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = SegTree(nums)\n ans = 0 \n for i, x in queries: \n tree.update(i, x)\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\n return ans ","runtime":"4180"},{"code":"class SegTree: \n\n def __init__(self, arr: List[int]):\n self.n = n = len(arr)\n self.tree = [0]*(4*n)\n self._build(arr, 0, 0, n)\n \n def _op(self, left, right): \n lv, ls, le, lse = left\n rv, rs, re, rse = right \n v = max(le+rv, lv+rs)\n s = max(ls+rs, lse+rv)\n e = max(le+re, lv+rse)\n se = max(lse+re, ls+rse)\n return (v, s, e, se)\n\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\n else:\n mid = lo + hi >> 1\n self._build(arr, 2*k+1, lo, mid)\n self._build(arr, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\n if not hi: hi = self.n\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\n else: \n mid = lo + hi >> 1\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\n else: self.update(i, x, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \n if not hi: hi = self.n\n if qhi <= lo or hi <= qlo: return inf # no overlap \n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \n mid = lo + hi >> 1 # partial overlap \n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = SegTree(nums)\n ans = 0 \n for i, x in queries: \n tree.update(i, x)\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\n return ans ","runtime":"4293"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tmp = 1\n while tmp < len(nums):\n tmp *= 2\n t = [[0]*4 for _ in range(tmp*2)]\n\n n = len(nums)\n\n def maintain(o: int):\n a, b = t[o * 2], t[o * 2 + 1]\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\n\n def build(o, l, r): \n if l == r:\n t[o][3] = max(nums[l], 0)\n return \n m = (l+r) // 2\n build(o*2, l, m)\n build(o*2+1, m+1, r)\n maintain(o)\n\n def update(o, l, r, i, val): \n if l == r: \n t[o][3] = max(val, 0)\n return \n m = (l+r) // 2\n if i <= m: \n update(o*2, l, m, i, val)\n else:\n update(o*2+1, m+1, r, i, val)\n maintain(o)\n\n build(1, 0, n-1)\n ans = 0\n for i, x in queries:\n update(1, 0, n-1, i, x)\n ans += t[1][3]\n return ans % 1_000_000_007","runtime":"4303"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n # f00, f01, f10, f11\n t = [[0] * 4 for _ in range(2 << n.bit_length())]\n \n def maintain(o: int):\n a, b = t[o * 2], t[o * 2 + 1]\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\n \n def build(o: int, l: int, r: int):\n if l == r:\n t[o][3] = max(nums[l], 0)\n return \n m = (l + r) // 2\n build(o * 2, l, m)\n build(o * 2 + 1, m + 1, r)\n maintain(o)\n\n def update(o: int, l: int, r: int, i: int, val: int):\n if l == r:\n t[o][3] = max(val, 0)\n return \n m = (l + r) // 2\n if i <= m:\n update(o * 2, l, m, i, val)\n else:\n update(o * 2 + 1, m + 1, r, i, val)\n maintain(o)\n \n build(1, 0, n - 1)\n ans = 0\n for i, x in queries:\n update(1, 0, n - 1, i, x)\n ans += t[1][3]\n\n return ans % (10 ** 9 + 7)","runtime":"4413"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\n BOTH = 0\n LEFT = 1\n RIGHT = 2\n NONE = 3\n N = len(nums)\n \n # segment tree\n tree = [[0, 0, 0, 0] for _ in range(4 * N)]\n\n # calculate values for just node i in the tree\n def update_i(i):\n left = tree[2 * i]\n right = tree[2 * i + 1]\n result = tree[i]\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\n\n # construct subtree at node i\n def construct(i, tl, tr):\n if tl == tr:\n tree[i][BOTH] = nums[tl]\n else:\n # construct subtrees and calculate outcome for this node\n m = (tl + tr) // 2\n construct(i * 2, tl, m)\n construct(i * 2 + 1, m + 1, tr)\n update_i(i)\n \n # update subtree at node i with change at index t in the original array\n def update(i, t, tl, tr):\n if tl == tr:\n tree[i][BOTH] = nums[t]\n else:\n m = (tl + tr) // 2\n if t <= m:\n update(i * 2, t, tl, m)\n else:\n update(i * 2 + 1, t, m + 1, tr)\n update_i(i)\n \n # construct tree\n construct(1, 0, N - 1)\n\n # process queries\n total = 0\n for q in queries:\n t, x = q\n nums[t] = x\n update(1, t, 0, N - 1)\n total += max(tree[1])\n\n return total % 1_000_000_007","runtime":"4522"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res","runtime":"4531"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4606"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n","runtime":"4620"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4638"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n\n","runtime":"4660"},{"code":"class SegmentTree:\n\n def __init__(self, arr: List[int]):\n self.n = len(arr)\n self.tree = [[0, 0, 0, 0] for _ in range(4 * self.n)]\n self._build(arr, 1, 0, self.n - 1)\n\n def _merge(self, v1: List[int], v2: List[int]) -> List[int]:\n a1, b1, c1, d1 = v1\n a2, b2, c2, d2 = v2\n\n return [\n max(a1 + c2, b1 + a2, b1 + c2),\n max(a1 + d2, b1 + b2, b1 + d2),\n max(c1 + c2, d1 + a2, d1 + c2),\n max(c1 + d2, d1 + b2, d1 + d2),\n ]\n\n def _build(self, arr: List[int], pos: int, l: int, r: int):\n if l == r:\n self.tree[pos][0] = max(0, arr[l])\n else:\n m = (l + r) // 2\n self._build(arr, 2 * pos, l, m)\n self._build(arr, 2 * pos + 1, m + 1, r)\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\n\n def _update(self, ind: int, new_val: int, pos: int, l: int, r: int):\n if l == r:\n self.tree[pos][0] = max(0, new_val)\n else:\n m = (l + r) // 2\n if ind <= m:\n self._update(ind, new_val, 2 * pos, l, m)\n else:\n self._update(ind, new_val, 2 * pos + 1, m + 1, r)\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\n\n def update(self, ind: int, new_val: int):\n self._update(ind, new_val, 1, 0, self.n - 1)\n \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n st, res = SegmentTree(nums), 0\n for ind, new_val in queries:\n st.update(ind, new_val)\n res = (res + max(st.tree[1])) % (10**9 + 7)\n \n return res","runtime":"4664"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4675"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n","runtime":"4685"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","runtime":"4692"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","runtime":"4693"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4701"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4718"},{"code":"class SegNode:\n def __init__(self, l, r, val, left, right):\n self.l, self.r, self.val = l, r, val\n self.left, self.right = left, right\n\n\nclass SegmentTree:\n def __init__(self, values):\n self.values = values\n self.root = self.build(0, len(values) - 1)\n\n def build(self, l, r):\n if l == r:\n val = [0, 0, 0, max(0, self.values[l])]\n return SegNode(l, r, val, None, None)\n mid = l + (r - l) // 2\n left = self.build(l, mid)\n right = self.build(mid+1, r)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return SegNode(l, r, val, left, right)\n\n def query(self, node, l, r):\n if l > r:\n return 0\n if node.l == l and node.r == r:\n return node.val\n\n mid = node.l + (node.r - node.l) // 2\n if mid < l:\n return self.query(node.right, l, r)\n elif mid >= r:\n return self.query(node.left, l, r)\n\n left = self.query(node.left, l, mid)\n right = self.query(node.right, mid+1, r)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def update(self, node, pos, val):\n l, r = node.l, node.r\n if l == r == pos:\n node.val[3] = val\n return\n\n mid = l + (r - l) // 2\n if pos > mid:\n self.update(node.right, pos, val)\n else:\n self.update(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n tree = SegmentTree(nums)\n ans = 0\n mod = 10 ** 9 + 7\n for i, v in queries:\n tree.update(tree.root, i, max(0, v))\n *_, q = tree.query(tree.root, 0, len(nums) - 1)\n ans = (ans + q) % mod\n\n return ans","runtime":"4748"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val.copy() # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","runtime":"4760"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4768"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4769"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4785"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n","runtime":"4831"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val.copy() # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n #print(\"build for start:\", start, \", end:\", end, \", val=\", val)\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n #print(tree.query(0, N-1))\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n #print(\" cur = \", cur)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","runtime":"4834"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n class SegTreeNode:\n def __init__(self, a, b, vals):\n self.left = None\n self.right = None\n self.start = a\n self.end = b\n self.info00 = 0\n self.info11 = 0\n self.info10 = -float('inf')\n self.info01 = -float('inf')\n \n if a == b:\n self.info11 = vals[self.start]\n return\n \n mid = (a + b) // 2\n \n self.left = SegTreeNode(a, mid, vals)\n self.right = SegTreeNode(mid + 1, b, vals)\n \n self.info11 = max(self.left.info10 + self.right.info01,\n self.left.info11 + self.right.info01,\n self.left.info10 + self.right.info11)\n self.info00 = max(self.left.info00 + self.right.info00,\n self.left.info01 + self.right.info00,\n self.left.info00 + self.right.info10)\n self.info10 = max(self.left.info10 + self.right.info00,\n self.left.info10 + self.right.info10,\n self.left.info11 + self.right.info00)\n self.info01 = max(self.left.info00 + self.right.info01,\n self.left.info01 + self.right.info01,\n self.left.info00 + self.right.info11)\n \n def update_range(self, a, val):\n if a < self.start or a > self.end:\n return\n \n if self.start == self.end:\n self.info00 = 0\n self.info11 = val\n return\n \n self.left.update_range(a, val)\n self.right.update_range(a, val)\n \n self.info11 = max(self.left.info10 + self.right.info01,\n self.left.info11 + self.right.info01,\n self.left.info10 + self.right.info11)\n self.info00 = max(self.left.info00 + self.right.info00,\n self.left.info01 + self.right.info00,\n self.left.info00 + self.right.info10)\n self.info10 = max(self.left.info10 + self.right.info00,\n self.left.info10 + self.right.info10,\n self.left.info11 + self.right.info00)\n self.info01 = max(self.left.info00 + self.right.info01,\n self.left.info01 + self.right.info01,\n self.left.info00 + self.right.info11)\n\n root = SegTreeNode(0, len(nums) - 1, nums)\n result = 0\n M = 10 ** 9 + 7\n \n for q in queries:\n root.update_range(q[0],q[1])\n result += max(root.info00, root.info01, root.info11, root.info10)\n result = result % M\n\n return result\n","runtime":"4858"},{"code":"class SegmentTreeNode:\n def __init__(self, nums, start, end):\n self.start = start\n self.end = end\n\n if start == end:\n self.select_nothing = 0\n # technically not valid\n self.select_left = -float('inf')\n # technically not valid\n self.select_right = -float('inf')\n self.select_both = nums[start]\n else:\n mid = (start + end) // 2\n left = SegmentTreeNode(nums, start, mid)\n right = SegmentTreeNode(nums, mid+1, end)\n\n self.select_nothing = max(\n left.select_nothing + right.select_nothing,\n left.select_nothing + right.select_left,\n left.select_right + right.select_nothing\n )\n\n self.select_left = max(\n left.select_both + right.select_nothing,\n left.select_left + right.select_left,\n left.select_left + right.select_nothing\n )\n\n self.select_right = max(\n left.select_nothing + right.select_both,\n left.select_nothing + right.select_right,\n left.select_right + right.select_right\n )\n\n self.select_both = max(\n left.select_both + right.select_right,\n left.select_left + right.select_both,\n left.select_left + right.select_right\n )\n\n self.left = left\n self.right = right\n \n def update(self, i, val):\n if self.start == self.end:\n self.select_both = val\n return\n if i <= self.left.end:\n self.left.update(i, val)\n elif i >= self.right.start:\n self.right.update(i, val)\n self.select_nothing = max(\n self.left.select_nothing + self.right.select_nothing,\n self.left.select_nothing + self.right.select_left,\n self.left.select_right + self.right.select_nothing\n )\n\n self.select_left = max(\n self.left.select_both + self.right.select_nothing,\n self.left.select_left + self.right.select_left,\n self.left.select_left + self.right.select_nothing\n )\n\n self.select_right = max(\n self.left.select_nothing + self.right.select_both,\n self.left.select_nothing + self.right.select_right,\n self.left.select_right + self.right.select_right\n )\n\n self.select_both = max(\n self.left.select_both + self.right.select_right,\n self.left.select_left + self.right.select_both,\n self.left.select_left + self.right.select_right\n )\n\nclass Solution:\n def maximumSumSubsequence(self, nums: list[int], queries: list[list[int]]) -> int:\n res = 0\n x = 10**9 + 7\n root = SegmentTreeNode(nums, 0, len(nums)-1)\n for i,val in queries:\n root.update(i, val)\n res += max(root.select_nothing, root.select_both, root.select_left, root.select_right)\n res = res % x\n return res\n","runtime":"4861"},{"code":"import math\n\nclass SegmentTree:\n def __init__(self, nums):\n self.n = len(nums)\n # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\n self.tree = [None] * (4 * self.n)\n self.build_tree(0, 0, self.n - 1, nums)\n\n def combine(self, left, right):\n nn, ny, yn, yy = left\n nn2, ny2, yn2, yy2 = right\n return [\n max(nn + yn2, nn + nn2, ny + nn2), # not_selected_not_selected\n max(nn + yy2, nn + ny2, ny + ny2), # not_selected_selected\n max(yn + yn2, yn + nn2, yy + nn2), # selected_not_selected\n max(yn + yy2, yn + ny2, yy + ny2) # selected_selected\n ]\n\n def build_tree(self, node, start, end, nums):\n if start == end:\n # Leaf node: [0, -inf, -inf, nums[start]]\n self.tree[node] = [0, -math.inf, -math.inf, nums[start]]\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n self.build_tree(left_child, start, mid, nums)\n self.build_tree(right_child, mid + 1, end, nums)\n \n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\n\n def update(self, node, start, end, index, value):\n if start == end:\n self.tree[node] = [0, -math.inf, -math.inf, value]\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n if index <= mid:\n self.update(left_child, start, mid, index, value)\n else:\n self.update(right_child, mid + 1, end, index, value)\n \n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = SegmentTree(nums)\n result = 0\n\n for index, value in queries:\n segment_tree.update(0, 0, len(nums) - 1, index, value)\n result += max(segment_tree.tree[0])\n result %= MOD\n\n return result","runtime":"4877"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4878"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","runtime":"4884"},{"code":"# # Data Structures: Array\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\n\n# # Short Intuition:\n# # We need to process multiple queries, where each query changes the array and requires recalculating\n# # the maximum sum of a subsequence where no two adjacent elements are selected. The goal is to return the\n# # sum of results of all queries.\n\n# # Detailed Intuition:\n# # - Each query updates one element in the array. After the update, we need to recalculate the maximum sum \n# # of a subsequence with no adjacent elements.\n# # - This problem is similar to the house robber problem, where at each element we decide whether to include it \n# # in the subsequence or skip it.\n# # - We use a simple dynamic programming approach to compute the max sum of non-adjacent elements:\n# # - Let `incl` be the maximum sum including the current element.\n# # - Let `excl` be the maximum sum excluding the current element.\n# # - After processing each query, sum up the results and return the final sum modulo 10^9 + 7.\n\n# # Pseudocode:\n# # 1. Initialize two variables `incl` and `excl` to store the maximum subsequence sum including/excluding the current element.\n# # 2. For each query:\n# # - Update the element in the array.\n# # - Recalculate the maximum sum of non-adjacent subsequence using DP.\n# # - Add the result to the final sum.\n# # 3. Return the final result modulo 10^9 + 7.\n\n# MOD = 10**9 + 7\n\n# class Solution:\n# def maxNonAdjacentSum(self, nums):\n# \"\"\"\n# Calculate the maximum sum of a subsequence where no two adjacent elements are selected.\n \n# Args:\n# nums (List[int]): The array of integers.\n \n# Returns:\n# int: The maximum sum of the subsequence with non-adjacent elements.\n# \"\"\"\n# incl, excl = 0, 0 # incl is the sum including the current element, excl is the sum excluding it\n \n# for num in nums:\n# new_incl = excl + num # Including the current element\n# excl = max(incl, excl) # Excluding the current element\n# incl = new_incl\n \n# return max(incl, excl)\n\n# def maximumSumSubsequence(self, nums, queries):\n# \"\"\"\n# Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\n \n# Args:\n# nums (List[int]): The initial array of integers.\n# queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\n \n# Returns:\n# int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\n# \"\"\"\n# total_sum = 0\n \n# for pos, xi in queries:\n# # Step 1: Update the element at position pos\n# nums[pos] = xi\n \n# # Step 2: Calculate the maximum non-adjacent subsequence sum\n# max_sum = self.maxNonAdjacentSum(nums)\n \n# # Step 3: Add to the total sum (mod MOD to avoid overflow)\n# total_sum = (total_sum + max_sum) % MOD\n \n# return total_sum\n\n# # Time Complexity: O(n * m), where n is the length of the array and m is the number of queries. \n# # We recalculate the maximum non-adjacent subsequence sum for the entire array after each query.\n# # Space Complexity: O(1) - We only use constant extra space to store the DP variables `incl` and `excl`.\n\n\ninf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n # nn: max subseq sum without using nums[i] or nums[j]\n # ny: max subseq sum without using nums[i] but with nums[j]\n # yn: max subseq sum with nums[i] but without nums[j]\n # yy: max subseq sum using both nums[i] and nums[j]\n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"4925"},{"code":"class SegmentTree:\n def __init__(self, nums):\n self.n = len(nums)\n # # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\n self.tree = [None] * (4 * self.n)\n self.inf = float(\"inf\")\n self.build_tree(0, 0, self.n - 1, nums)\n\n def build_tree(self, node, start, end, nums):\n if start == end:\n # leaf node: [0, -inf, -inf, nums[start]]\n self.tree[node] = [0, -self.inf, -self.inf, nums[start]]\n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n\n self.build_tree(left, start, mid, nums)\n self.build_tree(right, mid + 1, end, nums)\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\n\n def combine(self, left, right):\n lnn, lny, lyn, lyy = left\n rnn, rny, ryn, ryy = right\n return [\n max(lnn + ryn, lnn + rnn, lny + rnn), # not_selected_not_selected\n max(lnn + ryy, lnn + rny, lny + rny), # not_selected_selected\n max(lyn + ryn, lyn + rnn, lyy + rnn), # selected_not_selected\n max(lyn + ryy, lyn + rny, lyy + rny), # selected_selected\n ]\n\n def update(self, node, start, end, idx, val):\n if start == end:\n self.tree[node] = [0, -self.inf, -self.inf, val]\n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n\n if idx <= mid:\n self.update(left, start, mid, idx, val)\n else:\n self.update(right, mid + 1, end, idx, val)\n \n self.tree[node] = self.combine(self.tree[left], self.tree[right])\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = SegmentTree(nums)\n n = len(nums)\n ans = 0\n for idx, val in queries:\n segment_tree.update(0, 0, n - 1, idx, val)\n ans += max(segment_tree.tree[0])\n ans %= MOD\n return ans","runtime":"4982"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5015"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5016"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5028"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5111"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5138"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\n BOTH = 0\n LEFT = 1\n RIGHT = 2\n NONE = 3\n \n N = len(nums)\n \n # segment tree\n tree = [[0, 0, 0, 0]] * 4 * N\n TR = 2 ** ceil(log2(N))\n\n # calculate values for just node i in the tree\n def update_i(i):\n left = tree[2 * i]\n right = tree[2 * i + 1]\n result = [0, 0, 0, 0]\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\n tree[i] = result\n\n # construct subtree at node i\n def construct(i, tl, tr):\n if tl == tr:\n tree[i] = [nums[tl], 0, 0, 0]\n return\n \n # construct subtrees\n m = (tl + tr) // 2\n construct(i * 2, tl, m)\n if m + 1 < N:\n construct(i * 2 + 1, m + 1, tr)\n \n # calculate outcome\n update_i(i)\n \n # update subtree at node i with change at index t in the original array\n def update(i, t, tl, tr):\n if tl == tr:\n tree[i] = [nums[t], 0, 0, 0]\n else:\n m = (tl + tr) // 2\n if t <= m:\n update(i * 2, t, tl, m)\n else:\n update(i * 2 + 1, t, m + 1, tr)\n update_i(i)\n \n # construct tree\n construct(1, 0, TR)\n\n # process queries\n total = 0\n for q in queries:\n t, x = q\n nums[t] = x\n update(1, t, 0, TR)\n total += max(tree[1])\n\n return total % 1_000_000_007","runtime":"5149"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","runtime":"5241"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n maxSums = defaultdict() #first int: int/out, last: int/out\n\n\n\n def createTree(left=0, right=n-1, idx=0):\n if left > right: return\n if left == right:\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\n return\n mid = (left+right) //2\n createTree(left, mid, idx*2+1)\n createTree(mid+1, right, idx*2+2)\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\n maxSums[idx] = (inin, inout, outin, outout)\n createTree()\n # print(\"tree:\", maxSums)\n\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\n if listIdx < left or listIdx > right: return\n if left == right:\n maxSums[idx] = (max(val, 0), 0, 0, 0)\n return\n mid = (left+right) //2\n updateValue(listIdx, val,left, mid, idx*2+1)\n updateValue(listIdx, val, mid+1, right, idx*2+2)\n\n leftinin, leftinout, leftoutin, leftoutout = maxSums[idx*2+1]\n rightinin, rightinout, rightoutin, rightoutout = maxSums[idx*2+2]\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\n maxSums[idx] = (inin, inout, outin, outout)\n\n ans = 0\n for q in queries:\n pos, x = q\n updateValue(pos, x)\n ans += max(maxSums[0])\n return ans % (10**9+7)\n \n\n\n \n\n # n = len(nums)\n # if n==1:\n # ans = 0\n # for query in queries: ans += max(query[1], 0)\n # return ans\n # if n==2:\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # ans += max(0, max(nums))\n # return ans\n \n # # initially \n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\n # dp[n-1] = max(0,nums[n-1])\n # dp[n-2] = max(0,nums[n-2])\n \n # maxDpTwoStepsAway = max(dp[n-1], 0)\n # for i in range(n-3, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # # print(\"qeury:\", query,\"nums:\", nums)\n # maxDpTwoStepsAway = 0\n # if pos+2 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\n \n # for i in range(pos, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # if i + 1 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n \n # ans += max(dp)\n # # print(\"dp:\", dp)\n # return ans\n \n ","runtime":"5498"},{"code":"class Solution:\n def maximumSumSubsequence(self, performance_scores: List[int], inspections: List[List[int]]) -> int:\n \"\"\"\n Optimizes the performance of a fleet of trucks based on their performance scores and periodic inspections.\n\n Given a list of initial performance scores of trucks, and a series of inspections where the performance of\n certain trucks is updated, this function computes the maximum possible performance of the fleet, ensuring that \n no two adjacent trucks are selected for optimization. The result after all inspections is returned modulo 10^9 + 7.\n\n Args:\n performance_scores (List[int]): Initial performance scores of the fleet's trucks.\n inspections (List[List[int]]): A list of updates, where each update contains the truck index and its new performance score.\n\n Returns:\n int: The sum of the maximum subsequence performance after each inspection, modulo 10^9 + 7.\n \"\"\"\n \n MOD = 1_000_000_007\n n = len(performance_scores)\n # Segment tree to store maximum subsequence sums for different truck ranges\n segment_tree = [[0] * 4 for _ in range(4 * n)]\n\n def build_tree(node: int, start: int, end: int):\n \"\"\"\n Recursively builds the segment tree based on the initial performance scores.\n \"\"\"\n if start == end:\n segment_tree[node][0] = max(0, performance_scores[start])\n else:\n mid = (start + end) // 2\n build_tree(2 * node + 1, start, mid)\n build_tree(2 * node + 2, mid + 1, end)\n combine(node)\n\n def combine(node: int):\n \"\"\"\n Combines two child nodes in the segment tree to calculate the maximum subsequence sums for the parent node.\n \"\"\"\n left = segment_tree[2 * node + 1]\n right = segment_tree[2 * node + 2]\n # No adjacent trucks selected\n segment_tree[node][0] = max(left[2] + right[1], left[0] + right[1], left[2] + right[0])\n # Skipping the first truck\n segment_tree[node][1] = max(left[3] + right[1], left[1] + right[1], left[3] + right[0])\n # Skipping the last truck\n segment_tree[node][2] = max(left[2] + right[3], left[0] + right[3], left[2] + right[2])\n # Skipping both the first and last trucks\n segment_tree[node][3] = max(left[3] + right[3], left[1] + right[3], left[3] + right[2])\n\n def update_tree(node: int, start: int, end: int, idx: int, new_score: int):\n \"\"\"\n Updates the segment tree when a truck's performance score is changed after an inspection.\n \"\"\"\n if start == end:\n segment_tree[node][0] = max(0, new_score)\n else:\n mid = (start + end) // 2\n if idx > mid:\n update_tree(2 * node + 2, mid + 1, end, idx, new_score)\n else:\n update_tree(2 * node + 1, start, mid, idx, new_score)\n combine(node)\n\n # Build the initial segment tree\n build_tree(0, 0, n - 1)\n\n total_performance = 0\n\n # Process each inspection (update performance score and recalculate maximum subsequence sum)\n for idx, new_score in inspections:\n update_tree(0, 0, n - 1, idx, new_score)\n total_performance += max(segment_tree[0])\n total_performance %= MOD\n\n return total_performance","runtime":"5516"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n maxSums = defaultdict() #first int: int/out, last: int/out\n\n def updateEntry(idx):\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\n maxSums[idx] = (inin, inout, outin, outout)\n\n def createTree(left=0, right=n-1, idx=0):\n if left > right: return\n if left == right:\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\n return\n mid = (left+right) //2\n createTree(left, mid, idx*2+1)\n createTree(mid+1, right, idx*2+2)\n updateEntry(idx)\n \n createTree()\n # print(\"tree:\", maxSums)\n\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\n if listIdx < left or listIdx > right: return\n if left == right:\n maxSums[idx] = (max(val, 0), 0, 0, 0)\n return\n mid = (left+right) //2\n updateValue(listIdx, val,left, mid, idx*2+1)\n updateValue(listIdx, val, mid+1, right, idx*2+2)\n updateEntry(idx)\n\n ans = 0\n for q in queries:\n pos, x = q\n updateValue(pos, x)\n ans += max(maxSums[0])\n return ans % (10**9+7)\n \n\n\n \n\n # n = len(nums)\n # if n==1:\n # ans = 0\n # for query in queries: ans += max(query[1], 0)\n # return ans\n # if n==2:\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # ans += max(0, max(nums))\n # return ans\n \n # # initially \n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\n # dp[n-1] = max(0,nums[n-1])\n # dp[n-2] = max(0,nums[n-2])\n \n # maxDpTwoStepsAway = max(dp[n-1], 0)\n # for i in range(n-3, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # # print(\"qeury:\", query,\"nums:\", nums)\n # maxDpTwoStepsAway = 0\n # if pos+2 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\n \n # for i in range(pos, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # if i + 1 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n \n # ans += max(dp)\n # # print(\"dp:\", dp)\n # return ans\n \n ","runtime":"5536"},{"code":"class StVal:\n\n # Combining two nodes by adding their values (can be modified for other operations like min, max)\n def __init__(self, v : int = 0, L = None, R = None):\n\n if L == None or R == None:\n self.both = max(v,0)\n self.none = 0\n self.left = 0\n self.right = 0\n return\n \n self.both = max(L.left+R.right,L.both+R.right,L.left+R.both)\n self.none = max(L.none+R.none,L.right+R.none,L.none+R.left)\n self.left = max(L.left+R.left, L.left+R.none, L.both+R.none)\n self.right = max(L.none+R.right,L.right+R.right,L.none+R.both)\n\n\nclass SegmentTree:\n def __init__(self, v):\n \"\"\"\n :param v: The input array for the segment tree\n \"\"\"\n self.n = len(v)\n self.v = v\n self.leaves = [0] * (self.n+20)\n self.st = [StVal(v = 0)] * (10 * self.n ) # Initially fill with default StVal\n self.init(1, 0, self.n - 1)\n\n def init(self, treeIndex, low_range, high_range):\n \"\"\"\n Build the segment tree recursively\n :param treeIndex: Current index in segment tree\n :param low_range: Lower bound of current segment\n :param high_range: Upper bound of current segment\n \"\"\"\n if low_range == high_range:\n # Leaf node\n if treeIndex >= len(self.st):\n self.st = self.st + [StVal()]\n self.st[treeIndex] = StVal(v = self.v[low_range])\n self.leaves[low_range] = treeIndex # Save the index of the leaf node\n else:\n mid = (low_range + high_range) >> 1\n self.init(treeIndex << 1, low_range, mid)\n self.init((treeIndex << 1) + 1, mid + 1, high_range)\n # Merge child nodes\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\n\n def query(self, l, r):\n \"\"\"\n Public query function to find result in range [l, r]\n \"\"\"\n if l <= r and l < self.n and r >= 0:\n return self.query_recursive(l, r, 1, 0, self.n - 1)\n return StVal() # Return identity element for invalid range\n\n def query_recursive(self, left_index, right_index, treeIndex, low_range, high_range):\n \"\"\"\n Recursively query the range\n \"\"\"\n if left_index <= low_range and high_range <= right_index:\n return self.st[treeIndex]\n\n mid = (low_range + high_range) >> 1\n if right_index <= mid:\n # Only left child\n return self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\n if mid < left_index:\n # Only right child\n return self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\n\n # Overlapping segments, query both sides\n left_result = self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\n right_result = self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\n return StVal(L = left_result, R = right_result)\n\n def update(self, i, x):\n \"\"\"\n Incremental point update\n :param i: Index to update\n :param x: New value to update with\n \"\"\"\n treeIndex = self.leaves[i]\n self.st[treeIndex] = StVal(x)\n\n treeIndex = treeIndex >> 1\n while treeIndex:\n # Recompute parent nodes\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\n treeIndex = treeIndex >> 1\n\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n modulo = 10**9+7\n\n st = SegmentTree(nums)\n ans = 0\n for i in range(len(queries)):\n q = queries[i]\n st.update(q[0], q[1])\n val = st.query(0, n-1)\n \n ans = (ans + max(val.both,val.none,val.left,val.right)) % modulo\n return ans","runtime":"5654"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n base = 1\n n = len(nums)\n if n&1: # make n even\n nums.append(0)\n n += 1\n while base<n: base <<= 1\n last = base+n-1\n tree = [[[],[]],[[],[]]] # 00,01, 10,11; in(ex)cluding left and right \n for i,j in product((0,1),(0,1)):\n if i+j<2: tree[i][j] = [0]*(base+n)\n else: tree[i][j] = [0]*base + nums\n def update(p): # merge parent\n lc = p<<1\n rc = lc+1\n for i,j in product((0,1),(0,1)):\n tree[i][j][p] = max(tree[i][0][lc]+max(tree[0][j][rc],tree[1][j][rc]),\n tree[i][1][lc]+tree[0][j][rc])\n return\n for i in range(last//2,0,-1):\n update(i) # build\n #print(n,base,tree)\n ans = 0\n for pos,x in queries:\n i = base+pos\n tree[1][1][i] = x\n i >>= 1\n while i:\n update(i)\n i >>= 1\n ans += max(tree[i][j][1] for i,j in product((0,1),(0,1))) \n #\n return ans%(10**9+7) \n","runtime":"6641"},{"code":"class Node:\n def __init__(self, nums, lo, hi):\n self.l = None\n self.r = None\n self.lo = lo\n self.hi = hi\n self.selected = [[0, -float('inf')], [-float('inf'), 0]]\n\n if lo < hi:\n mid = (lo + hi) // 2\n self.l = Node(nums, lo, mid)\n self.r = Node(nums, mid + 1, hi)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = -float('inf')\n self.selected[1][0] = -float('inf')\n self.selected[1][1] = nums[lo]\n\n def combine(self):\n l, r = self.l.selected, self.r.selected\n self.selected[0][0] = max(l[0][0] + r[0][0], l[0][1] + r[0][0], l[0][0] + r[1][0])\n self.selected[0][1] = max(l[0][0] + r[0][1], l[0][1] + r[0][1], l[0][0] + r[1][1])\n self.selected[1][0] = max(l[1][0] + r[0][0], l[1][1] + r[0][0], l[1][0] + r[1][0])\n self.selected[1][1] = max(l[1][0] + r[0][1], l[1][1] + r[0][1], l[1][0] + r[1][1])\n\n def update(self, i, x):\n if i < self.lo or self.hi < i:\n return\n\n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = Node(nums, 0, len(nums) - 1)\n \n res = 0\n for query in queries:\n segment_tree.update(query[0], query[1])\n res += max(max(segment_tree.selected[0]), max(segment_tree.selected[1]))\n res %= MOD\n \n return res","runtime":"6847"},{"code":"\nclass Solution:\n\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n MOD = 10**9 + 7\n # 两边都不取 tree[o][00] = max(a[01]+b[00], a[00]+b[10])\n # 左边不取，右边可取可不取 tree[o][01] = max(a[01]+b[01], a[00]+b[11])\n # 左边可取可不取，右边不取 tree[o][10] = max(a[11]+b[00], a[10]+b[10])\n # 两边都可取可不取 tree[o][11] = max(a[11]+b[01], a[10]+b[11])\n tree = [[0] * 4 for _ in range(2 << n.bit_length())]\n\n # 单点更新线段树\n def set_value(o, l, r, idx, val):\n mid = (l + r) >> 1\n if l == idx and r == idx:\n tree[o][3] = max(val, 0)\n return\n if idx <= mid:\n set_value(o * 2 + 1, l, mid, idx, val)\n else:\n set_value(o * 2 + 2, mid + 1, r, idx, val)\n process(o)\n\n def process(o):\n a, b = tree[o * 2 + 1], tree[o * 2 + 2]\n tree[o][0] = max(a[1] + b[0], a[0] + b[2])\n tree[o][1] = max(a[1] + b[1], a[0] + b[3])\n tree[o][2] = max(a[3] + b[0], a[2] + b[2])\n tree[o][3] = max(a[3] + b[1], a[2] + b[3])\n\n for i, num in enumerate(nums):\n set_value(0, 0, n - 1, i, num)\n ans = 0\n for idx, num in queries:\n set_value(0, 0, n - 1, idx, num)\n ans += tree[0][3]\n return ans % MOD","runtime":"7007"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << (n.bit_length())\n nums += [0] * (m - n)\n n = m\n tree = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n tree[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n ans = 0\n for i, x in queries:\n update(i, x)\n ans += max(tree[1])\n return ans % 1_000_000_007","runtime":"7036"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n vals = [[0 for _ in range(4)] for _ in range(len(nums) * 4)]\n\n lst = [\n [ 0 , 0 , 0 , 0 , 0 , 0 ],\n [ 0 , 0 , 0 , 0 , 0 , 1 ],\n [ 0 , 0 , 0 , 0 , 1 , 0 ],\n [ 0 , 0 , 0 , 0 , 1 , 1 ],\n [ 0 , 0 , 0 , 1 , 0 , 1 ],\n [ 0 , 0 , 0 , 1 , 1 , 1 ],\n [ 0 , 0 , 1 , 0 , 0 , 0 ],\n [ 0 , 0 , 1 , 0 , 0 , 1 ],\n [ 0 , 0 , 1 , 0 , 1 , 0 ],\n [ 0 , 0 , 1 , 0 , 1 , 1 ],\n [ 0 , 0 , 1 , 1 , 0 , 1 ],\n [ 0 , 0 , 1 , 1 , 1 , 1 ],\n [ 0 , 1 , 0 , 0 , 0 , 0 ],\n [ 0 , 1 , 0 , 0 , 0 , 1 ],\n [ 0 , 1 , 0 , 0 , 1 , 0 ],\n [ 0 , 1 , 0 , 0 , 1 , 1 ],\n [ 0 , 1 , 0 , 1 , 0 , 1 ],\n [ 0 , 1 , 0 , 1 , 1 , 1 ],\n [ 1 , 0 , 0 , 0 , 1 , 0 ],\n [ 1 , 0 , 0 , 0 , 1 , 1 ],\n [ 1 , 0 , 0 , 1 , 1 , 1 ],\n [ 1 , 0 , 1 , 0 , 1 , 0 ],\n [ 1 , 0 , 1 , 0 , 1 , 1 ],\n [ 1 , 0 , 1 , 1 , 1 , 1 ],\n [ 1 , 1 , 0 , 0 , 1 , 0 ],\n [ 1 , 1 , 0 , 0 , 1 , 1 ],\n [ 1 , 1 , 0 , 1 , 1 , 1 ],\n ]\n\n def keep(idx, lb, rb):\n\n vals[idx] = [0 for _ in range(4)]\n\n lidx = idx * 2 + 1\n ridx = idx * 2 + 2\n\n if lb == rb:\n vals[idx][0] = max(0, nums[lb])\n\n else:\n # for i0 in (0, 1):\n # for i1 in (0, 1):\n # for j0 in (0, 1):\n # for j1 in (0, 1):\n # for k0 in (0, 1):\n # for k1 in (0, 1):\n # if i1 == 1 and j0 == 1:\n # continue\n \n # if i0 == 1 and k0 == 0:\n # continue\n\n # if j1 == 1 and k1 == 0:\n # continue\n\n \n # print(\"[\", i0, \", \", i1, \", \",j0, \", \",j1, \", \", k0, \", \", k1, \"],\")\n # node.val[k0][k1] = max(node.val[k0][k1], node.left.val[i0][i1] + node.right.val[j0][j1])\n\n # print()\n # print()\n # print()\n\n # for i0, i1, j0, j1, k0, k1 in lst:\n # vals[idx][k0][k1] = max(vals[idx][k0][k1], vals[lidx][i0][i1] + vals[ridx][j0][j1])\n\n l0h0A, l1h0A, l0h1A, l1h1A = vals[2 * idx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = vals[2 * idx + 2]\n # lo to hi\n vals[idx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n vals[idx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n vals[idx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n vals[idx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n def build(idx, lb, rb):\n\n if lb == rb:\n pass\n else:\n mid = (lb + rb) // 2\n\n build(2 * idx + 1, lb, mid)\n build(2 * idx + 2, mid + 1, rb)\n\n keep(idx, lb, rb)\n\n def update(nidx, idx, val, lb, rb):\n\n if not (lb <= idx <= rb):\n return\n\n elif lb == idx == rb:\n nums[idx] = val\n\n else:\n mid = (lb + rb) // 2\n update(2 * nidx + 1, idx, val, lb, mid)\n update(2 * nidx + 2, idx, val, mid + 1, rb)\n \n keep(nidx, lb, rb) \n\n build(0, 0, len(nums) - 1)\n\n\n res = 0\n for idx, val in queries:\n update(0, idx, val, 0, len(nums) - 1)\n res = (res + max(vals[0])) % (10 ** 9 + 7)\n\n return res\n \n","runtime":"7064"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = 0\n self.selected[1][0] = 0\n self.selected[1][1] = max(nums[lo], nums[hi])\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","runtime":"7067"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << (n.bit_length())\n nums += [0] * (m - n)\n n = m\n tree = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n tree[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\n # lo to hi\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n ans = 0\n for i, x in queries:\n update(i, x)\n ans += max(tree[1])\n return ans % 1_000_000_007","runtime":"7076"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M=10**9+7\n def buildst(n):\n for i in range(n,2*n):\n st[i]=elem(i-n)\n for i in range(n-1,0,-1):\n st[i]=merge(st[i<<1],st[i<<1|1])\n def value(l,r):\n r+=1\n if r<l:return neutral\n resl=resr=neutral;l+=n;r+=n\n while l<r:\n if l&1:\n resl=merge(resl,st[l])\n l+=1\n if r&1:\n r-=1\n if r:resr=merge(st[r],resr)\n l>>=1\n r>>=1\n return merge(resl,resr)\n def updatest(l,val):\n l+=n\n st[l]=val\n while l>1:\n l>>=1\n st[l]=merge(st[l<<1],st[l<<1|1])\n \n #[valeur, valeurs sans prendre 1er, valeur sans prendre dernier, valeur sans prendre 1er ou dernier]\n def merge(x,y):\n if x==None:\n return y\n if y==None:\n return x\n return (max(x[0],y[0],x[2]+y[0],x[0]+y[1],0),max(x[1],y[0],x[3]+y[0],x[1]+y[1],0),max(x[0],y[2],x[0]+y[3],x[2]+y[2],0),\\\n max(x[1],y[2],x[1]+y[3],x[3]+y[2],0))\n elem=lambda x:(max(0,nums[x]),0,0,0)\n neutral=None\n n=len(nums)\n st=[0]*2*n\n buildst(n)\n o=0\n for p,x in queries:\n updatest(p,(max(0,x),0,0,0))\n o+=value(0,n-1)[0]\n o%=M\n return o\n \n \n ","runtime":"7101"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << n.bit_length()\n nums += [0] * (m - n)\n n = m\n tree = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n tree[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\n # lo to hi\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n ans = 0\n\n for i, x in queries:\n update(i, x)\n ans += max(tree[1])\n return ans % 1_000_000_007","runtime":"7124"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = float('-inf')\n self.selected[1][0] = float('-inf')\n self.selected[1][1] = nums[lo]\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","runtime":"7207"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = 0\n self.selected[1][0] = 0\n self.selected[1][1] = max(nums[lo], nums[hi])\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","runtime":"7216"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], q: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << (n.bit_length())\n nums += [0] * (m - n)\n n = m\n t = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n t[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = t[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = t[2 * j + 1]\n t[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n t[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n t[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n t[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n res = 0\n for i, x in q:\n update(i, x)\n res += max(t[1])\n return res % 1_000_000_007","runtime":"7523"},{"code":"from collections import defaultdict\n\nM = 10 ** 9 + 7\n\nclass SegTree:\n def __init__(self):\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\n \n def merge(self, l, r):\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\n \n def update(self, index, val, i, j, k):\n if i + 1 == j:\n self.tree[k] = (val, 0, 0, 0)\n return\n mid = (i + j) // 2\n if index < mid:\n self.update(index, val, i, mid, 2 * k)\n else:\n self.update(index, val, mid, j, 2 * k + 1)\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\n \n def query(self, x, y, i, j, k):\n if y - 1 < i or x >= j:\n return (0, 0, 0, 0)\n if i >= x and j <= y:\n return self.tree[k]\n mid = (i + j) // 2\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n res = 0\n segtree = SegTree()\n for i in range(n):\n segtree.update(i, nums[i], 0, n, 1)\n for i, val in queries:\n segtree.update(i, val, 0, n, 1)\n res += max(segtree.query(0, n, 0, n, 1))\n res %= M\n return res","runtime":"7727"},{"code":"from collections import defaultdict\n\nM = 10 ** 9 + 7\n\nclass SegTree:\n def __init__(self):\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\n \n def merge(self, l, r):\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\n \n def update(self, index, val, i, j, k):\n if i + 1 == j:\n self.tree[k] = (val, 0, 0, 0)\n return\n mid = (i + j) // 2\n if index < mid:\n self.update(index, val, i, mid, 2 * k)\n else:\n self.update(index, val, mid, j, 2 * k + 1)\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\n \n def query(self, x, y, i, j, k):\n if y - 1 < i or x >= j:\n return (0, 0, 0, 0)\n if i >= x and j <= y:\n return self.tree[k]\n mid = (i + j) // 2\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n res = 0\n segtree = SegTree()\n for i in range(n):\n segtree.update(i, nums[i], 0, n, 1)\n for i, val in queries:\n segtree.update(i, val, 0, n, 1)\n res += max(segtree.query(0, n, 0, n, 1))\n res %= M\n return res","runtime":"7739"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = float('-inf')\n self.selected[1][0] = float('-inf')\n self.selected[1][1] = max(nums[lo], nums[hi])\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","runtime":"7749"},{"code":"class Node:\n def __init__(self, nums, lo, hi):\n self.lo = lo\n self.hi = hi\n self.selected = [[0, -float('inf')], [-float('inf'), -float('inf')]]\n \n if lo < hi:\n mid = (lo + hi) // 2\n self.l = Node(nums, lo, mid)\n self.r = Node(nums, mid + 1, hi)\n self.combine()\n else:\n self.selected[1][1] = nums[lo]\n \n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0] + self.r.selected[0][0], max(self.l.selected[0][1] + self.r.selected[0][0], self.l.selected[0][0] + self.r.selected[1][0]))\n self.selected[0][1] = max(self.l.selected[0][0] + self.r.selected[0][1], max(self.l.selected[0][1] + self.r.selected[0][1], self.l.selected[0][0] + self.r.selected[1][1]))\n self.selected[1][0] = max(self.l.selected[1][0] + self.r.selected[0][0], max(self.l.selected[1][1] + self.r.selected[0][0], self.l.selected[1][0] + self.r.selected[1][0]))\n self.selected[1][1] = max(self.l.selected[1][0] + self.r.selected[0][1], max(self.l.selected[1][1] + self.r.selected[0][1], self.l.selected[1][0] + self.r.selected[1][1]))\n\n def update(self, i, x):\n if i < self.lo or i > self.hi:\n return\n \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n \n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n segmentTree = Node(nums, 0, len(nums) - 1)\n\n res = 0\n for query in queries:\n segmentTree.update(query[0], query[1])\n res += max(segmentTree.selected[0][0], max(segmentTree.selected[0][1], max(segmentTree.selected[1][0], segmentTree.selected[1][1])))\n res %= 10**9 + 7\n return res","runtime":"7927"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n self.inf = float('inf')\n self.mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\n self.build(st, nums, 0, 0, n - 1)\n res = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\n return res\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n \n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","runtime":"8339"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\n self.build(st, nums, 0, 0, n -1)\n res = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return res\n \n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n \n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n \n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n \n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)\n ","runtime":"8407"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\n self.build(st, nums, 0, 0, n - 1)\n result = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return result\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][1][0] = -float('inf')\n st[node][0][1] = -float('inf')\n st[node][1][1] = nums[l]\n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n \n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)\n ","runtime":"8572"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\n self.build(st, nums, 0, 0, n - 1)\n res = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return res\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n \n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n \n )\n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r ) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","runtime":"8620"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\n self.build(st, nums, 0, 0, n - 1)\n result = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return result\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n \n )\n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n \n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","runtime":"8747"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n self.inf = float('inf')\n self.mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\n self.build(st, nums, 0, 0, n - 1)\n result = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\n return result\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n \n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n \n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","runtime":"8818"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\n self.build(st, nums, 0, 0, n-1)\n \n mod = 10 ** 9 + 7\n ans = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n ans = (ans + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return ans\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][1][0] = -float('inf')\n st[node][0][1] = -float('inf')\n st[node][1][1] = nums[l]\n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n \n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n \n \n )\n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n \n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","runtime":"8841"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\n self.build(st, nums, 0, 0, n - 1)\n res = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\n return res\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n \n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n \n else:\n m = (l + r) // 2\n lnode, rnode = node * 2 + 1, node * 2 + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)\n ","runtime":"8843"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # 11:17\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\n def glue(a, b):\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\n # def query(l, r, p=1, tl=0, tr=len(nums)):\n # if l == tl and r == tr:\n # return st[p];\n # tm = (tl + tr) // 2\n # return glue(query(l, min(r, tm), p * 2, tl, tm), \n # query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\n def update(pos, x, p=1, tl=0, tr=len(nums)):\n tm = (tl + tr) // 2\n if tl == tr:\n st[p][1][1] = x \n elif pos <= tm:\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\n else:\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\n return st[p]\n for i, n in enumerate(nums):\n update(i, n)\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007","runtime":"9031"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\n def glue(a, b):\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\n def query(l, r, p=1, tl=0, tr=len(nums)):\n if l == tl and r == tr:\n return st[p];\n tm = (tl + tr) // 2\n return glue(query(l, min(r, tm), p * 2, tl, tm), \n query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\n def update(pos, x, p=1, tl=0, tr=len(nums)):\n tm = (tl + tr) // 2\n if tl == tr:\n st[p][1][1] = x \n elif pos <= tm:\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\n else:\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\n return st[p]\n for i, n in enumerate(nums):\n update(i, n)\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007","runtime":"9053"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n class node:\\n def __init__(self,num,val):\\n self.range_left=num\\n self.range_right=num+1\\n self.full_v=max(val,0)\\n self.nleft_v=0\\n self.nright_v=0\\n self.nboth_v=0\\n\\n @classmethod\\n def grow(cls,range_left,range_right):\\n if range_right-range_left==1:\\n return node(range_left,nums[range_left])\\n root=node(0,0)\\n root.range_left=range_left\\n root.range_right=range_right\\n mid=(range_left+range_right)//2\\n root.left=cls.grow(range_left,mid)\\n root.right=cls.grow(mid,range_right)\\n root.left.parent=root\\n root.right.parent=root\\n root.parent=None\\n root.merge()\\n return root\\n \\n def merge(self):\\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\\n\\n def seek(self,n):\\n if self.range_left==n and self.range_right==n+1:\\n return self\\n mid=(self.range_left+self.range_right)//2\\n if n<mid:\\n return self.left.seek(n)\\n else:\\n return self.right.seek(n)\\n \\n def update_leaf(self,v):\\n self.full_v=max(v,0)\\n t=self.parent\\n while t:\\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\\n t.merge()\\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\\n break\\n t=t.parent\\n \\n root=node.grow(0,len(nums))\\n root.parent=None\\n sums=0\\n for i in queries:\\n nd=root.seek(i[0])\\n nd.update_leaf(i[1])\\n sums+=root.full_v\\n sums%=(10**9+7)\\n return sums\\n\\n\\n\",\n \"runtime\": \"3679\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n class node:\\n def __init__(self,num,val):\\n self.range_left=num\\n self.range_right=num+1\\n self.full_v=max(val,0)\\n self.nleft_v=0\\n self.nright_v=0\\n self.nboth_v=0\\n\\n @classmethod\\n def grow(cls,range_left,range_right):\\n if range_right-range_left==1:\\n return node(range_left,nums[range_left])\\n root=node(0,0)\\n root.range_left=range_left\\n root.range_right=range_right\\n mid=(range_left+range_right)//2\\n root.left=cls.grow(range_left,mid)\\n root.right=cls.grow(mid,range_right)\\n root.left.parent=root\\n root.right.parent=root\\n root.parent=None\\n root.merge()\\n return root\\n \\n def merge(self):\\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\\n\\n def seek(self,n):\\n if self.range_left==n and self.range_right==n+1:\\n return self\\n mid=(self.range_left+self.range_right)//2\\n if n<mid:\\n return self.left.seek(n)\\n else:\\n return self.right.seek(n)\\n \\n def update_leaf(self,v):\\n self.full_v=max(v,0)\\n t=self.parent\\n while t:\\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\\n t.merge()\\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\\n break\\n t=t.parent\\n \\n root=node.grow(0,len(nums))\\n root.parent=None\\n sums=0\\n for i in queries:\\n nd=root.seek(i[0])\\n nd.update_leaf(i[1])\\n sums+=root.full_v\\n sums%=(10**9+7)\\n return sums\\n\\n\",\n \"runtime\": \"3680\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self,start,end):\\n self.l = start\\n self.r = end\\n self.n = end-start+1\\n self.left = None\\n self.right = None\\n \\n self.all = 0\\n self.left_loo = 0\\n self.right_loo = 0\\n self.both_loo = 0\\n \\nclass QueryTree:\\n def __init__(self,nums):\\n self.nums = nums\\n self.root = self.build(0, len(nums)-1)\\n self.calc(self.root)\\n \\n def build(self,start,end):\\n if start == end:\\n return Node(start,end)\\n \\n mid = (start+end)//2\\n root = Node(start,end)\\n root.left = self.build(start,mid)\\n root.right = self.build(mid+1,end)\\n return root\\n \\n def calc(self,node):\\n if node is None:\\n return \\n \\n if node.n == 1:\\n node.all = max(self.nums[node.l],0)\\n node.left_loo = 0\\n node.right_loo = 0\\n node.both_loo = 0\\n return\\n \\n # node has at least two children\\n self.calc(node.left)\\n self.calc(node.right)\\n \\n node.all = max(node.left.all + node.right.left_loo, \\n node.left.right_loo + node.right.all)\\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\\n node.left.both_loo + node.right.all)\\n node.right_loo = max(node.left.all + node.right.both_loo,\\n node.left.right_loo + node.right.right_loo)\\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\\n node.left.both_loo + node.right.right_loo) \\n \\n def query(self):\\n return self.root.all\\n \\n def update(self,i,x):\\n self.nums[i] = x\\n self.recalc(self.root,i)\\n \\n def recalc(self,node,i):\\n if node is None:\\n return \\n \\n if node.n == 1:\\n if node.l == i:\\n node.all = max(self.nums[i],0)\\n return \\n \\n if (i < node.l) or (i > node.r):\\n return \\n \\n if i <= node.left.r:\\n self.recalc(node.left,i)\\n if i >= node.right.l:\\n self.recalc(node.right,i)\\n \\n node.all = max(node.left.all + node.right.left_loo, \\n node.left.right_loo + node.right.all)\\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\\n node.left.both_loo + node.right.all)\\n node.right_loo = max(node.left.all + node.right.both_loo,\\n node.left.right_loo + node.right.right_loo)\\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\\n node.left.both_loo + node.right.right_loo) \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n ans = []\\n qt = QueryTree(nums)\\n for i,x in queries:\\n qt.update(i,x)\\n ans.append(qt.query())\\n return sum(ans) % (10 ** 9 + 7)\",\n \"runtime\": \"3783\"\n },\n {\n \"code\": \"class Tree:\\n def __init__(self, l, r):\\n self.l = l\\n self.r = r\\n self.lt = None\\n self.rt = None\\n\\n self.noExc = 0\\n self.lExc = 0\\n self.rExc = 0\\n self.bothExc = 0\\n\\n\\n @staticmethod\\n def build(l, r, nums):\\n tree = Tree(l, r)\\n if l == r:\\n tree.noExc = nums[l]\\n return tree\\n\\n mid = l + (r-l)//2\\n tree.lt = Tree.build(l, mid, nums)\\n tree.rt = Tree.build(mid+1, r, nums)\\n tree.updateSsq()\\n return tree\\n\\n def update(self, idx, val):\\n if self.l == self.r:\\n self.noExc = max(val, 0)\\n return\\n\\n mid = self.l + (self.r-self.l)//2\\n\\n if idx <= mid:\\n self.lt.update(idx, val)\\n else:\\n self.rt.update(idx, val)\\n\\n self.updateSsq()\\n\\n def updateSsq(self):\\n self.noExc = max(self.lt.noExc + self.rt.lExc, self.lt.rExc + self.rt.noExc)\\n self.lExc = max(self.lt.lExc + self.rt.lExc, self.lt.bothExc + self.rt.noExc)\\n self.rExc = max(self.lt.noExc + self.rt.bothExc, self.lt.rExc + self.rt.rExc)\\n self.bothExc = max(self.lt.lExc + self.rt.bothExc, self.lt.bothExc + self.rt.rExc)\\n # print(self.noExc, self.lExc, self.rExc, self.noExc)\\n \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n n = len(nums)\\n MOD = 10**9 + 7\\n\\n tree = Tree.build(0, n-1, nums)\\n # print(tree.noExc)\\n ans = 0\\n for idx, val in queries:\\n tree.update(idx, val)\\n # print(tree.noExc)\\n ans += tree.noExc % MOD\\n\\n return ans % MOD\\n\\n# |----| + |-| |----|\\n# or |---| |-| + |---| \\n# all = max(l [] + r (], l [) + r[])\\n# (] = max(l (] + r(], l () + r[])\\n# [) = max(l [) + r[), l [] + r())\\n# () = max(l (] + r(), l() + r[))\\n\",\n \"runtime\": \"4072\"\n },\n {\n \"code\": \"modulus = 1000000007\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = Tree(0, len(nums), nums)\\n result = 0\\n for i, value in queries:\\n tree.change(i, value)\\n result = (result + tree.max) % modulus\\n return result\\n\\nclass Tree:\\n def __init__(self, start, end, nums):\\n self.start = start\\n self.end = end\\n\\n if end - start == 1:\\n self.max_without_start = 0\\n self.max_without_end = 0\\n self.max_without_either = 0\\n self.max = max(0, nums[start])\\n else:\\n mid = (start + end) // 2\\n self.left = Tree(start, mid, nums)\\n self.right = Tree(mid, end, nums)\\n self.update()\\n\\n def change(self, i, value):\\n if self.end - self.start == 1:\\n self.max = max(0, value)\\n return\\n if i < (self.start + self.end) // 2:\\n self.left.change(i, value)\\n else:\\n self.right.change(i, value)\\n self.update()\\n\\n def update(self):\\n self.max_without_start = max(\\n self.left.max_without_start + self.right.max_without_start,\\n self.left.max_without_either + self.right.max\\n ) % modulus\\n self.max_without_end = max(\\n self.left.max_without_end + self.right.max_without_end,\\n self.left.max + self.right.max_without_either\\n ) % modulus\\n self.max_without_either = max(\\n self.left.max_without_start + self.right.max_without_either,\\n self.left.max_without_either + self.right.max_without_end\\n ) % modulus\\n self.max = max(\\n self.left.max_without_end + self.right.max,\\n self.left.max + self.right.max_without_start\\n ) % modulus\",\n \"runtime\": \"4078\"\n },\n {\n \"code\": \"import typing\\n\\n\\nclass SegTree:\\n def __init__(\\n self,\\n op: typing.Callable[[typing.Any, typing.Any], typing.Any],\\n e: typing.Any,\\n v: typing.Union[int, typing.List[typing.Any]],\\n ) -> None:\\n self._op = op\\n self._e = e\\n\\n if isinstance(v, int):\\n v = [e] * v\\n\\n self._n = len(v)\\n self._log = self._ceil_pow2(self._n)\\n self._size = 1 << self._log\\n self._d = [e] * (2 * self._size)\\n\\n for i in range(self._n):\\n self._d[self._size + i] = v[i]\\n for i in range(self._size - 1, 0, -1):\\n self._update(i)\\n\\n def set(self, p: int, x: typing.Any) -> None:\\n assert 0 <= p < self._n\\n\\n p += self._size\\n self._d[p] = x\\n for i in range(1, self._log + 1):\\n self._update(p >> i)\\n\\n def get(self, p: int) -> typing.Any:\\n assert 0 <= p < self._n\\n\\n return self._d[p + self._size]\\n\\n def prod(self, left: int, right: int) -> typing.Any:\\n assert 0 <= left <= right <= self._n\\n sml = self._e\\n smr = self._e\\n left += self._size\\n right += self._size\\n\\n while left < right:\\n if left & 1:\\n sml = self._op(sml, self._d[left])\\n left += 1\\n if right & 1:\\n right -= 1\\n smr = self._op(self._d[right], smr)\\n left >>= 1\\n right >>= 1\\n\\n return self._op(sml, smr)\\n\\n def all_prod(self) -> typing.Any:\\n return self._d[1]\\n\\n def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int:\\n assert 0 <= left <= self._n\\n assert f(self._e)\\n\\n if left == self._n:\\n return self._n\\n\\n left += self._size\\n sm = self._e\\n\\n first = True\\n while first or (left & -left) != left:\\n first = False\\n while left % 2 == 0:\\n left >>= 1\\n if not f(self._op(sm, self._d[left])):\\n while left < self._size:\\n left *= 2\\n if f(self._op(sm, self._d[left])):\\n sm = self._op(sm, self._d[left])\\n left += 1\\n return left - self._size\\n sm = self._op(sm, self._d[left])\\n left += 1\\n\\n return self._n\\n\\n def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int:\\n assert 0 <= right <= self._n\\n assert f(self._e)\\n\\n if right == 0:\\n return 0\\n\\n right += self._size\\n sm = self._e\\n\\n first = True\\n while first or (right & -right) != right:\\n first = False\\n right -= 1\\n while right > 1 and right % 2:\\n right >>= 1\\n if not f(self._op(self._d[right], sm)):\\n while right < self._size:\\n right = 2 * right + 1\\n if f(self._op(self._d[right], sm)):\\n sm = self._op(self._d[right], sm)\\n right -= 1\\n return right + 1 - self._size\\n sm = self._op(self._d[right], sm)\\n\\n return 0\\n\\n def _update(self, k: int) -> None:\\n self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])\\n\\n @staticmethod\\n def _ceil_pow2(n: int) -> int:\\n x = 0\\n while (1 << x) < n:\\n x += 1\\n\\n return x\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n\\n def op(x, y) -> int:\\n left_max_without_start, left_max_without_end, left_max_without_either, left_max = x\\n right_max_without_start, right_max_without_end, right_max_without_either, right_max = y\\n\\n return (\\n max(left_max_without_start + right_max_without_start, left_max_without_either + right_max) % MOD,\\n max(left_max_without_end + right_max_without_end, left_max + right_max_without_either) % MOD,\\n max(left_max_without_start + right_max_without_either, left_max_without_either + right_max_without_end) % MOD,\\n max(left_max_without_end + right_max, left_max + right_max_without_start) % MOD,\\n )\\n\\n e = (0, 0, 0, 0)\\n nodes = [(0, 0, 0, max(num, 0)) for num in nums]\\n seg_tree = SegTree(op, e, nodes)\\n\\n ans = 0\\n for pos, x in queries:\\n seg_tree.set(pos, (0, 0, 0, max(0, x)))\\n _, _, _, v = seg_tree.all_prod()\\n ans += v % MOD\\n return ans % MOD\\n\\n\",\n \"runtime\": \"4085\"\n },\n {\n \"code\": \"class SegTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.tree = [None] * (4 * self.n)\\n self.build(nums, 0, 0, self.n - 1)\\n \\n def build(self, nums, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, nums[start]), 0, 0, 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n self.build(nums, left_child, start, mid)\\n self.build(nums, right_child, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n \\n def merge(self, left, right):\\n include = max(left[2] + right[0], left[0] + right[1])\\n exclude_l = max(left[3] + right[0], left[1] + right[1])\\n exclude_r = max(left[2] + right[2], left[0] + right[3])\\n exclude_both = max(left[3] + right[2], left[1] + right[3])\\n return (include, exclude_l, exclude_r, exclude_both)\\n \\n def update(self, idx, value, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, value), 0, 0, 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n if start <= idx <= mid:\\n self.update(idx, value, left_child, start, mid)\\n else:\\n self.update(idx, value, right_child, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n \\n def query(self):\\n return self.tree[0][0]\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n\\n segtree = SegTree(nums)\\n \\n MOD = 10 ** 9 + 7\\n \\n res = 0\\n for pos, val in queries:\\n segtree.update(pos, val, 0, 0, segtree.n - 1)\\n \\n #segtree.print_tree()\\n #print(segtree.query())\\n \\n res = (res + segtree.query()) % MOD\\n \\n return res\\n \",\n \"runtime\": \"4151\"\n },\n {\n \"code\": \"class SegTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.tree = [0] * (4 * self.n)\\n self.build(nums, 0, 0, self.n - 1)\\n \\n def build(self, nums, node, start, end):\\n if start == end:\\n self.tree[node] = (max(nums[start], 0), 0, 0, 0)\\n \\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n self.build(nums, left, start, mid)\\n self.build(nums, right, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\\n \\n def merge(self, left, right):\\n include = max(left[2] + right[0], left[0] + right[1])\\n ex_l = max(left[1] + right[1], left[3] + right[0])\\n ex_r = max(left[2] + right[2], left[0] + right[3])\\n ex_both = max(left[3] + right[2], left[1] + right[3])\\n return (include, ex_l, ex_r, ex_both)\\n \\n def update(self, idx, value, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, value), 0, 0, 0)\\n \\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n if start <= idx <= mid:\\n self.update(idx, value, left, start, mid)\\n else:\\n self.update(idx, value, right, mid + 1, end)\\n\\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\\n return\\n \\n def query(self):\\n return self.tree[0][0]\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n segtree = SegTree(nums)\\n mod = 10 ** 9 + 7\\n\\n ans = 0\\n for pos, val in queries:\\n segtree.update(pos, val, 0, 0, segtree.n - 1)\\n\\n ans = (ans + segtree.query()) % mod\\n\\n return ans\",\n \"runtime\": \"4156\"\n },\n {\n \"code\": \"class SegTree: \\n\\n def __init__(self, arr: List[int]):\\n self.n = n = len(arr)\\n self.tree = [0]*(4*n)\\n self._build(arr, 0, 0, n)\\n \\n def _op(self, left, right): \\n lv, ls, le, lse = left\\n rv, rs, re, rse = right \\n ov = max(le+rv, lv+rs)\\n os = max(ls+rs, lse+rv)\\n oe = max(le+re, lv+rse)\\n ose = max(lse+re, ls+rse)\\n return (ov, os, oe, ose)\\n\\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\\n else:\\n mid = lo + hi >> 1\\n self._build(arr, 2*k+1, lo, mid)\\n self._build(arr, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\\n if not hi: hi = self.n\\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\\n else: \\n mid = lo + hi >> 1\\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\\n else: self.update(i, x, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \\n if not hi: hi = self.n\\n if qhi <= lo or hi <= qlo: return inf # no overlap \\n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \\n mid = lo + hi >> 1 # partial overlap \\n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = SegTree(nums)\\n ans = 0 \\n for i, x in queries: \\n tree.update(i, x)\\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\\n return ans \",\n \"runtime\": \"4180\"\n },\n {\n \"code\": \"class SegTree: \\n\\n def __init__(self, arr: List[int]):\\n self.n = n = len(arr)\\n self.tree = [0]*(4*n)\\n self._build(arr, 0, 0, n)\\n \\n def _op(self, left, right): \\n lv, ls, le, lse = left\\n rv, rs, re, rse = right \\n v = max(le+rv, lv+rs)\\n s = max(ls+rs, lse+rv)\\n e = max(le+re, lv+rse)\\n se = max(lse+re, ls+rse)\\n return (v, s, e, se)\\n\\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\\n else:\\n mid = lo + hi >> 1\\n self._build(arr, 2*k+1, lo, mid)\\n self._build(arr, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\\n if not hi: hi = self.n\\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\\n else: \\n mid = lo + hi >> 1\\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\\n else: self.update(i, x, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \\n if not hi: hi = self.n\\n if qhi <= lo or hi <= qlo: return inf # no overlap \\n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \\n mid = lo + hi >> 1 # partial overlap \\n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = SegTree(nums)\\n ans = 0 \\n for i, x in queries: \\n tree.update(i, x)\\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\\n return ans \",\n \"runtime\": \"4293\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tmp = 1\\n while tmp < len(nums):\\n tmp *= 2\\n t = [[0]*4 for _ in range(tmp*2)]\\n\\n n = len(nums)\\n\\n def maintain(o: int):\\n a, b = t[o * 2], t[o * 2 + 1]\\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\\n\\n def build(o, l, r): \\n if l == r:\\n t[o][3] = max(nums[l], 0)\\n return \\n m = (l+r) // 2\\n build(o*2, l, m)\\n build(o*2+1, m+1, r)\\n maintain(o)\\n\\n def update(o, l, r, i, val): \\n if l == r: \\n t[o][3] = max(val, 0)\\n return \\n m = (l+r) // 2\\n if i <= m: \\n update(o*2, l, m, i, val)\\n else:\\n update(o*2+1, m+1, r, i, val)\\n maintain(o)\\n\\n build(1, 0, n-1)\\n ans = 0\\n for i, x in queries:\\n update(1, 0, n-1, i, x)\\n ans += t[1][3]\\n return ans % 1_000_000_007\",\n \"runtime\": \"4303\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n # f00, f01, f10, f11\\n t = [[0] * 4 for _ in range(2 << n.bit_length())]\\n \\n def maintain(o: int):\\n a, b = t[o * 2], t[o * 2 + 1]\\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\\n \\n def build(o: int, l: int, r: int):\\n if l == r:\\n t[o][3] = max(nums[l], 0)\\n return \\n m = (l + r) // 2\\n build(o * 2, l, m)\\n build(o * 2 + 1, m + 1, r)\\n maintain(o)\\n\\n def update(o: int, l: int, r: int, i: int, val: int):\\n if l == r:\\n t[o][3] = max(val, 0)\\n return \\n m = (l + r) // 2\\n if i <= m:\\n update(o * 2, l, m, i, val)\\n else:\\n update(o * 2 + 1, m + 1, r, i, val)\\n maintain(o)\\n \\n build(1, 0, n - 1)\\n ans = 0\\n for i, x in queries:\\n update(1, 0, n - 1, i, x)\\n ans += t[1][3]\\n\\n return ans % (10 ** 9 + 7)\",\n \"runtime\": \"4413\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\\n BOTH = 0\\n LEFT = 1\\n RIGHT = 2\\n NONE = 3\\n N = len(nums)\\n \\n # segment tree\\n tree = [[0, 0, 0, 0] for _ in range(4 * N)]\\n\\n # calculate values for just node i in the tree\\n def update_i(i):\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n result = tree[i]\\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\\n\\n # construct subtree at node i\\n def construct(i, tl, tr):\\n if tl == tr:\\n tree[i][BOTH] = nums[tl]\\n else:\\n # construct subtrees and calculate outcome for this node\\n m = (tl + tr) // 2\\n construct(i * 2, tl, m)\\n construct(i * 2 + 1, m + 1, tr)\\n update_i(i)\\n \\n # update subtree at node i with change at index t in the original array\\n def update(i, t, tl, tr):\\n if tl == tr:\\n tree[i][BOTH] = nums[t]\\n else:\\n m = (tl + tr) // 2\\n if t <= m:\\n update(i * 2, t, tl, m)\\n else:\\n update(i * 2 + 1, t, m + 1, tr)\\n update_i(i)\\n \\n # construct tree\\n construct(1, 0, N - 1)\\n\\n # process queries\\n total = 0\\n for q in queries:\\n t, x = q\\n nums[t] = x\\n update(1, t, 0, N - 1)\\n total += max(tree[1])\\n\\n return total % 1_000_000_007\",\n \"runtime\": \"4522\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\",\n \"runtime\": \"4531\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4606\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\",\n \"runtime\": \"4620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4638\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"runtime\": \"4660\"\n },\n {\n \"code\": \"class SegmentTree:\\n\\n def __init__(self, arr: List[int]):\\n self.n = len(arr)\\n self.tree = [[0, 0, 0, 0] for _ in range(4 * self.n)]\\n self._build(arr, 1, 0, self.n - 1)\\n\\n def _merge(self, v1: List[int], v2: List[int]) -> List[int]:\\n a1, b1, c1, d1 = v1\\n a2, b2, c2, d2 = v2\\n\\n return [\\n max(a1 + c2, b1 + a2, b1 + c2),\\n max(a1 + d2, b1 + b2, b1 + d2),\\n max(c1 + c2, d1 + a2, d1 + c2),\\n max(c1 + d2, d1 + b2, d1 + d2),\\n ]\\n\\n def _build(self, arr: List[int], pos: int, l: int, r: int):\\n if l == r:\\n self.tree[pos][0] = max(0, arr[l])\\n else:\\n m = (l + r) // 2\\n self._build(arr, 2 * pos, l, m)\\n self._build(arr, 2 * pos + 1, m + 1, r)\\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\\n\\n def _update(self, ind: int, new_val: int, pos: int, l: int, r: int):\\n if l == r:\\n self.tree[pos][0] = max(0, new_val)\\n else:\\n m = (l + r) // 2\\n if ind <= m:\\n self._update(ind, new_val, 2 * pos, l, m)\\n else:\\n self._update(ind, new_val, 2 * pos + 1, m + 1, r)\\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\\n\\n def update(self, ind: int, new_val: int):\\n self._update(ind, new_val, 1, 0, self.n - 1)\\n \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n st, res = SegmentTree(nums), 0\\n for ind, new_val in queries:\\n st.update(ind, new_val)\\n res = (res + max(st.tree[1])) % (10**9 + 7)\\n \\n return res\",\n \"runtime\": \"4664\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4675\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\",\n \"runtime\": \"4685\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"runtime\": \"4692\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"runtime\": \"4693\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4701\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4718\"\n },\n {\n \"code\": \"class SegNode:\\n def __init__(self, l, r, val, left, right):\\n self.l, self.r, self.val = l, r, val\\n self.left, self.right = left, right\\n\\n\\nclass SegmentTree:\\n def __init__(self, values):\\n self.values = values\\n self.root = self.build(0, len(values) - 1)\\n\\n def build(self, l, r):\\n if l == r:\\n val = [0, 0, 0, max(0, self.values[l])]\\n return SegNode(l, r, val, None, None)\\n mid = l + (r - l) // 2\\n left = self.build(l, mid)\\n right = self.build(mid+1, r)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return SegNode(l, r, val, left, right)\\n\\n def query(self, node, l, r):\\n if l > r:\\n return 0\\n if node.l == l and node.r == r:\\n return node.val\\n\\n mid = node.l + (node.r - node.l) // 2\\n if mid < l:\\n return self.query(node.right, l, r)\\n elif mid >= r:\\n return self.query(node.left, l, r)\\n\\n left = self.query(node.left, l, mid)\\n right = self.query(node.right, mid+1, r)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def update(self, node, pos, val):\\n l, r = node.l, node.r\\n if l == r == pos:\\n node.val[3] = val\\n return\\n\\n mid = l + (r - l) // 2\\n if pos > mid:\\n self.update(node.right, pos, val)\\n else:\\n self.update(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n tree = SegmentTree(nums)\\n ans = 0\\n mod = 10 ** 9 + 7\\n for i, v in queries:\\n tree.update(tree.root, i, max(0, v))\\n *_, q = tree.query(tree.root, 0, len(nums) - 1)\\n ans = (ans + q) % mod\\n\\n return ans\",\n \"runtime\": \"4748\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val.copy() # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"runtime\": \"4760\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4768\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4769\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4785\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\",\n \"runtime\": \"4831\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val.copy() # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n #print(\\\"build for start:\\\", start, \\\", end:\\\", end, \\\", val=\\\", val)\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n #print(tree.query(0, N-1))\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n #print(\\\" cur = \\\", cur)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"runtime\": \"4834\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n class SegTreeNode:\\n def __init__(self, a, b, vals):\\n self.left = None\\n self.right = None\\n self.start = a\\n self.end = b\\n self.info00 = 0\\n self.info11 = 0\\n self.info10 = -float('inf')\\n self.info01 = -float('inf')\\n \\n if a == b:\\n self.info11 = vals[self.start]\\n return\\n \\n mid = (a + b) // 2\\n \\n self.left = SegTreeNode(a, mid, vals)\\n self.right = SegTreeNode(mid + 1, b, vals)\\n \\n self.info11 = max(self.left.info10 + self.right.info01,\\n self.left.info11 + self.right.info01,\\n self.left.info10 + self.right.info11)\\n self.info00 = max(self.left.info00 + self.right.info00,\\n self.left.info01 + self.right.info00,\\n self.left.info00 + self.right.info10)\\n self.info10 = max(self.left.info10 + self.right.info00,\\n self.left.info10 + self.right.info10,\\n self.left.info11 + self.right.info00)\\n self.info01 = max(self.left.info00 + self.right.info01,\\n self.left.info01 + self.right.info01,\\n self.left.info00 + self.right.info11)\\n \\n def update_range(self, a, val):\\n if a < self.start or a > self.end:\\n return\\n \\n if self.start == self.end:\\n self.info00 = 0\\n self.info11 = val\\n return\\n \\n self.left.update_range(a, val)\\n self.right.update_range(a, val)\\n \\n self.info11 = max(self.left.info10 + self.right.info01,\\n self.left.info11 + self.right.info01,\\n self.left.info10 + self.right.info11)\\n self.info00 = max(self.left.info00 + self.right.info00,\\n self.left.info01 + self.right.info00,\\n self.left.info00 + self.right.info10)\\n self.info10 = max(self.left.info10 + self.right.info00,\\n self.left.info10 + self.right.info10,\\n self.left.info11 + self.right.info00)\\n self.info01 = max(self.left.info00 + self.right.info01,\\n self.left.info01 + self.right.info01,\\n self.left.info00 + self.right.info11)\\n\\n root = SegTreeNode(0, len(nums) - 1, nums)\\n result = 0\\n M = 10 ** 9 + 7\\n \\n for q in queries:\\n root.update_range(q[0],q[1])\\n result += max(root.info00, root.info01, root.info11, root.info10)\\n result = result % M\\n\\n return result\\n\",\n \"runtime\": \"4858\"\n },\n {\n \"code\": \"class SegmentTreeNode:\\n def __init__(self, nums, start, end):\\n self.start = start\\n self.end = end\\n\\n if start == end:\\n self.select_nothing = 0\\n # technically not valid\\n self.select_left = -float('inf')\\n # technically not valid\\n self.select_right = -float('inf')\\n self.select_both = nums[start]\\n else:\\n mid = (start + end) // 2\\n left = SegmentTreeNode(nums, start, mid)\\n right = SegmentTreeNode(nums, mid+1, end)\\n\\n self.select_nothing = max(\\n left.select_nothing + right.select_nothing,\\n left.select_nothing + right.select_left,\\n left.select_right + right.select_nothing\\n )\\n\\n self.select_left = max(\\n left.select_both + right.select_nothing,\\n left.select_left + right.select_left,\\n left.select_left + right.select_nothing\\n )\\n\\n self.select_right = max(\\n left.select_nothing + right.select_both,\\n left.select_nothing + right.select_right,\\n left.select_right + right.select_right\\n )\\n\\n self.select_both = max(\\n left.select_both + right.select_right,\\n left.select_left + right.select_both,\\n left.select_left + right.select_right\\n )\\n\\n self.left = left\\n self.right = right\\n \\n def update(self, i, val):\\n if self.start == self.end:\\n self.select_both = val\\n return\\n if i <= self.left.end:\\n self.left.update(i, val)\\n elif i >= self.right.start:\\n self.right.update(i, val)\\n self.select_nothing = max(\\n self.left.select_nothing + self.right.select_nothing,\\n self.left.select_nothing + self.right.select_left,\\n self.left.select_right + self.right.select_nothing\\n )\\n\\n self.select_left = max(\\n self.left.select_both + self.right.select_nothing,\\n self.left.select_left + self.right.select_left,\\n self.left.select_left + self.right.select_nothing\\n )\\n\\n self.select_right = max(\\n self.left.select_nothing + self.right.select_both,\\n self.left.select_nothing + self.right.select_right,\\n self.left.select_right + self.right.select_right\\n )\\n\\n self.select_both = max(\\n self.left.select_both + self.right.select_right,\\n self.left.select_left + self.right.select_both,\\n self.left.select_left + self.right.select_right\\n )\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: list[int], queries: list[list[int]]) -> int:\\n res = 0\\n x = 10**9 + 7\\n root = SegmentTreeNode(nums, 0, len(nums)-1)\\n for i,val in queries:\\n root.update(i, val)\\n res += max(root.select_nothing, root.select_both, root.select_left, root.select_right)\\n res = res % x\\n return res\\n\",\n \"runtime\": \"4861\"\n },\n {\n \"code\": \"import math\\n\\nclass SegmentTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\\n self.tree = [None] * (4 * self.n)\\n self.build_tree(0, 0, self.n - 1, nums)\\n\\n def combine(self, left, right):\\n nn, ny, yn, yy = left\\n nn2, ny2, yn2, yy2 = right\\n return [\\n max(nn + yn2, nn + nn2, ny + nn2), # not_selected_not_selected\\n max(nn + yy2, nn + ny2, ny + ny2), # not_selected_selected\\n max(yn + yn2, yn + nn2, yy + nn2), # selected_not_selected\\n max(yn + yy2, yn + ny2, yy + ny2) # selected_selected\\n ]\\n\\n def build_tree(self, node, start, end, nums):\\n if start == end:\\n # Leaf node: [0, -inf, -inf, nums[start]]\\n self.tree[node] = [0, -math.inf, -math.inf, nums[start]]\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n self.build_tree(left_child, start, mid, nums)\\n self.build_tree(right_child, mid + 1, end, nums)\\n \\n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\\n\\n def update(self, node, start, end, index, value):\\n if start == end:\\n self.tree[node] = [0, -math.inf, -math.inf, value]\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n if index <= mid:\\n self.update(left_child, start, mid, index, value)\\n else:\\n self.update(right_child, mid + 1, end, index, value)\\n \\n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = SegmentTree(nums)\\n result = 0\\n\\n for index, value in queries:\\n segment_tree.update(0, 0, len(nums) - 1, index, value)\\n result += max(segment_tree.tree[0])\\n result %= MOD\\n\\n return result\",\n \"runtime\": \"4877\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4878\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"runtime\": \"4884\"\n },\n {\n \"code\": \"# # Data Structures: Array\\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\\n\\n# # Short Intuition:\\n# # We need to process multiple queries, where each query changes the array and requires recalculating\\n# # the maximum sum of a subsequence where no two adjacent elements are selected. The goal is to return the\\n# # sum of results of all queries.\\n\\n# # Detailed Intuition:\\n# # - Each query updates one element in the array. After the update, we need to recalculate the maximum sum \\n# # of a subsequence with no adjacent elements.\\n# # - This problem is similar to the house robber problem, where at each element we decide whether to include it \\n# # in the subsequence or skip it.\\n# # - We use a simple dynamic programming approach to compute the max sum of non-adjacent elements:\\n# # - Let `incl` be the maximum sum including the current element.\\n# # - Let `excl` be the maximum sum excluding the current element.\\n# # - After processing each query, sum up the results and return the final sum modulo 10^9 + 7.\\n\\n# # Pseudocode:\\n# # 1. Initialize two variables `incl` and `excl` to store the maximum subsequence sum including/excluding the current element.\\n# # 2. For each query:\\n# # - Update the element in the array.\\n# # - Recalculate the maximum sum of non-adjacent subsequence using DP.\\n# # - Add the result to the final sum.\\n# # 3. Return the final result modulo 10^9 + 7.\\n\\n# MOD = 10**9 + 7\\n\\n# class Solution:\\n# def maxNonAdjacentSum(self, nums):\\n# \\\"\\\"\\\"\\n# Calculate the maximum sum of a subsequence where no two adjacent elements are selected.\\n \\n# Args:\\n# nums (List[int]): The array of integers.\\n \\n# Returns:\\n# int: The maximum sum of the subsequence with non-adjacent elements.\\n# \\\"\\\"\\\"\\n# incl, excl = 0, 0 # incl is the sum including the current element, excl is the sum excluding it\\n \\n# for num in nums:\\n# new_incl = excl + num # Including the current element\\n# excl = max(incl, excl) # Excluding the current element\\n# incl = new_incl\\n \\n# return max(incl, excl)\\n\\n# def maximumSumSubsequence(self, nums, queries):\\n# \\\"\\\"\\\"\\n# Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\\n \\n# Args:\\n# nums (List[int]): The initial array of integers.\\n# queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\\n \\n# Returns:\\n# int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\\n# \\\"\\\"\\\"\\n# total_sum = 0\\n \\n# for pos, xi in queries:\\n# # Step 1: Update the element at position pos\\n# nums[pos] = xi\\n \\n# # Step 2: Calculate the maximum non-adjacent subsequence sum\\n# max_sum = self.maxNonAdjacentSum(nums)\\n \\n# # Step 3: Add to the total sum (mod MOD to avoid overflow)\\n# total_sum = (total_sum + max_sum) % MOD\\n \\n# return total_sum\\n\\n# # Time Complexity: O(n * m), where n is the length of the array and m is the number of queries. \\n# # We recalculate the maximum non-adjacent subsequence sum for the entire array after each query.\\n# # Space Complexity: O(1) - We only use constant extra space to store the DP variables `incl` and `excl`.\\n\\n\\ninf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n # nn: max subseq sum without using nums[i] or nums[j]\\n # ny: max subseq sum without using nums[i] but with nums[j]\\n # yn: max subseq sum with nums[i] but without nums[j]\\n # yy: max subseq sum using both nums[i] and nums[j]\\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"4925\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n # # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\\n self.tree = [None] * (4 * self.n)\\n self.inf = float(\\\"inf\\\")\\n self.build_tree(0, 0, self.n - 1, nums)\\n\\n def build_tree(self, node, start, end, nums):\\n if start == end:\\n # leaf node: [0, -inf, -inf, nums[start]]\\n self.tree[node] = [0, -self.inf, -self.inf, nums[start]]\\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n\\n self.build_tree(left, start, mid, nums)\\n self.build_tree(right, mid + 1, end, nums)\\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\\n\\n def combine(self, left, right):\\n lnn, lny, lyn, lyy = left\\n rnn, rny, ryn, ryy = right\\n return [\\n max(lnn + ryn, lnn + rnn, lny + rnn), # not_selected_not_selected\\n max(lnn + ryy, lnn + rny, lny + rny), # not_selected_selected\\n max(lyn + ryn, lyn + rnn, lyy + rnn), # selected_not_selected\\n max(lyn + ryy, lyn + rny, lyy + rny), # selected_selected\\n ]\\n\\n def update(self, node, start, end, idx, val):\\n if start == end:\\n self.tree[node] = [0, -self.inf, -self.inf, val]\\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n\\n if idx <= mid:\\n self.update(left, start, mid, idx, val)\\n else:\\n self.update(right, mid + 1, end, idx, val)\\n \\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = SegmentTree(nums)\\n n = len(nums)\\n ans = 0\\n for idx, val in queries:\\n segment_tree.update(0, 0, n - 1, idx, val)\\n ans += max(segment_tree.tree[0])\\n ans %= MOD\\n return ans\",\n \"runtime\": \"4982\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5015\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5016\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5028\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5111\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5138\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\\n BOTH = 0\\n LEFT = 1\\n RIGHT = 2\\n NONE = 3\\n \\n N = len(nums)\\n \\n # segment tree\\n tree = [[0, 0, 0, 0]] * 4 * N\\n TR = 2 ** ceil(log2(N))\\n\\n # calculate values for just node i in the tree\\n def update_i(i):\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n result = [0, 0, 0, 0]\\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\\n tree[i] = result\\n\\n # construct subtree at node i\\n def construct(i, tl, tr):\\n if tl == tr:\\n tree[i] = [nums[tl], 0, 0, 0]\\n return\\n \\n # construct subtrees\\n m = (tl + tr) // 2\\n construct(i * 2, tl, m)\\n if m + 1 < N:\\n construct(i * 2 + 1, m + 1, tr)\\n \\n # calculate outcome\\n update_i(i)\\n \\n # update subtree at node i with change at index t in the original array\\n def update(i, t, tl, tr):\\n if tl == tr:\\n tree[i] = [nums[t], 0, 0, 0]\\n else:\\n m = (tl + tr) // 2\\n if t <= m:\\n update(i * 2, t, tl, m)\\n else:\\n update(i * 2 + 1, t, m + 1, tr)\\n update_i(i)\\n \\n # construct tree\\n construct(1, 0, TR)\\n\\n # process queries\\n total = 0\\n for q in queries:\\n t, x = q\\n nums[t] = x\\n update(1, t, 0, TR)\\n total += max(tree[1])\\n\\n return total % 1_000_000_007\",\n \"runtime\": \"5149\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"runtime\": \"5241\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n maxSums = defaultdict() #first int: int/out, last: int/out\\n\\n\\n\\n def createTree(left=0, right=n-1, idx=0):\\n if left > right: return\\n if left == right:\\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n createTree(left, mid, idx*2+1)\\n createTree(mid+1, right, idx*2+2)\\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\\n maxSums[idx] = (inin, inout, outin, outout)\\n createTree()\\n # print(\\\"tree:\\\", maxSums)\\n\\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\\n if listIdx < left or listIdx > right: return\\n if left == right:\\n maxSums[idx] = (max(val, 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n updateValue(listIdx, val,left, mid, idx*2+1)\\n updateValue(listIdx, val, mid+1, right, idx*2+2)\\n\\n leftinin, leftinout, leftoutin, leftoutout = maxSums[idx*2+1]\\n rightinin, rightinout, rightoutin, rightoutout = maxSums[idx*2+2]\\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\\n maxSums[idx] = (inin, inout, outin, outout)\\n\\n ans = 0\\n for q in queries:\\n pos, x = q\\n updateValue(pos, x)\\n ans += max(maxSums[0])\\n return ans % (10**9+7)\\n \\n\\n\\n \\n\\n # n = len(nums)\\n # if n==1:\\n # ans = 0\\n # for query in queries: ans += max(query[1], 0)\\n # return ans\\n # if n==2:\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # ans += max(0, max(nums))\\n # return ans\\n \\n # # initially \\n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\\n # dp[n-1] = max(0,nums[n-1])\\n # dp[n-2] = max(0,nums[n-2])\\n \\n # maxDpTwoStepsAway = max(dp[n-1], 0)\\n # for i in range(n-3, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # # print(\\\"qeury:\\\", query,\\\"nums:\\\", nums)\\n # maxDpTwoStepsAway = 0\\n # if pos+2 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\\n \\n # for i in range(pos, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # if i + 1 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n \\n # ans += max(dp)\\n # # print(\\\"dp:\\\", dp)\\n # return ans\\n \\n \",\n \"runtime\": \"5498\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, performance_scores: List[int], inspections: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n Optimizes the performance of a fleet of trucks based on their performance scores and periodic inspections.\\n\\n Given a list of initial performance scores of trucks, and a series of inspections where the performance of\\n certain trucks is updated, this function computes the maximum possible performance of the fleet, ensuring that \\n no two adjacent trucks are selected for optimization. The result after all inspections is returned modulo 10^9 + 7.\\n\\n Args:\\n performance_scores (List[int]): Initial performance scores of the fleet's trucks.\\n inspections (List[List[int]]): A list of updates, where each update contains the truck index and its new performance score.\\n\\n Returns:\\n int: The sum of the maximum subsequence performance after each inspection, modulo 10^9 + 7.\\n \\\"\\\"\\\"\\n \\n MOD = 1_000_000_007\\n n = len(performance_scores)\\n # Segment tree to store maximum subsequence sums for different truck ranges\\n segment_tree = [[0] * 4 for _ in range(4 * n)]\\n\\n def build_tree(node: int, start: int, end: int):\\n \\\"\\\"\\\"\\n Recursively builds the segment tree based on the initial performance scores.\\n \\\"\\\"\\\"\\n if start == end:\\n segment_tree[node][0] = max(0, performance_scores[start])\\n else:\\n mid = (start + end) // 2\\n build_tree(2 * node + 1, start, mid)\\n build_tree(2 * node + 2, mid + 1, end)\\n combine(node)\\n\\n def combine(node: int):\\n \\\"\\\"\\\"\\n Combines two child nodes in the segment tree to calculate the maximum subsequence sums for the parent node.\\n \\\"\\\"\\\"\\n left = segment_tree[2 * node + 1]\\n right = segment_tree[2 * node + 2]\\n # No adjacent trucks selected\\n segment_tree[node][0] = max(left[2] + right[1], left[0] + right[1], left[2] + right[0])\\n # Skipping the first truck\\n segment_tree[node][1] = max(left[3] + right[1], left[1] + right[1], left[3] + right[0])\\n # Skipping the last truck\\n segment_tree[node][2] = max(left[2] + right[3], left[0] + right[3], left[2] + right[2])\\n # Skipping both the first and last trucks\\n segment_tree[node][3] = max(left[3] + right[3], left[1] + right[3], left[3] + right[2])\\n\\n def update_tree(node: int, start: int, end: int, idx: int, new_score: int):\\n \\\"\\\"\\\"\\n Updates the segment tree when a truck's performance score is changed after an inspection.\\n \\\"\\\"\\\"\\n if start == end:\\n segment_tree[node][0] = max(0, new_score)\\n else:\\n mid = (start + end) // 2\\n if idx > mid:\\n update_tree(2 * node + 2, mid + 1, end, idx, new_score)\\n else:\\n update_tree(2 * node + 1, start, mid, idx, new_score)\\n combine(node)\\n\\n # Build the initial segment tree\\n build_tree(0, 0, n - 1)\\n\\n total_performance = 0\\n\\n # Process each inspection (update performance score and recalculate maximum subsequence sum)\\n for idx, new_score in inspections:\\n update_tree(0, 0, n - 1, idx, new_score)\\n total_performance += max(segment_tree[0])\\n total_performance %= MOD\\n\\n return total_performance\",\n \"runtime\": \"5516\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n maxSums = defaultdict() #first int: int/out, last: int/out\\n\\n def updateEntry(idx):\\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\\n maxSums[idx] = (inin, inout, outin, outout)\\n\\n def createTree(left=0, right=n-1, idx=0):\\n if left > right: return\\n if left == right:\\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n createTree(left, mid, idx*2+1)\\n createTree(mid+1, right, idx*2+2)\\n updateEntry(idx)\\n \\n createTree()\\n # print(\\\"tree:\\\", maxSums)\\n\\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\\n if listIdx < left or listIdx > right: return\\n if left == right:\\n maxSums[idx] = (max(val, 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n updateValue(listIdx, val,left, mid, idx*2+1)\\n updateValue(listIdx, val, mid+1, right, idx*2+2)\\n updateEntry(idx)\\n\\n ans = 0\\n for q in queries:\\n pos, x = q\\n updateValue(pos, x)\\n ans += max(maxSums[0])\\n return ans % (10**9+7)\\n \\n\\n\\n \\n\\n # n = len(nums)\\n # if n==1:\\n # ans = 0\\n # for query in queries: ans += max(query[1], 0)\\n # return ans\\n # if n==2:\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # ans += max(0, max(nums))\\n # return ans\\n \\n # # initially \\n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\\n # dp[n-1] = max(0,nums[n-1])\\n # dp[n-2] = max(0,nums[n-2])\\n \\n # maxDpTwoStepsAway = max(dp[n-1], 0)\\n # for i in range(n-3, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # # print(\\\"qeury:\\\", query,\\\"nums:\\\", nums)\\n # maxDpTwoStepsAway = 0\\n # if pos+2 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\\n \\n # for i in range(pos, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # if i + 1 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n \\n # ans += max(dp)\\n # # print(\\\"dp:\\\", dp)\\n # return ans\\n \\n \",\n \"runtime\": \"5536\"\n },\n {\n \"code\": \"class StVal:\\n\\n # Combining two nodes by adding their values (can be modified for other operations like min, max)\\n def __init__(self, v : int = 0, L = None, R = None):\\n\\n if L == None or R == None:\\n self.both = max(v,0)\\n self.none = 0\\n self.left = 0\\n self.right = 0\\n return\\n \\n self.both = max(L.left+R.right,L.both+R.right,L.left+R.both)\\n self.none = max(L.none+R.none,L.right+R.none,L.none+R.left)\\n self.left = max(L.left+R.left, L.left+R.none, L.both+R.none)\\n self.right = max(L.none+R.right,L.right+R.right,L.none+R.both)\\n\\n\\nclass SegmentTree:\\n def __init__(self, v):\\n \\\"\\\"\\\"\\n :param v: The input array for the segment tree\\n \\\"\\\"\\\"\\n self.n = len(v)\\n self.v = v\\n self.leaves = [0] * (self.n+20)\\n self.st = [StVal(v = 0)] * (10 * self.n ) # Initially fill with default StVal\\n self.init(1, 0, self.n - 1)\\n\\n def init(self, treeIndex, low_range, high_range):\\n \\\"\\\"\\\"\\n Build the segment tree recursively\\n :param treeIndex: Current index in segment tree\\n :param low_range: Lower bound of current segment\\n :param high_range: Upper bound of current segment\\n \\\"\\\"\\\"\\n if low_range == high_range:\\n # Leaf node\\n if treeIndex >= len(self.st):\\n self.st = self.st + [StVal()]\\n self.st[treeIndex] = StVal(v = self.v[low_range])\\n self.leaves[low_range] = treeIndex # Save the index of the leaf node\\n else:\\n mid = (low_range + high_range) >> 1\\n self.init(treeIndex << 1, low_range, mid)\\n self.init((treeIndex << 1) + 1, mid + 1, high_range)\\n # Merge child nodes\\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\\n\\n def query(self, l, r):\\n \\\"\\\"\\\"\\n Public query function to find result in range [l, r]\\n \\\"\\\"\\\"\\n if l <= r and l < self.n and r >= 0:\\n return self.query_recursive(l, r, 1, 0, self.n - 1)\\n return StVal() # Return identity element for invalid range\\n\\n def query_recursive(self, left_index, right_index, treeIndex, low_range, high_range):\\n \\\"\\\"\\\"\\n Recursively query the range\\n \\\"\\\"\\\"\\n if left_index <= low_range and high_range <= right_index:\\n return self.st[treeIndex]\\n\\n mid = (low_range + high_range) >> 1\\n if right_index <= mid:\\n # Only left child\\n return self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\\n if mid < left_index:\\n # Only right child\\n return self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\\n\\n # Overlapping segments, query both sides\\n left_result = self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\\n right_result = self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\\n return StVal(L = left_result, R = right_result)\\n\\n def update(self, i, x):\\n \\\"\\\"\\\"\\n Incremental point update\\n :param i: Index to update\\n :param x: New value to update with\\n \\\"\\\"\\\"\\n treeIndex = self.leaves[i]\\n self.st[treeIndex] = StVal(x)\\n\\n treeIndex = treeIndex >> 1\\n while treeIndex:\\n # Recompute parent nodes\\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\\n treeIndex = treeIndex >> 1\\n\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n modulo = 10**9+7\\n\\n st = SegmentTree(nums)\\n ans = 0\\n for i in range(len(queries)):\\n q = queries[i]\\n st.update(q[0], q[1])\\n val = st.query(0, n-1)\\n \\n ans = (ans + max(val.both,val.none,val.left,val.right)) % modulo\\n return ans\",\n \"runtime\": \"5654\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n base = 1\\n n = len(nums)\\n if n&1: # make n even\\n nums.append(0)\\n n += 1\\n while base<n: base <<= 1\\n last = base+n-1\\n tree = [[[],[]],[[],[]]] # 00,01, 10,11; in(ex)cluding left and right \\n for i,j in product((0,1),(0,1)):\\n if i+j<2: tree[i][j] = [0]*(base+n)\\n else: tree[i][j] = [0]*base + nums\\n def update(p): # merge parent\\n lc = p<<1\\n rc = lc+1\\n for i,j in product((0,1),(0,1)):\\n tree[i][j][p] = max(tree[i][0][lc]+max(tree[0][j][rc],tree[1][j][rc]),\\n tree[i][1][lc]+tree[0][j][rc])\\n return\\n for i in range(last//2,0,-1):\\n update(i) # build\\n #print(n,base,tree)\\n ans = 0\\n for pos,x in queries:\\n i = base+pos\\n tree[1][1][i] = x\\n i >>= 1\\n while i:\\n update(i)\\n i >>= 1\\n ans += max(tree[i][j][1] for i,j in product((0,1),(0,1))) \\n #\\n return ans%(10**9+7) \\n\",\n \"runtime\": \"6641\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, nums, lo, hi):\\n self.l = None\\n self.r = None\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0, -float('inf')], [-float('inf'), 0]]\\n\\n if lo < hi:\\n mid = (lo + hi) // 2\\n self.l = Node(nums, lo, mid)\\n self.r = Node(nums, mid + 1, hi)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = -float('inf')\\n self.selected[1][0] = -float('inf')\\n self.selected[1][1] = nums[lo]\\n\\n def combine(self):\\n l, r = self.l.selected, self.r.selected\\n self.selected[0][0] = max(l[0][0] + r[0][0], l[0][1] + r[0][0], l[0][0] + r[1][0])\\n self.selected[0][1] = max(l[0][0] + r[0][1], l[0][1] + r[0][1], l[0][0] + r[1][1])\\n self.selected[1][0] = max(l[1][0] + r[0][0], l[1][1] + r[0][0], l[1][0] + r[1][0])\\n self.selected[1][1] = max(l[1][0] + r[0][1], l[1][1] + r[0][1], l[1][0] + r[1][1])\\n\\n def update(self, i, x):\\n if i < self.lo or self.hi < i:\\n return\\n\\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = Node(nums, 0, len(nums) - 1)\\n \\n res = 0\\n for query in queries:\\n segment_tree.update(query[0], query[1])\\n res += max(max(segment_tree.selected[0]), max(segment_tree.selected[1]))\\n res %= MOD\\n \\n return res\",\n \"runtime\": \"6847\"\n },\n {\n \"code\": \"\\nclass Solution:\\n\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n MOD = 10**9 + 7\\n # 两边都不取 tree[o][00] = max(a[01]+b[00], a[00]+b[10])\\n # 左边不取，右边可取可不取 tree[o][01] = max(a[01]+b[01], a[00]+b[11])\\n # 左边可取可不取，右边不取 tree[o][10] = max(a[11]+b[00], a[10]+b[10])\\n # 两边都可取可不取 tree[o][11] = max(a[11]+b[01], a[10]+b[11])\\n tree = [[0] * 4 for _ in range(2 << n.bit_length())]\\n\\n # 单点更新线段树\\n def set_value(o, l, r, idx, val):\\n mid = (l + r) >> 1\\n if l == idx and r == idx:\\n tree[o][3] = max(val, 0)\\n return\\n if idx <= mid:\\n set_value(o * 2 + 1, l, mid, idx, val)\\n else:\\n set_value(o * 2 + 2, mid + 1, r, idx, val)\\n process(o)\\n\\n def process(o):\\n a, b = tree[o * 2 + 1], tree[o * 2 + 2]\\n tree[o][0] = max(a[1] + b[0], a[0] + b[2])\\n tree[o][1] = max(a[1] + b[1], a[0] + b[3])\\n tree[o][2] = max(a[3] + b[0], a[2] + b[2])\\n tree[o][3] = max(a[3] + b[1], a[2] + b[3])\\n\\n for i, num in enumerate(nums):\\n set_value(0, 0, n - 1, i, num)\\n ans = 0\\n for idx, num in queries:\\n set_value(0, 0, n - 1, idx, num)\\n ans += tree[0][3]\\n return ans % MOD\",\n \"runtime\": \"7007\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << (n.bit_length())\\n nums += [0] * (m - n)\\n n = m\\n tree = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n tree[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n ans = 0\\n for i, x in queries:\\n update(i, x)\\n ans += max(tree[1])\\n return ans % 1_000_000_007\",\n \"runtime\": \"7036\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n vals = [[0 for _ in range(4)] for _ in range(len(nums) * 4)]\\n\\n lst = [\\n [ 0 , 0 , 0 , 0 , 0 , 0 ],\\n [ 0 , 0 , 0 , 0 , 0 , 1 ],\\n [ 0 , 0 , 0 , 0 , 1 , 0 ],\\n [ 0 , 0 , 0 , 0 , 1 , 1 ],\\n [ 0 , 0 , 0 , 1 , 0 , 1 ],\\n [ 0 , 0 , 0 , 1 , 1 , 1 ],\\n [ 0 , 0 , 1 , 0 , 0 , 0 ],\\n [ 0 , 0 , 1 , 0 , 0 , 1 ],\\n [ 0 , 0 , 1 , 0 , 1 , 0 ],\\n [ 0 , 0 , 1 , 0 , 1 , 1 ],\\n [ 0 , 0 , 1 , 1 , 0 , 1 ],\\n [ 0 , 0 , 1 , 1 , 1 , 1 ],\\n [ 0 , 1 , 0 , 0 , 0 , 0 ],\\n [ 0 , 1 , 0 , 0 , 0 , 1 ],\\n [ 0 , 1 , 0 , 0 , 1 , 0 ],\\n [ 0 , 1 , 0 , 0 , 1 , 1 ],\\n [ 0 , 1 , 0 , 1 , 0 , 1 ],\\n [ 0 , 1 , 0 , 1 , 1 , 1 ],\\n [ 1 , 0 , 0 , 0 , 1 , 0 ],\\n [ 1 , 0 , 0 , 0 , 1 , 1 ],\\n [ 1 , 0 , 0 , 1 , 1 , 1 ],\\n [ 1 , 0 , 1 , 0 , 1 , 0 ],\\n [ 1 , 0 , 1 , 0 , 1 , 1 ],\\n [ 1 , 0 , 1 , 1 , 1 , 1 ],\\n [ 1 , 1 , 0 , 0 , 1 , 0 ],\\n [ 1 , 1 , 0 , 0 , 1 , 1 ],\\n [ 1 , 1 , 0 , 1 , 1 , 1 ],\\n ]\\n\\n def keep(idx, lb, rb):\\n\\n vals[idx] = [0 for _ in range(4)]\\n\\n lidx = idx * 2 + 1\\n ridx = idx * 2 + 2\\n\\n if lb == rb:\\n vals[idx][0] = max(0, nums[lb])\\n\\n else:\\n # for i0 in (0, 1):\\n # for i1 in (0, 1):\\n # for j0 in (0, 1):\\n # for j1 in (0, 1):\\n # for k0 in (0, 1):\\n # for k1 in (0, 1):\\n # if i1 == 1 and j0 == 1:\\n # continue\\n \\n # if i0 == 1 and k0 == 0:\\n # continue\\n\\n # if j1 == 1 and k1 == 0:\\n # continue\\n\\n \\n # print(\\\"[\\\", i0, \\\", \\\", i1, \\\", \\\",j0, \\\", \\\",j1, \\\", \\\", k0, \\\", \\\", k1, \\\"],\\\")\\n # node.val[k0][k1] = max(node.val[k0][k1], node.left.val[i0][i1] + node.right.val[j0][j1])\\n\\n # print()\\n # print()\\n # print()\\n\\n # for i0, i1, j0, j1, k0, k1 in lst:\\n # vals[idx][k0][k1] = max(vals[idx][k0][k1], vals[lidx][i0][i1] + vals[ridx][j0][j1])\\n\\n l0h0A, l1h0A, l0h1A, l1h1A = vals[2 * idx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = vals[2 * idx + 2]\\n # lo to hi\\n vals[idx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n vals[idx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n vals[idx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n vals[idx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n def build(idx, lb, rb):\\n\\n if lb == rb:\\n pass\\n else:\\n mid = (lb + rb) // 2\\n\\n build(2 * idx + 1, lb, mid)\\n build(2 * idx + 2, mid + 1, rb)\\n\\n keep(idx, lb, rb)\\n\\n def update(nidx, idx, val, lb, rb):\\n\\n if not (lb <= idx <= rb):\\n return\\n\\n elif lb == idx == rb:\\n nums[idx] = val\\n\\n else:\\n mid = (lb + rb) // 2\\n update(2 * nidx + 1, idx, val, lb, mid)\\n update(2 * nidx + 2, idx, val, mid + 1, rb)\\n \\n keep(nidx, lb, rb) \\n\\n build(0, 0, len(nums) - 1)\\n\\n\\n res = 0\\n for idx, val in queries:\\n update(0, idx, val, 0, len(nums) - 1)\\n res = (res + max(vals[0])) % (10 ** 9 + 7)\\n\\n return res\\n \\n\",\n \"runtime\": \"7064\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = 0\\n self.selected[1][0] = 0\\n self.selected[1][1] = max(nums[lo], nums[hi])\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"runtime\": \"7067\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << (n.bit_length())\\n nums += [0] * (m - n)\\n n = m\\n tree = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n tree[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\\n # lo to hi\\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n ans = 0\\n for i, x in queries:\\n update(i, x)\\n ans += max(tree[1])\\n return ans % 1_000_000_007\",\n \"runtime\": \"7076\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M=10**9+7\\n def buildst(n):\\n for i in range(n,2*n):\\n st[i]=elem(i-n)\\n for i in range(n-1,0,-1):\\n st[i]=merge(st[i<<1],st[i<<1|1])\\n def value(l,r):\\n r+=1\\n if r<l:return neutral\\n resl=resr=neutral;l+=n;r+=n\\n while l<r:\\n if l&1:\\n resl=merge(resl,st[l])\\n l+=1\\n if r&1:\\n r-=1\\n if r:resr=merge(st[r],resr)\\n l>>=1\\n r>>=1\\n return merge(resl,resr)\\n def updatest(l,val):\\n l+=n\\n st[l]=val\\n while l>1:\\n l>>=1\\n st[l]=merge(st[l<<1],st[l<<1|1])\\n \\n #[valeur, valeurs sans prendre 1er, valeur sans prendre dernier, valeur sans prendre 1er ou dernier]\\n def merge(x,y):\\n if x==None:\\n return y\\n if y==None:\\n return x\\n return (max(x[0],y[0],x[2]+y[0],x[0]+y[1],0),max(x[1],y[0],x[3]+y[0],x[1]+y[1],0),max(x[0],y[2],x[0]+y[3],x[2]+y[2],0),\\\\\\n max(x[1],y[2],x[1]+y[3],x[3]+y[2],0))\\n elem=lambda x:(max(0,nums[x]),0,0,0)\\n neutral=None\\n n=len(nums)\\n st=[0]*2*n\\n buildst(n)\\n o=0\\n for p,x in queries:\\n updatest(p,(max(0,x),0,0,0))\\n o+=value(0,n-1)[0]\\n o%=M\\n return o\\n \\n \\n \",\n \"runtime\": \"7101\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << n.bit_length()\\n nums += [0] * (m - n)\\n n = m\\n tree = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n tree[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\\n # lo to hi\\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n ans = 0\\n\\n for i, x in queries:\\n update(i, x)\\n ans += max(tree[1])\\n return ans % 1_000_000_007\",\n \"runtime\": \"7124\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = float('-inf')\\n self.selected[1][0] = float('-inf')\\n self.selected[1][1] = nums[lo]\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"runtime\": \"7207\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = 0\\n self.selected[1][0] = 0\\n self.selected[1][1] = max(nums[lo], nums[hi])\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"runtime\": \"7216\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], q: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << (n.bit_length())\\n nums += [0] * (m - n)\\n n = m\\n t = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n t[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = t[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = t[2 * j + 1]\\n t[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n t[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n t[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n t[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n res = 0\\n for i, x in q:\\n update(i, x)\\n res += max(t[1])\\n return res % 1_000_000_007\",\n \"runtime\": \"7523\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nM = 10 ** 9 + 7\\n\\nclass SegTree:\\n def __init__(self):\\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\\n \\n def merge(self, l, r):\\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\\n \\n def update(self, index, val, i, j, k):\\n if i + 1 == j:\\n self.tree[k] = (val, 0, 0, 0)\\n return\\n mid = (i + j) // 2\\n if index < mid:\\n self.update(index, val, i, mid, 2 * k)\\n else:\\n self.update(index, val, mid, j, 2 * k + 1)\\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\\n \\n def query(self, x, y, i, j, k):\\n if y - 1 < i or x >= j:\\n return (0, 0, 0, 0)\\n if i >= x and j <= y:\\n return self.tree[k]\\n mid = (i + j) // 2\\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n res = 0\\n segtree = SegTree()\\n for i in range(n):\\n segtree.update(i, nums[i], 0, n, 1)\\n for i, val in queries:\\n segtree.update(i, val, 0, n, 1)\\n res += max(segtree.query(0, n, 0, n, 1))\\n res %= M\\n return res\",\n \"runtime\": \"7727\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nM = 10 ** 9 + 7\\n\\nclass SegTree:\\n def __init__(self):\\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\\n \\n def merge(self, l, r):\\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\\n \\n def update(self, index, val, i, j, k):\\n if i + 1 == j:\\n self.tree[k] = (val, 0, 0, 0)\\n return\\n mid = (i + j) // 2\\n if index < mid:\\n self.update(index, val, i, mid, 2 * k)\\n else:\\n self.update(index, val, mid, j, 2 * k + 1)\\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\\n \\n def query(self, x, y, i, j, k):\\n if y - 1 < i or x >= j:\\n return (0, 0, 0, 0)\\n if i >= x and j <= y:\\n return self.tree[k]\\n mid = (i + j) // 2\\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n res = 0\\n segtree = SegTree()\\n for i in range(n):\\n segtree.update(i, nums[i], 0, n, 1)\\n for i, val in queries:\\n segtree.update(i, val, 0, n, 1)\\n res += max(segtree.query(0, n, 0, n, 1))\\n res %= M\\n return res\",\n \"runtime\": \"7739\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = float('-inf')\\n self.selected[1][0] = float('-inf')\\n self.selected[1][1] = max(nums[lo], nums[hi])\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"runtime\": \"7749\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, nums, lo, hi):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0, -float('inf')], [-float('inf'), -float('inf')]]\\n \\n if lo < hi:\\n mid = (lo + hi) // 2\\n self.l = Node(nums, lo, mid)\\n self.r = Node(nums, mid + 1, hi)\\n self.combine()\\n else:\\n self.selected[1][1] = nums[lo]\\n \\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0] + self.r.selected[0][0], max(self.l.selected[0][1] + self.r.selected[0][0], self.l.selected[0][0] + self.r.selected[1][0]))\\n self.selected[0][1] = max(self.l.selected[0][0] + self.r.selected[0][1], max(self.l.selected[0][1] + self.r.selected[0][1], self.l.selected[0][0] + self.r.selected[1][1]))\\n self.selected[1][0] = max(self.l.selected[1][0] + self.r.selected[0][0], max(self.l.selected[1][1] + self.r.selected[0][0], self.l.selected[1][0] + self.r.selected[1][0]))\\n self.selected[1][1] = max(self.l.selected[1][0] + self.r.selected[0][1], max(self.l.selected[1][1] + self.r.selected[0][1], self.l.selected[1][0] + self.r.selected[1][1]))\\n\\n def update(self, i, x):\\n if i < self.lo or i > self.hi:\\n return\\n \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n \\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n segmentTree = Node(nums, 0, len(nums) - 1)\\n\\n res = 0\\n for query in queries:\\n segmentTree.update(query[0], query[1])\\n res += max(segmentTree.selected[0][0], max(segmentTree.selected[0][1], max(segmentTree.selected[1][0], segmentTree.selected[1][1])))\\n res %= 10**9 + 7\\n return res\",\n \"runtime\": \"7927\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n self.inf = float('inf')\\n self.mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\\n self.build(st, nums, 0, 0, n - 1)\\n res = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\\n return res\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n \\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"runtime\": \"8339\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\\n self.build(st, nums, 0, 0, n -1)\\n res = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return res\\n \\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n \\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n \\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \",\n \"runtime\": \"8407\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\\n self.build(st, nums, 0, 0, n - 1)\\n result = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return result\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][1][0] = -float('inf')\\n st[node][0][1] = -float('inf')\\n st[node][1][1] = nums[l]\\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n \\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \",\n \"runtime\": \"8572\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\\n self.build(st, nums, 0, 0, n - 1)\\n res = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return res\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n \\n )\\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r ) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"runtime\": \"8620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\\n self.build(st, nums, 0, 0, n - 1)\\n result = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return result\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n \\n )\\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"runtime\": \"8747\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n self.inf = float('inf')\\n self.mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\\n self.build(st, nums, 0, 0, n - 1)\\n result = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n result = (result + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\\n return result\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n \\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"runtime\": \"8818\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(n * 4)]\\n self.build(st, nums, 0, 0, n-1)\\n \\n mod = 10 ** 9 + 7\\n ans = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n ans = (ans + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return ans\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][1][0] = -float('inf')\\n st[node][0][1] = -float('inf')\\n st[node][1][1] = nums[l]\\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n \\n \\n )\\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"runtime\": \"8841\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\\n self.build(st, nums, 0, 0, n - 1)\\n res = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % mod\\n return res\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = node * 2 + 1, node * 2 + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n \",\n \"runtime\": \"8843\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # 11:17\\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\\n def glue(a, b):\\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \\n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \\n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\\n # def query(l, r, p=1, tl=0, tr=len(nums)):\\n # if l == tl and r == tr:\\n # return st[p];\\n # tm = (tl + tr) // 2\\n # return glue(query(l, min(r, tm), p * 2, tl, tm), \\n # query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\\n def update(pos, x, p=1, tl=0, tr=len(nums)):\\n tm = (tl + tr) // 2\\n if tl == tr:\\n st[p][1][1] = x \\n elif pos <= tm:\\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\\n else:\\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\\n return st[p]\\n for i, n in enumerate(nums):\\n update(i, n)\\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007\",\n \"runtime\": \"9031\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\\n def glue(a, b):\\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \\n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \\n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\\n def query(l, r, p=1, tl=0, tr=len(nums)):\\n if l == tl and r == tr:\\n return st[p];\\n tm = (tl + tr) // 2\\n return glue(query(l, min(r, tm), p * 2, tl, tm), \\n query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\\n def update(pos, x, p=1, tl=0, tr=len(nums)):\\n tm = (tl + tr) // 2\\n if tl == tr:\\n st[p][1][1] = x \\n elif pos <= tm:\\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\\n else:\\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\\n return st[p]\\n for i, n in enumerate(nums):\\n update(i, n)\\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007\",\n \"runtime\": \"9053\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":76,"string":"76"},"mm_list":{"kind":"list like","value":[{"code":"class SegTree:\n def __init__(self, nums):\n self.n = len(nums)\n self.tree = [0] * (4 * self.n)\n self.build(nums, 0, 0, self.n - 1)\n \n def build(self, nums, node, start, end):\n if start == end:\n self.tree[node] = (max(nums[start], 0), 0, 0, 0)\n \n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n self.build(nums, left, start, mid)\n self.build(nums, right, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\n \n def merge(self, left, right):\n include = max(left[2] + right[0], left[0] + right[1])\n ex_l = max(left[1] + right[1], left[3] + right[0])\n ex_r = max(left[2] + right[2], left[0] + right[3])\n ex_both = max(left[3] + right[2], left[1] + right[3])\n return (include, ex_l, ex_r, ex_both)\n \n def update(self, idx, value, node, start, end):\n if start == end:\n self.tree[node] = (max(0, value), 0, 0, 0)\n \n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n if start <= idx <= mid:\n self.update(idx, value, left, start, mid)\n else:\n self.update(idx, value, right, mid + 1, end)\n\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\n return\n \n def query(self):\n return self.tree[0][0]\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n segtree = SegTree(nums)\n mod = 10 ** 9 + 7\n\n ans = 0\n for pos, val in queries:\n segtree.update(pos, val, 0, 0, segtree.n - 1)\n\n ans = (ans + segtree.query()) % mod\n\n return ans","memory":"43400"},{"code":"class SegTree: \n\n def __init__(self, arr: List[int]):\n self.n = n = len(arr)\n self.tree = [0]*(4*n)\n self._build(arr, 0, 0, n)\n \n def _op(self, left, right): \n lv, ls, le, lse = left\n rv, rs, re, rse = right \n ov = max(le+rv, lv+rs)\n os = max(ls+rs, lse+rv)\n oe = max(le+re, lv+rse)\n ose = max(lse+re, ls+rse)\n return (ov, os, oe, ose)\n\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\n else:\n mid = lo + hi >> 1\n self._build(arr, 2*k+1, lo, mid)\n self._build(arr, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\n if not hi: hi = self.n\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\n else: \n mid = lo + hi >> 1\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\n else: self.update(i, x, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \n if not hi: hi = self.n\n if qhi <= lo or hi <= qlo: return inf # no overlap \n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \n mid = lo + hi >> 1 # partial overlap \n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = SegTree(nums)\n ans = 0 \n for i, x in queries: \n tree.update(i, x)\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\n return ans ","memory":"43500"},{"code":"class SegTree: \n\n def __init__(self, arr: List[int]):\n self.n = n = len(arr)\n self.tree = [0]*(4*n)\n self._build(arr, 0, 0, n)\n \n def _op(self, left, right): \n lv, ls, le, lse = left\n rv, rs, re, rse = right \n v = max(le+rv, lv+rs)\n s = max(ls+rs, lse+rv)\n e = max(le+re, lv+rse)\n se = max(lse+re, ls+rse)\n return (v, s, e, se)\n\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\n else:\n mid = lo + hi >> 1\n self._build(arr, 2*k+1, lo, mid)\n self._build(arr, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\n if not hi: hi = self.n\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\n else: \n mid = lo + hi >> 1\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\n else: self.update(i, x, 2*k+2, mid, hi)\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\n\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \n if not hi: hi = self.n\n if qhi <= lo or hi <= qlo: return inf # no overlap \n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \n mid = lo + hi >> 1 # partial overlap \n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = SegTree(nums)\n ans = 0 \n for i, x in queries: \n tree.update(i, x)\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\n return ans ","memory":"43500"},{"code":"class SegTree:\n def __init__(self, nums):\n self.n = len(nums)\n self.tree = [None] * (4 * self.n)\n self.build(nums, 0, 0, self.n - 1)\n \n def build(self, nums, node, start, end):\n if start == end:\n self.tree[node] = (max(0, nums[start]), 0, 0, 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n self.build(nums, left_child, start, mid)\n self.build(nums, right_child, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n \n def merge(self, left, right):\n include = max(left[2] + right[0], left[0] + right[1])\n exclude_l = max(left[3] + right[0], left[1] + right[1])\n exclude_r = max(left[2] + right[2], left[0] + right[3])\n exclude_both = max(left[3] + right[2], left[1] + right[3])\n return (include, exclude_l, exclude_r, exclude_both)\n \n def update(self, idx, value, node, start, end):\n if start == end:\n self.tree[node] = (max(0, value), 0, 0, 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n if start <= idx <= mid:\n self.update(idx, value, left_child, start, mid)\n else:\n self.update(idx, value, right_child, mid + 1, end)\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n \n def query(self):\n return self.tree[0][0]\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n\n segtree = SegTree(nums)\n \n MOD = 10 ** 9 + 7\n \n res = 0\n for pos, val in queries:\n segtree.update(pos, val, 0, 0, segtree.n - 1)\n \n #segtree.print_tree()\n #print(segtree.query())\n \n res = (res + segtree.query()) % MOD\n \n return res\n ","memory":"43900"},{"code":"class SegmentTree:\n def __init__(self, n):\n self.n = n\n self.a1 = [0] * 4 * self.n # (l, r)\n self.a2 = [0] * 4 * self.n # (l, r - 1)\n self.a3 = [0] * 4 * self.n # (l + 1, r)\n self.a4 = [0] * 4 * self.n # (l + 1, r - 1)\n \n def query(self):\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\n\n def update(self, pos, val):\n self.updateHelper(0, self.n - 1, 0, pos, val)\n \n def updateHelper(self, left, right, ind, pos, val):\n if left==right:\n self.a1[ind] = val\n self.a2[ind] = 0\n self.a3[ind] = 0\n self.a4[ind] = 0\n return\n \n mid = (left + right) // 2\n if pos <= mid:\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\n else:\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\n\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n segTree = SegmentTree(n)\n total = 0\n MOD = 10**9 + 7\n for i, x in enumerate(nums):\n segTree.update(i, x)\n\n for i,x in queries:\n segTree.update(i, x)\n total += segTree.query()\n total %= MOD\n return total","memory":"44000"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n base = 1\n n = len(nums)\n if n&1: # make n even\n nums.append(0)\n n += 1\n while base<n: base <<= 1\n last = base+n-1\n tree = [[[],[]],[[],[]]] # 00,01, 10,11; in(ex)cluding left and right \n for i,j in product((0,1),(0,1)):\n if i+j<2: tree[i][j] = [0]*(base+n)\n else: tree[i][j] = [0]*base + nums\n def update(p): # merge parent\n lc = p<<1\n rc = lc+1\n for i,j in product((0,1),(0,1)):\n tree[i][j][p] = max(tree[i][0][lc]+max(tree[0][j][rc],tree[1][j][rc]),\n tree[i][1][lc]+tree[0][j][rc])\n return\n for i in range(last//2,0,-1):\n update(i) # build\n #print(n,base,tree)\n ans = 0\n for pos,x in queries:\n i = base+pos\n tree[1][1][i] = x\n i >>= 1\n while i:\n update(i)\n i >>= 1\n ans += max(tree[i][j][1] for i,j in product((0,1),(0,1))) \n #\n return ans%(10**9+7) \n","memory":"44100"},{"code":"class SegmentTree:\n def __init__(self, n):\n self.n = n\n self.a1 = [0] * 4 * self.n \n self.a2 = [0] * 4 * self.n \n self.a3 = [0] * 4 * self.n \n self.a4 = [0] * 4 * self.n \n def query(self):\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\n def update(self, pos, val):\n self.updateHelper(0, self.n - 1, 0, pos, val) \n def updateHelper(self, left, right, ind, pos, val):\n if left==right:\n self.a1[ind] = val\n self.a2[ind] = 0\n self.a3[ind] = 0\n self.a4[ind] = 0\n return \n mid = (left + right) // 2\n if pos <= mid:\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\n else:\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n segTree = SegmentTree(n)\n total = 0\n MOD = 10**9 + 7\n for i, x in enumerate(nums):\n segTree.update(i, x)\n for i,x in queries:\n segTree.update(i, x)\n total += segTree.query()\n total %= MOD\n return total ","memory":"44600"},{"code":"class SegmentTree:\n def __init__(self, n):\n self.n = n\n self.a1 = [0] * 4 * self.n \n self.a2 = [0] * 4 * self.n \n self.a3 = [0] * 4 * self.n \n self.a4 = [0] * 4 * self.n \n def query(self):\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\n def update(self, pos, val):\n self.updateHelper(0, self.n - 1, 0, pos, val) \n def updateHelper(self, left, right, ind, pos, val):\n if left==right:\n self.a1[ind] = val\n self.a2[ind] = 0\n self.a3[ind] = 0\n self.a4[ind] = 0\n return \n mid = (left + right) // 2\n if pos <= mid:\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\n else:\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n segTree = SegmentTree(n)\n total = 0\n MOD = 10**9 + 7\n for i, x in enumerate(nums):\n segTree.update(i, x)\n for i,x in queries:\n segTree.update(i, x)\n total += segTree.query()\n total %= MOD\n return total ","memory":"44800"},{"code":"import typing\n\n\nclass SegTree:\n def __init__(\n self,\n op: typing.Callable[[typing.Any, typing.Any], typing.Any],\n e: typing.Any,\n v: typing.Union[int, typing.List[typing.Any]],\n ) -> None:\n self._op = op\n self._e = e\n\n if isinstance(v, int):\n v = [e] * v\n\n self._n = len(v)\n self._log = self._ceil_pow2(self._n)\n self._size = 1 << self._log\n self._d = [e] * (2 * self._size)\n\n for i in range(self._n):\n self._d[self._size + i] = v[i]\n for i in range(self._size - 1, 0, -1):\n self._update(i)\n\n def set(self, p: int, x: typing.Any) -> None:\n assert 0 <= p < self._n\n\n p += self._size\n self._d[p] = x\n for i in range(1, self._log + 1):\n self._update(p >> i)\n\n def get(self, p: int) -> typing.Any:\n assert 0 <= p < self._n\n\n return self._d[p + self._size]\n\n def prod(self, left: int, right: int) -> typing.Any:\n assert 0 <= left <= right <= self._n\n sml = self._e\n smr = self._e\n left += self._size\n right += self._size\n\n while left < right:\n if left & 1:\n sml = self._op(sml, self._d[left])\n left += 1\n if right & 1:\n right -= 1\n smr = self._op(self._d[right], smr)\n left >>= 1\n right >>= 1\n\n return self._op(sml, smr)\n\n def all_prod(self) -> typing.Any:\n return self._d[1]\n\n def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int:\n assert 0 <= left <= self._n\n assert f(self._e)\n\n if left == self._n:\n return self._n\n\n left += self._size\n sm = self._e\n\n first = True\n while first or (left & -left) != left:\n first = False\n while left % 2 == 0:\n left >>= 1\n if not f(self._op(sm, self._d[left])):\n while left < self._size:\n left *= 2\n if f(self._op(sm, self._d[left])):\n sm = self._op(sm, self._d[left])\n left += 1\n return left - self._size\n sm = self._op(sm, self._d[left])\n left += 1\n\n return self._n\n\n def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int:\n assert 0 <= right <= self._n\n assert f(self._e)\n\n if right == 0:\n return 0\n\n right += self._size\n sm = self._e\n\n first = True\n while first or (right & -right) != right:\n first = False\n right -= 1\n while right > 1 and right % 2:\n right >>= 1\n if not f(self._op(self._d[right], sm)):\n while right < self._size:\n right = 2 * right + 1\n if f(self._op(self._d[right], sm)):\n sm = self._op(self._d[right], sm)\n right -= 1\n return right + 1 - self._size\n sm = self._op(self._d[right], sm)\n\n return 0\n\n def _update(self, k: int) -> None:\n self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])\n\n @staticmethod\n def _ceil_pow2(n: int) -> int:\n x = 0\n while (1 << x) < n:\n x += 1\n\n return x\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n\n def op(x, y) -> int:\n left_max_without_start, left_max_without_end, left_max_without_either, left_max = x\n right_max_without_start, right_max_without_end, right_max_without_either, right_max = y\n\n return (\n max(left_max_without_start + right_max_without_start, left_max_without_either + right_max) % MOD,\n max(left_max_without_end + right_max_without_end, left_max + right_max_without_either) % MOD,\n max(left_max_without_start + right_max_without_either, left_max_without_either + right_max_without_end) % MOD,\n max(left_max_without_end + right_max, left_max + right_max_without_start) % MOD,\n )\n\n e = (0, 0, 0, 0)\n nodes = [(0, 0, 0, max(num, 0)) for num in nums]\n seg_tree = SegTree(op, e, nodes)\n\n ans = 0\n for pos, x in queries:\n seg_tree.set(pos, (0, 0, 0, max(0, x)))\n _, _, _, v = seg_tree.all_prod()\n ans += v % MOD\n return ans % MOD\n\n","memory":"46700"},{"code":"# # Data Structures: Array\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\n\n# # Short Intuition:\n# # We need to process multiple queries, where each query changes the array and requires recalculating\n# # the maximum sum of a subsequence where no two adjacent elements are selected. The goal is to return the\n# # sum of results of all queries.\n\n# # Detailed Intuition:\n# # - Each query updates one element in the array. After the update, we need to recalculate the maximum sum \n# # of a subsequence with no adjacent elements.\n# # - This problem is similar to the house robber problem, where at each element we decide whether to include it \n# # in the subsequence or skip it.\n# # - We use a simple dynamic programming approach to compute the max sum of non-adjacent elements:\n# # - Let `incl` be the maximum sum including the current element.\n# # - Let `excl` be the maximum sum excluding the current element.\n# # - After processing each query, sum up the results and return the final sum modulo 10^9 + 7.\n\n# # Pseudocode:\n# # 1. Initialize two variables `incl` and `excl` to store the maximum subsequence sum including/excluding the current element.\n# # 2. For each query:\n# # - Update the element in the array.\n# # - Recalculate the maximum sum of non-adjacent subsequence using DP.\n# # - Add the result to the final sum.\n# # 3. Return the final result modulo 10^9 + 7.\n\n# MOD = 10**9 + 7\n\n# class Solution:\n# def maxNonAdjacentSum(self, nums):\n# \"\"\"\n# Calculate the maximum sum of a subsequence where no two adjacent elements are selected.\n \n# Args:\n# nums (List[int]): The array of integers.\n \n# Returns:\n# int: The maximum sum of the subsequence with non-adjacent elements.\n# \"\"\"\n# incl, excl = 0, 0 # incl is the sum including the current element, excl is the sum excluding it\n \n# for num in nums:\n# new_incl = excl + num # Including the current element\n# excl = max(incl, excl) # Excluding the current element\n# incl = new_incl\n \n# return max(incl, excl)\n\n# def maximumSumSubsequence(self, nums, queries):\n# \"\"\"\n# Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\n \n# Args:\n# nums (List[int]): The initial array of integers.\n# queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\n \n# Returns:\n# int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\n# \"\"\"\n# total_sum = 0\n \n# for pos, xi in queries:\n# # Step 1: Update the element at position pos\n# nums[pos] = xi\n \n# # Step 2: Calculate the maximum non-adjacent subsequence sum\n# max_sum = self.maxNonAdjacentSum(nums)\n \n# # Step 3: Add to the total sum (mod MOD to avoid overflow)\n# total_sum = (total_sum + max_sum) % MOD\n \n# return total_sum\n\n# # Time Complexity: O(n * m), where n is the length of the array and m is the number of queries. \n# # We recalculate the maximum non-adjacent subsequence sum for the entire array after each query.\n# # Space Complexity: O(1) - We only use constant extra space to store the DP variables `incl` and `excl`.\n\n\ninf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n # nn: max subseq sum without using nums[i] or nums[j]\n # ny: max subseq sum without using nums[i] but with nums[j]\n # yn: max subseq sum with nums[i] but without nums[j]\n # yy: max subseq sum using both nums[i] and nums[j]\n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","memory":"46800"},{"code":"# Data Structures: Segment Tree\n# Algorithm: Segment Tree for Range Maximum Query\n\n# Short Intuition:\n# We will use a Segment Tree to efficiently process range queries. After each query that modifies the array,\n# we will recalculate the maximum sum of a subsequence with non-adjacent elements in `nums`.\n\n# Detailed Intuition:\n# - A segment tree is used to store the maximum sum of non-adjacent subsequences for different ranges of the array.\n# - Each node in the segment tree stores a tuple with:\n# - `incl`: The maximum sum of a subsequence including the last element in the segment.\n# - `excl`: The maximum sum of a subsequence excluding the last element in the segment.\n# - For each query, we update the segment tree and retrieve the maximum sum of the entire array (root node).\n# - The segment tree allows efficient range updates and queries (both in O(log n) time).\n\n# Pseudocode:\n# 1. Build the segment tree with initial values.\n# 2. For each query:\n# - Update the segment tree with the new value at the given position.\n# - Query the segment tree to get the maximum sum of non-adjacent elements in the array.\n# - Add the result to the total sum.\n# 3. Return the total sum modulo 10^9 + 7.\n\nMOD = 10**9 + 7\n\nclass SegmentTree:\n def __init__(self, nums):\n \"\"\"\n Initialize the segment tree with the given array of numbers.\n \n Args:\n nums (List[int]): The initial array of integers.\n \"\"\"\n self.n = len(nums)\n self.tree = [None] * (4 * self.n) # Segment tree array\n self.build(nums, 0, 0, self.n - 1) # Build the tree\n\n def build(self, nums, node, start, end):\n \"\"\"\n Build the segment tree by recursively calculating the incl and excl sums.\n \n Args:\n nums (List[int]): The array of numbers.\n node (int): The current node in the segment tree.\n start (int): Start index of the current segment.\n end (int): End index of the current segment.\n \"\"\"\n if start == end:\n # Leaf node: Only one element, so `incl` is the element itself, `excl` is 0\n self.tree[node] = (nums[start], 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n # Recursively build the left and right subtrees\n self.build(nums, left_child, start, mid)\n self.build(nums, right_child, mid + 1, end)\n \n # Merge the results from left and right subtrees\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n\n def merge(self, left, right):\n \"\"\"\n Merge two nodes (left and right) to calculate the max sum for their parent node.\n \n Args:\n left (tuple): The incl and excl values from the left child.\n right (tuple): The incl and excl values from the right child.\n \n Returns:\n tuple: The merged result containing the incl and excl values for the parent node.\n \"\"\"\n incl = max(left[1] + right[0], left[0] + right[1])\n excl = max(left[0], left[1]) + max(right[0], right[1])\n return (incl, excl)\n\n def update(self, idx, value, node, start, end):\n \"\"\"\n Update the segment tree when an element in the array changes.\n \n Args:\n idx (int): The index of the element to update.\n value (int): The new value to update at the index.\n node (int): The current node in the segment tree.\n start (int): Start index of the current segment.\n end (int): End index of the current segment.\n \"\"\"\n if start == end:\n # Leaf node: Update the value directly\n self.tree[node] = (value, 0)\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n # Recursively update the appropriate child\n if idx <= mid:\n self.update(idx, value, left_child, start, mid)\n else:\n self.update(idx, value, right_child, mid + 1, end)\n \n # After updating the child, merge the changes to the current node\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\n\n def query(self):\n \"\"\"\n Query the segment tree to get the maximum sum of non-adjacent elements for the entire array.\n \n Returns:\n int: The maximum sum of non-adjacent subsequence for the entire array.\n \"\"\"\n return max(self.tree[0]) # The root node stores the result for the entire array\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums, queries):\n \"\"\"\n Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\n \n Args:\n nums (List[int]): The initial array of integers.\n queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\n \n Returns:\n int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\n \"\"\"\n total_sum = 0\n seg_tree = SegmentTree(nums) # Initialize the segment tree\n \n for pos, xi in queries:\n # Step 1: Update the element at position pos in the segment tree\n seg_tree.update(pos, xi, 0, 0, len(nums) - 1)\n \n # Step 2: Query the segment tree to get the max non-adjacent subsequence sum\n max_sum = seg_tree.query()\n \n # Step 3: Add the result to the total sum (mod MOD to avoid overflow)\n total_sum = (total_sum + max_sum) % MOD\n \n return total_sum\n\n\n# Time Complexity:\n# - Build the segment tree: O(n)\n# - Each update and query operation: O(log n)\n# So, for m queries, the total time complexity is O(n + m log n).\n\n# Space Complexity: O(n) for the segment tree.\n# # Data Structures: Array\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\n\ninf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n # nn: max subseq sum without using nums[i] or nums[j]\n # ny: max subseq sum without using nums[i] but with nums[j]\n # yn: max subseq sum with nums[i] but without nums[j]\n # yy: max subseq sum using both nums[i] and nums[j]\n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","memory":"46900"},{"code":"inf = -float('inf')\nclass SegTree:\n def __init__(self, nums):\n n = len(nums)\n # each element: [nn, ny, yn, yy]\n self.ar = [None] * (4*n+1)\n self.build(0, 0, n-1, nums)\n \n def combine(self, t1, t2):\n nn1, ny1, yn1, yy1 = t1\n nn2, ny2, yn2, yy2 = t2\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\n return [nn, ny, yn, yy]\n \n def build(self, i, l, r, nums):\n if l == r:\n self.ar[i] = [0, inf, inf, nums[l]]\n else:\n m = (l+r) // 2\n self.build(2*i+1, l, m, nums)\n self.build(2*i+2, m+1, r, nums)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n \n def update_v(self, i, l, r, idx, v):\n if l == r and l == idx:\n self.ar[i] = [0, inf, inf, v]\n else:\n m = (l+r)//2\n if m < idx:\n self.update_v(2*i+2, m+1, r, idx, v)\n else:\n self.update_v(2*i+1, l, m, idx, v)\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n M = 10**9 + 7\n st = SegTree(nums)\n n = len(nums)\n res = 0\n # print(st.ar)\n for p, v in queries:\n st.update_v(0, 0, n-1, p, v)\n # print(st.ar)\n res += max(st.ar[0])\n res %= M\n return res","memory":"47000"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], q: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << (n.bit_length())\n nums += [0] * (m - n)\n n = m\n t = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n t[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = t[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = t[2 * j + 1]\n t[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n t[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n t[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n t[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n res = 0\n for i, x in q:\n update(i, x)\n res += max(t[1])\n return res % 1_000_000_007","memory":"47300"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = 1 << (n.bit_length())\n nums += [0] * (m - n)\n n = m\n tree = [[0] * 4 for _ in range(2 * n + 1)]\n\n def update(i, x):\n j = i + n\n tree[j][0] = max(0, x)\n while j:\n j >>= 1\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\n # lo to hi\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n for i, x in enumerate(nums):\n update(i, x)\n\n ans = 0\n for i, x in queries:\n update(i, x)\n ans += max(tree[1])\n return ans % 1_000_000_007","memory":"47800"},{"code":"import math\n\nclass SegmentTree:\n def __init__(self, nums):\n self.n = len(nums)\n # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\n self.tree = [None] * (4 * self.n)\n self.build_tree(0, 0, self.n - 1, nums)\n\n def combine(self, left, right):\n nn, ny, yn, yy = left\n nn2, ny2, yn2, yy2 = right\n return [\n max(nn + yn2, nn + nn2, ny + nn2), # not_selected_not_selected\n max(nn + yy2, nn + ny2, ny + ny2), # not_selected_selected\n max(yn + yn2, yn + nn2, yy + nn2), # selected_not_selected\n max(yn + yy2, yn + ny2, yy + ny2) # selected_selected\n ]\n\n def build_tree(self, node, start, end, nums):\n if start == end:\n # Leaf node: [0, -inf, -inf, nums[start]]\n self.tree[node] = [0, -math.inf, -math.inf, nums[start]]\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n self.build_tree(left_child, start, mid, nums)\n self.build_tree(right_child, mid + 1, end, nums)\n \n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\n\n def update(self, node, start, end, index, value):\n if start == end:\n self.tree[node] = [0, -math.inf, -math.inf, value]\n else:\n mid = (start + end) // 2\n left_child = 2 * node + 1\n right_child = 2 * node + 2\n \n if index <= mid:\n self.update(left_child, start, mid, index, value)\n else:\n self.update(right_child, mid + 1, end, index, value)\n \n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = SegmentTree(nums)\n result = 0\n\n for index, value in queries:\n segment_tree.update(0, 0, len(nums) - 1, index, value)\n result += max(segment_tree.tree[0])\n result %= MOD\n\n return result","memory":"49000"},{"code":"class SegmentTree:\n def __init__(self, nums):\n self.n = len(nums)\n # # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\n self.tree = [None] * (4 * self.n)\n self.inf = float(\"inf\")\n self.build_tree(0, 0, self.n - 1, nums)\n\n def build_tree(self, node, start, end, nums):\n if start == end:\n # leaf node: [0, -inf, -inf, nums[start]]\n self.tree[node] = [0, -self.inf, -self.inf, nums[start]]\n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n\n self.build_tree(left, start, mid, nums)\n self.build_tree(right, mid + 1, end, nums)\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\n\n def combine(self, left, right):\n lnn, lny, lyn, lyy = left\n rnn, rny, ryn, ryy = right\n return [\n max(lnn + ryn, lnn + rnn, lny + rnn), # not_selected_not_selected\n max(lnn + ryy, lnn + rny, lny + rny), # not_selected_selected\n max(lyn + ryn, lyn + rnn, lyy + rnn), # selected_not_selected\n max(lyn + ryy, lyn + rny, lyy + rny), # selected_selected\n ]\n\n def update(self, node, start, end, idx, val):\n if start == end:\n self.tree[node] = [0, -self.inf, -self.inf, val]\n else:\n mid = (start + end) // 2\n left = 2 * node + 1\n right = 2 * node + 2\n\n if idx <= mid:\n self.update(left, start, mid, idx, val)\n else:\n self.update(right, mid + 1, end, idx, val)\n \n self.tree[node] = self.combine(self.tree[left], self.tree[right])\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = SegmentTree(nums)\n n = len(nums)\n ans = 0\n for idx, val in queries:\n segment_tree.update(0, 0, n - 1, idx, val)\n ans += max(segment_tree.tree[0])\n ans %= MOD\n return ans","memory":"49000"},{"code":"class StVal:\n\n # Combining two nodes by adding their values (can be modified for other operations like min, max)\n def __init__(self, v : int = 0, L = None, R = None):\n\n if L == None or R == None:\n self.both = max(v,0)\n self.none = 0\n self.left = 0\n self.right = 0\n return\n \n self.both = max(L.left+R.right,L.both+R.right,L.left+R.both)\n self.none = max(L.none+R.none,L.right+R.none,L.none+R.left)\n self.left = max(L.left+R.left, L.left+R.none, L.both+R.none)\n self.right = max(L.none+R.right,L.right+R.right,L.none+R.both)\n\n\nclass SegmentTree:\n def __init__(self, v):\n \"\"\"\n :param v: The input array for the segment tree\n \"\"\"\n self.n = len(v)\n self.v = v\n self.leaves = [0] * (self.n+20)\n self.st = [StVal(v = 0)] * (10 * self.n ) # Initially fill with default StVal\n self.init(1, 0, self.n - 1)\n\n def init(self, treeIndex, low_range, high_range):\n \"\"\"\n Build the segment tree recursively\n :param treeIndex: Current index in segment tree\n :param low_range: Lower bound of current segment\n :param high_range: Upper bound of current segment\n \"\"\"\n if low_range == high_range:\n # Leaf node\n if treeIndex >= len(self.st):\n self.st = self.st + [StVal()]\n self.st[treeIndex] = StVal(v = self.v[low_range])\n self.leaves[low_range] = treeIndex # Save the index of the leaf node\n else:\n mid = (low_range + high_range) >> 1\n self.init(treeIndex << 1, low_range, mid)\n self.init((treeIndex << 1) + 1, mid + 1, high_range)\n # Merge child nodes\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\n\n def query(self, l, r):\n \"\"\"\n Public query function to find result in range [l, r]\n \"\"\"\n if l <= r and l < self.n and r >= 0:\n return self.query_recursive(l, r, 1, 0, self.n - 1)\n return StVal() # Return identity element for invalid range\n\n def query_recursive(self, left_index, right_index, treeIndex, low_range, high_range):\n \"\"\"\n Recursively query the range\n \"\"\"\n if left_index <= low_range and high_range <= right_index:\n return self.st[treeIndex]\n\n mid = (low_range + high_range) >> 1\n if right_index <= mid:\n # Only left child\n return self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\n if mid < left_index:\n # Only right child\n return self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\n\n # Overlapping segments, query both sides\n left_result = self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\n right_result = self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\n return StVal(L = left_result, R = right_result)\n\n def update(self, i, x):\n \"\"\"\n Incremental point update\n :param i: Index to update\n :param x: New value to update with\n \"\"\"\n treeIndex = self.leaves[i]\n self.st[treeIndex] = StVal(x)\n\n treeIndex = treeIndex >> 1\n while treeIndex:\n # Recompute parent nodes\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\n treeIndex = treeIndex >> 1\n\n\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n modulo = 10**9+7\n\n st = SegmentTree(nums)\n ans = 0\n for i in range(len(queries)):\n q = queries[i]\n st.update(q[0], q[1])\n val = st.query(0, n-1)\n \n ans = (ans + max(val.both,val.none,val.left,val.right)) % modulo\n return ans","memory":"50700"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n # f00, f01, f10, f11\n t = [[0] * 4 for _ in range(2 << n.bit_length())]\n \n def maintain(o: int):\n a, b = t[o * 2], t[o * 2 + 1]\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\n \n def build(o: int, l: int, r: int):\n if l == r:\n t[o][3] = max(nums[l], 0)\n return \n m = (l + r) // 2\n build(o * 2, l, m)\n build(o * 2 + 1, m + 1, r)\n maintain(o)\n\n def update(o: int, l: int, r: int, i: int, val: int):\n if l == r:\n t[o][3] = max(val, 0)\n return \n m = (l + r) // 2\n if i <= m:\n update(o * 2, l, m, i, val)\n else:\n update(o * 2 + 1, m + 1, r, i, val)\n maintain(o)\n \n build(1, 0, n - 1)\n ans = 0\n for i, x in queries:\n update(1, 0, n - 1, i, x)\n ans += t[1][3]\n\n return ans % (10 ** 9 + 7)","memory":"51400"},{"code":"modulus = 1000000007\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tree = Tree(0, len(nums), nums)\n result = 0\n for i, value in queries:\n tree.change(i, value)\n result = (result + tree.max) % modulus\n return result\n\nclass Tree:\n def __init__(self, start, end, nums):\n self.start = start\n self.end = end\n\n if end - start == 1:\n self.max_without_start = 0\n self.max_without_end = 0\n self.max_without_either = 0\n self.max = max(0, nums[start])\n else:\n mid = (start + end) // 2\n self.left = Tree(start, mid, nums)\n self.right = Tree(mid, end, nums)\n self.update()\n\n def change(self, i, value):\n if self.end - self.start == 1:\n self.max = max(0, value)\n return\n if i < (self.start + self.end) // 2:\n self.left.change(i, value)\n else:\n self.right.change(i, value)\n self.update()\n\n def update(self):\n self.max_without_start = max(\n self.left.max_without_start + self.right.max_without_start,\n self.left.max_without_either + self.right.max\n ) % modulus\n self.max_without_end = max(\n self.left.max_without_end + self.right.max_without_end,\n self.left.max + self.right.max_without_either\n ) % modulus\n self.max_without_either = max(\n self.left.max_without_start + self.right.max_without_either,\n self.left.max_without_either + self.right.max_without_end\n ) % modulus\n self.max = max(\n self.left.max_without_end + self.right.max,\n self.left.max + self.right.max_without_start\n ) % modulus","memory":"51500"},{"code":"\nclass Solution:\n\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n MOD = 10**9 + 7\n # 两边都不取 tree[o][00] = max(a[01]+b[00], a[00]+b[10])\n # 左边不取，右边可取可不取 tree[o][01] = max(a[01]+b[01], a[00]+b[11])\n # 左边可取可不取，右边不取 tree[o][10] = max(a[11]+b[00], a[10]+b[10])\n # 两边都可取可不取 tree[o][11] = max(a[11]+b[01], a[10]+b[11])\n tree = [[0] * 4 for _ in range(2 << n.bit_length())]\n\n # 单点更新线段树\n def set_value(o, l, r, idx, val):\n mid = (l + r) >> 1\n if l == idx and r == idx:\n tree[o][3] = max(val, 0)\n return\n if idx <= mid:\n set_value(o * 2 + 1, l, mid, idx, val)\n else:\n set_value(o * 2 + 2, mid + 1, r, idx, val)\n process(o)\n\n def process(o):\n a, b = tree[o * 2 + 1], tree[o * 2 + 2]\n tree[o][0] = max(a[1] + b[0], a[0] + b[2])\n tree[o][1] = max(a[1] + b[1], a[0] + b[3])\n tree[o][2] = max(a[3] + b[0], a[2] + b[2])\n tree[o][3] = max(a[3] + b[1], a[2] + b[3])\n\n for i, num in enumerate(nums):\n set_value(0, 0, n - 1, i, num)\n ans = 0\n for idx, num in queries:\n set_value(0, 0, n - 1, idx, num)\n ans += tree[0][3]\n return ans % MOD","memory":"51900"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n tmp = 1\n while tmp < len(nums):\n tmp *= 2\n t = [[0]*4 for _ in range(tmp*2)]\n\n n = len(nums)\n\n def maintain(o: int):\n a, b = t[o * 2], t[o * 2 + 1]\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\n\n def build(o, l, r): \n if l == r:\n t[o][3] = max(nums[l], 0)\n return \n m = (l+r) // 2\n build(o*2, l, m)\n build(o*2+1, m+1, r)\n maintain(o)\n\n def update(o, l, r, i, val): \n if l == r: \n t[o][3] = max(val, 0)\n return \n m = (l+r) // 2\n if i <= m: \n update(o*2, l, m, i, val)\n else:\n update(o*2+1, m+1, r, i, val)\n maintain(o)\n\n build(1, 0, n-1)\n ans = 0\n for i, x in queries:\n update(1, 0, n-1, i, x)\n ans += t[1][3]\n return ans % 1_000_000_007","memory":"52200"},{"code":"class Tree:\n def __init__(self, l, r):\n self.l = l\n self.r = r\n self.lt = None\n self.rt = None\n\n self.noExc = 0\n self.lExc = 0\n self.rExc = 0\n self.bothExc = 0\n\n\n @staticmethod\n def build(l, r, nums):\n tree = Tree(l, r)\n if l == r:\n tree.noExc = nums[l]\n return tree\n\n mid = l + (r-l)//2\n tree.lt = Tree.build(l, mid, nums)\n tree.rt = Tree.build(mid+1, r, nums)\n tree.updateSsq()\n return tree\n\n def update(self, idx, val):\n if self.l == self.r:\n self.noExc = max(val, 0)\n return\n\n mid = self.l + (self.r-self.l)//2\n\n if idx <= mid:\n self.lt.update(idx, val)\n else:\n self.rt.update(idx, val)\n\n self.updateSsq()\n\n def updateSsq(self):\n self.noExc = max(self.lt.noExc + self.rt.lExc, self.lt.rExc + self.rt.noExc)\n self.lExc = max(self.lt.lExc + self.rt.lExc, self.lt.bothExc + self.rt.noExc)\n self.rExc = max(self.lt.noExc + self.rt.bothExc, self.lt.rExc + self.rt.rExc)\n self.bothExc = max(self.lt.lExc + self.rt.bothExc, self.lt.bothExc + self.rt.rExc)\n # print(self.noExc, self.lExc, self.rExc, self.noExc)\n \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n n = len(nums)\n MOD = 10**9 + 7\n\n tree = Tree.build(0, n-1, nums)\n # print(tree.noExc)\n ans = 0\n for idx, val in queries:\n tree.update(idx, val)\n # print(tree.noExc)\n ans += tree.noExc % MOD\n\n return ans % MOD\n\n# |----| + |-| |----|\n# or |---| |-| + |---| \n# all = max(l [] + r (], l [) + r[])\n# (] = max(l (] + r(], l () + r[])\n# [) = max(l [) + r[), l [] + r())\n# () = max(l (] + r(), l() + r[))\n","memory":"53400"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\n BOTH = 0\n LEFT = 1\n RIGHT = 2\n NONE = 3\n \n N = len(nums)\n \n # segment tree\n tree = [[0, 0, 0, 0]] * 4 * N\n TR = 2 ** ceil(log2(N))\n\n # calculate values for just node i in the tree\n def update_i(i):\n left = tree[2 * i]\n right = tree[2 * i + 1]\n result = [0, 0, 0, 0]\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\n tree[i] = result\n\n # construct subtree at node i\n def construct(i, tl, tr):\n if tl == tr:\n tree[i] = [nums[tl], 0, 0, 0]\n return\n \n # construct subtrees\n m = (tl + tr) // 2\n construct(i * 2, tl, m)\n if m + 1 < N:\n construct(i * 2 + 1, m + 1, tr)\n \n # calculate outcome\n update_i(i)\n \n # update subtree at node i with change at index t in the original array\n def update(i, t, tl, tr):\n if tl == tr:\n tree[i] = [nums[t], 0, 0, 0]\n else:\n m = (tl + tr) // 2\n if t <= m:\n update(i * 2, t, tl, m)\n else:\n update(i * 2 + 1, t, m + 1, tr)\n update_i(i)\n \n # construct tree\n construct(1, 0, TR)\n\n # process queries\n total = 0\n for q in queries:\n t, x = q\n nums[t] = x\n update(1, t, 0, TR)\n total += max(tree[1])\n\n return total % 1_000_000_007","memory":"54100"},{"code":"class Node:\n def __init__(self,start,end):\n self.l = start\n self.r = end\n self.n = end-start+1\n self.left = None\n self.right = None\n \n self.all = 0\n self.left_loo = 0\n self.right_loo = 0\n self.both_loo = 0\n \nclass QueryTree:\n def __init__(self,nums):\n self.nums = nums\n self.root = self.build(0, len(nums)-1)\n self.calc(self.root)\n \n def build(self,start,end):\n if start == end:\n return Node(start,end)\n \n mid = (start+end)//2\n root = Node(start,end)\n root.left = self.build(start,mid)\n root.right = self.build(mid+1,end)\n return root\n \n def calc(self,node):\n if node is None:\n return \n \n if node.n == 1:\n node.all = max(self.nums[node.l],0)\n node.left_loo = 0\n node.right_loo = 0\n node.both_loo = 0\n return\n \n # node has at least two children\n self.calc(node.left)\n self.calc(node.right)\n \n node.all = max(node.left.all + node.right.left_loo, \n node.left.right_loo + node.right.all)\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\n node.left.both_loo + node.right.all)\n node.right_loo = max(node.left.all + node.right.both_loo,\n node.left.right_loo + node.right.right_loo)\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\n node.left.both_loo + node.right.right_loo) \n \n def query(self):\n return self.root.all\n \n def update(self,i,x):\n self.nums[i] = x\n self.recalc(self.root,i)\n \n def recalc(self,node,i):\n if node is None:\n return \n \n if node.n == 1:\n if node.l == i:\n node.all = max(self.nums[i],0)\n return \n \n if (i < node.l) or (i > node.r):\n return \n \n if i <= node.left.r:\n self.recalc(node.left,i)\n if i >= node.right.l:\n self.recalc(node.right,i)\n \n node.all = max(node.left.all + node.right.left_loo, \n node.left.right_loo + node.right.all)\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\n node.left.both_loo + node.right.all)\n node.right_loo = max(node.left.all + node.right.both_loo,\n node.left.right_loo + node.right.right_loo)\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\n node.left.both_loo + node.right.right_loo) \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n ans = []\n qt = QueryTree(nums)\n for i,x in queries:\n qt.update(i,x)\n ans.append(qt.query())\n return sum(ans) % (10 ** 9 + 7)","memory":"54400"},{"code":"from collections import defaultdict\n\nM = 10 ** 9 + 7\n\nclass SegTree:\n def __init__(self):\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\n \n def merge(self, l, r):\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\n \n def update(self, index, val, i, j, k):\n if i + 1 == j:\n self.tree[k] = (val, 0, 0, 0)\n return\n mid = (i + j) // 2\n if index < mid:\n self.update(index, val, i, mid, 2 * k)\n else:\n self.update(index, val, mid, j, 2 * k + 1)\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\n \n def query(self, x, y, i, j, k):\n if y - 1 < i or x >= j:\n return (0, 0, 0, 0)\n if i >= x and j <= y:\n return self.tree[k]\n mid = (i + j) // 2\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n res = 0\n segtree = SegTree()\n for i in range(n):\n segtree.update(i, nums[i], 0, n, 1)\n for i, val in queries:\n segtree.update(i, val, 0, n, 1)\n res += max(segtree.query(0, n, 0, n, 1))\n res %= M\n return res","memory":"54600"},{"code":"class SegmentTree:\n\n def __init__(self, arr: List[int]):\n self.n = len(arr)\n self.tree = [[0, 0, 0, 0] for _ in range(4 * self.n)]\n self._build(arr, 1, 0, self.n - 1)\n\n def _merge(self, v1: List[int], v2: List[int]) -> List[int]:\n a1, b1, c1, d1 = v1\n a2, b2, c2, d2 = v2\n\n return [\n max(a1 + c2, b1 + a2, b1 + c2),\n max(a1 + d2, b1 + b2, b1 + d2),\n max(c1 + c2, d1 + a2, d1 + c2),\n max(c1 + d2, d1 + b2, d1 + d2),\n ]\n\n def _build(self, arr: List[int], pos: int, l: int, r: int):\n if l == r:\n self.tree[pos][0] = max(0, arr[l])\n else:\n m = (l + r) // 2\n self._build(arr, 2 * pos, l, m)\n self._build(arr, 2 * pos + 1, m + 1, r)\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\n\n def _update(self, ind: int, new_val: int, pos: int, l: int, r: int):\n if l == r:\n self.tree[pos][0] = max(0, new_val)\n else:\n m = (l + r) // 2\n if ind <= m:\n self._update(ind, new_val, 2 * pos, l, m)\n else:\n self._update(ind, new_val, 2 * pos + 1, m + 1, r)\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\n\n def update(self, ind: int, new_val: int):\n self._update(ind, new_val, 1, 0, self.n - 1)\n \n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n st, res = SegmentTree(nums), 0\n for ind, new_val in queries:\n st.update(ind, new_val)\n res = (res + max(st.tree[1])) % (10**9 + 7)\n \n return res","memory":"54800"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n class SegTreeNode:\n def __init__(self, a, b, vals):\n self.left = None\n self.right = None\n self.start = a\n self.end = b\n self.info00 = 0\n self.info11 = 0\n self.info10 = -float('inf')\n self.info01 = -float('inf')\n \n if a == b:\n self.info11 = vals[self.start]\n return\n \n mid = (a + b) // 2\n \n self.left = SegTreeNode(a, mid, vals)\n self.right = SegTreeNode(mid + 1, b, vals)\n \n self.info11 = max(self.left.info10 + self.right.info01,\n self.left.info11 + self.right.info01,\n self.left.info10 + self.right.info11)\n self.info00 = max(self.left.info00 + self.right.info00,\n self.left.info01 + self.right.info00,\n self.left.info00 + self.right.info10)\n self.info10 = max(self.left.info10 + self.right.info00,\n self.left.info10 + self.right.info10,\n self.left.info11 + self.right.info00)\n self.info01 = max(self.left.info00 + self.right.info01,\n self.left.info01 + self.right.info01,\n self.left.info00 + self.right.info11)\n \n def update_range(self, a, val):\n if a < self.start or a > self.end:\n return\n \n if self.start == self.end:\n self.info00 = 0\n self.info11 = val\n return\n \n self.left.update_range(a, val)\n self.right.update_range(a, val)\n \n self.info11 = max(self.left.info10 + self.right.info01,\n self.left.info11 + self.right.info01,\n self.left.info10 + self.right.info11)\n self.info00 = max(self.left.info00 + self.right.info00,\n self.left.info01 + self.right.info00,\n self.left.info00 + self.right.info10)\n self.info10 = max(self.left.info10 + self.right.info00,\n self.left.info10 + self.right.info10,\n self.left.info11 + self.right.info00)\n self.info01 = max(self.left.info00 + self.right.info01,\n self.left.info01 + self.right.info01,\n self.left.info00 + self.right.info11)\n\n root = SegTreeNode(0, len(nums) - 1, nums)\n result = 0\n M = 10 ** 9 + 7\n \n for q in queries:\n root.update_range(q[0],q[1])\n result += max(root.info00, root.info01, root.info11, root.info10)\n result = result % M\n\n return result\n","memory":"57200"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n maxSums = defaultdict() #first int: int/out, last: int/out\n\n def updateEntry(idx):\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\n maxSums[idx] = (inin, inout, outin, outout)\n\n def createTree(left=0, right=n-1, idx=0):\n if left > right: return\n if left == right:\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\n return\n mid = (left+right) //2\n createTree(left, mid, idx*2+1)\n createTree(mid+1, right, idx*2+2)\n updateEntry(idx)\n \n createTree()\n # print(\"tree:\", maxSums)\n\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\n if listIdx < left or listIdx > right: return\n if left == right:\n maxSums[idx] = (max(val, 0), 0, 0, 0)\n return\n mid = (left+right) //2\n updateValue(listIdx, val,left, mid, idx*2+1)\n updateValue(listIdx, val, mid+1, right, idx*2+2)\n updateEntry(idx)\n\n ans = 0\n for q in queries:\n pos, x = q\n updateValue(pos, x)\n ans += max(maxSums[0])\n return ans % (10**9+7)\n \n\n\n \n\n # n = len(nums)\n # if n==1:\n # ans = 0\n # for query in queries: ans += max(query[1], 0)\n # return ans\n # if n==2:\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # ans += max(0, max(nums))\n # return ans\n \n # # initially \n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\n # dp[n-1] = max(0,nums[n-1])\n # dp[n-2] = max(0,nums[n-2])\n \n # maxDpTwoStepsAway = max(dp[n-1], 0)\n # for i in range(n-3, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n\n # ans = 0\n # for query in queries:\n # pos, val = query\n # nums[pos] = val\n # # print(\"qeury:\", query,\"nums:\", nums)\n # maxDpTwoStepsAway = 0\n # if pos+2 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\n \n # for i in range(pos, -1, -1):\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\n # if i + 1 < n:\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\n \n # ans += max(dp)\n # # print(\"dp:\", dp)\n # return ans\n \n ","memory":"57500"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","memory":"58700"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","memory":"59100"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val.copy() # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n #print(\"build for start:\", start, \", end:\", end, \", val=\", val)\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n #print(tree.query(0, N-1))\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n #print(\" cur = \", cur)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","memory":"59200"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val.copy() # [left, right, mid, both]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start]]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n for i in range(N):\n if nums[i] < 0:\n nums[i] = 0\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n if cur[3] > 0:\n res = (res + cur[3]) % MOD\n return res\n\n","memory":"59300"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res","memory":"59400"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n","memory":"59500"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n \n # val not only save the [start,end] range val\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\n self.val = val # [left, right, mid, both]\n # left --> [start, end-1]\n # right --> [start+1, end]\n # mid --> [start+1, end-1]\n # both --> [start, end]\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\n return TreeNode(start, end, val, None, None)\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\n val = [val_left, val_right, val_mid, val_both]\n return TreeNode(start, end, val, left, right)\n\n self.root = build(nums, 0, len(nums)-1)\n def doQuery(self, node, start, end):\n if start > end:\n return 0\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return self.doQuery(node.right, start, end)\n elif mid >= end:\n return self.doQuery(node.left, start, end)\n\n left = self.doQuery(node.left, start, mid)\n right = self.doQuery(node.right, mid+1, end)\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n val = [val_left, val_right, val_mid, val_both]\n return val\n\n def query(self, start, end):\n return self.doQuery(self.root, start, end)\n\n def doUpdate(self, node, pos, val):\n start, end = node.start, node.end\n if start == end == pos:\n node.val[3] = val\n return\n\n mid = start + (end - start) // 2\n if pos > mid:\n self.doUpdate(node.right, pos, val)\n else:\n self.doUpdate(node.left, pos, val)\n\n left, right = node.left.val, node.right.val\n val_left = max(left[3] + right[2], left[0] + right[0])\n val_right = max(left[1] + right[1], left[2] + right[3])\n val_mid = max(left[1] + right[2], left[2] + right[0])\n val_both = max(left[3] + right[1], left[0] + right[3])\n node.val = [val_left, val_right, val_mid, val_both]\n\n def update(self, pos, val):\n self.doUpdate(self.root, pos, val)\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n N = len(nums)\n tree = SegmentTree(nums)\n res, MOD = 0, 10**9+7\n for query in queries:\n tree.update(query[0], query[1] if query[1] > 0 else 0)\n cur = tree.query(0, N-1)\n res = (res + cur[3]) % MOD\n return res\n","memory":"59600"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n class node:\n def __init__(self,num,val):\n self.range_left=num\n self.range_right=num+1\n self.full_v=max(val,0)\n self.nleft_v=0\n self.nright_v=0\n self.nboth_v=0\n\n @classmethod\n def grow(cls,range_left,range_right):\n if range_right-range_left==1:\n return node(range_left,nums[range_left])\n root=node(0,0)\n root.range_left=range_left\n root.range_right=range_right\n mid=(range_left+range_right)//2\n root.left=cls.grow(range_left,mid)\n root.right=cls.grow(mid,range_right)\n root.left.parent=root\n root.right.parent=root\n root.parent=None\n root.merge()\n return root\n \n def merge(self):\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\n\n def seek(self,n):\n if self.range_left==n and self.range_right==n+1:\n return self\n mid=(self.range_left+self.range_right)//2\n if n<mid:\n return self.left.seek(n)\n else:\n return self.right.seek(n)\n \n def update_leaf(self,v):\n self.full_v=max(v,0)\n t=self.parent\n while t:\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\n t.merge()\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\n break\n t=t.parent\n \n root=node.grow(0,len(nums))\n root.parent=None\n sums=0\n for i in queries:\n nd=root.seek(i[0])\n nd.update_leaf(i[1])\n sums+=root.full_v\n sums%=(10**9+7)\n return sums\n\n","memory":"61300"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n \n vals = [[0 for _ in range(4)] for _ in range(len(nums) * 4)]\n\n lst = [\n [ 0 , 0 , 0 , 0 , 0 , 0 ],\n [ 0 , 0 , 0 , 0 , 0 , 1 ],\n [ 0 , 0 , 0 , 0 , 1 , 0 ],\n [ 0 , 0 , 0 , 0 , 1 , 1 ],\n [ 0 , 0 , 0 , 1 , 0 , 1 ],\n [ 0 , 0 , 0 , 1 , 1 , 1 ],\n [ 0 , 0 , 1 , 0 , 0 , 0 ],\n [ 0 , 0 , 1 , 0 , 0 , 1 ],\n [ 0 , 0 , 1 , 0 , 1 , 0 ],\n [ 0 , 0 , 1 , 0 , 1 , 1 ],\n [ 0 , 0 , 1 , 1 , 0 , 1 ],\n [ 0 , 0 , 1 , 1 , 1 , 1 ],\n [ 0 , 1 , 0 , 0 , 0 , 0 ],\n [ 0 , 1 , 0 , 0 , 0 , 1 ],\n [ 0 , 1 , 0 , 0 , 1 , 0 ],\n [ 0 , 1 , 0 , 0 , 1 , 1 ],\n [ 0 , 1 , 0 , 1 , 0 , 1 ],\n [ 0 , 1 , 0 , 1 , 1 , 1 ],\n [ 1 , 0 , 0 , 0 , 1 , 0 ],\n [ 1 , 0 , 0 , 0 , 1 , 1 ],\n [ 1 , 0 , 0 , 1 , 1 , 1 ],\n [ 1 , 0 , 1 , 0 , 1 , 0 ],\n [ 1 , 0 , 1 , 0 , 1 , 1 ],\n [ 1 , 0 , 1 , 1 , 1 , 1 ],\n [ 1 , 1 , 0 , 0 , 1 , 0 ],\n [ 1 , 1 , 0 , 0 , 1 , 1 ],\n [ 1 , 1 , 0 , 1 , 1 , 1 ],\n ]\n\n def keep(idx, lb, rb):\n\n vals[idx] = [0 for _ in range(4)]\n\n lidx = idx * 2 + 1\n ridx = idx * 2 + 2\n\n if lb == rb:\n vals[idx][0] = max(0, nums[lb])\n\n else:\n # for i0 in (0, 1):\n # for i1 in (0, 1):\n # for j0 in (0, 1):\n # for j1 in (0, 1):\n # for k0 in (0, 1):\n # for k1 in (0, 1):\n # if i1 == 1 and j0 == 1:\n # continue\n \n # if i0 == 1 and k0 == 0:\n # continue\n\n # if j1 == 1 and k1 == 0:\n # continue\n\n \n # print(\"[\", i0, \", \", i1, \", \",j0, \", \",j1, \", \", k0, \", \", k1, \"],\")\n # node.val[k0][k1] = max(node.val[k0][k1], node.left.val[i0][i1] + node.right.val[j0][j1])\n\n # print()\n # print()\n # print()\n\n # for i0, i1, j0, j1, k0, k1 in lst:\n # vals[idx][k0][k1] = max(vals[idx][k0][k1], vals[lidx][i0][i1] + vals[ridx][j0][j1])\n\n l0h0A, l1h0A, l0h1A, l1h1A = vals[2 * idx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = vals[2 * idx + 2]\n # lo to hi\n vals[idx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n vals[idx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n vals[idx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n vals[idx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n\n def build(idx, lb, rb):\n\n if lb == rb:\n pass\n else:\n mid = (lb + rb) // 2\n\n build(2 * idx + 1, lb, mid)\n build(2 * idx + 2, mid + 1, rb)\n\n keep(idx, lb, rb)\n\n def update(nidx, idx, val, lb, rb):\n\n if not (lb <= idx <= rb):\n return\n\n elif lb == idx == rb:\n nums[idx] = val\n\n else:\n mid = (lb + rb) // 2\n update(2 * nidx + 1, idx, val, lb, mid)\n update(2 * nidx + 2, idx, val, mid + 1, rb)\n \n keep(nidx, lb, rb) \n\n build(0, 0, len(nums) - 1)\n\n\n res = 0\n for idx, val in queries:\n update(0, idx, val, 0, len(nums) - 1)\n res = (res + max(vals[0])) % (10 ** 9 + 7)\n\n return res\n \n","memory":"62200"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\n BOTH = 0\n LEFT = 1\n RIGHT = 2\n NONE = 3\n N = len(nums)\n \n # segment tree\n tree = [[0, 0, 0, 0] for _ in range(4 * N)]\n\n # calculate values for just node i in the tree\n def update_i(i):\n left = tree[2 * i]\n right = tree[2 * i + 1]\n result = tree[i]\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\n\n # construct subtree at node i\n def construct(i, tl, tr):\n if tl == tr:\n tree[i][BOTH] = nums[tl]\n else:\n # construct subtrees and calculate outcome for this node\n m = (tl + tr) // 2\n construct(i * 2, tl, m)\n construct(i * 2 + 1, m + 1, tr)\n update_i(i)\n \n # update subtree at node i with change at index t in the original array\n def update(i, t, tl, tr):\n if tl == tr:\n tree[i][BOTH] = nums[t]\n else:\n m = (tl + tr) // 2\n if t <= m:\n update(i * 2, t, tl, m)\n else:\n update(i * 2 + 1, t, m + 1, tr)\n update_i(i)\n \n # construct tree\n construct(1, 0, N - 1)\n\n # process queries\n total = 0\n for q in queries:\n t, x = q\n nums[t] = x\n update(1, t, 0, N - 1)\n total += max(tree[1])\n\n return total % 1_000_000_007","memory":"63100"},{"code":"class Solution:\n def maximumSumSubsequence(self, performance_scores: List[int], inspections: List[List[int]]) -> int:\n \"\"\"\n Optimizes the performance of a fleet of trucks based on their performance scores and periodic inspections.\n\n Given a list of initial performance scores of trucks, and a series of inspections where the performance of\n certain trucks is updated, this function computes the maximum possible performance of the fleet, ensuring that \n no two adjacent trucks are selected for optimization. The result after all inspections is returned modulo 10^9 + 7.\n\n Args:\n performance_scores (List[int]): Initial performance scores of the fleet's trucks.\n inspections (List[List[int]]): A list of updates, where each update contains the truck index and its new performance score.\n\n Returns:\n int: The sum of the maximum subsequence performance after each inspection, modulo 10^9 + 7.\n \"\"\"\n \n MOD = 1_000_000_007\n n = len(performance_scores)\n # Segment tree to store maximum subsequence sums for different truck ranges\n segment_tree = [[0] * 4 for _ in range(4 * n)]\n\n def build_tree(node: int, start: int, end: int):\n \"\"\"\n Recursively builds the segment tree based on the initial performance scores.\n \"\"\"\n if start == end:\n segment_tree[node][0] = max(0, performance_scores[start])\n else:\n mid = (start + end) // 2\n build_tree(2 * node + 1, start, mid)\n build_tree(2 * node + 2, mid + 1, end)\n combine(node)\n\n def combine(node: int):\n \"\"\"\n Combines two child nodes in the segment tree to calculate the maximum subsequence sums for the parent node.\n \"\"\"\n left = segment_tree[2 * node + 1]\n right = segment_tree[2 * node + 2]\n # No adjacent trucks selected\n segment_tree[node][0] = max(left[2] + right[1], left[0] + right[1], left[2] + right[0])\n # Skipping the first truck\n segment_tree[node][1] = max(left[3] + right[1], left[1] + right[1], left[3] + right[0])\n # Skipping the last truck\n segment_tree[node][2] = max(left[2] + right[3], left[0] + right[3], left[2] + right[2])\n # Skipping both the first and last trucks\n segment_tree[node][3] = max(left[3] + right[3], left[1] + right[3], left[3] + right[2])\n\n def update_tree(node: int, start: int, end: int, idx: int, new_score: int):\n \"\"\"\n Updates the segment tree when a truck's performance score is changed after an inspection.\n \"\"\"\n if start == end:\n segment_tree[node][0] = max(0, new_score)\n else:\n mid = (start + end) // 2\n if idx > mid:\n update_tree(2 * node + 2, mid + 1, end, idx, new_score)\n else:\n update_tree(2 * node + 1, start, mid, idx, new_score)\n combine(node)\n\n # Build the initial segment tree\n build_tree(0, 0, n - 1)\n\n total_performance = 0\n\n # Process each inspection (update performance score and recalculate maximum subsequence sum)\n for idx, new_score in inspections:\n update_tree(0, 0, n - 1, idx, new_score)\n total_performance += max(segment_tree[0])\n total_performance %= MOD\n\n return total_performance","memory":"63600"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","memory":"63700"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","memory":"63800"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","memory":"63900"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = [[0] * 4 for _ in range(4 * n)]\n \n def build(tidx, lo, hi):\n if lo == hi:\n tree[tidx][0] = max(0, nums[lo])\n else:\n mid = (lo + hi) // 2\n build(2 * tidx + 1, lo, mid)\n build(2 * tidx + 2, mid + 1, hi)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n build(0, 0, n - 1)\n \n def update(tidx, lo, hi, i, val):\n if lo == hi:\n tree[tidx][0] = max(0, val)\n else:\n mid = (lo + hi) // 2\n if i > mid:\n update(tidx * 2 + 2, mid + 1, hi, i, val)\n else:\n update(tidx * 2 + 1, lo, mid, i, val)\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\n # lo to hi\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\n # lo + 1 to hi\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\n # lo to hi - 1\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\n # lo + 1 to hi - 1\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\n \n ans = 0\n for i, x in queries:\n update(0, 0, n - 1, i, x)\n ans += max(tree[0])\n return ans % 1_000_000_007","memory":"64000"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = 0\n self.selected[1][0] = 0\n self.selected[1][1] = max(nums[lo], nums[hi])\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","memory":"75200"},{"code":"class Node:\n def __init__(self, nums, lo, hi):\n self.lo = lo\n self.hi = hi\n self.selected = [[0, -float('inf')], [-float('inf'), -float('inf')]]\n \n if lo < hi:\n mid = (lo + hi) // 2\n self.l = Node(nums, lo, mid)\n self.r = Node(nums, mid + 1, hi)\n self.combine()\n else:\n self.selected[1][1] = nums[lo]\n \n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0] + self.r.selected[0][0], max(self.l.selected[0][1] + self.r.selected[0][0], self.l.selected[0][0] + self.r.selected[1][0]))\n self.selected[0][1] = max(self.l.selected[0][0] + self.r.selected[0][1], max(self.l.selected[0][1] + self.r.selected[0][1], self.l.selected[0][0] + self.r.selected[1][1]))\n self.selected[1][0] = max(self.l.selected[1][0] + self.r.selected[0][0], max(self.l.selected[1][1] + self.r.selected[0][0], self.l.selected[1][0] + self.r.selected[1][0]))\n self.selected[1][1] = max(self.l.selected[1][0] + self.r.selected[0][1], max(self.l.selected[1][1] + self.r.selected[0][1], self.l.selected[1][0] + self.r.selected[1][1]))\n\n def update(self, i, x):\n if i < self.lo or i > self.hi:\n return\n \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n \n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n segmentTree = Node(nums, 0, len(nums) - 1)\n\n res = 0\n for query in queries:\n segmentTree.update(query[0], query[1])\n res += max(segmentTree.selected[0][0], max(segmentTree.selected[0][1], max(segmentTree.selected[1][0], segmentTree.selected[1][1])))\n res %= 10**9 + 7\n return res","memory":"77400"},{"code":"class Node:\n def __init__(self, nums, lo, hi):\n self.l = None\n self.r = None\n self.lo = lo\n self.hi = hi\n self.selected = [[0, -float('inf')], [-float('inf'), 0]]\n\n if lo < hi:\n mid = (lo + hi) // 2\n self.l = Node(nums, lo, mid)\n self.r = Node(nums, mid + 1, hi)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = -float('inf')\n self.selected[1][0] = -float('inf')\n self.selected[1][1] = nums[lo]\n\n def combine(self):\n l, r = self.l.selected, self.r.selected\n self.selected[0][0] = max(l[0][0] + r[0][0], l[0][1] + r[0][0], l[0][0] + r[1][0])\n self.selected[0][1] = max(l[0][0] + r[0][1], l[0][1] + r[0][1], l[0][0] + r[1][1])\n self.selected[1][0] = max(l[1][0] + r[0][0], l[1][1] + r[0][0], l[1][0] + r[1][0])\n self.selected[1][1] = max(l[1][0] + r[0][1], l[1][1] + r[0][1], l[1][0] + r[1][1])\n\n def update(self, i, x):\n if i < self.lo or self.hi < i:\n return\n\n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n MOD = 10**9 + 7\n segment_tree = Node(nums, 0, len(nums) - 1)\n \n res = 0\n for query in queries:\n segment_tree.update(query[0], query[1])\n res += max(max(segment_tree.selected[0]), max(segment_tree.selected[1]))\n res %= MOD\n \n return res","memory":"77500"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = float('-inf')\n self.selected[1][0] = float('-inf')\n self.selected[1][1] = max(nums[lo], nums[hi])\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","memory":"78800"},{"code":"class Node:\n def __init__(self, lo, hi, nums):\n self.lo = lo\n self.hi = hi\n self.selected = [[0]*2 for _ in range(2)]\n if lo < hi:\n mid = (lo + hi)//2\n self.l = Node(lo, mid, nums)\n self.r = Node(mid+1, hi, nums)\n self.combine()\n else:\n self.selected[0][0] = 0\n self.selected[0][1] = float('-inf')\n self.selected[1][0] = float('-inf')\n self.selected[1][1] = nums[lo]\n def combine(self):\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\n def update(self, i, x):\n if i < self.lo or self.hi < i: return \n if self.lo == self.hi:\n self.selected[0][0] = 0\n self.selected[1][1] = x\n return\n self.l.update(i, x)\n self.r.update(i, x)\n self.combine()\n\nclass Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n tree = Node(0,len(nums)-1,nums)\n res = 0\n MOD = 10**9+7\n for i,x in queries:\n tree.update(i,x)\n res += max(max(tree.selected[0]), max(tree.selected[1]))\n res %= MOD\n return res","memory":"78800"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\n def glue(a, b):\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\n def query(l, r, p=1, tl=0, tr=len(nums)):\n if l == tl and r == tr:\n return st[p];\n tm = (tl + tr) // 2\n return glue(query(l, min(r, tm), p * 2, tl, tm), \n query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\n def update(pos, x, p=1, tl=0, tr=len(nums)):\n tm = (tl + tr) // 2\n if tl == tr:\n st[p][1][1] = x \n elif pos <= tm:\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\n else:\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\n return st[p]\n for i, n in enumerate(nums):\n update(i, n)\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007","memory":"88400"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n # 11:17\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\n def glue(a, b):\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\n # def query(l, r, p=1, tl=0, tr=len(nums)):\n # if l == tl and r == tr:\n # return st[p];\n # tm = (tl + tr) // 2\n # return glue(query(l, min(r, tm), p * 2, tl, tm), \n # query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\n def update(pos, x, p=1, tl=0, tr=len(nums)):\n tm = (tl + tr) // 2\n if tl == tr:\n st[p][1][1] = x \n elif pos <= tm:\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\n else:\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\n return st[p]\n for i, n in enumerate(nums):\n update(i, n)\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007","memory":"88500"},{"code":"class Solution:\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\n self.inf = float('inf')\n self.mod = 10 ** 9 + 7\n n = len(nums)\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\n self.build(st, nums, 0, 0, n - 1)\n res = 0\n for ind, val in queries:\n self.update(st, 0, ind, val, 0, n - 1)\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\n return res\n \n def build(self, st, nums, node, l, r):\n if l == r:\n st[node][0][0] = 0\n st[node][0][1] = -float('inf')\n st[node][1][0] = -float('inf')\n st[node][1][1] = nums[l]\n \n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n self.build(st, nums, lnode, l, m)\n self.build(st, nums, rnode, m + 1, r)\n self.combine(st, node, lnode, rnode)\n def combine(self, st, node, lnode, rnode):\n for x in range(2):\n for y in range(2):\n st[node][x][y] = max(\n st[lnode][x][0] + st[rnode][0][y],\n st[lnode][x][1] + st[rnode][0][y],\n st[lnode][x][0] + st[rnode][1][y]\n )\n \n def update(self, st, node, ind, val, l, r):\n if l == r:\n st[node][1][1] = val\n else:\n m = (l + r) // 2\n lnode, rnode = 2 * node + 1, 2 * node + 2\n if ind <= m:\n self.update(st, lnode, ind, val, l, m)\n else:\n self.update(st, rnode, ind, val, m + 1, r)\n self.combine(st, node, lnode, rnode)","memory":"90200"}],"string":"[\n {\n \"code\": \"class SegTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.tree = [0] * (4 * self.n)\\n self.build(nums, 0, 0, self.n - 1)\\n \\n def build(self, nums, node, start, end):\\n if start == end:\\n self.tree[node] = (max(nums[start], 0), 0, 0, 0)\\n \\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n self.build(nums, left, start, mid)\\n self.build(nums, right, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\\n \\n def merge(self, left, right):\\n include = max(left[2] + right[0], left[0] + right[1])\\n ex_l = max(left[1] + right[1], left[3] + right[0])\\n ex_r = max(left[2] + right[2], left[0] + right[3])\\n ex_both = max(left[3] + right[2], left[1] + right[3])\\n return (include, ex_l, ex_r, ex_both)\\n \\n def update(self, idx, value, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, value), 0, 0, 0)\\n \\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n if start <= idx <= mid:\\n self.update(idx, value, left, start, mid)\\n else:\\n self.update(idx, value, right, mid + 1, end)\\n\\n self.tree[node] = self.merge(self.tree[left], self.tree[right])\\n return\\n \\n def query(self):\\n return self.tree[0][0]\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n segtree = SegTree(nums)\\n mod = 10 ** 9 + 7\\n\\n ans = 0\\n for pos, val in queries:\\n segtree.update(pos, val, 0, 0, segtree.n - 1)\\n\\n ans = (ans + segtree.query()) % mod\\n\\n return ans\",\n \"memory\": \"43400\"\n },\n {\n \"code\": \"class SegTree: \\n\\n def __init__(self, arr: List[int]):\\n self.n = n = len(arr)\\n self.tree = [0]*(4*n)\\n self._build(arr, 0, 0, n)\\n \\n def _op(self, left, right): \\n lv, ls, le, lse = left\\n rv, rs, re, rse = right \\n ov = max(le+rv, lv+rs)\\n os = max(ls+rs, lse+rv)\\n oe = max(le+re, lv+rse)\\n ose = max(lse+re, ls+rse)\\n return (ov, os, oe, ose)\\n\\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\\n else:\\n mid = lo + hi >> 1\\n self._build(arr, 2*k+1, lo, mid)\\n self._build(arr, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\\n if not hi: hi = self.n\\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\\n else: \\n mid = lo + hi >> 1\\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\\n else: self.update(i, x, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \\n if not hi: hi = self.n\\n if qhi <= lo or hi <= qlo: return inf # no overlap \\n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \\n mid = lo + hi >> 1 # partial overlap \\n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = SegTree(nums)\\n ans = 0 \\n for i, x in queries: \\n tree.update(i, x)\\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\\n return ans \",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class SegTree: \\n\\n def __init__(self, arr: List[int]):\\n self.n = n = len(arr)\\n self.tree = [0]*(4*n)\\n self._build(arr, 0, 0, n)\\n \\n def _op(self, left, right): \\n lv, ls, le, lse = left\\n rv, rs, re, rse = right \\n v = max(le+rv, lv+rs)\\n s = max(ls+rs, lse+rv)\\n e = max(le+re, lv+rse)\\n se = max(lse+re, ls+rse)\\n return (v, s, e, se)\\n\\n def _build(self, arr: List[int], k: int, lo: int, hi: int) -> None:\\n if lo+1 == hi: self.tree[k] = (max(0, arr[lo]), 0, 0, 0)\\n else:\\n mid = lo + hi >> 1\\n self._build(arr, 2*k+1, lo, mid)\\n self._build(arr, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def update(self, i: int, x: int, k: int = 0, lo: int = 0, hi: int = 0) -> None:\\n if not hi: hi = self.n\\n if lo+1 == hi: self.tree[k] = (max(0, x), 0, 0, 0) # leaf node\\n else: \\n mid = lo + hi >> 1\\n if i < mid: self.update(i, x, 2*k+1, lo, mid)\\n else: self.update(i, x, 2*k+2, mid, hi)\\n self.tree[k] = self._op(self.tree[2*k+1], self.tree[2*k+2])\\n\\n def query(self, qlo: int, qhi: int, k: int = 0, lo: int = 0, hi: int = 0) -> int: \\n if not hi: hi = self.n\\n if qhi <= lo or hi <= qlo: return inf # no overlap \\n if qlo <= lo and hi <= qhi: return self.tree[k] # total overlap \\n mid = lo + hi >> 1 # partial overlap \\n return self._op(self.query(qlo, qhi, 2*k+1, lo, mid), self.query(qlo, qhi, 2*k+2, mid, hi))\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = SegTree(nums)\\n ans = 0 \\n for i, x in queries: \\n tree.update(i, x)\\n ans = (ans + tree.query(0, len(nums))[0]) % 1_000_000_007\\n return ans \",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class SegTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.tree = [None] * (4 * self.n)\\n self.build(nums, 0, 0, self.n - 1)\\n \\n def build(self, nums, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, nums[start]), 0, 0, 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n self.build(nums, left_child, start, mid)\\n self.build(nums, right_child, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n \\n def merge(self, left, right):\\n include = max(left[2] + right[0], left[0] + right[1])\\n exclude_l = max(left[3] + right[0], left[1] + right[1])\\n exclude_r = max(left[2] + right[2], left[0] + right[3])\\n exclude_both = max(left[3] + right[2], left[1] + right[3])\\n return (include, exclude_l, exclude_r, exclude_both)\\n \\n def update(self, idx, value, node, start, end):\\n if start == end:\\n self.tree[node] = (max(0, value), 0, 0, 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n if start <= idx <= mid:\\n self.update(idx, value, left_child, start, mid)\\n else:\\n self.update(idx, value, right_child, mid + 1, end)\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n \\n def query(self):\\n return self.tree[0][0]\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n\\n segtree = SegTree(nums)\\n \\n MOD = 10 ** 9 + 7\\n \\n res = 0\\n for pos, val in queries:\\n segtree.update(pos, val, 0, 0, segtree.n - 1)\\n \\n #segtree.print_tree()\\n #print(segtree.query())\\n \\n res = (res + segtree.query()) % MOD\\n \\n return res\\n \",\n \"memory\": \"43900\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, n):\\n self.n = n\\n self.a1 = [0] * 4 * self.n # (l, r)\\n self.a2 = [0] * 4 * self.n # (l, r - 1)\\n self.a3 = [0] * 4 * self.n # (l + 1, r)\\n self.a4 = [0] * 4 * self.n # (l + 1, r - 1)\\n \\n def query(self):\\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\\n\\n def update(self, pos, val):\\n self.updateHelper(0, self.n - 1, 0, pos, val)\\n \\n def updateHelper(self, left, right, ind, pos, val):\\n if left==right:\\n self.a1[ind] = val\\n self.a2[ind] = 0\\n self.a3[ind] = 0\\n self.a4[ind] = 0\\n return\\n \\n mid = (left + right) // 2\\n if pos <= mid:\\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\\n else:\\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\\n\\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n segTree = SegmentTree(n)\\n total = 0\\n MOD = 10**9 + 7\\n for i, x in enumerate(nums):\\n segTree.update(i, x)\\n\\n for i,x in queries:\\n segTree.update(i, x)\\n total += segTree.query()\\n total %= MOD\\n return total\",\n \"memory\": \"44000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n base = 1\\n n = len(nums)\\n if n&1: # make n even\\n nums.append(0)\\n n += 1\\n while base<n: base <<= 1\\n last = base+n-1\\n tree = [[[],[]],[[],[]]] # 00,01, 10,11; in(ex)cluding left and right \\n for i,j in product((0,1),(0,1)):\\n if i+j<2: tree[i][j] = [0]*(base+n)\\n else: tree[i][j] = [0]*base + nums\\n def update(p): # merge parent\\n lc = p<<1\\n rc = lc+1\\n for i,j in product((0,1),(0,1)):\\n tree[i][j][p] = max(tree[i][0][lc]+max(tree[0][j][rc],tree[1][j][rc]),\\n tree[i][1][lc]+tree[0][j][rc])\\n return\\n for i in range(last//2,0,-1):\\n update(i) # build\\n #print(n,base,tree)\\n ans = 0\\n for pos,x in queries:\\n i = base+pos\\n tree[1][1][i] = x\\n i >>= 1\\n while i:\\n update(i)\\n i >>= 1\\n ans += max(tree[i][j][1] for i,j in product((0,1),(0,1))) \\n #\\n return ans%(10**9+7) \\n\",\n \"memory\": \"44100\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, n):\\n self.n = n\\n self.a1 = [0] * 4 * self.n \\n self.a2 = [0] * 4 * self.n \\n self.a3 = [0] * 4 * self.n \\n self.a4 = [0] * 4 * self.n \\n def query(self):\\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\\n def update(self, pos, val):\\n self.updateHelper(0, self.n - 1, 0, pos, val) \\n def updateHelper(self, left, right, ind, pos, val):\\n if left==right:\\n self.a1[ind] = val\\n self.a2[ind] = 0\\n self.a3[ind] = 0\\n self.a4[ind] = 0\\n return \\n mid = (left + right) // 2\\n if pos <= mid:\\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\\n else:\\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n segTree = SegmentTree(n)\\n total = 0\\n MOD = 10**9 + 7\\n for i, x in enumerate(nums):\\n segTree.update(i, x)\\n for i,x in queries:\\n segTree.update(i, x)\\n total += segTree.query()\\n total %= MOD\\n return total \",\n \"memory\": \"44600\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, n):\\n self.n = n\\n self.a1 = [0] * 4 * self.n \\n self.a2 = [0] * 4 * self.n \\n self.a3 = [0] * 4 * self.n \\n self.a4 = [0] * 4 * self.n \\n def query(self):\\n return max(self.a1[0], self.a2[0], self.a3[0], self.a4[0])\\n def update(self, pos, val):\\n self.updateHelper(0, self.n - 1, 0, pos, val) \\n def updateHelper(self, left, right, ind, pos, val):\\n if left==right:\\n self.a1[ind] = val\\n self.a2[ind] = 0\\n self.a3[ind] = 0\\n self.a4[ind] = 0\\n return \\n mid = (left + right) // 2\\n if pos <= mid:\\n self.updateHelper(left, mid, ind*2 + 1, pos, val)\\n else:\\n self.updateHelper(mid + 1, right, ind*2 + 2, pos, val)\\n self.a1[ind] = max(self.a1[ind*2 + 1] + self.a3[ind*2 + 2], self.a2[ind*2 + 1] + self.a1[ind*2 + 2], self.a2[ind*2 + 1] + self.a3[ind*2 + 2])\\n self.a2[ind] = max(self.a1[ind*2 + 1] + self.a4[ind*2 + 2], self.a2[ind*2 + 1] + self.a2[ind*2 + 2], self.a2[ind*2 + 1] + self.a4[ind*2 + 2])\\n self.a3[ind] = max(self.a3[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a3[ind*2 + 2], self.a4[ind*2 + 1] + self.a1[ind*2 + 2])\\n self.a4[ind] = max(self.a3[ind*2 + 1] + self.a4[ind*2 + 2], self.a4[ind*2 + 1] + self.a2[ind*2 + 2], self.a4[ind*2 + 1] + self.a4[ind*2 + 2])\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n segTree = SegmentTree(n)\\n total = 0\\n MOD = 10**9 + 7\\n for i, x in enumerate(nums):\\n segTree.update(i, x)\\n for i,x in queries:\\n segTree.update(i, x)\\n total += segTree.query()\\n total %= MOD\\n return total \",\n \"memory\": \"44800\"\n },\n {\n \"code\": \"import typing\\n\\n\\nclass SegTree:\\n def __init__(\\n self,\\n op: typing.Callable[[typing.Any, typing.Any], typing.Any],\\n e: typing.Any,\\n v: typing.Union[int, typing.List[typing.Any]],\\n ) -> None:\\n self._op = op\\n self._e = e\\n\\n if isinstance(v, int):\\n v = [e] * v\\n\\n self._n = len(v)\\n self._log = self._ceil_pow2(self._n)\\n self._size = 1 << self._log\\n self._d = [e] * (2 * self._size)\\n\\n for i in range(self._n):\\n self._d[self._size + i] = v[i]\\n for i in range(self._size - 1, 0, -1):\\n self._update(i)\\n\\n def set(self, p: int, x: typing.Any) -> None:\\n assert 0 <= p < self._n\\n\\n p += self._size\\n self._d[p] = x\\n for i in range(1, self._log + 1):\\n self._update(p >> i)\\n\\n def get(self, p: int) -> typing.Any:\\n assert 0 <= p < self._n\\n\\n return self._d[p + self._size]\\n\\n def prod(self, left: int, right: int) -> typing.Any:\\n assert 0 <= left <= right <= self._n\\n sml = self._e\\n smr = self._e\\n left += self._size\\n right += self._size\\n\\n while left < right:\\n if left & 1:\\n sml = self._op(sml, self._d[left])\\n left += 1\\n if right & 1:\\n right -= 1\\n smr = self._op(self._d[right], smr)\\n left >>= 1\\n right >>= 1\\n\\n return self._op(sml, smr)\\n\\n def all_prod(self) -> typing.Any:\\n return self._d[1]\\n\\n def max_right(self, left: int, f: typing.Callable[[typing.Any], bool]) -> int:\\n assert 0 <= left <= self._n\\n assert f(self._e)\\n\\n if left == self._n:\\n return self._n\\n\\n left += self._size\\n sm = self._e\\n\\n first = True\\n while first or (left & -left) != left:\\n first = False\\n while left % 2 == 0:\\n left >>= 1\\n if not f(self._op(sm, self._d[left])):\\n while left < self._size:\\n left *= 2\\n if f(self._op(sm, self._d[left])):\\n sm = self._op(sm, self._d[left])\\n left += 1\\n return left - self._size\\n sm = self._op(sm, self._d[left])\\n left += 1\\n\\n return self._n\\n\\n def min_left(self, right: int, f: typing.Callable[[typing.Any], bool]) -> int:\\n assert 0 <= right <= self._n\\n assert f(self._e)\\n\\n if right == 0:\\n return 0\\n\\n right += self._size\\n sm = self._e\\n\\n first = True\\n while first or (right & -right) != right:\\n first = False\\n right -= 1\\n while right > 1 and right % 2:\\n right >>= 1\\n if not f(self._op(self._d[right], sm)):\\n while right < self._size:\\n right = 2 * right + 1\\n if f(self._op(self._d[right], sm)):\\n sm = self._op(self._d[right], sm)\\n right -= 1\\n return right + 1 - self._size\\n sm = self._op(self._d[right], sm)\\n\\n return 0\\n\\n def _update(self, k: int) -> None:\\n self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])\\n\\n @staticmethod\\n def _ceil_pow2(n: int) -> int:\\n x = 0\\n while (1 << x) < n:\\n x += 1\\n\\n return x\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n\\n def op(x, y) -> int:\\n left_max_without_start, left_max_without_end, left_max_without_either, left_max = x\\n right_max_without_start, right_max_without_end, right_max_without_either, right_max = y\\n\\n return (\\n max(left_max_without_start + right_max_without_start, left_max_without_either + right_max) % MOD,\\n max(left_max_without_end + right_max_without_end, left_max + right_max_without_either) % MOD,\\n max(left_max_without_start + right_max_without_either, left_max_without_either + right_max_without_end) % MOD,\\n max(left_max_without_end + right_max, left_max + right_max_without_start) % MOD,\\n )\\n\\n e = (0, 0, 0, 0)\\n nodes = [(0, 0, 0, max(num, 0)) for num in nums]\\n seg_tree = SegTree(op, e, nodes)\\n\\n ans = 0\\n for pos, x in queries:\\n seg_tree.set(pos, (0, 0, 0, max(0, x)))\\n _, _, _, v = seg_tree.all_prod()\\n ans += v % MOD\\n return ans % MOD\\n\\n\",\n \"memory\": \"46700\"\n },\n {\n \"code\": \"# # Data Structures: Array\\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\\n\\n# # Short Intuition:\\n# # We need to process multiple queries, where each query changes the array and requires recalculating\\n# # the maximum sum of a subsequence where no two adjacent elements are selected. The goal is to return the\\n# # sum of results of all queries.\\n\\n# # Detailed Intuition:\\n# # - Each query updates one element in the array. After the update, we need to recalculate the maximum sum \\n# # of a subsequence with no adjacent elements.\\n# # - This problem is similar to the house robber problem, where at each element we decide whether to include it \\n# # in the subsequence or skip it.\\n# # - We use a simple dynamic programming approach to compute the max sum of non-adjacent elements:\\n# # - Let `incl` be the maximum sum including the current element.\\n# # - Let `excl` be the maximum sum excluding the current element.\\n# # - After processing each query, sum up the results and return the final sum modulo 10^9 + 7.\\n\\n# # Pseudocode:\\n# # 1. Initialize two variables `incl` and `excl` to store the maximum subsequence sum including/excluding the current element.\\n# # 2. For each query:\\n# # - Update the element in the array.\\n# # - Recalculate the maximum sum of non-adjacent subsequence using DP.\\n# # - Add the result to the final sum.\\n# # 3. Return the final result modulo 10^9 + 7.\\n\\n# MOD = 10**9 + 7\\n\\n# class Solution:\\n# def maxNonAdjacentSum(self, nums):\\n# \\\"\\\"\\\"\\n# Calculate the maximum sum of a subsequence where no two adjacent elements are selected.\\n \\n# Args:\\n# nums (List[int]): The array of integers.\\n \\n# Returns:\\n# int: The maximum sum of the subsequence with non-adjacent elements.\\n# \\\"\\\"\\\"\\n# incl, excl = 0, 0 # incl is the sum including the current element, excl is the sum excluding it\\n \\n# for num in nums:\\n# new_incl = excl + num # Including the current element\\n# excl = max(incl, excl) # Excluding the current element\\n# incl = new_incl\\n \\n# return max(incl, excl)\\n\\n# def maximumSumSubsequence(self, nums, queries):\\n# \\\"\\\"\\\"\\n# Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\\n \\n# Args:\\n# nums (List[int]): The initial array of integers.\\n# queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\\n \\n# Returns:\\n# int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\\n# \\\"\\\"\\\"\\n# total_sum = 0\\n \\n# for pos, xi in queries:\\n# # Step 1: Update the element at position pos\\n# nums[pos] = xi\\n \\n# # Step 2: Calculate the maximum non-adjacent subsequence sum\\n# max_sum = self.maxNonAdjacentSum(nums)\\n \\n# # Step 3: Add to the total sum (mod MOD to avoid overflow)\\n# total_sum = (total_sum + max_sum) % MOD\\n \\n# return total_sum\\n\\n# # Time Complexity: O(n * m), where n is the length of the array and m is the number of queries. \\n# # We recalculate the maximum non-adjacent subsequence sum for the entire array after each query.\\n# # Space Complexity: O(1) - We only use constant extra space to store the DP variables `incl` and `excl`.\\n\\n\\ninf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n # nn: max subseq sum without using nums[i] or nums[j]\\n # ny: max subseq sum without using nums[i] but with nums[j]\\n # yn: max subseq sum with nums[i] but without nums[j]\\n # yy: max subseq sum using both nums[i] and nums[j]\\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"memory\": \"46800\"\n },\n {\n \"code\": \"# Data Structures: Segment Tree\\n# Algorithm: Segment Tree for Range Maximum Query\\n\\n# Short Intuition:\\n# We will use a Segment Tree to efficiently process range queries. After each query that modifies the array,\\n# we will recalculate the maximum sum of a subsequence with non-adjacent elements in `nums`.\\n\\n# Detailed Intuition:\\n# - A segment tree is used to store the maximum sum of non-adjacent subsequences for different ranges of the array.\\n# - Each node in the segment tree stores a tuple with:\\n# - `incl`: The maximum sum of a subsequence including the last element in the segment.\\n# - `excl`: The maximum sum of a subsequence excluding the last element in the segment.\\n# - For each query, we update the segment tree and retrieve the maximum sum of the entire array (root node).\\n# - The segment tree allows efficient range updates and queries (both in O(log n) time).\\n\\n# Pseudocode:\\n# 1. Build the segment tree with initial values.\\n# 2. For each query:\\n# - Update the segment tree with the new value at the given position.\\n# - Query the segment tree to get the maximum sum of non-adjacent elements in the array.\\n# - Add the result to the total sum.\\n# 3. Return the total sum modulo 10^9 + 7.\\n\\nMOD = 10**9 + 7\\n\\nclass SegmentTree:\\n def __init__(self, nums):\\n \\\"\\\"\\\"\\n Initialize the segment tree with the given array of numbers.\\n \\n Args:\\n nums (List[int]): The initial array of integers.\\n \\\"\\\"\\\"\\n self.n = len(nums)\\n self.tree = [None] * (4 * self.n) # Segment tree array\\n self.build(nums, 0, 0, self.n - 1) # Build the tree\\n\\n def build(self, nums, node, start, end):\\n \\\"\\\"\\\"\\n Build the segment tree by recursively calculating the incl and excl sums.\\n \\n Args:\\n nums (List[int]): The array of numbers.\\n node (int): The current node in the segment tree.\\n start (int): Start index of the current segment.\\n end (int): End index of the current segment.\\n \\\"\\\"\\\"\\n if start == end:\\n # Leaf node: Only one element, so `incl` is the element itself, `excl` is 0\\n self.tree[node] = (nums[start], 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n # Recursively build the left and right subtrees\\n self.build(nums, left_child, start, mid)\\n self.build(nums, right_child, mid + 1, end)\\n \\n # Merge the results from left and right subtrees\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n\\n def merge(self, left, right):\\n \\\"\\\"\\\"\\n Merge two nodes (left and right) to calculate the max sum for their parent node.\\n \\n Args:\\n left (tuple): The incl and excl values from the left child.\\n right (tuple): The incl and excl values from the right child.\\n \\n Returns:\\n tuple: The merged result containing the incl and excl values for the parent node.\\n \\\"\\\"\\\"\\n incl = max(left[1] + right[0], left[0] + right[1])\\n excl = max(left[0], left[1]) + max(right[0], right[1])\\n return (incl, excl)\\n\\n def update(self, idx, value, node, start, end):\\n \\\"\\\"\\\"\\n Update the segment tree when an element in the array changes.\\n \\n Args:\\n idx (int): The index of the element to update.\\n value (int): The new value to update at the index.\\n node (int): The current node in the segment tree.\\n start (int): Start index of the current segment.\\n end (int): End index of the current segment.\\n \\\"\\\"\\\"\\n if start == end:\\n # Leaf node: Update the value directly\\n self.tree[node] = (value, 0)\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n # Recursively update the appropriate child\\n if idx <= mid:\\n self.update(idx, value, left_child, start, mid)\\n else:\\n self.update(idx, value, right_child, mid + 1, end)\\n \\n # After updating the child, merge the changes to the current node\\n self.tree[node] = self.merge(self.tree[left_child], self.tree[right_child])\\n\\n def query(self):\\n \\\"\\\"\\\"\\n Query the segment tree to get the maximum sum of non-adjacent elements for the entire array.\\n \\n Returns:\\n int: The maximum sum of non-adjacent subsequence for the entire array.\\n \\\"\\\"\\\"\\n return max(self.tree[0]) # The root node stores the result for the entire array\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums, queries):\\n \\\"\\\"\\\"\\n Process each query by updating the array and finding the maximum sum of non-adjacent subsequence.\\n \\n Args:\\n nums (List[int]): The initial array of integers.\\n queries (List[List[int]]): 2D array of queries, where each query is of the form [pos, xi].\\n \\n Returns:\\n int: The sum of the maximum subsequence sums for all queries, modulo 10^9 + 7.\\n \\\"\\\"\\\"\\n total_sum = 0\\n seg_tree = SegmentTree(nums) # Initialize the segment tree\\n \\n for pos, xi in queries:\\n # Step 1: Update the element at position pos in the segment tree\\n seg_tree.update(pos, xi, 0, 0, len(nums) - 1)\\n \\n # Step 2: Query the segment tree to get the max non-adjacent subsequence sum\\n max_sum = seg_tree.query()\\n \\n # Step 3: Add the result to the total sum (mod MOD to avoid overflow)\\n total_sum = (total_sum + max_sum) % MOD\\n \\n return total_sum\\n\\n\\n# Time Complexity:\\n# - Build the segment tree: O(n)\\n# - Each update and query operation: O(log n)\\n# So, for m queries, the total time complexity is O(n + m log n).\\n\\n# Space Complexity: O(n) for the segment tree.\\n# # Data Structures: Array\\n# # Algorithm: Dynamic Programming (for non-adjacent subsequence sum) + Query Processing\\n\\ninf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n # nn: max subseq sum without using nums[i] or nums[j]\\n # ny: max subseq sum without using nums[i] but with nums[j]\\n # yn: max subseq sum with nums[i] but without nums[j]\\n # yy: max subseq sum using both nums[i] and nums[j]\\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"memory\": \"46900\"\n },\n {\n \"code\": \"inf = -float('inf')\\nclass SegTree:\\n def __init__(self, nums):\\n n = len(nums)\\n # each element: [nn, ny, yn, yy]\\n self.ar = [None] * (4*n+1)\\n self.build(0, 0, n-1, nums)\\n \\n def combine(self, t1, t2):\\n nn1, ny1, yn1, yy1 = t1\\n nn2, ny2, yn2, yy2 = t2\\n nn = max(nn1 + yn2, nn1 + nn2, ny1 + nn2)\\n ny = max(nn1 + yy2, nn1 + ny2, ny1 + ny2)\\n yn = max(yn1 + yn2, yn1 + nn2, yy1 + nn2)\\n yy = max(yn1 + yy2, yn1 + ny2, yy1 + ny2)\\n return [nn, ny, yn, yy]\\n \\n def build(self, i, l, r, nums):\\n if l == r:\\n self.ar[i] = [0, inf, inf, nums[l]]\\n else:\\n m = (l+r) // 2\\n self.build(2*i+1, l, m, nums)\\n self.build(2*i+2, m+1, r, nums)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n \\n def update_v(self, i, l, r, idx, v):\\n if l == r and l == idx:\\n self.ar[i] = [0, inf, inf, v]\\n else:\\n m = (l+r)//2\\n if m < idx:\\n self.update_v(2*i+2, m+1, r, idx, v)\\n else:\\n self.update_v(2*i+1, l, m, idx, v)\\n self.ar[i] = self.combine(self.ar[2*i+1], self.ar[2*i+2])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n M = 10**9 + 7\\n st = SegTree(nums)\\n n = len(nums)\\n res = 0\\n # print(st.ar)\\n for p, v in queries:\\n st.update_v(0, 0, n-1, p, v)\\n # print(st.ar)\\n res += max(st.ar[0])\\n res %= M\\n return res\",\n \"memory\": \"47000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], q: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << (n.bit_length())\\n nums += [0] * (m - n)\\n n = m\\n t = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n t[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = t[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = t[2 * j + 1]\\n t[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n t[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n t[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n t[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n res = 0\\n for i, x in q:\\n update(i, x)\\n res += max(t[1])\\n return res % 1_000_000_007\",\n \"memory\": \"47300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n m = 1 << (n.bit_length())\\n nums += [0] * (m - n)\\n n = m\\n tree = [[0] * 4 for _ in range(2 * n + 1)]\\n\\n def update(i, x):\\n j = i + n\\n tree[j][0] = max(0, x)\\n while j:\\n j >>= 1\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * j]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * j + 1]\\n # lo to hi\\n tree[j][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[j][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[j][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[j][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n for i, x in enumerate(nums):\\n update(i, x)\\n\\n ans = 0\\n for i, x in queries:\\n update(i, x)\\n ans += max(tree[1])\\n return ans % 1_000_000_007\",\n \"memory\": \"47800\"\n },\n {\n \"code\": \"import math\\n\\nclass SegmentTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\\n self.tree = [None] * (4 * self.n)\\n self.build_tree(0, 0, self.n - 1, nums)\\n\\n def combine(self, left, right):\\n nn, ny, yn, yy = left\\n nn2, ny2, yn2, yy2 = right\\n return [\\n max(nn + yn2, nn + nn2, ny + nn2), # not_selected_not_selected\\n max(nn + yy2, nn + ny2, ny + ny2), # not_selected_selected\\n max(yn + yn2, yn + nn2, yy + nn2), # selected_not_selected\\n max(yn + yy2, yn + ny2, yy + ny2) # selected_selected\\n ]\\n\\n def build_tree(self, node, start, end, nums):\\n if start == end:\\n # Leaf node: [0, -inf, -inf, nums[start]]\\n self.tree[node] = [0, -math.inf, -math.inf, nums[start]]\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n self.build_tree(left_child, start, mid, nums)\\n self.build_tree(right_child, mid + 1, end, nums)\\n \\n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\\n\\n def update(self, node, start, end, index, value):\\n if start == end:\\n self.tree[node] = [0, -math.inf, -math.inf, value]\\n else:\\n mid = (start + end) // 2\\n left_child = 2 * node + 1\\n right_child = 2 * node + 2\\n \\n if index <= mid:\\n self.update(left_child, start, mid, index, value)\\n else:\\n self.update(right_child, mid + 1, end, index, value)\\n \\n self.tree[node] = self.combine(self.tree[left_child], self.tree[right_child])\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = SegmentTree(nums)\\n result = 0\\n\\n for index, value in queries:\\n segment_tree.update(0, 0, len(nums) - 1, index, value)\\n result += max(segment_tree.tree[0])\\n result %= MOD\\n\\n return result\",\n \"memory\": \"49000\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, nums):\\n self.n = len(nums)\\n # # Each node contains [not_selected_not_selected, not_selected_selected, selected_not_selected, selected_selected]\\n self.tree = [None] * (4 * self.n)\\n self.inf = float(\\\"inf\\\")\\n self.build_tree(0, 0, self.n - 1, nums)\\n\\n def build_tree(self, node, start, end, nums):\\n if start == end:\\n # leaf node: [0, -inf, -inf, nums[start]]\\n self.tree[node] = [0, -self.inf, -self.inf, nums[start]]\\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n\\n self.build_tree(left, start, mid, nums)\\n self.build_tree(right, mid + 1, end, nums)\\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\\n\\n def combine(self, left, right):\\n lnn, lny, lyn, lyy = left\\n rnn, rny, ryn, ryy = right\\n return [\\n max(lnn + ryn, lnn + rnn, lny + rnn), # not_selected_not_selected\\n max(lnn + ryy, lnn + rny, lny + rny), # not_selected_selected\\n max(lyn + ryn, lyn + rnn, lyy + rnn), # selected_not_selected\\n max(lyn + ryy, lyn + rny, lyy + rny), # selected_selected\\n ]\\n\\n def update(self, node, start, end, idx, val):\\n if start == end:\\n self.tree[node] = [0, -self.inf, -self.inf, val]\\n else:\\n mid = (start + end) // 2\\n left = 2 * node + 1\\n right = 2 * node + 2\\n\\n if idx <= mid:\\n self.update(left, start, mid, idx, val)\\n else:\\n self.update(right, mid + 1, end, idx, val)\\n \\n self.tree[node] = self.combine(self.tree[left], self.tree[right])\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = SegmentTree(nums)\\n n = len(nums)\\n ans = 0\\n for idx, val in queries:\\n segment_tree.update(0, 0, n - 1, idx, val)\\n ans += max(segment_tree.tree[0])\\n ans %= MOD\\n return ans\",\n \"memory\": \"49000\"\n },\n {\n \"code\": \"class StVal:\\n\\n # Combining two nodes by adding their values (can be modified for other operations like min, max)\\n def __init__(self, v : int = 0, L = None, R = None):\\n\\n if L == None or R == None:\\n self.both = max(v,0)\\n self.none = 0\\n self.left = 0\\n self.right = 0\\n return\\n \\n self.both = max(L.left+R.right,L.both+R.right,L.left+R.both)\\n self.none = max(L.none+R.none,L.right+R.none,L.none+R.left)\\n self.left = max(L.left+R.left, L.left+R.none, L.both+R.none)\\n self.right = max(L.none+R.right,L.right+R.right,L.none+R.both)\\n\\n\\nclass SegmentTree:\\n def __init__(self, v):\\n \\\"\\\"\\\"\\n :param v: The input array for the segment tree\\n \\\"\\\"\\\"\\n self.n = len(v)\\n self.v = v\\n self.leaves = [0] * (self.n+20)\\n self.st = [StVal(v = 0)] * (10 * self.n ) # Initially fill with default StVal\\n self.init(1, 0, self.n - 1)\\n\\n def init(self, treeIndex, low_range, high_range):\\n \\\"\\\"\\\"\\n Build the segment tree recursively\\n :param treeIndex: Current index in segment tree\\n :param low_range: Lower bound of current segment\\n :param high_range: Upper bound of current segment\\n \\\"\\\"\\\"\\n if low_range == high_range:\\n # Leaf node\\n if treeIndex >= len(self.st):\\n self.st = self.st + [StVal()]\\n self.st[treeIndex] = StVal(v = self.v[low_range])\\n self.leaves[low_range] = treeIndex # Save the index of the leaf node\\n else:\\n mid = (low_range + high_range) >> 1\\n self.init(treeIndex << 1, low_range, mid)\\n self.init((treeIndex << 1) + 1, mid + 1, high_range)\\n # Merge child nodes\\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\\n\\n def query(self, l, r):\\n \\\"\\\"\\\"\\n Public query function to find result in range [l, r]\\n \\\"\\\"\\\"\\n if l <= r and l < self.n and r >= 0:\\n return self.query_recursive(l, r, 1, 0, self.n - 1)\\n return StVal() # Return identity element for invalid range\\n\\n def query_recursive(self, left_index, right_index, treeIndex, low_range, high_range):\\n \\\"\\\"\\\"\\n Recursively query the range\\n \\\"\\\"\\\"\\n if left_index <= low_range and high_range <= right_index:\\n return self.st[treeIndex]\\n\\n mid = (low_range + high_range) >> 1\\n if right_index <= mid:\\n # Only left child\\n return self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\\n if mid < left_index:\\n # Only right child\\n return self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\\n\\n # Overlapping segments, query both sides\\n left_result = self.query_recursive(left_index, right_index, treeIndex << 1, low_range, mid)\\n right_result = self.query_recursive(left_index, right_index, (treeIndex << 1) + 1, mid + 1, high_range)\\n return StVal(L = left_result, R = right_result)\\n\\n def update(self, i, x):\\n \\\"\\\"\\\"\\n Incremental point update\\n :param i: Index to update\\n :param x: New value to update with\\n \\\"\\\"\\\"\\n treeIndex = self.leaves[i]\\n self.st[treeIndex] = StVal(x)\\n\\n treeIndex = treeIndex >> 1\\n while treeIndex:\\n # Recompute parent nodes\\n self.st[treeIndex] = StVal(L = self.st[treeIndex << 1], R = self.st[(treeIndex << 1) + 1])\\n treeIndex = treeIndex >> 1\\n\\n\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n modulo = 10**9+7\\n\\n st = SegmentTree(nums)\\n ans = 0\\n for i in range(len(queries)):\\n q = queries[i]\\n st.update(q[0], q[1])\\n val = st.query(0, n-1)\\n \\n ans = (ans + max(val.both,val.none,val.left,val.right)) % modulo\\n return ans\",\n \"memory\": \"50700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n # f00, f01, f10, f11\\n t = [[0] * 4 for _ in range(2 << n.bit_length())]\\n \\n def maintain(o: int):\\n a, b = t[o * 2], t[o * 2 + 1]\\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\\n \\n def build(o: int, l: int, r: int):\\n if l == r:\\n t[o][3] = max(nums[l], 0)\\n return \\n m = (l + r) // 2\\n build(o * 2, l, m)\\n build(o * 2 + 1, m + 1, r)\\n maintain(o)\\n\\n def update(o: int, l: int, r: int, i: int, val: int):\\n if l == r:\\n t[o][3] = max(val, 0)\\n return \\n m = (l + r) // 2\\n if i <= m:\\n update(o * 2, l, m, i, val)\\n else:\\n update(o * 2 + 1, m + 1, r, i, val)\\n maintain(o)\\n \\n build(1, 0, n - 1)\\n ans = 0\\n for i, x in queries:\\n update(1, 0, n - 1, i, x)\\n ans += t[1][3]\\n\\n return ans % (10 ** 9 + 7)\",\n \"memory\": \"51400\"\n },\n {\n \"code\": \"modulus = 1000000007\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tree = Tree(0, len(nums), nums)\\n result = 0\\n for i, value in queries:\\n tree.change(i, value)\\n result = (result + tree.max) % modulus\\n return result\\n\\nclass Tree:\\n def __init__(self, start, end, nums):\\n self.start = start\\n self.end = end\\n\\n if end - start == 1:\\n self.max_without_start = 0\\n self.max_without_end = 0\\n self.max_without_either = 0\\n self.max = max(0, nums[start])\\n else:\\n mid = (start + end) // 2\\n self.left = Tree(start, mid, nums)\\n self.right = Tree(mid, end, nums)\\n self.update()\\n\\n def change(self, i, value):\\n if self.end - self.start == 1:\\n self.max = max(0, value)\\n return\\n if i < (self.start + self.end) // 2:\\n self.left.change(i, value)\\n else:\\n self.right.change(i, value)\\n self.update()\\n\\n def update(self):\\n self.max_without_start = max(\\n self.left.max_without_start + self.right.max_without_start,\\n self.left.max_without_either + self.right.max\\n ) % modulus\\n self.max_without_end = max(\\n self.left.max_without_end + self.right.max_without_end,\\n self.left.max + self.right.max_without_either\\n ) % modulus\\n self.max_without_either = max(\\n self.left.max_without_start + self.right.max_without_either,\\n self.left.max_without_either + self.right.max_without_end\\n ) % modulus\\n self.max = max(\\n self.left.max_without_end + self.right.max,\\n self.left.max + self.right.max_without_start\\n ) % modulus\",\n \"memory\": \"51500\"\n },\n {\n \"code\": \"\\nclass Solution:\\n\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n MOD = 10**9 + 7\\n # 两边都不取 tree[o][00] = max(a[01]+b[00], a[00]+b[10])\\n # 左边不取，右边可取可不取 tree[o][01] = max(a[01]+b[01], a[00]+b[11])\\n # 左边可取可不取，右边不取 tree[o][10] = max(a[11]+b[00], a[10]+b[10])\\n # 两边都可取可不取 tree[o][11] = max(a[11]+b[01], a[10]+b[11])\\n tree = [[0] * 4 for _ in range(2 << n.bit_length())]\\n\\n # 单点更新线段树\\n def set_value(o, l, r, idx, val):\\n mid = (l + r) >> 1\\n if l == idx and r == idx:\\n tree[o][3] = max(val, 0)\\n return\\n if idx <= mid:\\n set_value(o * 2 + 1, l, mid, idx, val)\\n else:\\n set_value(o * 2 + 2, mid + 1, r, idx, val)\\n process(o)\\n\\n def process(o):\\n a, b = tree[o * 2 + 1], tree[o * 2 + 2]\\n tree[o][0] = max(a[1] + b[0], a[0] + b[2])\\n tree[o][1] = max(a[1] + b[1], a[0] + b[3])\\n tree[o][2] = max(a[3] + b[0], a[2] + b[2])\\n tree[o][3] = max(a[3] + b[1], a[2] + b[3])\\n\\n for i, num in enumerate(nums):\\n set_value(0, 0, n - 1, i, num)\\n ans = 0\\n for idx, num in queries:\\n set_value(0, 0, n - 1, idx, num)\\n ans += tree[0][3]\\n return ans % MOD\",\n \"memory\": \"51900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n tmp = 1\\n while tmp < len(nums):\\n tmp *= 2\\n t = [[0]*4 for _ in range(tmp*2)]\\n\\n n = len(nums)\\n\\n def maintain(o: int):\\n a, b = t[o * 2], t[o * 2 + 1]\\n t[o][0] = max(a[0] + b[2], a[1] + b[0])\\n t[o][1] = max(a[0] + b[3], a[1] + b[1])\\n t[o][2] = max(a[2] + b[2], a[3] + b[0])\\n t[o][3] = max(a[2] + b[3], a[3] + b[1])\\n\\n def build(o, l, r): \\n if l == r:\\n t[o][3] = max(nums[l], 0)\\n return \\n m = (l+r) // 2\\n build(o*2, l, m)\\n build(o*2+1, m+1, r)\\n maintain(o)\\n\\n def update(o, l, r, i, val): \\n if l == r: \\n t[o][3] = max(val, 0)\\n return \\n m = (l+r) // 2\\n if i <= m: \\n update(o*2, l, m, i, val)\\n else:\\n update(o*2+1, m+1, r, i, val)\\n maintain(o)\\n\\n build(1, 0, n-1)\\n ans = 0\\n for i, x in queries:\\n update(1, 0, n-1, i, x)\\n ans += t[1][3]\\n return ans % 1_000_000_007\",\n \"memory\": \"52200\"\n },\n {\n \"code\": \"class Tree:\\n def __init__(self, l, r):\\n self.l = l\\n self.r = r\\n self.lt = None\\n self.rt = None\\n\\n self.noExc = 0\\n self.lExc = 0\\n self.rExc = 0\\n self.bothExc = 0\\n\\n\\n @staticmethod\\n def build(l, r, nums):\\n tree = Tree(l, r)\\n if l == r:\\n tree.noExc = nums[l]\\n return tree\\n\\n mid = l + (r-l)//2\\n tree.lt = Tree.build(l, mid, nums)\\n tree.rt = Tree.build(mid+1, r, nums)\\n tree.updateSsq()\\n return tree\\n\\n def update(self, idx, val):\\n if self.l == self.r:\\n self.noExc = max(val, 0)\\n return\\n\\n mid = self.l + (self.r-self.l)//2\\n\\n if idx <= mid:\\n self.lt.update(idx, val)\\n else:\\n self.rt.update(idx, val)\\n\\n self.updateSsq()\\n\\n def updateSsq(self):\\n self.noExc = max(self.lt.noExc + self.rt.lExc, self.lt.rExc + self.rt.noExc)\\n self.lExc = max(self.lt.lExc + self.rt.lExc, self.lt.bothExc + self.rt.noExc)\\n self.rExc = max(self.lt.noExc + self.rt.bothExc, self.lt.rExc + self.rt.rExc)\\n self.bothExc = max(self.lt.lExc + self.rt.bothExc, self.lt.bothExc + self.rt.rExc)\\n # print(self.noExc, self.lExc, self.rExc, self.noExc)\\n \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n n = len(nums)\\n MOD = 10**9 + 7\\n\\n tree = Tree.build(0, n-1, nums)\\n # print(tree.noExc)\\n ans = 0\\n for idx, val in queries:\\n tree.update(idx, val)\\n # print(tree.noExc)\\n ans += tree.noExc % MOD\\n\\n return ans % MOD\\n\\n# |----| + |-| |----|\\n# or |---| |-| + |---| \\n# all = max(l [] + r (], l [) + r[])\\n# (] = max(l (] + r(], l () + r[])\\n# [) = max(l [) + r[), l [] + r())\\n# () = max(l (] + r(), l() + r[))\\n\",\n \"memory\": \"53400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\\n BOTH = 0\\n LEFT = 1\\n RIGHT = 2\\n NONE = 3\\n \\n N = len(nums)\\n \\n # segment tree\\n tree = [[0, 0, 0, 0]] * 4 * N\\n TR = 2 ** ceil(log2(N))\\n\\n # calculate values for just node i in the tree\\n def update_i(i):\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n result = [0, 0, 0, 0]\\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\\n tree[i] = result\\n\\n # construct subtree at node i\\n def construct(i, tl, tr):\\n if tl == tr:\\n tree[i] = [nums[tl], 0, 0, 0]\\n return\\n \\n # construct subtrees\\n m = (tl + tr) // 2\\n construct(i * 2, tl, m)\\n if m + 1 < N:\\n construct(i * 2 + 1, m + 1, tr)\\n \\n # calculate outcome\\n update_i(i)\\n \\n # update subtree at node i with change at index t in the original array\\n def update(i, t, tl, tr):\\n if tl == tr:\\n tree[i] = [nums[t], 0, 0, 0]\\n else:\\n m = (tl + tr) // 2\\n if t <= m:\\n update(i * 2, t, tl, m)\\n else:\\n update(i * 2 + 1, t, m + 1, tr)\\n update_i(i)\\n \\n # construct tree\\n construct(1, 0, TR)\\n\\n # process queries\\n total = 0\\n for q in queries:\\n t, x = q\\n nums[t] = x\\n update(1, t, 0, TR)\\n total += max(tree[1])\\n\\n return total % 1_000_000_007\",\n \"memory\": \"54100\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self,start,end):\\n self.l = start\\n self.r = end\\n self.n = end-start+1\\n self.left = None\\n self.right = None\\n \\n self.all = 0\\n self.left_loo = 0\\n self.right_loo = 0\\n self.both_loo = 0\\n \\nclass QueryTree:\\n def __init__(self,nums):\\n self.nums = nums\\n self.root = self.build(0, len(nums)-1)\\n self.calc(self.root)\\n \\n def build(self,start,end):\\n if start == end:\\n return Node(start,end)\\n \\n mid = (start+end)//2\\n root = Node(start,end)\\n root.left = self.build(start,mid)\\n root.right = self.build(mid+1,end)\\n return root\\n \\n def calc(self,node):\\n if node is None:\\n return \\n \\n if node.n == 1:\\n node.all = max(self.nums[node.l],0)\\n node.left_loo = 0\\n node.right_loo = 0\\n node.both_loo = 0\\n return\\n \\n # node has at least two children\\n self.calc(node.left)\\n self.calc(node.right)\\n \\n node.all = max(node.left.all + node.right.left_loo, \\n node.left.right_loo + node.right.all)\\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\\n node.left.both_loo + node.right.all)\\n node.right_loo = max(node.left.all + node.right.both_loo,\\n node.left.right_loo + node.right.right_loo)\\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\\n node.left.both_loo + node.right.right_loo) \\n \\n def query(self):\\n return self.root.all\\n \\n def update(self,i,x):\\n self.nums[i] = x\\n self.recalc(self.root,i)\\n \\n def recalc(self,node,i):\\n if node is None:\\n return \\n \\n if node.n == 1:\\n if node.l == i:\\n node.all = max(self.nums[i],0)\\n return \\n \\n if (i < node.l) or (i > node.r):\\n return \\n \\n if i <= node.left.r:\\n self.recalc(node.left,i)\\n if i >= node.right.l:\\n self.recalc(node.right,i)\\n \\n node.all = max(node.left.all + node.right.left_loo, \\n node.left.right_loo + node.right.all)\\n node.left_loo = max(node.left.left_loo + node.right.left_loo,\\n node.left.both_loo + node.right.all)\\n node.right_loo = max(node.left.all + node.right.both_loo,\\n node.left.right_loo + node.right.right_loo)\\n node.both_loo = max(node.left.left_loo + node.right.both_loo,\\n node.left.both_loo + node.right.right_loo) \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n ans = []\\n qt = QueryTree(nums)\\n for i,x in queries:\\n qt.update(i,x)\\n ans.append(qt.query())\\n return sum(ans) % (10 ** 9 + 7)\",\n \"memory\": \"54400\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nM = 10 ** 9 + 7\\n\\nclass SegTree:\\n def __init__(self):\\n self.tree = defaultdict(lambda: (0, 0, 0, 0))\\n \\n def merge(self, l, r):\\n l_with_f_with_end, l_with_f_without_end, l_without_f_with_end, l_without_f_without_end = l\\n r_with_f_with_end, r_with_f_without_end, r_without_f_with_end, r_without_f_without_end = r\\n r_end_max = max(r_with_f_with_end, r_without_f_with_end)\\n r_without_end_max = max(r_with_f_without_end, r_without_f_without_end)\\n return (max(l_with_f_with_end + r_without_f_with_end, l_with_f_without_end + r_end_max), max(l_with_f_with_end + r_without_f_without_end, l_with_f_without_end + r_without_end_max), max(l_without_f_with_end + r_without_f_with_end, l_without_f_without_end + r_end_max), max(l_without_f_with_end + r_without_f_without_end, l_without_f_without_end + r_without_end_max))\\n \\n def update(self, index, val, i, j, k):\\n if i + 1 == j:\\n self.tree[k] = (val, 0, 0, 0)\\n return\\n mid = (i + j) // 2\\n if index < mid:\\n self.update(index, val, i, mid, 2 * k)\\n else:\\n self.update(index, val, mid, j, 2 * k + 1)\\n self.tree[k] = self.merge(self.tree[2 * k], self.tree[2 * k + 1])\\n \\n def query(self, x, y, i, j, k):\\n if y - 1 < i or x >= j:\\n return (0, 0, 0, 0)\\n if i >= x and j <= y:\\n return self.tree[k]\\n mid = (i + j) // 2\\n return self.merge(self.query(x, y, i, mid, 2 * k), self.query(x, y, mid, j, 2 * k + 1))\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n res = 0\\n segtree = SegTree()\\n for i in range(n):\\n segtree.update(i, nums[i], 0, n, 1)\\n for i, val in queries:\\n segtree.update(i, val, 0, n, 1)\\n res += max(segtree.query(0, n, 0, n, 1))\\n res %= M\\n return res\",\n \"memory\": \"54600\"\n },\n {\n \"code\": \"class SegmentTree:\\n\\n def __init__(self, arr: List[int]):\\n self.n = len(arr)\\n self.tree = [[0, 0, 0, 0] for _ in range(4 * self.n)]\\n self._build(arr, 1, 0, self.n - 1)\\n\\n def _merge(self, v1: List[int], v2: List[int]) -> List[int]:\\n a1, b1, c1, d1 = v1\\n a2, b2, c2, d2 = v2\\n\\n return [\\n max(a1 + c2, b1 + a2, b1 + c2),\\n max(a1 + d2, b1 + b2, b1 + d2),\\n max(c1 + c2, d1 + a2, d1 + c2),\\n max(c1 + d2, d1 + b2, d1 + d2),\\n ]\\n\\n def _build(self, arr: List[int], pos: int, l: int, r: int):\\n if l == r:\\n self.tree[pos][0] = max(0, arr[l])\\n else:\\n m = (l + r) // 2\\n self._build(arr, 2 * pos, l, m)\\n self._build(arr, 2 * pos + 1, m + 1, r)\\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\\n\\n def _update(self, ind: int, new_val: int, pos: int, l: int, r: int):\\n if l == r:\\n self.tree[pos][0] = max(0, new_val)\\n else:\\n m = (l + r) // 2\\n if ind <= m:\\n self._update(ind, new_val, 2 * pos, l, m)\\n else:\\n self._update(ind, new_val, 2 * pos + 1, m + 1, r)\\n self.tree[pos] = self._merge(self.tree[2 * pos], self.tree[2 * pos + 1])\\n\\n def update(self, ind: int, new_val: int):\\n self._update(ind, new_val, 1, 0, self.n - 1)\\n \\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n st, res = SegmentTree(nums), 0\\n for ind, new_val in queries:\\n st.update(ind, new_val)\\n res = (res + max(st.tree[1])) % (10**9 + 7)\\n \\n return res\",\n \"memory\": \"54800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n class SegTreeNode:\\n def __init__(self, a, b, vals):\\n self.left = None\\n self.right = None\\n self.start = a\\n self.end = b\\n self.info00 = 0\\n self.info11 = 0\\n self.info10 = -float('inf')\\n self.info01 = -float('inf')\\n \\n if a == b:\\n self.info11 = vals[self.start]\\n return\\n \\n mid = (a + b) // 2\\n \\n self.left = SegTreeNode(a, mid, vals)\\n self.right = SegTreeNode(mid + 1, b, vals)\\n \\n self.info11 = max(self.left.info10 + self.right.info01,\\n self.left.info11 + self.right.info01,\\n self.left.info10 + self.right.info11)\\n self.info00 = max(self.left.info00 + self.right.info00,\\n self.left.info01 + self.right.info00,\\n self.left.info00 + self.right.info10)\\n self.info10 = max(self.left.info10 + self.right.info00,\\n self.left.info10 + self.right.info10,\\n self.left.info11 + self.right.info00)\\n self.info01 = max(self.left.info00 + self.right.info01,\\n self.left.info01 + self.right.info01,\\n self.left.info00 + self.right.info11)\\n \\n def update_range(self, a, val):\\n if a < self.start or a > self.end:\\n return\\n \\n if self.start == self.end:\\n self.info00 = 0\\n self.info11 = val\\n return\\n \\n self.left.update_range(a, val)\\n self.right.update_range(a, val)\\n \\n self.info11 = max(self.left.info10 + self.right.info01,\\n self.left.info11 + self.right.info01,\\n self.left.info10 + self.right.info11)\\n self.info00 = max(self.left.info00 + self.right.info00,\\n self.left.info01 + self.right.info00,\\n self.left.info00 + self.right.info10)\\n self.info10 = max(self.left.info10 + self.right.info00,\\n self.left.info10 + self.right.info10,\\n self.left.info11 + self.right.info00)\\n self.info01 = max(self.left.info00 + self.right.info01,\\n self.left.info01 + self.right.info01,\\n self.left.info00 + self.right.info11)\\n\\n root = SegTreeNode(0, len(nums) - 1, nums)\\n result = 0\\n M = 10 ** 9 + 7\\n \\n for q in queries:\\n root.update_range(q[0],q[1])\\n result += max(root.info00, root.info01, root.info11, root.info10)\\n result = result % M\\n\\n return result\\n\",\n \"memory\": \"57200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n maxSums = defaultdict() #first int: int/out, last: int/out\\n\\n def updateEntry(idx):\\n leftinin, leftinout, leftoutin, leftoutout= maxSums[idx*2+1]\\n rightinin, rightinout, rightoutin, rightoutout= maxSums[idx*2+2]\\n outout = max([0, leftoutin + rightoutout, leftoutout+ rightinout])\\n outin = max([outout, leftoutin + rightoutin, leftoutout+rightinin])\\n inout = max([outout, leftinin + rightoutout, leftinout + rightinout])\\n inin = max([outout, outin, inout, leftinin + rightoutin, leftinout+ rightinin])\\n maxSums[idx] = (inin, inout, outin, outout)\\n\\n def createTree(left=0, right=n-1, idx=0):\\n if left > right: return\\n if left == right:\\n maxSums[idx] = (max(nums[left], 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n createTree(left, mid, idx*2+1)\\n createTree(mid+1, right, idx*2+2)\\n updateEntry(idx)\\n \\n createTree()\\n # print(\\\"tree:\\\", maxSums)\\n\\n def updateValue(listIdx, val, left=0, right=n-1, idx=0):\\n if listIdx < left or listIdx > right: return\\n if left == right:\\n maxSums[idx] = (max(val, 0), 0, 0, 0)\\n return\\n mid = (left+right) //2\\n updateValue(listIdx, val,left, mid, idx*2+1)\\n updateValue(listIdx, val, mid+1, right, idx*2+2)\\n updateEntry(idx)\\n\\n ans = 0\\n for q in queries:\\n pos, x = q\\n updateValue(pos, x)\\n ans += max(maxSums[0])\\n return ans % (10**9+7)\\n \\n\\n\\n \\n\\n # n = len(nums)\\n # if n==1:\\n # ans = 0\\n # for query in queries: ans += max(query[1], 0)\\n # return ans\\n # if n==2:\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # ans += max(0, max(nums))\\n # return ans\\n \\n # # initially \\n # dp = [-2**32] * n # dp[i]: max sum of seq in nums[i:] including [i]\\n # dp[n-1] = max(0,nums[n-1])\\n # dp[n-2] = max(0,nums[n-2])\\n \\n # maxDpTwoStepsAway = max(dp[n-1], 0)\\n # for i in range(n-3, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n\\n # ans = 0\\n # for query in queries:\\n # pos, val = query\\n # nums[pos] = val\\n # # print(\\\"qeury:\\\", query,\\\"nums:\\\", nums)\\n # maxDpTwoStepsAway = 0\\n # if pos+2 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, max(dp[pos+2:]))\\n \\n # for i in range(pos, -1, -1):\\n # dp[i] = max(maxDpTwoStepsAway + nums[i], 0)\\n # if i + 1 < n:\\n # maxDpTwoStepsAway = max(maxDpTwoStepsAway, dp[i+1])\\n \\n # ans += max(dp)\\n # # print(\\\"dp:\\\", dp)\\n # return ans\\n \\n \",\n \"memory\": \"57500\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"memory\": \"58700\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"memory\": \"59100\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val.copy() # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n #print(\\\"build for start:\\\", start, \\\", end:\\\", end, \\\", val=\\\", val)\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n #print(tree.query(0, N-1))\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n #print(\\\" cur = \\\", cur)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"memory\": \"59200\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val.copy() # [left, right, mid, both]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start]]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n for i in range(N):\\n if nums[i] < 0:\\n nums[i] = 0\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n if cur[3] > 0:\\n res = (res + cur[3]) % MOD\\n return res\\n\\n\",\n \"memory\": \"59300\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\",\n \"memory\": \"59400\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\",\n \"memory\": \"59500\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n \\n # val not only save the [start,end] range val\\n # but also save other 3 cases, [start, end-1], [start+1, end], [start+1, end-1]\\n self.val = val # [left, right, mid, both]\\n # left --> [start, end-1]\\n # right --> [start+1, end]\\n # mid --> [start+1, end-1]\\n # both --> [start, end]\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n val = [0, 0, 0, nums[start] if nums[start] > 0 else 0]\\n return TreeNode(start, end, val, None, None)\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val_left = max(left.val[3]+right.val[2], left.val[0]+right.val[0])\\n val_right = max(left.val[1]+right.val[1], left.val[2]+right.val[3])\\n val_mid = max(left.val[1]+right.val[2], left.val[2]+right.val[0])\\n val_both = max(left.val[3]+right.val[1], left.val[0]+right.val[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return TreeNode(start, end, val, left, right)\\n\\n self.root = build(nums, 0, len(nums)-1)\\n def doQuery(self, node, start, end):\\n if start > end:\\n return 0\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return self.doQuery(node.right, start, end)\\n elif mid >= end:\\n return self.doQuery(node.left, start, end)\\n\\n left = self.doQuery(node.left, start, mid)\\n right = self.doQuery(node.right, mid+1, end)\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n val = [val_left, val_right, val_mid, val_both]\\n return val\\n\\n def query(self, start, end):\\n return self.doQuery(self.root, start, end)\\n\\n def doUpdate(self, node, pos, val):\\n start, end = node.start, node.end\\n if start == end == pos:\\n node.val[3] = val\\n return\\n\\n mid = start + (end - start) // 2\\n if pos > mid:\\n self.doUpdate(node.right, pos, val)\\n else:\\n self.doUpdate(node.left, pos, val)\\n\\n left, right = node.left.val, node.right.val\\n val_left = max(left[3] + right[2], left[0] + right[0])\\n val_right = max(left[1] + right[1], left[2] + right[3])\\n val_mid = max(left[1] + right[2], left[2] + right[0])\\n val_both = max(left[3] + right[1], left[0] + right[3])\\n node.val = [val_left, val_right, val_mid, val_both]\\n\\n def update(self, pos, val):\\n self.doUpdate(self.root, pos, val)\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n N = len(nums)\\n tree = SegmentTree(nums)\\n res, MOD = 0, 10**9+7\\n for query in queries:\\n tree.update(query[0], query[1] if query[1] > 0 else 0)\\n cur = tree.query(0, N-1)\\n res = (res + cur[3]) % MOD\\n return res\\n\",\n \"memory\": \"59600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n class node:\\n def __init__(self,num,val):\\n self.range_left=num\\n self.range_right=num+1\\n self.full_v=max(val,0)\\n self.nleft_v=0\\n self.nright_v=0\\n self.nboth_v=0\\n\\n @classmethod\\n def grow(cls,range_left,range_right):\\n if range_right-range_left==1:\\n return node(range_left,nums[range_left])\\n root=node(0,0)\\n root.range_left=range_left\\n root.range_right=range_right\\n mid=(range_left+range_right)//2\\n root.left=cls.grow(range_left,mid)\\n root.right=cls.grow(mid,range_right)\\n root.left.parent=root\\n root.right.parent=root\\n root.parent=None\\n root.merge()\\n return root\\n \\n def merge(self):\\n self.full_v=max(self.left.nright_v+self.right.full_v,self.left.full_v+self.right.nleft_v)\\n self.nboth_v=max(self.left.nboth_v+self.right.nright_v,self.left.nleft_v+self.right.nboth_v)\\n self.nleft_v=max(self.left.nboth_v+self.right.full_v,self.left.nleft_v+self.right.nleft_v)\\n self.nright_v=max(self.left.nright_v+self.right.nright_v,self.left.full_v+self.right.nboth_v)\\n\\n def seek(self,n):\\n if self.range_left==n and self.range_right==n+1:\\n return self\\n mid=(self.range_left+self.range_right)//2\\n if n<mid:\\n return self.left.seek(n)\\n else:\\n return self.right.seek(n)\\n \\n def update_leaf(self,v):\\n self.full_v=max(v,0)\\n t=self.parent\\n while t:\\n dt=(t.full_v,t.nboth_v,t.nleft_v,t.nright_v)\\n t.merge()\\n if (t.full_v,t.nboth_v,t.nleft_v,t.nright_v)==dt:\\n break\\n t=t.parent\\n \\n root=node.grow(0,len(nums))\\n root.parent=None\\n sums=0\\n for i in queries:\\n nd=root.seek(i[0])\\n nd.update_leaf(i[1])\\n sums+=root.full_v\\n sums%=(10**9+7)\\n return sums\\n\\n\",\n \"memory\": \"61300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n \\n vals = [[0 for _ in range(4)] for _ in range(len(nums) * 4)]\\n\\n lst = [\\n [ 0 , 0 , 0 , 0 , 0 , 0 ],\\n [ 0 , 0 , 0 , 0 , 0 , 1 ],\\n [ 0 , 0 , 0 , 0 , 1 , 0 ],\\n [ 0 , 0 , 0 , 0 , 1 , 1 ],\\n [ 0 , 0 , 0 , 1 , 0 , 1 ],\\n [ 0 , 0 , 0 , 1 , 1 , 1 ],\\n [ 0 , 0 , 1 , 0 , 0 , 0 ],\\n [ 0 , 0 , 1 , 0 , 0 , 1 ],\\n [ 0 , 0 , 1 , 0 , 1 , 0 ],\\n [ 0 , 0 , 1 , 0 , 1 , 1 ],\\n [ 0 , 0 , 1 , 1 , 0 , 1 ],\\n [ 0 , 0 , 1 , 1 , 1 , 1 ],\\n [ 0 , 1 , 0 , 0 , 0 , 0 ],\\n [ 0 , 1 , 0 , 0 , 0 , 1 ],\\n [ 0 , 1 , 0 , 0 , 1 , 0 ],\\n [ 0 , 1 , 0 , 0 , 1 , 1 ],\\n [ 0 , 1 , 0 , 1 , 0 , 1 ],\\n [ 0 , 1 , 0 , 1 , 1 , 1 ],\\n [ 1 , 0 , 0 , 0 , 1 , 0 ],\\n [ 1 , 0 , 0 , 0 , 1 , 1 ],\\n [ 1 , 0 , 0 , 1 , 1 , 1 ],\\n [ 1 , 0 , 1 , 0 , 1 , 0 ],\\n [ 1 , 0 , 1 , 0 , 1 , 1 ],\\n [ 1 , 0 , 1 , 1 , 1 , 1 ],\\n [ 1 , 1 , 0 , 0 , 1 , 0 ],\\n [ 1 , 1 , 0 , 0 , 1 , 1 ],\\n [ 1 , 1 , 0 , 1 , 1 , 1 ],\\n ]\\n\\n def keep(idx, lb, rb):\\n\\n vals[idx] = [0 for _ in range(4)]\\n\\n lidx = idx * 2 + 1\\n ridx = idx * 2 + 2\\n\\n if lb == rb:\\n vals[idx][0] = max(0, nums[lb])\\n\\n else:\\n # for i0 in (0, 1):\\n # for i1 in (0, 1):\\n # for j0 in (0, 1):\\n # for j1 in (0, 1):\\n # for k0 in (0, 1):\\n # for k1 in (0, 1):\\n # if i1 == 1 and j0 == 1:\\n # continue\\n \\n # if i0 == 1 and k0 == 0:\\n # continue\\n\\n # if j1 == 1 and k1 == 0:\\n # continue\\n\\n \\n # print(\\\"[\\\", i0, \\\", \\\", i1, \\\", \\\",j0, \\\", \\\",j1, \\\", \\\", k0, \\\", \\\", k1, \\\"],\\\")\\n # node.val[k0][k1] = max(node.val[k0][k1], node.left.val[i0][i1] + node.right.val[j0][j1])\\n\\n # print()\\n # print()\\n # print()\\n\\n # for i0, i1, j0, j1, k0, k1 in lst:\\n # vals[idx][k0][k1] = max(vals[idx][k0][k1], vals[lidx][i0][i1] + vals[ridx][j0][j1])\\n\\n l0h0A, l1h0A, l0h1A, l1h1A = vals[2 * idx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = vals[2 * idx + 2]\\n # lo to hi\\n vals[idx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n vals[idx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n vals[idx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n vals[idx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n\\n def build(idx, lb, rb):\\n\\n if lb == rb:\\n pass\\n else:\\n mid = (lb + rb) // 2\\n\\n build(2 * idx + 1, lb, mid)\\n build(2 * idx + 2, mid + 1, rb)\\n\\n keep(idx, lb, rb)\\n\\n def update(nidx, idx, val, lb, rb):\\n\\n if not (lb <= idx <= rb):\\n return\\n\\n elif lb == idx == rb:\\n nums[idx] = val\\n\\n else:\\n mid = (lb + rb) // 2\\n update(2 * nidx + 1, idx, val, lb, mid)\\n update(2 * nidx + 2, idx, val, mid + 1, rb)\\n \\n keep(nidx, lb, rb) \\n\\n build(0, 0, len(nums) - 1)\\n\\n\\n res = 0\\n for idx, val in queries:\\n update(0, idx, val, 0, len(nums) - 1)\\n res = (res + max(vals[0])) % (10 ** 9 + 7)\\n\\n return res\\n \\n\",\n \"memory\": \"62200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # indices for subsarray results if both, only the left endm only the right end, or neither ends are allowed to be selected\\n BOTH = 0\\n LEFT = 1\\n RIGHT = 2\\n NONE = 3\\n N = len(nums)\\n \\n # segment tree\\n tree = [[0, 0, 0, 0] for _ in range(4 * N)]\\n\\n # calculate values for just node i in the tree\\n def update_i(i):\\n left = tree[2 * i]\\n right = tree[2 * i + 1]\\n result = tree[i]\\n result[BOTH] = max(left[LEFT] + right[BOTH], left[BOTH] + right[RIGHT])\\n result[LEFT] = max(left[LEFT] + right[LEFT], left[BOTH] + right[NONE])\\n result[RIGHT] = max(left[NONE] + right[BOTH], left[RIGHT] + right[RIGHT])\\n result[NONE] = max(left[RIGHT] + right[NONE], left[NONE] + right[LEFT])\\n\\n # construct subtree at node i\\n def construct(i, tl, tr):\\n if tl == tr:\\n tree[i][BOTH] = nums[tl]\\n else:\\n # construct subtrees and calculate outcome for this node\\n m = (tl + tr) // 2\\n construct(i * 2, tl, m)\\n construct(i * 2 + 1, m + 1, tr)\\n update_i(i)\\n \\n # update subtree at node i with change at index t in the original array\\n def update(i, t, tl, tr):\\n if tl == tr:\\n tree[i][BOTH] = nums[t]\\n else:\\n m = (tl + tr) // 2\\n if t <= m:\\n update(i * 2, t, tl, m)\\n else:\\n update(i * 2 + 1, t, m + 1, tr)\\n update_i(i)\\n \\n # construct tree\\n construct(1, 0, N - 1)\\n\\n # process queries\\n total = 0\\n for q in queries:\\n t, x = q\\n nums[t] = x\\n update(1, t, 0, N - 1)\\n total += max(tree[1])\\n\\n return total % 1_000_000_007\",\n \"memory\": \"63100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, performance_scores: List[int], inspections: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n Optimizes the performance of a fleet of trucks based on their performance scores and periodic inspections.\\n\\n Given a list of initial performance scores of trucks, and a series of inspections where the performance of\\n certain trucks is updated, this function computes the maximum possible performance of the fleet, ensuring that \\n no two adjacent trucks are selected for optimization. The result after all inspections is returned modulo 10^9 + 7.\\n\\n Args:\\n performance_scores (List[int]): Initial performance scores of the fleet's trucks.\\n inspections (List[List[int]]): A list of updates, where each update contains the truck index and its new performance score.\\n\\n Returns:\\n int: The sum of the maximum subsequence performance after each inspection, modulo 10^9 + 7.\\n \\\"\\\"\\\"\\n \\n MOD = 1_000_000_007\\n n = len(performance_scores)\\n # Segment tree to store maximum subsequence sums for different truck ranges\\n segment_tree = [[0] * 4 for _ in range(4 * n)]\\n\\n def build_tree(node: int, start: int, end: int):\\n \\\"\\\"\\\"\\n Recursively builds the segment tree based on the initial performance scores.\\n \\\"\\\"\\\"\\n if start == end:\\n segment_tree[node][0] = max(0, performance_scores[start])\\n else:\\n mid = (start + end) // 2\\n build_tree(2 * node + 1, start, mid)\\n build_tree(2 * node + 2, mid + 1, end)\\n combine(node)\\n\\n def combine(node: int):\\n \\\"\\\"\\\"\\n Combines two child nodes in the segment tree to calculate the maximum subsequence sums for the parent node.\\n \\\"\\\"\\\"\\n left = segment_tree[2 * node + 1]\\n right = segment_tree[2 * node + 2]\\n # No adjacent trucks selected\\n segment_tree[node][0] = max(left[2] + right[1], left[0] + right[1], left[2] + right[0])\\n # Skipping the first truck\\n segment_tree[node][1] = max(left[3] + right[1], left[1] + right[1], left[3] + right[0])\\n # Skipping the last truck\\n segment_tree[node][2] = max(left[2] + right[3], left[0] + right[3], left[2] + right[2])\\n # Skipping both the first and last trucks\\n segment_tree[node][3] = max(left[3] + right[3], left[1] + right[3], left[3] + right[2])\\n\\n def update_tree(node: int, start: int, end: int, idx: int, new_score: int):\\n \\\"\\\"\\\"\\n Updates the segment tree when a truck's performance score is changed after an inspection.\\n \\\"\\\"\\\"\\n if start == end:\\n segment_tree[node][0] = max(0, new_score)\\n else:\\n mid = (start + end) // 2\\n if idx > mid:\\n update_tree(2 * node + 2, mid + 1, end, idx, new_score)\\n else:\\n update_tree(2 * node + 1, start, mid, idx, new_score)\\n combine(node)\\n\\n # Build the initial segment tree\\n build_tree(0, 0, n - 1)\\n\\n total_performance = 0\\n\\n # Process each inspection (update performance score and recalculate maximum subsequence sum)\\n for idx, new_score in inspections:\\n update_tree(0, 0, n - 1, idx, new_score)\\n total_performance += max(segment_tree[0])\\n total_performance %= MOD\\n\\n return total_performance\",\n \"memory\": \"63600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"memory\": \"63700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"memory\": \"63900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = [[0] * 4 for _ in range(4 * n)]\\n \\n def build(tidx, lo, hi):\\n if lo == hi:\\n tree[tidx][0] = max(0, nums[lo])\\n else:\\n mid = (lo + hi) // 2\\n build(2 * tidx + 1, lo, mid)\\n build(2 * tidx + 2, mid + 1, hi)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n build(0, 0, n - 1)\\n \\n def update(tidx, lo, hi, i, val):\\n if lo == hi:\\n tree[tidx][0] = max(0, val)\\n else:\\n mid = (lo + hi) // 2\\n if i > mid:\\n update(tidx * 2 + 2, mid + 1, hi, i, val)\\n else:\\n update(tidx * 2 + 1, lo, mid, i, val)\\n l0h0A, l1h0A, l0h1A, l1h1A = tree[2 * tidx + 1]\\n l0h0B, l1h0B, l0h1B, l1h1B = tree[2 * tidx + 2]\\n # lo to hi\\n tree[tidx][0] = max(l0h1A + l1h0B, l0h0A + l1h0B, l0h1A + l0h0B)\\n # lo + 1 to hi\\n tree[tidx][1] = max(l1h1A + l1h0B, l1h0A + l1h0B, l1h1A + l0h0B)\\n # lo to hi - 1\\n tree[tidx][2] = max(l0h1A + l1h1B, l0h0A + l1h1B, l0h1A + l0h1B)\\n # lo + 1 to hi - 1\\n tree[tidx][3] = max(l1h1A + l1h1B, l1h0A + l1h1B, l1h1A + l0h1B)\\n \\n ans = 0\\n for i, x in queries:\\n update(0, 0, n - 1, i, x)\\n ans += max(tree[0])\\n return ans % 1_000_000_007\",\n \"memory\": \"64000\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = 0\\n self.selected[1][0] = 0\\n self.selected[1][1] = max(nums[lo], nums[hi])\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"memory\": \"75200\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, nums, lo, hi):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0, -float('inf')], [-float('inf'), -float('inf')]]\\n \\n if lo < hi:\\n mid = (lo + hi) // 2\\n self.l = Node(nums, lo, mid)\\n self.r = Node(nums, mid + 1, hi)\\n self.combine()\\n else:\\n self.selected[1][1] = nums[lo]\\n \\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0] + self.r.selected[0][0], max(self.l.selected[0][1] + self.r.selected[0][0], self.l.selected[0][0] + self.r.selected[1][0]))\\n self.selected[0][1] = max(self.l.selected[0][0] + self.r.selected[0][1], max(self.l.selected[0][1] + self.r.selected[0][1], self.l.selected[0][0] + self.r.selected[1][1]))\\n self.selected[1][0] = max(self.l.selected[1][0] + self.r.selected[0][0], max(self.l.selected[1][1] + self.r.selected[0][0], self.l.selected[1][0] + self.r.selected[1][0]))\\n self.selected[1][1] = max(self.l.selected[1][0] + self.r.selected[0][1], max(self.l.selected[1][1] + self.r.selected[0][1], self.l.selected[1][0] + self.r.selected[1][1]))\\n\\n def update(self, i, x):\\n if i < self.lo or i > self.hi:\\n return\\n \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n \\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n segmentTree = Node(nums, 0, len(nums) - 1)\\n\\n res = 0\\n for query in queries:\\n segmentTree.update(query[0], query[1])\\n res += max(segmentTree.selected[0][0], max(segmentTree.selected[0][1], max(segmentTree.selected[1][0], segmentTree.selected[1][1])))\\n res %= 10**9 + 7\\n return res\",\n \"memory\": \"77400\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, nums, lo, hi):\\n self.l = None\\n self.r = None\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0, -float('inf')], [-float('inf'), 0]]\\n\\n if lo < hi:\\n mid = (lo + hi) // 2\\n self.l = Node(nums, lo, mid)\\n self.r = Node(nums, mid + 1, hi)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = -float('inf')\\n self.selected[1][0] = -float('inf')\\n self.selected[1][1] = nums[lo]\\n\\n def combine(self):\\n l, r = self.l.selected, self.r.selected\\n self.selected[0][0] = max(l[0][0] + r[0][0], l[0][1] + r[0][0], l[0][0] + r[1][0])\\n self.selected[0][1] = max(l[0][0] + r[0][1], l[0][1] + r[0][1], l[0][0] + r[1][1])\\n self.selected[1][0] = max(l[1][0] + r[0][0], l[1][1] + r[0][0], l[1][0] + r[1][0])\\n self.selected[1][1] = max(l[1][0] + r[0][1], l[1][1] + r[0][1], l[1][0] + r[1][1])\\n\\n def update(self, i, x):\\n if i < self.lo or self.hi < i:\\n return\\n\\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n segment_tree = Node(nums, 0, len(nums) - 1)\\n \\n res = 0\\n for query in queries:\\n segment_tree.update(query[0], query[1])\\n res += max(max(segment_tree.selected[0]), max(segment_tree.selected[1]))\\n res %= MOD\\n \\n return res\",\n \"memory\": \"77500\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = float('-inf')\\n self.selected[1][0] = float('-inf')\\n self.selected[1][1] = max(nums[lo], nums[hi])\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"memory\": \"78800\"\n },\n {\n \"code\": \"class Node:\\n def __init__(self, lo, hi, nums):\\n self.lo = lo\\n self.hi = hi\\n self.selected = [[0]*2 for _ in range(2)]\\n if lo < hi:\\n mid = (lo + hi)//2\\n self.l = Node(lo, mid, nums)\\n self.r = Node(mid+1, hi, nums)\\n self.combine()\\n else:\\n self.selected[0][0] = 0\\n self.selected[0][1] = float('-inf')\\n self.selected[1][0] = float('-inf')\\n self.selected[1][1] = nums[lo]\\n def combine(self):\\n self.selected[0][0] = max(self.l.selected[0][0]+self.r.selected[0][0], self.l.selected[0][1]+self.r.selected[0][0],self.l.selected[0][0]+self.r.selected[1][0])\\n self.selected[0][1] = max(self.l.selected[0][0]+self.r.selected[0][1], self.l.selected[0][1]+self.r.selected[0][1],self.l.selected[0][0]+self.r.selected[1][1])\\n self.selected[1][0] = max(self.l.selected[1][0]+self.r.selected[0][0], self.l.selected[1][1]+self.r.selected[0][0],self.l.selected[1][0]+self.r.selected[1][0])\\n self.selected[1][1] = max(self.l.selected[1][0]+self.r.selected[0][1], self.l.selected[1][1]+self.r.selected[0][1],self.l.selected[1][0]+self.r.selected[1][1])\\n def update(self, i, x):\\n if i < self.lo or self.hi < i: return \\n if self.lo == self.hi:\\n self.selected[0][0] = 0\\n self.selected[1][1] = x\\n return\\n self.l.update(i, x)\\n self.r.update(i, x)\\n self.combine()\\n\\nclass Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n n = len(nums)\\n tree = Node(0,len(nums)-1,nums)\\n res = 0\\n MOD = 10**9+7\\n for i,x in queries:\\n tree.update(i,x)\\n res += max(max(tree.selected[0]), max(tree.selected[1]))\\n res %= MOD\\n return res\",\n \"memory\": \"78800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\\n def glue(a, b):\\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \\n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \\n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\\n def query(l, r, p=1, tl=0, tr=len(nums)):\\n if l == tl and r == tr:\\n return st[p];\\n tm = (tl + tr) // 2\\n return glue(query(l, min(r, tm), p * 2, tl, tm), \\n query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\\n def update(pos, x, p=1, tl=0, tr=len(nums)):\\n tm = (tl + tr) // 2\\n if tl == tr:\\n st[p][1][1] = x \\n elif pos <= tm:\\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\\n else:\\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\\n return st[p]\\n for i, n in enumerate(nums):\\n update(i, n)\\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007\",\n \"memory\": \"88400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n # 11:17\\n st, res = [[[0, 0], [0, 0]] for _ in range(0, 4 * len(nums))], 0\\n def glue(a, b):\\n return [[max(a[0][1] + b[0][0], a[0][0] + b[1][0]), \\n max(a[0][1] + b[0][1], a[0][0] + b[1][1])],\\n [max(a[1][1] + b[0][0], a[1][0] + b[1][0]), \\n max(a[1][1] + b[0][1], a[1][0] + b[1][1])]]\\n # def query(l, r, p=1, tl=0, tr=len(nums)):\\n # if l == tl and r == tr:\\n # return st[p];\\n # tm = (tl + tr) // 2\\n # return glue(query(l, min(r, tm), p * 2, tl, tm), \\n # query(max(l, tm + 1), r, p * 2 + 1, tm + 1, tr));\\n def update(pos, x, p=1, tl=0, tr=len(nums)):\\n tm = (tl + tr) // 2\\n if tl == tr:\\n st[p][1][1] = x \\n elif pos <= tm:\\n st[p] = glue(update(pos, x, p * 2, tl, tm), st[p * 2 + 1])\\n else:\\n st[p] = glue(st[p * 2], update(pos, x, p * 2 + 1, tm + 1, tr))\\n return st[p]\\n for i, n in enumerate(nums):\\n update(i, n)\\n return sum(update(pos, x)[1][1] for pos, x in queries) % 1000000007\",\n \"memory\": \"88500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumSumSubsequence(self, nums: List[int], queries: List[List[int]]) -> int:\\n self.inf = float('inf')\\n self.mod = 10 ** 9 + 7\\n n = len(nums)\\n st = [[[0] * 2 for _ in range(2)] for _ in range(4 * n)]\\n self.build(st, nums, 0, 0, n - 1)\\n res = 0\\n for ind, val in queries:\\n self.update(st, 0, ind, val, 0, n - 1)\\n res = (res + max(st[0][x][y] for x in range(2) for y in range(2))) % self.mod\\n return res\\n \\n def build(self, st, nums, node, l, r):\\n if l == r:\\n st[node][0][0] = 0\\n st[node][0][1] = -float('inf')\\n st[node][1][0] = -float('inf')\\n st[node][1][1] = nums[l]\\n \\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n self.build(st, nums, lnode, l, m)\\n self.build(st, nums, rnode, m + 1, r)\\n self.combine(st, node, lnode, rnode)\\n def combine(self, st, node, lnode, rnode):\\n for x in range(2):\\n for y in range(2):\\n st[node][x][y] = max(\\n st[lnode][x][0] + st[rnode][0][y],\\n st[lnode][x][1] + st[rnode][0][y],\\n st[lnode][x][0] + st[rnode][1][y]\\n )\\n \\n def update(self, st, node, ind, val, l, r):\\n if l == r:\\n st[node][1][1] = val\\n else:\\n m = (l + r) // 2\\n lnode, rnode = 2 * node + 1, 2 * node + 2\\n if ind <= m:\\n self.update(st, lnode, ind, val, l, m)\\n else:\\n self.update(st, rnode, ind, val, m + 1, r)\\n self.combine(st, node, lnode, rnode)\",\n \"memory\": \"90200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":51,"string":"51"}}},{"rowIdx":2449,"cells":{"question_id":{"kind":"number","value":1644,"string":"1,644"},"name":{"kind":"string","value":"maximum-number-of-non-overlapping-substrings"},"content":{"kind":"string","value":"<p>Given a string <code>s</code> of lowercase letters, you need to find the maximum number of <strong>non-empty</strong> substrings of <code>s</code> that meet the following conditions:</p>\n\n<ol>\n\t<li>The substrings do not overlap, that is for any two substrings <code>s[i..j]</code> and <code>s[x..y]</code>, either <code>j < x</code> or <code>i > y</code> is true.</li>\n\t<li>A substring that contains a certain character <code>c</code> must also contain all occurrences of <code>c</code>.</li>\n</ol>\n\n<p>Find <em>the maximum number of substrings that meet the above conditions</em>. If there are multiple solutions with the same number of substrings, <em>return the one with minimum total length. </em>It can be shown that there exists a unique solution of minimum total length.</p>\n\n<p>Notice that you can return the substrings in <strong>any</strong> order.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "adefaddaccc"\n<strong>Output:</strong> ["e","f","ccc"]\n<b>Explanation:</b> The following are all the possible substrings that meet the conditions:\n[\n "adefaddaccc"\n "adefadda",\n "ef",\n "e",\n "f",\n "ccc",\n]\nIf we choose the first string, we cannot choose anything else and we'd get only 1. If we choose "adefadda", we are left with "ccc" which is the only one that doesn't overlap, thus obtaining 2 substrings. Notice also, that it's not optimal to choose "ef" since it can be split into two. Therefore, the optimal way is to choose ["e","f","ccc"] which gives us 3 substrings. No other solution of the same number of substrings exist.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "abbaccd"\n<strong>Output:</strong> ["d","bb","cc"]\n<b>Explanation: </b>Notice that while the set of substrings ["d","abba","cc"] also has length 3, it's considered incorrect since it has larger total length.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length <= 10<sup>5</sup></code></li>\n\t<li><code>s</code> contains only lowercase English letters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":39.74119944954943,"string":"39.741199"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["string","greedy"],"string":"[\n \"string\",\n \"greedy\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"186\", 8.485199999999997], [\"234\", 4.8488], [\"283\", 13.333899999999996], [\"331\", 12.727599999999995], [\"379\", 6.060899999999998], [\"428\", 1.8182], [\"476\", 7.879199999999998], [\"525\", 2.4244], [\"573\", 0.6061], [\"622\", 3.0305], [\"670\", 1.8182999999999998], [\"719\", 4.2425], [\"767\", 2.4244], [\"815\", 1.2122], [\"864\", 1.2122], [\"912\", 0.6061], [\"961\", 0.6061], [\"1009\", 0.6061], [\"1058\", 3.0305], [\"1106\", 1.2122], [\"1154\", 0.6061], [\"1203\", 0.6061], [\"1251\", 0.6061], [\"1300\", 0.6061], [\"1348\", 0.6061], [\"1397\", 0.6061], [\"1445\", 0.6061], [\"1494\", 0.6061], [\"1542\", 0.6061], [\"1590\", 0.6061], [\"1639\", 0.6061], [\"1687\", 0.6061], [\"1736\", 0.6061], [\"1784\", 0.6061], [\"1833\", 0.6061], [\"1881\", 0.6061], [\"1929\", 0.6061], [\"1978\", 0.6061], [\"2026\", 0.6061], [\"2075\", 0.6061], [\"2123\", 0.6061], [\"2172\", 0.6061], [\"2220\", 0.6061], [\"2269\", 0.6061], [\"2317\", 0.6061], [\"2365\", 0.6061], [\"2414\", 0.6061]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 0.6061], [\"17400\", 0.6061], [\"17600\", 1.8182], [\"17700\", 18.1818], [\"17800\", 21.2121], [\"17900\", 8.4848], [\"18000\", 6.6667], [\"18100\", 4.8485], [\"18200\", 1.8182], [\"18300\", 0.6061], [\"18400\", 0.6061], [\"18500\", 1.2121], [\"18600\", 1.8182], [\"18700\", 2.4242], [\"18800\", 1.8182], [\"18900\", 0.6061], [\"19000\", 1.2121], [\"19500\", 0.6061], [\"19700\", 0.6061], [\"19900\", 0.6061], [\"21500\", 1.8182], [\"21600\", 5.4545], [\"21700\", 0.6061], [\"22400\", 0.6061], [\"23400\", 0.6061], [\"25800\", 0.6061], [\"27700\", 0.6061], [\"27900\", 1.8182], [\"28000\", 1.8182], [\"28100\", 0.6061], [\"32900\", 0.6061], [\"45000\", 0.6061], [\"45700\", 1.2121], [\"48200\", 0.6061], [\"49100\", 0.6061]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def dfs(self, i):\n if i in self.dfs_store:\n return self.dfs_store[i]\n \n v = self.dfs(i+1)\n \n _, end = self.valid_intervals[i]\n j = i + 1\n while j < self.len and self.valid_intervals[j][0] < end:\n j += 1\n if len(v) >= 1 + len(self.dfs(j)):\n self.dfs_store[i] = v\n else:\n self.dfs_store[i] = [self.valid_intervals[i]] + self.dfs_store[j]\n return self.dfs_store[i]\n \n def maxNumOfSubstrings(self, s: str):\n store = {}\n for i, c in enumerate(s):\n if c not in store:\n store[c] = [i, i]\n else:\n store[c][-1] = i\n valid_intervals = []\n for c in store:\n begin, end = store[c]\n checked = set([c])\n flag = True\n i = begin + 1\n while i <= end:\n d = s[i]\n i += 1\n if d in checked:\n continue\n d_begin, d_end = store[d]\n if d_begin < begin:\n flag = False\n break\n if d_end > end:\n end = d_end\n checked.add(d)\n if flag:\n valid_intervals.append([begin, end])\n valid_intervals.sort()\n \n self.len = len(valid_intervals)\n self.dfs_store = {self.len: []}\n self.valid_intervals = valid_intervals\n self.dfs(0)\n rt = []\n for begin, end in self.dfs_store[0]:\n rt.append(s[begin: end+1])\n \n return rt","runtime":"186"},{"code":"from typing import List\nfrom bisect import bisect_left\n\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Step 1: Record the first and last occurrence of each character\n locs = {}\n for i, x in enumerate(s):\n locs.setdefault(x, []).append(i)\n \n # Step 2: Define a function to expand the range to cover all occurrences of characters\n def fn(lo, hi):\n \"\"\"Return expanded range covering all chars in s[lo:hi+1].\"\"\"\n for xx in locs:\n k0 = bisect_left(locs[xx], lo)\n k1 = bisect_left(locs[xx], hi)\n # Check if the current range [lo, hi] needs to be expanded\n if k0 < k1 and (locs[xx][0] < lo or hi < locs[xx][-1]):\n lo = min(lo, locs[xx][0])\n hi = max(hi, locs[xx][-1])\n lo, hi = fn(lo, hi) # Recursively expand the range\n return lo, hi\n \n # Step 3: Determine all possible non-overlapping substrings\n group = set()\n for x in locs:\n group.add(fn(locs[x][0], locs[x][-1]))\n \n # Step 4: Solve the interval scheduling maximization problem\n ans = []\n prev = -1\n for lo, hi in sorted(group, key=lambda x: x[1]):\n if prev < lo:\n ans.append(s[lo:hi+1])\n prev = hi\n \n return ans","runtime":"186"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n \"\"\"\n Did not solve\n 1. Get the first and last occurance of each characters\n 2. For the range of each letter, we need to update the range according to all the characters within the range. For example: abab we would have the initial range as a: [0,2], b: [1:3]. Since the range of a which is [0,2] will include b, we need to update the range of a to also include all occurances of b as well.\n 3. Finally, we sort all the ranges according to it's end (since we want to take smallest range possible) and take as much as we can as long as the start of the current range is >= the end of the previous range.\n \"\"\"\n ranges = collections.defaultdict(list)\n # 1\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n # 2\n for r in ranges:\n left, right = ranges[r][0], ranges[r][-1]\n templ, tempr = left, right\n while True:\n for ch in set(s[templ:tempr+1]):\n templ = min(templ, ranges[ch][0])\n tempr = max(tempr, ranges[ch][-1])\n if (templ, tempr) == (left, right): break\n left, right = templ, tempr\n ranges[r] = (templ, tempr)\n # 3\t\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end+1])\n prev = end\n return ans","runtime":"234"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n ends = {}\n counter = defaultdict(int)\n for i in range(n-1,-1,-1):\n if s[i] not in ends:\n ends[s[i]] = i\n counter[s[i]] += 1\n ans = []\n seen = set()\n stack = []\n i = 0\n \n included = -1\n while i < n:\n #print(s[i])\n if s[i] not in seen:\n seen.add(s[i])\n stack.append(i)\n if ends[s[i]] == i:\n seen.remove(s[i])\n stack_index = len(stack)-1\n curr = 0\n #print(stack,s[i],included,stack_index,seen)\n while stack[stack_index] > included and s[stack[stack_index]] not in seen:\n curr += counter[s[stack[stack_index]]]\n if i - stack[stack_index] + 1 == curr:\n # shortest segment found\n ans.append(s[stack[stack_index]:i+1])\n included = i\n stack_index -= 1\n \n \n i += 1\n return ans if ans else [s]","runtime":"234"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = collections.defaultdict(list)\n # 1\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n # 2\n for r in ranges:\n left, right = ranges[r][0], ranges[r][-1]+1\n templ, tempr = left, right\n while True:\n for ch in set(s[templ:tempr]):\n templ = min(templ, ranges[ch][0])\n tempr = max(tempr, ranges[ch][-1]+1)\n if (templ, tempr) == (left, right): break\n left, right = templ, tempr\n ranges[r] = (templ, tempr)\n # 3\t\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end])\n prev = end\n return ans","runtime":"283"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = defaultdict(list)\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n for r in ranges:\n left, right = ranges[r][0], ranges[r][-1]+1\n templ, tempr = left, right\n while True:\n for ch in set(s[templ:tempr]):\n templ = min(templ, ranges[ch][0])\n tempr = max(tempr, ranges[ch][-1]+1)\n if (templ, tempr) == (left, right): break\n left, right = templ, tempr\n ranges[r] = (templ, tempr)\n # 3\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end])\n prev = end\n return ans","runtime":"283"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n h,bIndex,eIndex,end = {},{},{},{}\n n = len(s)\n for i in range(n):\n if s[i] not in h:\n bIndex[i] = True\n h[s[i]] = True\n h = {}\n for i in range(n-1,-1,-1):\n if s[i] not in h:\n eIndex[i] = True\n end[s[i]] = i\n h[s[i]] = True\n \n #print(f\"bIndex={bIndex}\\neIndex={eIndex}\\nend={end}\")\n\n stack = [] #[set(),b,e,t]\n ans = [] \n for i in range(n):\n x = s[i]\n if i in bIndex:\n if len(stack) > 0 and end[x] > stack[-1][2]: # extend\n xset = {x} # set\n while len(stack) > 0 and end[x] > stack[-1][2]:\n xs, b, _, t = stack.pop()\n xset |= xs \n stack.append([xset,b,end[x],t])\n else: # end[x] < stack[-1][2]:\n #if len(stack) > 0:\n # stack[-1][0] |= {x}\n stack.append([{x},i,end[x],False]) # inclusion\n\n if i in eIndex:\n if len(stack) > 0 and stack[-1][2]==i:\n _,b,e,t = stack.pop()\n if t==False: \n ans.append(s[b:e+1])\n while len(stack) > 1:\n stack.pop() \n if len(stack)==1:\n stack[-1][3]=True # s[stack[-1][0]:stack[-1][1]+1] is a superset of s[i:i+1]\n elif len(stack) > 0 and stack[-1][2] > i:\n while len(stack) > 0 and x not in stack[-1][0]:\n xs,_,_,_ = stack.pop()\n if len(stack) > 0:\n stack[-1][0] |= xs\n\n if i not in bIndex and i not in eIndex:\n while len(stack) > 0 and x not in stack[-1][0]:\n xs,_,_,_ = stack.pop()\n if len(stack) > 0:\n stack[-1][0] |= xs\n\n #print(f\"after i={i} x={x} stack={stack}\")\n return ans\n \n\n","runtime":"331"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n h,bIndex,eIndex,end = {},{},{},{}\n n = len(s)\n for i in range(n):\n if s[i] not in h:\n bIndex[i] = True\n h[s[i]] = True\n h = {}\n for i in range(n-1,-1,-1):\n if s[i] not in h:\n eIndex[i] = True\n end[s[i]] = i\n h[s[i]] = True\n\n stack = [] #[set(),b,e,t] # store the informatrion of the interval from b to e that contain the characters in set and t==True denote it is a superset of a substring in ans.\n ans = [] \n for i in range(n):\n x = s[i]\n if i in bIndex:\n if len(stack) > 0 and end[x] > stack[-1][2]: # merge the interval on the top of stack and the interval [i,end(x)]\n xset = {x} # set\n while len(stack) > 0 and end[x] > stack[-1][2]:\n xs, b, _, t = stack.pop()\n xset |= xs \n stack.append([xset,b,end[x],t])\n else: # end[x] < stack[-1][2]: # The interval on the top of stack includes the the interval [i,end(x)].\n stack.append([{x},i,end[x],False]) # push the interval [i,end(x)] on the top of the stack.\n\n if i in eIndex:\n if len(stack) > 0 and stack[-1][2]==i:\n _,b,e,t = stack.pop()\n if t==False: # The interval [b:e+1] is the substring that meets the conditions of the answers.\n ans.append(s[b:e+1])\n while len(stack) > 1: # pop all supersets of the interval [b:e+1] until the last one on the stack.\n stack.pop() \n if len(stack)==1:\n stack[-1][3]=True # the last one interval on the stack is a superset of the interval [b:e+1].\n elif len(stack) > 0 and stack[-1][2] > i:\n while len(stack) > 0 and x not in stack[-1][0]: # x is not in characters set of the interval on the top of the stack.\n xs,_,_,_ = stack.pop() # remove it and pass the characters set to the next one on the stack\n if len(stack) > 0:\n stack[-1][0] |= xs\n\n if i not in bIndex and i not in eIndex:\n while len(stack) > 0 and x not in stack[-1][0]: # the same approach as above\n xs,_,_,_ = stack.pop()\n if len(stack) > 0:\n stack[-1][0] |= xs\n\n return ans\n \n\n","runtime":"331"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_pos = dict()\n for i, c in enumerate(s):\n if c not in char_pos:\n char_pos[c] = (i, i)\n char_pos[c] = (char_pos[c][0], i)\n\n substrings = []\n #find every shortest substring that start at each position that meets 2\n for i, c in enumerate(s):\n start, end = char_pos[c]\n if i > start: continue\n index = i + 1\n canFormSubstring = True\n while index < end:\n new_start, new_end = char_pos[s[index]]\n if new_start < start:\n #impossible at start\n canFormSubstring = False\n break\n end = max(new_end, end)\n index += 1\n \n if canFormSubstring:\n substrings.append((i, end))\n \n\n #sort substrings by right hand side of the interval ascending order\n #then we loop over the sorted substrings, and find the longest\n #non-overlapping substrings at each substring\n substrings = sorted(substrings, key=lambda x: x[1])\n n = len(substrings)\n\n max_number = 0\n min_length = 100000000000\n out = []\n for i, pos in enumerate(substrings):\n start, end = pos\n curr_strs = [s[start:end+1]]\n curr_number = 1\n for j in range(i+1, n):\n new_start, new_end = substrings[j]\n if new_start > end:\n end = new_end\n curr_number += 1\n curr_strs.append(s[new_start:new_end+1])\n \n if curr_number > max_number:\n max_number = curr_number\n min_length = len(''.join(curr_strs))\n out = curr_strs\n elif curr_number == max_number and min_length > len(''.join(curr_strs)):\n min_length = min(min_length, len(''.join(curr_strs)))\n out = curr_strs\n \n return out\n\n\n \n \n\n\n \n\n\n ","runtime":"379"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # find max num of nonempty substrs that\n # do not overlap\n # if one contains c, then it must contain ALL the characters of c\n\n # probably dynamic programming? 2^26 is too high for a DFS+backtracking or knapsack-style solution\n\n # what's the best with a substring with a's?\n # if we take a:\n # then first[a]..last[a] is the minimum bounds of a substring to take\n # if we make that a substring, then the max number of remaining substrings is reduced by\n # num uniques in first[a]..last[a]\n\n # doesn't seem promising\n\n # what about classic best answer in ..i?\n # suppose we know best[i-1], and earlier best entries\n # then if i is the last copy of a character c:\n # then we can form one window with first[c]..i, and add the best window of 0..first[c]-1\n # otherwise, there's no valid window that can end here, because last[c] is later and we'd violate the constraints\n\n # basic: store O(N) entries\n # fancier: store O(26) entries\n\n # let's get fancy\n\n first = {}\n last = {}\n for i, c in enumerate(s):\n if c not in first: first[c] = i\n last[c] = i\n\n best = [(-1, [])] # (lastIdx, substrs)\n for i in sorted(last.values()): # O(26) iterations\n c = s[i]\n print(f\"{i=}, {c=}\")\n # if last[c] != i: continue # instead of iterating over all chars, just iterate over lasts\n\n # O(N) scan back\n # extend window back to include the earliest unique in f..l\n # strategy: start with j=i-1. While j > f (we already know the char at f),\n # look at what the first index of s[j] is and shrink f if needed\n ## TODO: we could probably handle this faster by using another layer of dynamic\n # programming or caching. Can't reduce complexity below O(N) though\n # so it would just be a speed improvement, not a complexity improvement.\n # Sketch idea: for each of the 26 characters, we know first and last\n # So as preprocessing, we can scan over the characters again. If c occurs at i,\n # and i is between [first, last] for some other character c', add an edge c' -> c\n # to mean \"if you take c' in a window, you also must take c\".\n # Then do a DFS traversal from each `c` to find the \"windened window\" for each\n # `c`. Finally, do what another solution I saw does: put those windows into a `set()`,\n # then iterate over the set's entries (sorted by end) instead of iterating over all ends.\n # TC for that part is O(C**2) where there are C unique characters; C <= N.\n # For C**2 << N that would give us a complexity improvement over this O(C*N) algo.\n f = first[c]\n l = i\n j = i-1\n while j > f and l == i:\n f = min(f, first[s[j]])\n l = max(l, last[s[j]])\n j -= 1\n\n if l > i:\n # first[c]..last[c] contains some other character c' we haven't\n # seen all copies of yet --> we'll wait until we get to last[c']\n continue\n\n # O(log(26)) because at most we have one entry per end character\n p = bisect_left(best, f, key=lambda pair: pair[0])-1\n take = False\n if len(best[p][1]) + 1 > len(best[-1][1]):\n take = True\n elif len(best[p][1]) + 1 == len(best[-1][1]) and sum(len(t) for t in best[p][1]) + i-f+1 < sum(len(t) for t in best[-1][1]):\n take = True\n\n # O(N) because we \"reify\" the strings; instead we could store bounds for O(26) here\n if take:\n entry = (i, [(s[f:i+1])])\n entry[1].extend(best[p][1])\n best.append(entry)\n\n # best[-1] is the best overall answer\n # [1] is the list of strings\n return best[-1][1]\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # if there are multiple soluitons, return the one with min total length\n\n # first = {}\n # last = {}\n # count = {}\n # for i, c in enumerate(s):\n # if c not in first: first[c] = i\n # last[c] = i\n # count[c] = count.get(c, 0) + 1\n\n # bounds = list((first[c], last[c], count[c], c) for c in first)\n # C = len(bounds)\n\n # @cache\n # def best(l: int, r: int, i: int) -> list[tuple[int, chr]]:\n # \"\"\"Returns the best answer for l..r for the letters indexed i:\"\"\"\n\n # if i == C: return []\n\n\n # lc, rc, nc, c = bounds[i]\n\n # # base case: don't take c\n # ans = best(l, r, i+1)\n\n # if l <= lc and rc <= r:\n # cand = [(nc, c)]\n # cand.extend(best(l, lc-1, i+1))\n # cand.extend(best(rc+1, r, i+1))\n # if len(cand) > len(ans):\n # ans = cand\n # elif len(cand) == len(ans) and sum(e[0] for e in cand) < sum(e[0] for e in ans):\n # ans = cand\n\n # return ans\n\n # ans = best(0, len(s)-1, 0)\n # return list(c*f for f, c in ans)","runtime":"379"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n intervals = []\n for c in set(s):\n b, e = fst[c], lst[c]\n i = b\n while i <= e and b == fst[c]:\n b = min(b, fst[s[i]])\n e = max(e, lst[s[i]])\n i += 1\n if b == fst[c]:\n intervals.append((e, b))\n \n intervals.sort()\n ans, prev = [], -1\n for e, b in intervals:\n if b > prev:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","runtime":"428"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n start_i, end_i = start, end\n for c in set(s[start:end]):\n print(\"for \", c, ref[c][0], ref[c][-1])\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n if (start, end) != (start_i, end_i):\n return isValid(start, end)\n return (start, end)\n\n for c in set(s):\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1]) \n print(substrs)\n res = []\n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]\n \n \n \n \n \n \n \n ","runtime":"428"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n ans, prev = [], -1\n for i in sorted(lst.values()):\n b, e = fst[s[i]], lst[s[i]]\n j = e\n while j >= b and b > prev and e == i:\n b = min(b, fst[s[j]])\n e = max(e, lst[s[j]])\n j -= 1\n if b > prev and e == i:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","runtime":"476"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n intervals = []\n for c in set(s):\n b, e = fst[c], lst[c]\n i = b\n while i <= e and b == fst[c]:\n b = min(b, fst[s[i]])\n e = max(e, lst[s[i]])\n i += 1\n if b == fst[c]:\n intervals.append((e, b))\n \n intervals.sort()\n ans, prev = [], -1\n for e, b in intervals:\n if b > prev:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","runtime":"476"},{"code":"from typing import List\n\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n first = {c: float('inf') for c in set(s)}\n last = {c: float('-inf') for c in set(s)}\n \n for i, c in enumerate(s):\n first[c] = min(first[c], i)\n last[c] = max(last[c], i)\n \n def get_valid_interval(start):\n end = last[s[start]]\n j = start\n while j <= end:\n if first[s[j]] < start:\n return None\n end = max(end, last[s[j]])\n j += 1\n return (start, end)\n \n intervals = []\n for i in range(len(s)):\n if i == first[s[i]]:\n interval = get_valid_interval(i)\n if interval:\n intervals.append(interval)\n \n intervals.sort(key=lambda x: x[1])\n \n ans = []\n prev_end = -1\n for start, end in intervals:\n if start > prev_end:\n ans.append(s[start:end+1])\n prev_end = end\n \n return ans","runtime":"525"},{"code":"class Solution:\n def isOverlap(self, res, start, end):\n for (currStart, currEnd) in res:\n if currStart <= start and start <= currEnd:\n return True\n \n if currStart <= end and end <= currEnd:\n return True\n\n if start <= currStart and currStart <= end:\n return True\n \n\n return False\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n left = [float(\"inf\") for i in range(26)]\n right = [float(\"-inf\") for i in range(26)]\n intervals = []\n\n for i, c in enumerate(s):\n idx = ord(c) - ord('a')\n left[idx] = min(left[idx], i)\n right[idx] = max(right[idx], i)\n \n for i in range(26):\n start = left[i]\n end = right[i]\n valid = True\n if start != float(\"inf\"):\n idx = start\n while idx < end:\n if left[ord(s[idx]) - ord('a')] < start:\n valid = False\n break\n\n end = max(end, right[ord(s[idx]) - ord('a')])\n idx += 1\n \n if valid:\n intervals.append((start, end))\n\n intervals.sort(key=lambda x: ((x[1] - x[0], x[0])))\n\n res = []\n for (start, end) in intervals:\n if not self.isOverlap(res, start, end):\n res.append((start, end))\n\n return [s[start:end+1] for (start, end) in res]","runtime":"525"},{"code":"class Solution:\n def create_graph(self, s, dic):\n graph = {}\n for k in dic.keys():\n graph[k] = set()\n\n for k, v in dic.items():\n i, j = v\n\n for c in s[i : j + 1]:\n if c != k:\n graph[c].add(k)\n \n return graph\n \n def reverse_graph(self, graph):\n graph2 = {}\n for k in graph.keys():\n graph2[k] = set()\n\n for u, vs in graph.items():\n\n for v in vs:\n graph2[v].add(u)\n \n return graph2\n \n\n def topological_sort(self, graph):\n def dfs(u):\n visited.add(u)\n\n if u in graph:\n for v in graph[u]:\n if v not in visited:\n dfs(v)\n \n topo.append(u)\n\n topo = []\n visited = set()\n for u in graph.keys():\n if u not in visited:\n dfs(u)\n \n topo.reverse()\n return topo\n \n\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\n visited2.add(u)\n mmin[0] = min(mmin[0], dic[u][0])\n mmax[0] = max(mmax[0], dic[u][1])\n\n for v in graph[u]:\n if v in visited:\n return False\n \n if v in visited2:\n continue\n \n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\n return False\n \n return True\n\n \n\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n dic = {}\n for i, c in enumerate(s):\n if c not in dic:\n dic[c] = [i, i]\n else:\n dic[c][1] = i\n\n graph = self.create_graph(s, dic)\n print(graph)\n topo = self.topological_sort(graph)\n print(topo)\n\n graph_rev = self.reverse_graph(graph)\n print(\"reverse graph\", graph_rev)\n visited = set()\n ans = []\n for u in topo:\n if u in visited:\n continue\n \n visited2 = set()\n mmin = [math.inf]\n mmax = [-math.inf]\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\n if is_possible:\n visited = visited.union(visited2)\n ans.append(s[mmin[0] : mmax[0] + 1])\n \n return ans\n ","runtime":"573"},{"code":"class Solution:\n def create_graph(self, s, dic):\n graph = {}\n for k in dic.keys():\n graph[k] = set()\n\n for k, v in dic.items():\n i, j = v\n\n for c in s[i : j + 1]:\n if c != k:\n graph[c].add(k)\n \n return graph\n \n def reverse_graph(self, graph):\n graph2 = {}\n for k in graph.keys():\n graph2[k] = set()\n\n for u, vs in graph.items():\n\n for v in vs:\n graph2[v].add(u)\n \n return graph2\n \n\n def topological_sort(self, graph):\n def dfs(u):\n visited.add(u)\n\n if u in graph:\n for v in graph[u]:\n if v not in visited:\n dfs(v)\n \n topo.append(u)\n\n topo = []\n visited = set()\n for u in graph.keys():\n if u not in visited:\n dfs(u)\n \n topo.reverse()\n return topo\n \n\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\n visited2.add(u)\n mmin[0] = min(mmin[0], dic[u][0])\n mmax[0] = max(mmax[0], dic[u][1])\n\n for v in graph[u]:\n if v in visited:\n return False\n \n if v in visited2:\n continue\n \n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\n return False\n \n return True\n\n \n\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n dic = {}\n for i, c in enumerate(s):\n if c not in dic:\n dic[c] = [i, i]\n else:\n dic[c][1] = i\n\n graph = self.create_graph(s, dic)\n topo = self.topological_sort(graph)\n\n graph_rev = self.reverse_graph(graph)\n visited = set()\n ans = []\n for u in topo:\n if u in visited:\n continue\n \n visited2 = set()\n mmin = [math.inf]\n mmax = [-math.inf]\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\n if is_possible:\n visited = visited.union(visited2)\n ans.append(s[mmin[0] : mmax[0] + 1])\n \n return ans\n ","runtime":"622"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n\n def find_right_from_left(s, first, last, left):\n right, i = last[ord(s[left]) - ord(\"a\")], left\n while i <= right:\n if first[ord(s[i]) - ord(\"a\")] < left:\n return -1\n right = max(right, last[ord(s[i]) - ord(\"a\")])\n i += 1\n return right\n\n first, last = [float(\"inf\")] * 26, [float(\"-inf\")] * 26\n for i, c in enumerate(s):\n first[ord(c) - ord(\"a\")] = min(first[ord(c) - ord(\"a\")], i)\n last[ord(c) - ord(\"a\")] = max(last[ord(c) - ord(\"a\")], i)\n result = [\"\"]\n right = float(\"inf\")\n for left, c in enumerate(s):\n if left != first[ord(c) - ord(\"a\")]:\n continue\n new_right = find_right_from_left(s, first, last, left)\n if new_right == -1:\n continue\n if left > right:\n result.append(\"\")\n right = new_right\n result[-1] = s[left : right + 1]\n return result\n","runtime":"622"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n letlength=defaultdict(list)\n letheap=[]\n for i in range(len(s)):\n if s[i] in letlength:\n if i<letlength[s[i]][0]:\n letlength[s[i]][0]=i\n if i>letlength[s[i]][1]:\n letlength[s[i]][1]=i\n else:\n letlength[s[i]]=[i,i]\n pool=[]\n for letter in letlength:\n start,end=letlength[letter]\n temp=set()\n temp.add(letter)\n ogstart,ogend=start,end\n while start<=end:\n if s[start] not in temp:\n start=min(start,letlength[s[start]][0])\n ogstart=min(start,ogstart)\n end=max(end,letlength[s[start]][1])\n ogend=max(end,ogend)\n temp.add(s[start])\n else:\n start+=1\n # print(start,end+1)\n pool.append([s[ogstart:ogend+1],ogstart,ogend])\n pool=sorted(pool,key= lambda x:len(x[0]))\n # print(pool)\n minind=float('inf')\n maxind=-1\n res=[]\n for sub,start,end in pool:\n canadd=True\n for _,restart,resend in res:\n if start<=restart and end>=resend:\n canadd=False\n if canadd:\n res.append([sub,start,end])\n return [i[0] for i in res]\n ","runtime":"670"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n last, interval = {}, {}\n for i, c in enumerate(s):\n last[c] = i + 1\n if c not in interval:\n interval[c] = set(''.join(s.split(c)[1:-1]))\n \n parent = {c: c for c in s}\n \n def find(x):\n if parent[x] != x:\n parent[x] = find(parent[x])\n return parent[x]\n \n def union(x, y):\n parent[find(x)] = find(y)\n return\n \n for c in interval:\n for n in interval[c]:\n if c in interval[n]:\n union(c, n)\n \n splits, max_splits = [(s, 0)], []\n \n while splits:\n \n splits_cut = []\n for string, start in splits:\n left = right = 0 \n for i, c in enumerate(string):\n right = max(right, last[c] - start)\n if i == right - 1:\n splits_cut.append((string[left:right], start + left))\n left = right\n \n splits_rem = []\n for string, start in splits_cut:\n len_splits_rem = len(splits_rem)\n redundant = find(string[0])\n \n left = 0\n while left < len(string):\n if find(string[left]) == redundant:\n left += 1\n else:\n right = left\n while right < len(string) and find(string[right]) != redundant:\n right += 1\n splits_rem.append((string[left:right], start + left))\n left = right\n\n if len_splits_rem == len(splits_rem):\n max_splits.append(string)\n\n splits = splits_rem\n \n return max_splits","runtime":"670"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = {}\n for i in range(len(s)):\n if s[i] in d:\n d[s[i]][1] = i\n else:\n d[s[i]] = [i, i]\n for key in d:\n start, end = d[key]\n q = deque([(start, end)])\n while q:\n scur, ecur = q.popleft()\n for i in range(scur, ecur + 1):\n snew, enew = d[s[i]]\n if snew < start:\n q.append((snew, start - 1))\n start = snew\n if enew > end:\n q.append((end + 1, enew))\n end = enew\n d[key] = [start, end]\n\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\n seen = []\n ans = []\n for start, end in sorted_ranges:\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\n continue\n ans.append(s[start: end + 1])\n seen.append((start, end))\n return ans","runtime":"719"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n indices = char_indices(s)\n merge_indices(s, indices)\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\n result = []\n for substring in substrings:\n if not contains_substring(result, substring):\n result.append(substring)\n return result\n\n\ndef substring_chars(s: str) -> Set[str]:\n return set(c for c in s)\n\ndef char_indices(s: str) -> Dict[str, List[int]]:\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\n\ndef contains_substring(ls: List[str], ss: str):\n for s in ls:\n if s in ss:\n return True\n return False\n\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\n for c in indices:\n changed = True\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\n prev_chars.discard(c)\n while changed:\n for other_c in prev_chars:\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\n chars.discard(c)\n changed = prev_chars != chars\n prev_chars = chars","runtime":"719"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = {}\n for i in range(len(s)):\n if s[i] in d:\n d[s[i]][1] = i\n else:\n d[s[i]] = [i, i]\n for key in d:\n start, end = d[key]\n q = deque([(start, end)])\n while q:\n scur, ecur = q.popleft()\n for i in range(scur, ecur + 1):\n snew, enew = d[s[i]]\n if snew < start:\n q.append((snew, start - 1))\n start = snew\n if enew > end:\n q.append((end + 1, enew))\n end = enew\n d[key] = [start, end]\n\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\n seen = []\n ans = []\n for start, end in sorted_ranges:\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\n continue\n ans.append(s[start: end + 1])\n seen.append((start, end))\n return ans","runtime":"767"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = {}\n for i in range(len(s)):\n if s[i] in d:\n d[s[i]][1] = i\n else:\n d[s[i]] = [i, i]\n for key in d:\n start, end = d[key]\n q = deque([(start, end)])\n while q:\n scur, ecur = q.popleft()\n for i in range(scur, ecur + 1):\n snew, enew = d[s[i]]\n if snew < start:\n q.append((snew, start - 1))\n start = snew\n if enew > end:\n q.append((end + 1, enew))\n end = enew\n d[key] = [start, end]\n\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\n seen = []\n ans = []\n for start, end in sorted_ranges:\n if any(end >= s1 and e1 >= start for s1, e1 in seen):\n continue\n ans.append(s[start: end + 1])\n seen.append((start, end))\n return ans","runtime":"767"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n m={}\n for i,ch in enumerate(s):\n if ch not in m: m[ch]=[i,i]\n else: m[ch][1] = i\n res, st, start = [], [], -1\n for ind,ch in enumerate(s):\n if st and st[-1][1] == ind:\n i,j,_ = st.pop()\n if i>start:\n res.append(s[i:j+1])\n start=j\n continue\n i,j = m[ch]\n setch = {ch}\n if i==j:\n res.append(s[i])\n start=j\n continue\n while st and (st[-1][0]>=i or st[-1][1]<=j or ch in st[-1][2]):\n x = st.pop()\n i,j = min(i, x[0]), max(j, x[1])\n setch.update(x[2])\n st.append((i,j,setch))\n return res","runtime":"815"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n m={}\n for i,ch in enumerate(s):\n if ch not in m: m[ch]=[i,i]\n else: m[ch][1] = i\n res, st, start = [], [], -1\n for ind,ch in enumerate(s):\n if st and st[-1][1] == ind:\n i,j,_ = st.pop()\n if i>start:\n res.append(s[i:j+1])\n start=j\n continue\n i,j = m[ch]\n setch = {ch}\n if i==j:\n res.append(s[i])\n start=j\n continue\n while st and (st[-1][0]>=i or st[-1][1]<=j or ch in st[-1][2]):\n x = st.pop()\n i,j = min(i, x[0]), max(j, x[1])\n setch.update(x[2])\n st.append((i,j,setch))\n return res\n \n ","runtime":"815"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n letter_range=defaultdict(list)\n for i,c in enumerate(s):\n if c not in letter_range:\n letter_range[c].extend([i,i])\n else:\n letter_range[c][1]=i\n #try to expand the range for each letter\n for key in letter_range:\n start,end=letter_range[key]\n stack=[(start,end)]\n while stack:\n cur_s,cur_e=stack.pop()\n for i in range(cur_s,cur_e+1):\n new_s,new_e=letter_range[s[i]]\n if new_s<start:\n stack.append((new_s,start-1))\n start=new_s\n if new_e>end:\n stack.append((end+1,new_e))\n end=new_e\n letter_range[key]=(start,end)\n sorted_ranges=sorted(letter_range.values(),key=lambda x:x[1]-x[0])\n seen_ranges=[]\n ans=[]\n for start,end in sorted_ranges:\n if any(end>=s1 and e1>=start for s1,e1 in seen_ranges):\n continue\n seen_ranges.append((start,end))\n ans.append(s[start:end+1])\n return ans\n\n ","runtime":"864"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = defaultdict(list)\n for i, c in enumerate(s):\n d[c].append(i)\n new = defaultdict(list)\n for i in range(26):\n if chr(i+97) not in d: continue\n idx = d[chr(i+97)][0]\n mx = 0\n for j in range(idx, len(s)):\n mx = max(mx, d[s[j]][-1])\n if idx > d[s[j]][0]: break\n if j == mx:\n new[idx].append(j+1)\n break\n @cache\n def dp(idx):\n if idx == len(s): return []\n res = dp(idx+1)\n for ch in new[idx]:\n if len(dp(ch))+1 > len(res):\n res = [s[idx:ch]]+dp(ch)\n return res\n return dp(0)","runtime":"864"},{"code":"\"\"\"\nadefaddaccc\na: 0, 7\nc: 8, 10\nd: 1, 6\ne: 2, 2\nf: 3, 3\n\na: [d: [a, e, f], e: [], f: []]\nc: []\n\nabhahbccd\n\na: [b]\nb: [a]\nh: [a]\nc: []\nd: []\n\n\"\"\"\n\nclass Solution:\n def make_alphabet(self, s: str) -> dict[str, list[int]]:\n alpha = {}\n for i, ch in enumerate(s):\n if ch not in alpha:\n alpha[ch] = [i]\n continue\n if len(alpha[ch]) == 1:\n alpha[ch].append(i)\n else:\n alpha[ch][-1] = i\n return alpha\n \n def del_tree(self, graph: dict, root: str):\n if root not in graph:\n return\n children = graph[root]\n del graph[root]\n for child in children:\n self.del_tree(graph, child)\n \n def clean_tree(self, graph: dict):\n keys = list(graph.keys())\n for k in keys:\n if not graph[k]:\n for v in graph.values():\n v.discard(k)\n del graph[k]\n self.clean_tree(graph)\n return\n \n def maxNumOfSubstrings(self, s: str) -> List[str]:\n al = self.make_alphabet(s)\n #print(f'{al=}')\n gr = {ch: set() for ch in set(s)}\n nodes = set()\n for ch in set(s):\n for i in range(al[ch][0], al[ch][-1] + 1):\n if s[i] != ch:\n gr[s[i]].add(ch)\n nodes.add(ch)\n #print(f'{gr=}')\n \n roots = set(s) - nodes\n #print(f'{roots=}')\n output = []\n for root in roots:\n output.append(s[al[root][0]:al[root][-1] + 1])\n self.del_tree(gr, root)\n #print(f'{output=}\\n{gr=}')\n \n \n self.clean_tree(gr)\n #print(f'cleaned {gr=}')\n \n while gr:\n to_go = list(gr.keys())[0:1]\n st, fin = None, None\n while to_go:\n curr = to_go.pop()\n if curr not in gr:\n continue\n if not gr[curr]:\n del gr[curr]\n continue\n to_go.extend(gr[curr])\n curr_st, curr_fin = al[curr][0], al[curr][-1] + 1\n st = curr_st if st is None else min(st, curr_st)\n fin = curr_fin if fin is None else max(fin, curr_fin)\n del gr[curr]\n if st is not None:\n output.append(s[st:fin])\n \n return output\n \n \n \n ","runtime":"961"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Identifica os intervalos válidos para cada caractere\n intervals = {}\n for i, char in enumerate(s):\n if char in intervals:\n intervals[char][1] = i\n else:\n intervals[char] = [i, i]\n # Em seguida, expandimos os intervalos para atender às condições\n valid_intervals = []\n for interval in intervals.values():\n start, end = interval[0], interval[1]\n i = start\n while i <= end:\n if intervals[s[i]][0] < start:\n start = intervals[s[i]][0]\n i = start\n if intervals[s[i]][1] > end:\n end = intervals[s[i]][1]\n i += 1\n valid_intervals.append([start, end])\n\n # Ordenamos os intervalos pelo fim em ordem crescente\n valid_intervals.sort(key=lambda x: x[1])\n\n # Construímos as substrings usando os intervalos válidos\n result = []\n prev_end = float('-inf')\n\n for start, end in valid_intervals:\n if start > prev_end:\n result.append(s[start:end+1])\n prev_end = end\n return result","runtime":"1009"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Identifica os intervalos válidos para cada caractere\n intervals = {}\n for i, char in enumerate(s):\n if char in intervals:\n intervals[char][1] = i\n else:\n intervals[char] = [i, i]\n # Em seguida, expandimos os intervalos para atender às condições\n valid_intervals = []\n for interval in intervals.values():\n start, end = interval[0], interval[1]\n i = start\n while i <= end:\n if intervals[s[i]][0] < start:\n start = intervals[s[i]][0]\n i = start\n if intervals[s[i]][1] > end:\n end = intervals[s[i]][1]\n i += 1\n valid_intervals.append([start, end])\n\n # Ordenamos os intervalos pelo fim em ordem crescente\n valid_intervals.sort(key=lambda x: x[1])\n\n # Construímos as substrings usando os intervalos válidos\n result = []\n prev_end = float('-inf')\n for interval in valid_intervals:\n start, end = interval[0], interval[1]\n if start > prev_end:\n result.append(s[start:end+1])\n prev_end = end\n\n return result","runtime":"1058"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Primeiro, identificamos os intervalos válidos para cada caractere\n intervals = {}\n for i, char in enumerate(s):\n if char not in intervals:\n intervals[char] = [i, i]\n else:\n intervals[char][1] = i\n\n # Em seguida, expandimos os intervalos para atender às condições\n valid_intervals = []\n for interval in intervals.values():\n start, end = interval[0], interval[1]\n i = start\n while i <= end:\n if intervals[s[i]][0] < start:\n start = intervals[s[i]][0]\n i = start\n if intervals[s[i]][1] > end:\n end = intervals[s[i]][1]\n i += 1\n valid_intervals.append([start, end])\n\n # Ordenamos os intervalos pelo fim em ordem crescente\n valid_intervals.sort(key=lambda x: x[1])\n\n # Construímos as substrings usando os intervalos válidos\n result = []\n prev_end = float('-inf')\n for interval in valid_intervals:\n start, end = interval[0], interval[1]\n if start > prev_end:\n result.append(s[start:end+1])\n prev_end = end\n\n return result","runtime":"1058"},{"code":"class Solution:\n def maxNumOfSubstrings(self, S: str) -> List[str]:\n mins = [float('inf')]*26\n maxs = [-1]*26\n exists = [False]*26\n prefix_sum = [[0]*26 for _ in range(len(S)+1)]\n\n for i,char in enumerate(S):\n prefix_sum[i+1]=prefix_sum[i][:]\n prefix_sum[i+1][ord(char)-ord('a')]+=1\n mins[ord(char)-ord('a')] = min(mins[ord(char)-ord('a')],i)\n maxs[ord(char)-ord('a')] = max(maxs[ord(char)-ord('a')],i)\n exists[ord(char)-ord('a')]=True\n\n graph = [[False]*26 for _ in range(26)]\n for i in range(26):\n if exists[i]:\n for j in range(26):\n if prefix_sum[maxs[i]+1][j]-prefix_sum[mins[i]][j]>0:\n graph[i][j]=True\n\n stack = []\n visited = [False]*26\n\n def dfs1(v):\n if not visited[v]:\n visited[v]=True\n for i in range(26):\n if graph[v][i] and not visited[i]:\n dfs1(i)\n stack.append(v)\n \n for i in range(26):\n if exists[i] and not visited[i]:\n dfs1(i)\n\n batch = 0\n batches = [-1]*26\n degree = [0]*26\n\n def dfs2(v,batch):\n if batches[v]<0:\n batches[v]=batch\n for i in range(26):\n if graph[i][v]:\n dfs2(i,batch)\n else:\n if batches[v]!=batch:\n degree[batches[v]]+=1\n while stack:\n v = stack.pop()\n if batches[v]<0:\n dfs2(v,batch)\n batch+=1\n\n res = []\n for i in range(batch -1,-1,-1):\n if degree[i]==0:\n min_idx = float('inf')\n max_idx = -1\n for j in range(26):\n if batches[j]==i:\n min_idx = min(mins[j],min_idx)\n max_idx = max(maxs[j],max_idx)\n res.append(S[min_idx:max_idx+1])\n return res","runtime":"1106"},{"code":"from collections import Counter\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n # graph = [[] for _ in range((len(s)))]\n\n count = Counter(s)\n\n original_count = Counter(s)\n\n ans = []\n\n isDone = [False] * len(s)\n\n first_pos = {}\n\n parent = -1\n\n # graph[len(s)-1].append(0)\n\n for i in range(len(s)):\n count[s[i]] -= 1\n\n if s[i] not in first_pos:\n first_pos[s[i]] = i\n \n if count[s[i]] == 0:\n start = first_pos[s[i]]\n begin = start\n\n while start <= i:\n if first_pos[s[start]] < begin:\n start = first_pos[s[start]]\n begin = start\n start += 1\n \n start = begin\n temp_count = Counter(s[start : i+1])\n\n while start <= i:\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\n break\n start += 1\n \n if start > i:\n isDone[i] = True\n # print(s[begin : i + 1], isDone, sep = '->')\n ans.append(s[begin : i + 1])\n \n if len(ans) == 0:\n ans.append(s)\n print(ans)\n\n return ans","runtime":"1106"},{"code":"from collections import Counter\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n # graph = [[] for _ in range((len(s)))]\n\n count = Counter(s)\n\n original_count = Counter(s)\n\n ans = []\n\n isDone = [False] * len(s)\n\n first_pos = {}\n\n parent = -1\n\n # graph[len(s)-1].append(0)\n\n for i in range(len(s)):\n count[s[i]] -= 1\n\n if s[i] not in first_pos:\n first_pos[s[i]] = i\n \n if count[s[i]] == 0:\n start = first_pos[s[i]]\n begin = start\n\n while start <= i:\n if first_pos[s[start]] < begin:\n start = first_pos[s[start]]\n begin = start\n start += 1\n \n start = begin\n temp_count = Counter(s[start : i+1])\n\n while start <= i:\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\n break\n start += 1\n \n if start > i:\n isDone[i] = True\n # print(s[begin : i + 1], isDone, sep = '->')\n ans.append(s[begin : i + 1])\n \n if len(ans) == 0:\n ans.append(s)\n print(ans)\n\n return ans","runtime":"1154"},{"code":"from collections import Counter\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n # graph = [[] for _ in range((len(s)))]\n\n count = Counter(s)\n\n original_count = Counter(s)\n\n ans = []\n\n isDone = [False] * len(s)\n\n first_pos = {}\n\n parent = -1\n\n # graph[len(s)-1].append(0)\n\n for i in range(len(s)):\n count[s[i]] -= 1\n\n if s[i] not in first_pos:\n first_pos[s[i]] = i\n \n if count[s[i]] == 0:\n start = first_pos[s[i]]\n begin = start\n\n while start <= i:\n if first_pos[s[start]] < begin:\n start = first_pos[s[start]]\n begin = start\n start += 1\n \n start = begin\n temp_count = Counter(s[start : i+1])\n\n while start <= i:\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\n break\n start += 1\n \n if start > i:\n isDone[i] = True\n # print(s[begin : i + 1], isDone, sep = '->')\n ans.append(s[begin : i + 1])\n \n if len(ans) == 0:\n ans.append(s)\n print(ans)\n\n return ans","runtime":"1203"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Step 1: Determine the start and end indices of each character\n start_idx = {}\n end_idx = {}\n for i, c in enumerate(s):\n if c not in start_idx:\n start_idx[c] = i\n end_idx[c] = i\n \n # Step 2: Extend the intervals\n intervals = []\n for c in start_idx.keys():\n left = start_idx[c]\n right = end_idx[c]\n while True:\n for i in range(left, right + 1):\n if start_idx[s[i]] < left:\n left = start_idx[s[i]]\n if end_idx[s[i]] > right:\n right = end_idx[s[i]]\n if left == start_idx[c] and right == end_idx[c]:\n break\n start_idx[c] = left\n end_idx[c] = right\n intervals.append((left, right))\n \n # Step 3: Merge overlapping intervals\n intervals.sort(key=lambda x: x[1])\n result = []\n current_end = -1\n for start, end in intervals:\n if start > current_end:\n result.append(s[start:end + 1])\n current_end = end\n \n return result\n\n# Example usage:\nsolution = Solution()\ns = \"adefaddaccc\"\nprint(solution.maxNumOfSubstrings(s)) # Output: [\"e\",\"f\",\"ccc\"]","runtime":"1251"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n chars = \"abcdefghijklmnopqrstuvwxyz\"\n cache = {}\n n = len(s)\n for ch in chars:\n i = 0\n start, end = -1, -1\n while i < n:\n if s[i] == ch:\n start = i\n break\n i += 1\n j = n - 1\n while j >= 0:\n if s[j] == ch:\n end = j\n break\n j -= 1\n if start != -1:\n cache[ch] = [start, end]\n intervals = []\n for ch in chars:\n if ch in cache:\n seen = set(ch)\n start = cache[ch][0]\n end = cache[ch][1]\n needed = True\n while needed:\n needed = False\n ranges = []\n for i in range(start, end):\n if s[i] not in seen:\n needed = True\n ranges.append(cache[s[i]])\n seen.add(s[i])\n for r in ranges:\n start = min(start, r[0])\n end = max(end, r[1])\n intervals.append([start, end])\n intervals.sort(key = lambda x: x[1])\n res = [[] for i in range(len(intervals))]\n res[0] = [[intervals[0]],(intervals[0][1] - intervals[0][0] + 1) ]\n for j in range(1, len(intervals)):\n interval = intervals[j]\n k = j - 1\n while k >= 0 and intervals[k][1] > interval[0]:\n k -= 1\n count = 1 + (0 if k == -1 else len(res[k][0]))\n if count > len(res[j - 1][0]):\n res[j] = [res[k][0] + [interval], res[k][1] + (interval[1] - interval[0] + 1)]\n elif count <= len(res[j - 1][0]):\n res[j] = res[j - 1]\n res.sort(key = lambda x: (len(x[0]), -x[1]))\n ans = []\n for r in res[-1][0]:\n ans.append(s[r[0]: r[1] + 1])\n return ans\n \n\n","runtime":"1300"},{"code":"class Solution:\n def construct(self,exists,prefixsum,charstarts,charends):\n graph=[[False for _ in range(26)] for _ in range(26)]\n for vertex in range(26):\n if exists[vertex]:\n charstart,charend=charstarts[vertex],charends[vertex]\n for nbr in range(26):\n nbrcount=prefixsum[charend+1][nbr]-prefixsum[charstart][nbr]\n if nbrcount>0:\n graph[vertex][nbr] = True\n return graph\n \n def topo(self,graph,exists):\n st,vis=[],[False for _ in range(26)]\n def dfs(vertex):\n vis[vertex]=True\n for nbr in range(26):\n if graph[vertex][nbr] and not vis[nbr]:\n dfs(nbr)\n st.append(vertex)\n for vertex in range(26):\n if exists[vertex] and not vis[vertex]:\n dfs(vertex)\n return st\n \n def getandbatchesoutdegree(self,graph,st):\n batches,degree,totalbatches=[-1 for _ in range(26)],[False for _ in range(26)],0\n def dfs(vertex):\n vertexbatch=batches[vertex]\n if vertexbatch<0:\n batches[vertex]=totalbatches\n for nbr in range(26):\n if graph[nbr][vertex]:\n dfs(nbr)\n else:\n if vertexbatch!=totalbatches:\n degree[vertexbatch]+=1\n while st:\n vertex=st.pop()\n vertexbatch=batches[vertex]\n if vertexbatch<0:\n dfs(vertex)\n totalbatches+=1\n return batches,degree,totalbatches\n \n def maxNumOfSubstrings(self, s: str) -> List[str]:\n length=len(s)\n charstarts=[float(\"inf\") for _ in range(26)]\n charends=[-1 for _ in range(26)]\n exists=[False for _ in range(26)]\n prefixsum = [[0 for _ in range(26)] for _ in range(length+1)]\n for index,char in enumerate(s):\n prefixsum[index+1]=prefixsum[index][:]\n charidx=ord(char)-ord('a')\n exists[charidx]=True\n charstarts[charidx]=min(charstarts[charidx],index)\n charends[charidx]=max(charends[charidx],index)\n prefixsum[index+1][charidx]+=1\n graph=self.construct(exists,prefixsum,charstarts,charends)\n st=self.topo(graph,exists)\n batches,degree,totalbatches=self.getandbatchesoutdegree(graph,st)\n res=[]\n for batch in range(totalbatches):\n if degree[batch]==0:\n mini,maxi=float(\"inf\"),-1\n for vertex in range(26):\n vertexbatch=batches[vertex]\n if batch==vertexbatch:\n mini=min(mini,charstarts[vertex])\n maxi=max(maxi,charends[vertex])\n res.append(s[mini:maxi+1])\n return res","runtime":"1348"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n map = {}\n interval = []\n for i in range(n):\n if map.get(s[i]):\n map[s[i]][1] = i\n else:\n map[s[i]] = [i,i]\n\n for i in range(n):\n if map[s[i]][0] == i:\n left = i\n right = map[s[i]][1]\n\n j = left\n flag = True\n while j <= right:\n if map[s[j]][0] < left:\n flag = False;\n right = max(right,map[s[j]][1])\n j+=1\n if flag:\n interval.append([left,right])\n interval.sort(key = lambda x : x[1])\n ans = []\n hi = -1\n for pair in interval:\n if pair[0] > hi:\n ans.append(s[pair[0]:pair[1]+1])\n hi = pair[1]\n return ans if ans else [s]\n\n ","runtime":"1397"},{"code":"from typing import List\n\n\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n\n\n first_and_last = {}\n for i in range(len(s)):\n if s[i] not in first_and_last:\n for j in range(len(s)-1,i-1,-1):\n if s[j]==s[i]:\n first_and_last[s[i]]=(i,j)\n break\n\n letters_in_between = {}\n for key in first_and_last.keys():\n t = [False for _ in range(26)]\n\n for i in range(first_and_last[key][0],first_and_last[key][1]):\n t[ord(s[i])-97]=True\n\n t[ord(key)-97]=False\n letters_in_between[key] = set()\n for i in range(26):\n if t[i]:\n letters_in_between[key].add(chr(i+97))\n\n\n\n intervals = []\n for key, value in first_and_last.items():\n intervals.append((value[0], value[1], key))\n\n some_change = True\n while some_change:\n intervals = sorted(intervals)\n\n some_change = False\n for i in range(len(intervals)):\n start,end,bukva = intervals[i]\n\n for letter in letters_in_between[bukva]:\n start = min(start,first_and_last[letter][0])\n end = max(end,first_and_last[letter][1])\n\n intervals[i] = [start,end,bukva]\n if start !=first_and_last[bukva][0] or end!=first_and_last[bukva][1]:\n some_change = True\n first_and_last[bukva]=(start,end)\n\n for i in range(len(intervals)):\n intervals[i][0], intervals[i][1] =intervals[i][1],intervals[i][0]\n for end,start,bukva in intervals:\n first_and_last[bukva]=(start,end)\n intervals = sorted(intervals)\n\n beginning_intervals = {}\n ending_intervals = {}\n\n d = [[] for _ in s]\n for i in range(len(intervals)):\n end,start,bukva = intervals[i]\n if end not in ending_intervals:\n ending_intervals[end]=[]\n if start not in beginning_intervals:\n beginning_intervals[start]=[]\n beginning_intervals[start].append((end,bukva))\n ending_intervals[end].append((start,bukva))\n\n if 0 in ending_intervals:\n d[0]=[[1,1,s[0]]] # howmany strings, total length all combined, which letters\n\n for i in range(1,len(s)):\n best = {}\n for j in d[i-1]:\n best[j[0]]=(j[1],j[2])\n\n if i in ending_intervals:\n for start,bukva in ending_intervals[i]:\n if 1 not in best or best[1][0]>i-start+1:\n best[1]=(i-start+1,bukva)\n\n\n if start-1>=0:\n for howmany,totallength,allletters in d[start-1]:\n if howmany+1 not in best or best[howmany+1][0]>totallength+i-start+1:\n best[howmany+1]=(totallength+ i-start+1, allletters+bukva)\n\n for j in range(1,27):\n if j in best:\n d[i].append((j, best[j][0],best[j][1]))\n else:\n break\n\n\n\n t = d[-1][-1][-1] # for the last dp index, take the last one, which is the most letters, and take the last index which can tell you with which letters you need to construct this\n\n ans = []\n for bukva in t:\n ans.append(s[first_and_last[bukva][0]: first_and_last[bukva][1]+1])\n\n return ans\n","runtime":"1445"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n map = {}\n interval = []\n for i in range(n):\n if map.get(s[i]):\n map[s[i]][1] = i\n else:\n map[s[i]] = [i,i]\n\n for i in range(n):\n if map[s[i]][0] == i:\n left = i\n right = map[s[i]][1]\n\n j = left\n flag = True\n while j <= right:\n if map[s[j]][0] < left:\n flag = False;\n right = max(right,map[s[j]][1])\n j+=1\n if flag:\n interval.append([left,right])\n print(interval)\n interval.sort(key = lambda x : x[1])\n ans = []\n hi = -1\n for pair in interval:\n if pair[0] > hi:\n ans.append(s[pair[0]:pair[1]+1])\n hi = pair[1]\n return ans if ans else [s]\n\n ","runtime":"1494"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Compute occurrency range for each character.\n occurrence = dict()\n for i, c in enumerate(s):\n if c not in occurrence:\n # New character.\n occurrence[c] = [i, i]\n else:\n # Update last occurrence of seen character.\n occurrence[c][1] = i\n \n # Align interval beginnings.\n open_intervals = set()\n for i, c in enumerate(s):\n # Update all open intervals.\n for o in open_intervals:\n if occurrence[o][0] > occurrence[c][0]:\n occurrence[o][0] = occurrence[c][0]\n if occurrence[o][1] < occurrence[c][1]:\n occurrence[o][1] = occurrence[c][1]\n open_intervals.add(c)\n open_intervals = {\n o\n for o in open_intervals\n if occurrence[o][1] != i\n }\n\n # Compute adjacency list.\n intervals = sorted(list(set(tuple(o) for o in occurrence.values())))\n n = len(intervals)\n adj_list = [list() for _ in range(n)]\n for i in range(n):\n for j in range(i + 1, n):\n if intervals[i][1] < intervals[j][0]:\n adj_list[i].append(j)\n\n # Compute longest path.\n HOP = len(s) + 1\n dist_to = [-float('inf')] * n\n edge_to = [-1] * n\n queue = deque()\n for i in range(n):\n dist_to[i] = intervals[i][0] - intervals[i][1]\n queue.append(i)\n while queue:\n i = queue.popleft()\n for nxt in adj_list[i]:\n dist = dist_to[i] + HOP + (intervals[nxt][0] - intervals[nxt][1])\n if dist_to[nxt] < dist:\n dist_to[nxt] = dist\n edge_to[nxt] = i\n queue.append(nxt)\n\n # Compute result.\n res = []\n idx = max(range(n), key=lambda i: dist_to[i])\n while idx != -1:\n res.append(s[intervals[idx][0]:intervals[idx][1] + 1])\n idx = edge_to[idx]\n return res","runtime":"1542"},{"code":"\"\"\"\n\"cabcccbaa\"\n\n\n\"bbcacbaba\"\n\n 0123456789\n\"bbeadcxede\" ->[\"bb\",\"a\",\"c\",\"x\"]\n\n\"abcdefghijklmnopqrstuvwxyz\"\n\n\"\"\"\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n def dp(idx, cur_list):\n if idx == len(condition_1_candidates):\n num_strs = len(cur_list)\n all_together_list = [s[x:y + 1] for x, y in cur_list]\n all_together = \"\".join(all_together_list)\n if result:\n prev_num = result[0]\n len_prev = result[1]\n if num_strs > prev_num:\n result[0] = num_strs\n result[1] = len(all_together)\n result[2] = all_together_list\n elif num_strs == prev_num and len(all_together) < len_prev:\n result[0] = num_strs\n result[1] = len(all_together)\n result[2] = all_together_list\n else:\n result.append(num_strs)\n result.append(len(all_together))\n result.append(all_together_list)\n\n return\n\n cur_i, cur_j = condition_1_candidates[idx]\n \n # always take it if it's once char\n if cur_i == cur_j:\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\n return\n\n is_cur_valid = True\n for i, j in cur_list:\n if cur_i <= i <= cur_j:\n is_cur_valid = False\n break\n if cur_i <= j <= cur_j:\n is_cur_valid = False\n break\n\n if is_cur_valid:\n # take it\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\n # or skip it\n dp(idx + 1, cur_list.copy())\n else:\n # skip it\n dp(idx + 1, cur_list.copy())\n\n char_to_start_end = {}\n for i, c in enumerate(s):\n if c in char_to_start_end:\n char_to_start_end[c][1] = i\n else:\n char_to_start_end[c] = [i, i]\n\n condition_1_candidates = set()\n for c, (s_i, e_i) in char_to_start_end.items():\n min_i = s_i\n min_j = e_i\n seen = set()\n seen.add(c)\n for j in range(s_i + 1, e_i):\n next_char = s[j]\n h = [char_to_start_end[next_char][0]]\n max_h = [-char_to_start_end[next_char][1]]\n while h[0] < min_i:\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\n min_i = min_i - 1\n\n while -max_h[0] > min_j:\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\n min_j = min_j + 1\n\n while h[0] < min_i:\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\n min_i = min_i - 1\n\n while -max_h[0] > min_j:\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\n min_j = min_j + 1\n\n condition_1_candidates.add((min_i, min_j))\n\n condition_1_candidates = list(condition_1_candidates)\n condition_1_candidates.sort(key=lambda x:abs(x[0] - x[1]))\n print(condition_1_candidates)\n result = []\n dp(0, [])\n\n return result[2]","runtime":"1590"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n left = defaultdict(int)\n right = defaultdict(int)\n chars = set()\n n = len(s)\n for c in s:\n chars.add(c)\n for c in chars:\n for i, c in enumerate(s):\n if c not in left:\n left[c] = i\n else:\n right[c] = i\n candidates = list()\n for c in chars:\n range_list = [[left[c],right[c]]]\n start, end = left[c], right[c]\n visited = set()\n while range_list:\n l,r = range_list.pop()\n next_start, next_end = l, r\n for i in range(l, r):\n if s[i] in visited:\n continue\n visited.add(s[i])\n next_end = max(right[s[i]], next_end)\n next_start = min(left[s[i]], next_start)\n if next_start != l:\n range_list.append([next_start, l])\n if next_end != r:\n range_list.append([r, next_end])\n start = min(next_start, start)\n end = max(end, next_end)\n candidates.append((start,end))\n\n def bisect(interval):\n if len(result) == 0:\n return 0\n l = 0\n r = len(result)\n while l < r:\n mid = l + (r-l)//2\n if result[mid][0] > interval[1]:\n r = mid\n elif result[mid][1] < interval[0]:\n l = mid + 1\n else:\n return -1\n return l\n candidates.sort(key=lambda x: x[1]-x[0])\n result = list()\n for candidate in candidates: \n i = bisect(candidate)\n if i >= 0:\n result.insert(i, candidate) \n return [s[l:r+1] for l,r in result]\n ","runtime":"1639"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n left = defaultdict(int)\n right = defaultdict(int)\n chars = set()\n n = len(s)\n for c in s:\n chars.add(c)\n if len(chars) == 26:\n break\n for c in chars:\n for i, c in enumerate(s):\n if c not in left:\n left[c] = i\n else:\n right[c] = i\n candidates = list()\n for c in chars:\n range_list = [[left[c],right[c]]]\n start, end = left[c], right[c]\n visited = set()\n while range_list:\n l,r = range_list.pop()\n next_start, next_end = l, r\n for i in range(l, r):\n if s[i] in visited:\n continue\n visited.add(s[i])\n next_end = max(right[s[i]], next_end)\n next_start = min(left[s[i]], next_start)\n if next_start != l:\n range_list.append([next_start, l])\n if next_end != r:\n range_list.append([r, next_end])\n start = min(next_start, start)\n end = max(end, next_end)\n candidates.append((start,end))\n\n def bisect(interval):\n if len(result) == 0:\n return 0\n l = 0\n r = len(result)\n while l < r:\n mid = l + (r-l)//2\n if result[mid][0] > interval[1]:\n r = mid\n elif result[mid][1] < interval[0]:\n l = mid + 1\n else:\n return -1\n return l\n candidates.sort(key=lambda x: x[1]-x[0])\n result = list()\n for candidate in candidates: \n i = bisect(candidate)\n if i >= 0:\n result.insert(i, candidate) \n return [s[l:r+1] for l,r in result]\n ","runtime":"1687"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n first = {}\n last = {}\n \n # Find the first and last occurrence of each character\n for i in range(n):\n if s[i] not in first:\n first[s[i]] = i\n last[s[i]] = i\n \n intervals = []\n \n # Generate valid intervals for each character\n for i in range(n):\n if first[s[i]] == i: # Only consider the first occurrence\n left = i\n right = last[s[i]]\n \n # Expand the interval to include all characters\n j = left\n while j <= right:\n left = min(left, first[s[j]])\n right = max(right, last[s[j]])\n j += 1\n \n # Only add the interval if it's still valid (start == first occurrence)\n if left == i:\n intervals.append((left, right))\n \n # Sort intervals by their end positions\n intervals.sort(key=lambda x: x[1])\n \n ans = []\n last_end = -1\n \n # Select non-overlapping intervals\n for start, end in intervals:\n if start > last_end:\n ans.append(s[start:end+1])\n last_end = end\n \n return ans\n","runtime":"1736"},{"code":"'''\n\n'''\n\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n N = len(s)\n \n left = right = 0\n starts = defaultdict(int)\n ends = defaultdict(int)\n for i in range(N):\n curr = s[i]\n if curr not in starts:\n starts[curr] = i\n for j in range(N-1, -1,- 1):\n curr = s[j]\n if curr not in ends:\n ends[curr] = j\n \n letters = set(list(s))\n ranges = []\n \n \n for i,curr in enumerate(letters):\n # r = (starts[curr], ends[curr])\n # ranges.append(r)\n left = starts[curr]\n right = ends[curr]\n new_left = left\n new_right = right\n \n j = left\n while j <= right:\n other = s[j]\n new_left = min(new_left, starts[other])\n right = new_right = max(new_right, ends[other])\n j += 1\n \n # if left == 2:\n # print(starts)\n # print(ends)\n # print(curr, (left, new_left), (right, new_right), s[new_left:new_right+1])\n \n if new_left == left:\n ranges.append((left,new_right))\n \n \n ranges.sort(key = lambda x:x[1])\n stack = []\n for a,b in ranges:\n if stack:\n c,d = stack[-1]\n if a <= c:\n continue\n else:\n stack.append((a,b))\n else:\n stack.append((a,b))\n \n return [s[i:j+1] for i,j in stack]\n \n ","runtime":"1784"},{"code":"from typing import List\n\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n first = {}\n last = {}\n \n # Record the first and last occurrence of each character\n for i, c in enumerate(s):\n if c not in first:\n first[c] = i\n last[c] = i\n \n intervals = []\n \n # Create intervals for each character\n for c in set(s):\n start, end = first[c], last[c]\n j = start\n while j <= end:\n start = min(start, first[s[j]])\n end = max(end, last[s[j]])\n j += 1\n intervals.append((start, end))\n \n # Sort intervals by end position, then by start position\n intervals.sort(key=lambda x: (x[1], x[0]))\n \n result = []\n prev_end = -1\n \n # Select non-overlapping intervals\n for start, end in intervals:\n if start > prev_end:\n # Check if the current interval is valid\n valid = True\n for i in range(start, end + 1):\n if first[s[i]] < start or last[s[i]] > end:\n valid = False\n break\n if valid:\n result.append(s[start:end+1])\n prev_end = end\n \n return result","runtime":"1833"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n curr_count = Counter(s[start:end])\n for c in s[start:end]:\n if count[c] != curr_count[c]:\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n return isValid(start, end)\n return (start, end)\n\n for i, c in enumerate(s):\n if i != ref[c][0]:\n continue\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1]) \n \n res = []\n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]","runtime":"1881"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n \n charBoundedSubstring = {}\n\n for i, c in enumerate(s):\n\n if c not in charBoundedSubstring:\n charBoundedSubstring[c] = [i, i]\n \n left = charBoundedSubstring[c][0]\n right = charBoundedSubstring[c][1]\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\n\n # print(charBoundedSubstring)\n intervals = []\n for alpha in set(s):\n left = charBoundedSubstring[alpha][0]\n right = charBoundedSubstring[alpha][1]\n leftMost, rightMost = left, right\n # print(left, right)\n i = left\n while i <= rightMost:\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\n i += 1\n # print(leftMost, rightMost)\n \n if leftMost == left:\n intervals.append((leftMost, rightMost))\n \n intervals.sort()\n res = []\n curStart, curEnd = intervals[0][0], intervals[0][1]\n for interval in intervals:\n start, end = interval\n \n if curStart < start < curEnd and curStart < end < curEnd:\n curStart, curEnd = start, end\n \n if start > curEnd and start > curStart:\n res.append(s[curStart: curEnd + 1])\n curStart = start\n curEnd = end\n print()\n res.append(s[curStart: curEnd + 1])\n print(intervals, res)\n # intervals.sort()\n return res\n\n\n","runtime":"1929"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n \n charBoundedSubstring = {}\n\n for i, c in enumerate(s):\n\n if c not in charBoundedSubstring:\n charBoundedSubstring[c] = [i, i]\n \n left = charBoundedSubstring[c][0]\n right = charBoundedSubstring[c][1]\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\n\n # print(charBoundedSubstring)\n intervals = []\n for alpha in set(s):\n left = charBoundedSubstring[alpha][0]\n right = charBoundedSubstring[alpha][1]\n leftMost, rightMost = left, right\n # print(left, right)\n i = left\n while i <= rightMost:\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\n i += 1\n # print(leftMost, rightMost)\n \n if leftMost == left:\n intervals.append((leftMost, rightMost))\n \n intervals.sort()\n res = []\n curStart, curEnd = intervals[0][0], intervals[0][1]\n for interval in intervals:\n start, end = interval\n \n if curStart < start < curEnd and curStart < end < curEnd:\n curStart, curEnd = start, end\n \n if start > curEnd and start > curStart:\n res.append(s[curStart: curEnd + 1])\n curStart = start\n curEnd = end\n # print()\n res.append(s[curStart: curEnd + 1])\n # print(intervals, res)\n # intervals.sort()\n return res\n\n\n","runtime":"1978"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n curr_count = Counter(s[start:end])\n #print(s[start:end], curr_count)\n for c in s[start:end]:\n if count[c] != curr_count[c]:\n #print(c, \"not it\")\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n return isValid(start, end)\n return (start, end)\n\n for i, c in enumerate(s):\n if i != ref[c][0]:\n continue\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n #print(\"got\", start, end, \"for\", i, c)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1])\n\n print(substrs)\n \n \n \n res = []\n \n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]\n \n \n \n \n \n \n \n ","runtime":"2026"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n crange = {}\n aset = []\n for i in range(len(s)):\n if s[i] not in crange:\n crange[s[i]] = []\n crange[s[i]].append(i)\n \n #print(crange)\n\n \n for p in crange.keys():\n i = crange[p][0]\n for _ in crange.keys():\n j = crange[_][-1]\n if i > j:\n continue\n valid = True\n #print(s[i],s[j])\n for k in range(i,j+1):\n if i <= crange[s[k]][0] and j >= crange[s[k]][-1]:\n continue\n else:\n valid = False\n break\n\n if valid:\n aset.append(s[i:j+1])\n\n aset.sort(key = lambda x : len(x))\n ansr = set()\n ans = []\n for i in aset:\n val = True\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\n if j in ansr:\n val = False\n break\n if val:\n ans.append(i)\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\n ansr.add(j)\n\n #print(aset)\n return ans","runtime":"2075"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n min_idx, max_idx = [n]*26, [-1]*26\n base_char_ord = ord(\"a\")\n\n for i in range(n):\n char_idx = ord(s[i]) - base_char_ord\n min_idx[char_idx] = min(i, min_idx[char_idx])\n max_idx[char_idx] = max(i, max_idx[char_idx])\n\n # print(*min_idx)\n # print(*max_idx)\n \n for char_idx in range(26):\n if min_idx[char_idx] == n : continue\n l = min_idx[char_idx]\n r = l\n while min_idx[char_idx] < l or r < max_idx[char_idx]:\n if min_idx[char_idx] < l:\n l -= 1\n new_char_idx = ord(s[l]) - base_char_ord\n min_idx[char_idx] = min(min_idx[new_char_idx], min_idx[char_idx])\n max_idx[char_idx] = max(max_idx[new_char_idx], max_idx[char_idx])\n if r < max_idx[char_idx]:\n r += 1\n new_char_idx = ord(s[r]) - base_char_ord\n min_idx[char_idx] = min(min_idx[new_char_idx], min_idx[char_idx])\n max_idx[char_idx] = max(max_idx[new_char_idx], max_idx[char_idx])\n # print(f\"for char : {char_idx} {s[min_idx[char_idx]:max_idx[char_idx]+1]}\")\n min_idx\n\n # print(min_idx[:10])\n # print(max_idx[:10])\n\n char_idxs_sorted = sorted(list(range(26)), key = lambda idx: (max_idx[idx], min_idx[idx]))\n ans = []\n prev_str_idx = -1\n\n for char_idx in char_idxs_sorted:\n l, r = min_idx[char_idx], max_idx[char_idx]\n if prev_str_idx >= l or l == n : \n continue\n ans.append(s[l:r+1])\n prev_str_idx = r\n\n return ans\n\n\n\n\n\n\n\n ","runtime":"2123"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n arr = [ord(c) - ord('a') for c in s]\n leftest = [-1] * 26\n rightest = [-1] * 26\n prefixsum = [[0 for _ in range(26)] for __ in range(n)]\n \n for i in range(n):\n x = arr[i]\n if leftest[x] == -1:\n leftest[x] = i\n rightest[x] = i\n prefixsum[i][x] = 1\n if i - 1 >= 0:\n for x in range(26):\n prefixsum[i][x] += prefixsum[i - 1][x]\n def check_exist(l, r, x):\n v = prefixsum[r][x]\n if l - 1 >= 0:\n v -= prefixsum[l - 1][x]\n return v > 0\n\n dp = [(0, 0, 0, -1, -1)] * n # dp[r2] = (max cnts, min total length at max cnts, l, r, prev r) at r where r <= r2\n for r in range(n):\n if r - 1 >= 0:\n dp[r] = dp[r - 1]\n \n l = r\n # find largest l such that s[l to r] is a valid substring\n chars = [0] * 26\n chars[arr[r]] = 1\n new_chars = [arr[r]]\n ok = True\n while new_chars: # This can happen for at most 26 times.\n x = new_chars.pop()\n if rightest[x] > r:\n ok = False\n break\n l = min(l, leftest[x])\n # Check for new characters in O(26)\n for i in range(26):\n if check_exist(l, r, i) and chars[i] == 0:\n new_chars.append(i)\n chars[i] = 1\n if ok:\n if l - 1 >= 0:\n prev_max_cnts = dp[l - 1][0]\n prev_total_length = dp[l - 1][1]\n prev_r = dp[l - 1][3]\n else:\n prev_max_cnts = 0\n prev_total_length = 0\n prev_r = -1\n if (prev_max_cnts + 1 > dp[r][0]) or (prev_max_cnts + 1 == dp[r][0] and prev_total_length + r - l + 1 < dp[r][1]):\n dp[r] = (prev_max_cnts + 1, prev_total_length + r - l + 1, l, r, prev_r)\n # print(s)\n # print(dp)\n ans = []\n r2 = n - 1\n while True:\n l = dp[r2][2]\n r = dp[r2][3] # best r <= r2\n # print(f'r2={r2} l={l} r={r} s[l: r + 1]={s[l: r + 1]}')\n prev_r = dp[r2][4]\n ans.append(s[l: r + 1])\n if prev_r == -1:\n break\n r2 = prev_r\n ans.reverse()\n return ans","runtime":"2172"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = sorted(char_to_intervals.values())\n merged_intervals = set()\n print(\"start_ends\", start_ends)\n\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n ret = []\n # print(merged_intervals)\n merged_intervals = list(merged_intervals)\n for i in range(len(merged_intervals)):\n cur = merged_intervals[i]\n has_nested = False\n for j in range(len(merged_intervals)):\n if i == j:\n continue\n inter = merged_intervals[j]\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\n has_nested = True\n break\n if not has_nested:\n ret.append(cur)\n return [s[start:end + 1] for start, end in ret]\n\n\n \n\n\n\n\n\n \n \n ","runtime":"2220"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = sorted(char_to_intervals.values())\n merged_intervals = set()\n print(\"start_ends\", start_ends)\n\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n ret = []\n # print(merged_intervals)\n merged_intervals = list(merged_intervals)\n for i in range(len(merged_intervals)):\n cur = merged_intervals[i]\n has_nested = False\n for j in range(len(merged_intervals)):\n if i == j:\n continue\n inter = merged_intervals[j]\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\n has_nested = True\n break\n if not has_nested:\n ret.append(cur)\n return [s[start:end + 1] for start, end in ret]\n\n\n \n\n\n\n\n\n \n \n ","runtime":"2269"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = list(char_to_intervals.values())\n merged_intervals = set()\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n merged_intervals = sorted(list(merged_intervals), key=lambda x:x[1])\n ret = []\n last = None\n for start, end in merged_intervals:\n if last == None or start >= last:\n ret.append(s[start:end + 1])\n last = end\n return ret\n\n\n \n\n\n\n\n\n \n \n ","runtime":"2317"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = {}\n for index, char in enumerate(s):\n if char not in ranges:\n ranges[char] = [index, index + 1]\n else:\n ranges[char][1] = index + 1\n for char, (first, last) in ranges.items():\n while True:\n newFirst, newLast = first, last\n for otherChar in s[first:last]:\n newFirst = min(newFirst, ranges[otherChar][0])\n newLast = max(newLast, ranges[otherChar][1])\n if (newFirst, newLast) == (first, last):\n break\n first, last = newFirst, newLast\n ranges[char][0], ranges[char][1] = first, last\n \n prev = 0\n res = []\n for start, end in sorted(ranges.values(), key=lambda x: x[1]):\n if start >= prev:\n res.append(s[start:end])\n prev = end\n return res","runtime":"2365"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = sorted(char_to_intervals.values())\n merged_intervals = set()\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n ret = []\n merged_intervals = list(merged_intervals)\n for i in range(len(merged_intervals)):\n cur = merged_intervals[i]\n has_nested = False\n for j in range(len(merged_intervals)):\n if i == j:\n continue\n inter = merged_intervals[j]\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\n has_nested = True\n break\n if not has_nested:\n ret.append(cur)\n return [s[start:end + 1] for start, end in ret]\n\n\n \n\n\n\n\n\n \n \n ","runtime":"2414"}],"string":"[\n {\n \"code\": \"class Solution:\\n def dfs(self, i):\\n if i in self.dfs_store:\\n return self.dfs_store[i]\\n \\n v = self.dfs(i+1)\\n \\n _, end = self.valid_intervals[i]\\n j = i + 1\\n while j < self.len and self.valid_intervals[j][0] < end:\\n j += 1\\n if len(v) >= 1 + len(self.dfs(j)):\\n self.dfs_store[i] = v\\n else:\\n self.dfs_store[i] = [self.valid_intervals[i]] + self.dfs_store[j]\\n return self.dfs_store[i]\\n \\n def maxNumOfSubstrings(self, s: str):\\n store = {}\\n for i, c in enumerate(s):\\n if c not in store:\\n store[c] = [i, i]\\n else:\\n store[c][-1] = i\\n valid_intervals = []\\n for c in store:\\n begin, end = store[c]\\n checked = set([c])\\n flag = True\\n i = begin + 1\\n while i <= end:\\n d = s[i]\\n i += 1\\n if d in checked:\\n continue\\n d_begin, d_end = store[d]\\n if d_begin < begin:\\n flag = False\\n break\\n if d_end > end:\\n end = d_end\\n checked.add(d)\\n if flag:\\n valid_intervals.append([begin, end])\\n valid_intervals.sort()\\n \\n self.len = len(valid_intervals)\\n self.dfs_store = {self.len: []}\\n self.valid_intervals = valid_intervals\\n self.dfs(0)\\n rt = []\\n for begin, end in self.dfs_store[0]:\\n rt.append(s[begin: end+1])\\n \\n return rt\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"from typing import List\\nfrom bisect import bisect_left\\n\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Step 1: Record the first and last occurrence of each character\\n locs = {}\\n for i, x in enumerate(s):\\n locs.setdefault(x, []).append(i)\\n \\n # Step 2: Define a function to expand the range to cover all occurrences of characters\\n def fn(lo, hi):\\n \\\"\\\"\\\"Return expanded range covering all chars in s[lo:hi+1].\\\"\\\"\\\"\\n for xx in locs:\\n k0 = bisect_left(locs[xx], lo)\\n k1 = bisect_left(locs[xx], hi)\\n # Check if the current range [lo, hi] needs to be expanded\\n if k0 < k1 and (locs[xx][0] < lo or hi < locs[xx][-1]):\\n lo = min(lo, locs[xx][0])\\n hi = max(hi, locs[xx][-1])\\n lo, hi = fn(lo, hi) # Recursively expand the range\\n return lo, hi\\n \\n # Step 3: Determine all possible non-overlapping substrings\\n group = set()\\n for x in locs:\\n group.add(fn(locs[x][0], locs[x][-1]))\\n \\n # Step 4: Solve the interval scheduling maximization problem\\n ans = []\\n prev = -1\\n for lo, hi in sorted(group, key=lambda x: x[1]):\\n if prev < lo:\\n ans.append(s[lo:hi+1])\\n prev = hi\\n \\n return ans\",\n \"runtime\": \"186\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n \\\"\\\"\\\"\\n Did not solve\\n 1. Get the first and last occurance of each characters\\n 2. For the range of each letter, we need to update the range according to all the characters within the range. For example: abab we would have the initial range as a: [0,2], b: [1:3]. Since the range of a which is [0,2] will include b, we need to update the range of a to also include all occurances of b as well.\\n 3. Finally, we sort all the ranges according to it's end (since we want to take smallest range possible) and take as much as we can as long as the start of the current range is >= the end of the previous range.\\n \\\"\\\"\\\"\\n ranges = collections.defaultdict(list)\\n # 1\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n # 2\\n for r in ranges:\\n left, right = ranges[r][0], ranges[r][-1]\\n templ, tempr = left, right\\n while True:\\n for ch in set(s[templ:tempr+1]):\\n templ = min(templ, ranges[ch][0])\\n tempr = max(tempr, ranges[ch][-1])\\n if (templ, tempr) == (left, right): break\\n left, right = templ, tempr\\n ranges[r] = (templ, tempr)\\n # 3\\t\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end+1])\\n prev = end\\n return ans\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n ends = {}\\n counter = defaultdict(int)\\n for i in range(n-1,-1,-1):\\n if s[i] not in ends:\\n ends[s[i]] = i\\n counter[s[i]] += 1\\n ans = []\\n seen = set()\\n stack = []\\n i = 0\\n \\n included = -1\\n while i < n:\\n #print(s[i])\\n if s[i] not in seen:\\n seen.add(s[i])\\n stack.append(i)\\n if ends[s[i]] == i:\\n seen.remove(s[i])\\n stack_index = len(stack)-1\\n curr = 0\\n #print(stack,s[i],included,stack_index,seen)\\n while stack[stack_index] > included and s[stack[stack_index]] not in seen:\\n curr += counter[s[stack[stack_index]]]\\n if i - stack[stack_index] + 1 == curr:\\n # shortest segment found\\n ans.append(s[stack[stack_index]:i+1])\\n included = i\\n stack_index -= 1\\n \\n \\n i += 1\\n return ans if ans else [s]\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = collections.defaultdict(list)\\n # 1\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n # 2\\n for r in ranges:\\n left, right = ranges[r][0], ranges[r][-1]+1\\n templ, tempr = left, right\\n while True:\\n for ch in set(s[templ:tempr]):\\n templ = min(templ, ranges[ch][0])\\n tempr = max(tempr, ranges[ch][-1]+1)\\n if (templ, tempr) == (left, right): break\\n left, right = templ, tempr\\n ranges[r] = (templ, tempr)\\n # 3\\t\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end])\\n prev = end\\n return ans\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = defaultdict(list)\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n for r in ranges:\\n left, right = ranges[r][0], ranges[r][-1]+1\\n templ, tempr = left, right\\n while True:\\n for ch in set(s[templ:tempr]):\\n templ = min(templ, ranges[ch][0])\\n tempr = max(tempr, ranges[ch][-1]+1)\\n if (templ, tempr) == (left, right): break\\n left, right = templ, tempr\\n ranges[r] = (templ, tempr)\\n # 3\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end])\\n prev = end\\n return ans\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n h,bIndex,eIndex,end = {},{},{},{}\\n n = len(s)\\n for i in range(n):\\n if s[i] not in h:\\n bIndex[i] = True\\n h[s[i]] = True\\n h = {}\\n for i in range(n-1,-1,-1):\\n if s[i] not in h:\\n eIndex[i] = True\\n end[s[i]] = i\\n h[s[i]] = True\\n \\n #print(f\\\"bIndex={bIndex}\\\\neIndex={eIndex}\\\\nend={end}\\\")\\n\\n stack = [] #[set(),b,e,t]\\n ans = [] \\n for i in range(n):\\n x = s[i]\\n if i in bIndex:\\n if len(stack) > 0 and end[x] > stack[-1][2]: # extend\\n xset = {x} # set\\n while len(stack) > 0 and end[x] > stack[-1][2]:\\n xs, b, _, t = stack.pop()\\n xset |= xs \\n stack.append([xset,b,end[x],t])\\n else: # end[x] < stack[-1][2]:\\n #if len(stack) > 0:\\n # stack[-1][0] |= {x}\\n stack.append([{x},i,end[x],False]) # inclusion\\n\\n if i in eIndex:\\n if len(stack) > 0 and stack[-1][2]==i:\\n _,b,e,t = stack.pop()\\n if t==False: \\n ans.append(s[b:e+1])\\n while len(stack) > 1:\\n stack.pop() \\n if len(stack)==1:\\n stack[-1][3]=True # s[stack[-1][0]:stack[-1][1]+1] is a superset of s[i:i+1]\\n elif len(stack) > 0 and stack[-1][2] > i:\\n while len(stack) > 0 and x not in stack[-1][0]:\\n xs,_,_,_ = stack.pop()\\n if len(stack) > 0:\\n stack[-1][0] |= xs\\n\\n if i not in bIndex and i not in eIndex:\\n while len(stack) > 0 and x not in stack[-1][0]:\\n xs,_,_,_ = stack.pop()\\n if len(stack) > 0:\\n stack[-1][0] |= xs\\n\\n #print(f\\\"after i={i} x={x} stack={stack}\\\")\\n return ans\\n \\n\\n\",\n \"runtime\": \"331\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n h,bIndex,eIndex,end = {},{},{},{}\\n n = len(s)\\n for i in range(n):\\n if s[i] not in h:\\n bIndex[i] = True\\n h[s[i]] = True\\n h = {}\\n for i in range(n-1,-1,-1):\\n if s[i] not in h:\\n eIndex[i] = True\\n end[s[i]] = i\\n h[s[i]] = True\\n\\n stack = [] #[set(),b,e,t] # store the informatrion of the interval from b to e that contain the characters in set and t==True denote it is a superset of a substring in ans.\\n ans = [] \\n for i in range(n):\\n x = s[i]\\n if i in bIndex:\\n if len(stack) > 0 and end[x] > stack[-1][2]: # merge the interval on the top of stack and the interval [i,end(x)]\\n xset = {x} # set\\n while len(stack) > 0 and end[x] > stack[-1][2]:\\n xs, b, _, t = stack.pop()\\n xset |= xs \\n stack.append([xset,b,end[x],t])\\n else: # end[x] < stack[-1][2]: # The interval on the top of stack includes the the interval [i,end(x)].\\n stack.append([{x},i,end[x],False]) # push the interval [i,end(x)] on the top of the stack.\\n\\n if i in eIndex:\\n if len(stack) > 0 and stack[-1][2]==i:\\n _,b,e,t = stack.pop()\\n if t==False: # The interval [b:e+1] is the substring that meets the conditions of the answers.\\n ans.append(s[b:e+1])\\n while len(stack) > 1: # pop all supersets of the interval [b:e+1] until the last one on the stack.\\n stack.pop() \\n if len(stack)==1:\\n stack[-1][3]=True # the last one interval on the stack is a superset of the interval [b:e+1].\\n elif len(stack) > 0 and stack[-1][2] > i:\\n while len(stack) > 0 and x not in stack[-1][0]: # x is not in characters set of the interval on the top of the stack.\\n xs,_,_,_ = stack.pop() # remove it and pass the characters set to the next one on the stack\\n if len(stack) > 0:\\n stack[-1][0] |= xs\\n\\n if i not in bIndex and i not in eIndex:\\n while len(stack) > 0 and x not in stack[-1][0]: # the same approach as above\\n xs,_,_,_ = stack.pop()\\n if len(stack) > 0:\\n stack[-1][0] |= xs\\n\\n return ans\\n \\n\\n\",\n \"runtime\": \"331\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_pos = dict()\\n for i, c in enumerate(s):\\n if c not in char_pos:\\n char_pos[c] = (i, i)\\n char_pos[c] = (char_pos[c][0], i)\\n\\n substrings = []\\n #find every shortest substring that start at each position that meets 2\\n for i, c in enumerate(s):\\n start, end = char_pos[c]\\n if i > start: continue\\n index = i + 1\\n canFormSubstring = True\\n while index < end:\\n new_start, new_end = char_pos[s[index]]\\n if new_start < start:\\n #impossible at start\\n canFormSubstring = False\\n break\\n end = max(new_end, end)\\n index += 1\\n \\n if canFormSubstring:\\n substrings.append((i, end))\\n \\n\\n #sort substrings by right hand side of the interval ascending order\\n #then we loop over the sorted substrings, and find the longest\\n #non-overlapping substrings at each substring\\n substrings = sorted(substrings, key=lambda x: x[1])\\n n = len(substrings)\\n\\n max_number = 0\\n min_length = 100000000000\\n out = []\\n for i, pos in enumerate(substrings):\\n start, end = pos\\n curr_strs = [s[start:end+1]]\\n curr_number = 1\\n for j in range(i+1, n):\\n new_start, new_end = substrings[j]\\n if new_start > end:\\n end = new_end\\n curr_number += 1\\n curr_strs.append(s[new_start:new_end+1])\\n \\n if curr_number > max_number:\\n max_number = curr_number\\n min_length = len(''.join(curr_strs))\\n out = curr_strs\\n elif curr_number == max_number and min_length > len(''.join(curr_strs)):\\n min_length = min(min_length, len(''.join(curr_strs)))\\n out = curr_strs\\n \\n return out\\n\\n\\n \\n \\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"379\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # find max num of nonempty substrs that\\n # do not overlap\\n # if one contains c, then it must contain ALL the characters of c\\n\\n # probably dynamic programming? 2^26 is too high for a DFS+backtracking or knapsack-style solution\\n\\n # what's the best with a substring with a's?\\n # if we take a:\\n # then first[a]..last[a] is the minimum bounds of a substring to take\\n # if we make that a substring, then the max number of remaining substrings is reduced by\\n # num uniques in first[a]..last[a]\\n\\n # doesn't seem promising\\n\\n # what about classic best answer in ..i?\\n # suppose we know best[i-1], and earlier best entries\\n # then if i is the last copy of a character c:\\n # then we can form one window with first[c]..i, and add the best window of 0..first[c]-1\\n # otherwise, there's no valid window that can end here, because last[c] is later and we'd violate the constraints\\n\\n # basic: store O(N) entries\\n # fancier: store O(26) entries\\n\\n # let's get fancy\\n\\n first = {}\\n last = {}\\n for i, c in enumerate(s):\\n if c not in first: first[c] = i\\n last[c] = i\\n\\n best = [(-1, [])] # (lastIdx, substrs)\\n for i in sorted(last.values()): # O(26) iterations\\n c = s[i]\\n print(f\\\"{i=}, {c=}\\\")\\n # if last[c] != i: continue # instead of iterating over all chars, just iterate over lasts\\n\\n # O(N) scan back\\n # extend window back to include the earliest unique in f..l\\n # strategy: start with j=i-1. While j > f (we already know the char at f),\\n # look at what the first index of s[j] is and shrink f if needed\\n ## TODO: we could probably handle this faster by using another layer of dynamic\\n # programming or caching. Can't reduce complexity below O(N) though\\n # so it would just be a speed improvement, not a complexity improvement.\\n # Sketch idea: for each of the 26 characters, we know first and last\\n # So as preprocessing, we can scan over the characters again. If c occurs at i,\\n # and i is between [first, last] for some other character c', add an edge c' -> c\\n # to mean \\\"if you take c' in a window, you also must take c\\\".\\n # Then do a DFS traversal from each `c` to find the \\\"windened window\\\" for each\\n # `c`. Finally, do what another solution I saw does: put those windows into a `set()`,\\n # then iterate over the set's entries (sorted by end) instead of iterating over all ends.\\n # TC for that part is O(C**2) where there are C unique characters; C <= N.\\n # For C**2 << N that would give us a complexity improvement over this O(C*N) algo.\\n f = first[c]\\n l = i\\n j = i-1\\n while j > f and l == i:\\n f = min(f, first[s[j]])\\n l = max(l, last[s[j]])\\n j -= 1\\n\\n if l > i:\\n # first[c]..last[c] contains some other character c' we haven't\\n # seen all copies of yet --> we'll wait until we get to last[c']\\n continue\\n\\n # O(log(26)) because at most we have one entry per end character\\n p = bisect_left(best, f, key=lambda pair: pair[0])-1\\n take = False\\n if len(best[p][1]) + 1 > len(best[-1][1]):\\n take = True\\n elif len(best[p][1]) + 1 == len(best[-1][1]) and sum(len(t) for t in best[p][1]) + i-f+1 < sum(len(t) for t in best[-1][1]):\\n take = True\\n\\n # O(N) because we \\\"reify\\\" the strings; instead we could store bounds for O(26) here\\n if take:\\n entry = (i, [(s[f:i+1])])\\n entry[1].extend(best[p][1])\\n best.append(entry)\\n\\n # best[-1] is the best overall answer\\n # [1] is the list of strings\\n return best[-1][1]\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # if there are multiple soluitons, return the one with min total length\\n\\n # first = {}\\n # last = {}\\n # count = {}\\n # for i, c in enumerate(s):\\n # if c not in first: first[c] = i\\n # last[c] = i\\n # count[c] = count.get(c, 0) + 1\\n\\n # bounds = list((first[c], last[c], count[c], c) for c in first)\\n # C = len(bounds)\\n\\n # @cache\\n # def best(l: int, r: int, i: int) -> list[tuple[int, chr]]:\\n # \\\"\\\"\\\"Returns the best answer for l..r for the letters indexed i:\\\"\\\"\\\"\\n\\n # if i == C: return []\\n\\n\\n # lc, rc, nc, c = bounds[i]\\n\\n # # base case: don't take c\\n # ans = best(l, r, i+1)\\n\\n # if l <= lc and rc <= r:\\n # cand = [(nc, c)]\\n # cand.extend(best(l, lc-1, i+1))\\n # cand.extend(best(rc+1, r, i+1))\\n # if len(cand) > len(ans):\\n # ans = cand\\n # elif len(cand) == len(ans) and sum(e[0] for e in cand) < sum(e[0] for e in ans):\\n # ans = cand\\n\\n # return ans\\n\\n # ans = best(0, len(s)-1, 0)\\n # return list(c*f for f, c in ans)\",\n \"runtime\": \"379\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n intervals = []\\n for c in set(s):\\n b, e = fst[c], lst[c]\\n i = b\\n while i <= e and b == fst[c]:\\n b = min(b, fst[s[i]])\\n e = max(e, lst[s[i]])\\n i += 1\\n if b == fst[c]:\\n intervals.append((e, b))\\n \\n intervals.sort()\\n ans, prev = [], -1\\n for e, b in intervals:\\n if b > prev:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"runtime\": \"428\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n start_i, end_i = start, end\\n for c in set(s[start:end]):\\n print(\\\"for \\\", c, ref[c][0], ref[c][-1])\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n if (start, end) != (start_i, end_i):\\n return isValid(start, end)\\n return (start, end)\\n\\n for c in set(s):\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1]) \\n print(substrs)\\n res = []\\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"428\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n ans, prev = [], -1\\n for i in sorted(lst.values()):\\n b, e = fst[s[i]], lst[s[i]]\\n j = e\\n while j >= b and b > prev and e == i:\\n b = min(b, fst[s[j]])\\n e = max(e, lst[s[j]])\\n j -= 1\\n if b > prev and e == i:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"runtime\": \"476\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n intervals = []\\n for c in set(s):\\n b, e = fst[c], lst[c]\\n i = b\\n while i <= e and b == fst[c]:\\n b = min(b, fst[s[i]])\\n e = max(e, lst[s[i]])\\n i += 1\\n if b == fst[c]:\\n intervals.append((e, b))\\n \\n intervals.sort()\\n ans, prev = [], -1\\n for e, b in intervals:\\n if b > prev:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"runtime\": \"476\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n first = {c: float('inf') for c in set(s)}\\n last = {c: float('-inf') for c in set(s)}\\n \\n for i, c in enumerate(s):\\n first[c] = min(first[c], i)\\n last[c] = max(last[c], i)\\n \\n def get_valid_interval(start):\\n end = last[s[start]]\\n j = start\\n while j <= end:\\n if first[s[j]] < start:\\n return None\\n end = max(end, last[s[j]])\\n j += 1\\n return (start, end)\\n \\n intervals = []\\n for i in range(len(s)):\\n if i == first[s[i]]:\\n interval = get_valid_interval(i)\\n if interval:\\n intervals.append(interval)\\n \\n intervals.sort(key=lambda x: x[1])\\n \\n ans = []\\n prev_end = -1\\n for start, end in intervals:\\n if start > prev_end:\\n ans.append(s[start:end+1])\\n prev_end = end\\n \\n return ans\",\n \"runtime\": \"525\"\n },\n {\n \"code\": \"class Solution:\\n def isOverlap(self, res, start, end):\\n for (currStart, currEnd) in res:\\n if currStart <= start and start <= currEnd:\\n return True\\n \\n if currStart <= end and end <= currEnd:\\n return True\\n\\n if start <= currStart and currStart <= end:\\n return True\\n \\n\\n return False\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n left = [float(\\\"inf\\\") for i in range(26)]\\n right = [float(\\\"-inf\\\") for i in range(26)]\\n intervals = []\\n\\n for i, c in enumerate(s):\\n idx = ord(c) - ord('a')\\n left[idx] = min(left[idx], i)\\n right[idx] = max(right[idx], i)\\n \\n for i in range(26):\\n start = left[i]\\n end = right[i]\\n valid = True\\n if start != float(\\\"inf\\\"):\\n idx = start\\n while idx < end:\\n if left[ord(s[idx]) - ord('a')] < start:\\n valid = False\\n break\\n\\n end = max(end, right[ord(s[idx]) - ord('a')])\\n idx += 1\\n \\n if valid:\\n intervals.append((start, end))\\n\\n intervals.sort(key=lambda x: ((x[1] - x[0], x[0])))\\n\\n res = []\\n for (start, end) in intervals:\\n if not self.isOverlap(res, start, end):\\n res.append((start, end))\\n\\n return [s[start:end+1] for (start, end) in res]\",\n \"runtime\": \"525\"\n },\n {\n \"code\": \"class Solution:\\n def create_graph(self, s, dic):\\n graph = {}\\n for k in dic.keys():\\n graph[k] = set()\\n\\n for k, v in dic.items():\\n i, j = v\\n\\n for c in s[i : j + 1]:\\n if c != k:\\n graph[c].add(k)\\n \\n return graph\\n \\n def reverse_graph(self, graph):\\n graph2 = {}\\n for k in graph.keys():\\n graph2[k] = set()\\n\\n for u, vs in graph.items():\\n\\n for v in vs:\\n graph2[v].add(u)\\n \\n return graph2\\n \\n\\n def topological_sort(self, graph):\\n def dfs(u):\\n visited.add(u)\\n\\n if u in graph:\\n for v in graph[u]:\\n if v not in visited:\\n dfs(v)\\n \\n topo.append(u)\\n\\n topo = []\\n visited = set()\\n for u in graph.keys():\\n if u not in visited:\\n dfs(u)\\n \\n topo.reverse()\\n return topo\\n \\n\\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\\n visited2.add(u)\\n mmin[0] = min(mmin[0], dic[u][0])\\n mmax[0] = max(mmax[0], dic[u][1])\\n\\n for v in graph[u]:\\n if v in visited:\\n return False\\n \\n if v in visited2:\\n continue\\n \\n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\\n return False\\n \\n return True\\n\\n \\n\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n dic = {}\\n for i, c in enumerate(s):\\n if c not in dic:\\n dic[c] = [i, i]\\n else:\\n dic[c][1] = i\\n\\n graph = self.create_graph(s, dic)\\n print(graph)\\n topo = self.topological_sort(graph)\\n print(topo)\\n\\n graph_rev = self.reverse_graph(graph)\\n print(\\\"reverse graph\\\", graph_rev)\\n visited = set()\\n ans = []\\n for u in topo:\\n if u in visited:\\n continue\\n \\n visited2 = set()\\n mmin = [math.inf]\\n mmax = [-math.inf]\\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\\n if is_possible:\\n visited = visited.union(visited2)\\n ans.append(s[mmin[0] : mmax[0] + 1])\\n \\n return ans\\n \",\n \"runtime\": \"573\"\n },\n {\n \"code\": \"class Solution:\\n def create_graph(self, s, dic):\\n graph = {}\\n for k in dic.keys():\\n graph[k] = set()\\n\\n for k, v in dic.items():\\n i, j = v\\n\\n for c in s[i : j + 1]:\\n if c != k:\\n graph[c].add(k)\\n \\n return graph\\n \\n def reverse_graph(self, graph):\\n graph2 = {}\\n for k in graph.keys():\\n graph2[k] = set()\\n\\n for u, vs in graph.items():\\n\\n for v in vs:\\n graph2[v].add(u)\\n \\n return graph2\\n \\n\\n def topological_sort(self, graph):\\n def dfs(u):\\n visited.add(u)\\n\\n if u in graph:\\n for v in graph[u]:\\n if v not in visited:\\n dfs(v)\\n \\n topo.append(u)\\n\\n topo = []\\n visited = set()\\n for u in graph.keys():\\n if u not in visited:\\n dfs(u)\\n \\n topo.reverse()\\n return topo\\n \\n\\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\\n visited2.add(u)\\n mmin[0] = min(mmin[0], dic[u][0])\\n mmax[0] = max(mmax[0], dic[u][1])\\n\\n for v in graph[u]:\\n if v in visited:\\n return False\\n \\n if v in visited2:\\n continue\\n \\n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\\n return False\\n \\n return True\\n\\n \\n\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n dic = {}\\n for i, c in enumerate(s):\\n if c not in dic:\\n dic[c] = [i, i]\\n else:\\n dic[c][1] = i\\n\\n graph = self.create_graph(s, dic)\\n topo = self.topological_sort(graph)\\n\\n graph_rev = self.reverse_graph(graph)\\n visited = set()\\n ans = []\\n for u in topo:\\n if u in visited:\\n continue\\n \\n visited2 = set()\\n mmin = [math.inf]\\n mmax = [-math.inf]\\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\\n if is_possible:\\n visited = visited.union(visited2)\\n ans.append(s[mmin[0] : mmax[0] + 1])\\n \\n return ans\\n \",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n\\n def find_right_from_left(s, first, last, left):\\n right, i = last[ord(s[left]) - ord(\\\"a\\\")], left\\n while i <= right:\\n if first[ord(s[i]) - ord(\\\"a\\\")] < left:\\n return -1\\n right = max(right, last[ord(s[i]) - ord(\\\"a\\\")])\\n i += 1\\n return right\\n\\n first, last = [float(\\\"inf\\\")] * 26, [float(\\\"-inf\\\")] * 26\\n for i, c in enumerate(s):\\n first[ord(c) - ord(\\\"a\\\")] = min(first[ord(c) - ord(\\\"a\\\")], i)\\n last[ord(c) - ord(\\\"a\\\")] = max(last[ord(c) - ord(\\\"a\\\")], i)\\n result = [\\\"\\\"]\\n right = float(\\\"inf\\\")\\n for left, c in enumerate(s):\\n if left != first[ord(c) - ord(\\\"a\\\")]:\\n continue\\n new_right = find_right_from_left(s, first, last, left)\\n if new_right == -1:\\n continue\\n if left > right:\\n result.append(\\\"\\\")\\n right = new_right\\n result[-1] = s[left : right + 1]\\n return result\\n\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n letlength=defaultdict(list)\\n letheap=[]\\n for i in range(len(s)):\\n if s[i] in letlength:\\n if i<letlength[s[i]][0]:\\n letlength[s[i]][0]=i\\n if i>letlength[s[i]][1]:\\n letlength[s[i]][1]=i\\n else:\\n letlength[s[i]]=[i,i]\\n pool=[]\\n for letter in letlength:\\n start,end=letlength[letter]\\n temp=set()\\n temp.add(letter)\\n ogstart,ogend=start,end\\n while start<=end:\\n if s[start] not in temp:\\n start=min(start,letlength[s[start]][0])\\n ogstart=min(start,ogstart)\\n end=max(end,letlength[s[start]][1])\\n ogend=max(end,ogend)\\n temp.add(s[start])\\n else:\\n start+=1\\n # print(start,end+1)\\n pool.append([s[ogstart:ogend+1],ogstart,ogend])\\n pool=sorted(pool,key= lambda x:len(x[0]))\\n # print(pool)\\n minind=float('inf')\\n maxind=-1\\n res=[]\\n for sub,start,end in pool:\\n canadd=True\\n for _,restart,resend in res:\\n if start<=restart and end>=resend:\\n canadd=False\\n if canadd:\\n res.append([sub,start,end])\\n return [i[0] for i in res]\\n \",\n \"runtime\": \"670\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n last, interval = {}, {}\\n for i, c in enumerate(s):\\n last[c] = i + 1\\n if c not in interval:\\n interval[c] = set(''.join(s.split(c)[1:-1]))\\n \\n parent = {c: c for c in s}\\n \\n def find(x):\\n if parent[x] != x:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n parent[find(x)] = find(y)\\n return\\n \\n for c in interval:\\n for n in interval[c]:\\n if c in interval[n]:\\n union(c, n)\\n \\n splits, max_splits = [(s, 0)], []\\n \\n while splits:\\n \\n splits_cut = []\\n for string, start in splits:\\n left = right = 0 \\n for i, c in enumerate(string):\\n right = max(right, last[c] - start)\\n if i == right - 1:\\n splits_cut.append((string[left:right], start + left))\\n left = right\\n \\n splits_rem = []\\n for string, start in splits_cut:\\n len_splits_rem = len(splits_rem)\\n redundant = find(string[0])\\n \\n left = 0\\n while left < len(string):\\n if find(string[left]) == redundant:\\n left += 1\\n else:\\n right = left\\n while right < len(string) and find(string[right]) != redundant:\\n right += 1\\n splits_rem.append((string[left:right], start + left))\\n left = right\\n\\n if len_splits_rem == len(splits_rem):\\n max_splits.append(string)\\n\\n splits = splits_rem\\n \\n return max_splits\",\n \"runtime\": \"670\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = {}\\n for i in range(len(s)):\\n if s[i] in d:\\n d[s[i]][1] = i\\n else:\\n d[s[i]] = [i, i]\\n for key in d:\\n start, end = d[key]\\n q = deque([(start, end)])\\n while q:\\n scur, ecur = q.popleft()\\n for i in range(scur, ecur + 1):\\n snew, enew = d[s[i]]\\n if snew < start:\\n q.append((snew, start - 1))\\n start = snew\\n if enew > end:\\n q.append((end + 1, enew))\\n end = enew\\n d[key] = [start, end]\\n\\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\\n seen = []\\n ans = []\\n for start, end in sorted_ranges:\\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\\n continue\\n ans.append(s[start: end + 1])\\n seen.append((start, end))\\n return ans\",\n \"runtime\": \"719\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n indices = char_indices(s)\\n merge_indices(s, indices)\\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\\n result = []\\n for substring in substrings:\\n if not contains_substring(result, substring):\\n result.append(substring)\\n return result\\n\\n\\ndef substring_chars(s: str) -> Set[str]:\\n return set(c for c in s)\\n\\ndef char_indices(s: str) -> Dict[str, List[int]]:\\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\\n\\ndef contains_substring(ls: List[str], ss: str):\\n for s in ls:\\n if s in ss:\\n return True\\n return False\\n\\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\\n for c in indices:\\n changed = True\\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n prev_chars.discard(c)\\n while changed:\\n for other_c in prev_chars:\\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n chars.discard(c)\\n changed = prev_chars != chars\\n prev_chars = chars\",\n \"runtime\": \"719\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = {}\\n for i in range(len(s)):\\n if s[i] in d:\\n d[s[i]][1] = i\\n else:\\n d[s[i]] = [i, i]\\n for key in d:\\n start, end = d[key]\\n q = deque([(start, end)])\\n while q:\\n scur, ecur = q.popleft()\\n for i in range(scur, ecur + 1):\\n snew, enew = d[s[i]]\\n if snew < start:\\n q.append((snew, start - 1))\\n start = snew\\n if enew > end:\\n q.append((end + 1, enew))\\n end = enew\\n d[key] = [start, end]\\n\\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\\n seen = []\\n ans = []\\n for start, end in sorted_ranges:\\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\\n continue\\n ans.append(s[start: end + 1])\\n seen.append((start, end))\\n return ans\",\n \"runtime\": \"767\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = {}\\n for i in range(len(s)):\\n if s[i] in d:\\n d[s[i]][1] = i\\n else:\\n d[s[i]] = [i, i]\\n for key in d:\\n start, end = d[key]\\n q = deque([(start, end)])\\n while q:\\n scur, ecur = q.popleft()\\n for i in range(scur, ecur + 1):\\n snew, enew = d[s[i]]\\n if snew < start:\\n q.append((snew, start - 1))\\n start = snew\\n if enew > end:\\n q.append((end + 1, enew))\\n end = enew\\n d[key] = [start, end]\\n\\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\\n seen = []\\n ans = []\\n for start, end in sorted_ranges:\\n if any(end >= s1 and e1 >= start for s1, e1 in seen):\\n continue\\n ans.append(s[start: end + 1])\\n seen.append((start, end))\\n return ans\",\n \"runtime\": \"767\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n m={}\\n for i,ch in enumerate(s):\\n if ch not in m: m[ch]=[i,i]\\n else: m[ch][1] = i\\n res, st, start = [], [], -1\\n for ind,ch in enumerate(s):\\n if st and st[-1][1] == ind:\\n i,j,_ = st.pop()\\n if i>start:\\n res.append(s[i:j+1])\\n start=j\\n continue\\n i,j = m[ch]\\n setch = {ch}\\n if i==j:\\n res.append(s[i])\\n start=j\\n continue\\n while st and (st[-1][0]>=i or st[-1][1]<=j or ch in st[-1][2]):\\n x = st.pop()\\n i,j = min(i, x[0]), max(j, x[1])\\n setch.update(x[2])\\n st.append((i,j,setch))\\n return res\",\n \"runtime\": \"815\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n m={}\\n for i,ch in enumerate(s):\\n if ch not in m: m[ch]=[i,i]\\n else: m[ch][1] = i\\n res, st, start = [], [], -1\\n for ind,ch in enumerate(s):\\n if st and st[-1][1] == ind:\\n i,j,_ = st.pop()\\n if i>start:\\n res.append(s[i:j+1])\\n start=j\\n continue\\n i,j = m[ch]\\n setch = {ch}\\n if i==j:\\n res.append(s[i])\\n start=j\\n continue\\n while st and (st[-1][0]>=i or st[-1][1]<=j or ch in st[-1][2]):\\n x = st.pop()\\n i,j = min(i, x[0]), max(j, x[1])\\n setch.update(x[2])\\n st.append((i,j,setch))\\n return res\\n \\n \",\n \"runtime\": \"815\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n letter_range=defaultdict(list)\\n for i,c in enumerate(s):\\n if c not in letter_range:\\n letter_range[c].extend([i,i])\\n else:\\n letter_range[c][1]=i\\n #try to expand the range for each letter\\n for key in letter_range:\\n start,end=letter_range[key]\\n stack=[(start,end)]\\n while stack:\\n cur_s,cur_e=stack.pop()\\n for i in range(cur_s,cur_e+1):\\n new_s,new_e=letter_range[s[i]]\\n if new_s<start:\\n stack.append((new_s,start-1))\\n start=new_s\\n if new_e>end:\\n stack.append((end+1,new_e))\\n end=new_e\\n letter_range[key]=(start,end)\\n sorted_ranges=sorted(letter_range.values(),key=lambda x:x[1]-x[0])\\n seen_ranges=[]\\n ans=[]\\n for start,end in sorted_ranges:\\n if any(end>=s1 and e1>=start for s1,e1 in seen_ranges):\\n continue\\n seen_ranges.append((start,end))\\n ans.append(s[start:end+1])\\n return ans\\n\\n \",\n \"runtime\": \"864\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = defaultdict(list)\\n for i, c in enumerate(s):\\n d[c].append(i)\\n new = defaultdict(list)\\n for i in range(26):\\n if chr(i+97) not in d: continue\\n idx = d[chr(i+97)][0]\\n mx = 0\\n for j in range(idx, len(s)):\\n mx = max(mx, d[s[j]][-1])\\n if idx > d[s[j]][0]: break\\n if j == mx:\\n new[idx].append(j+1)\\n break\\n @cache\\n def dp(idx):\\n if idx == len(s): return []\\n res = dp(idx+1)\\n for ch in new[idx]:\\n if len(dp(ch))+1 > len(res):\\n res = [s[idx:ch]]+dp(ch)\\n return res\\n return dp(0)\",\n \"runtime\": \"864\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nadefaddaccc\\na: 0, 7\\nc: 8, 10\\nd: 1, 6\\ne: 2, 2\\nf: 3, 3\\n\\na: [d: [a, e, f], e: [], f: []]\\nc: []\\n\\nabhahbccd\\n\\na: [b]\\nb: [a]\\nh: [a]\\nc: []\\nd: []\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def make_alphabet(self, s: str) -> dict[str, list[int]]:\\n alpha = {}\\n for i, ch in enumerate(s):\\n if ch not in alpha:\\n alpha[ch] = [i]\\n continue\\n if len(alpha[ch]) == 1:\\n alpha[ch].append(i)\\n else:\\n alpha[ch][-1] = i\\n return alpha\\n \\n def del_tree(self, graph: dict, root: str):\\n if root not in graph:\\n return\\n children = graph[root]\\n del graph[root]\\n for child in children:\\n self.del_tree(graph, child)\\n \\n def clean_tree(self, graph: dict):\\n keys = list(graph.keys())\\n for k in keys:\\n if not graph[k]:\\n for v in graph.values():\\n v.discard(k)\\n del graph[k]\\n self.clean_tree(graph)\\n return\\n \\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n al = self.make_alphabet(s)\\n #print(f'{al=}')\\n gr = {ch: set() for ch in set(s)}\\n nodes = set()\\n for ch in set(s):\\n for i in range(al[ch][0], al[ch][-1] + 1):\\n if s[i] != ch:\\n gr[s[i]].add(ch)\\n nodes.add(ch)\\n #print(f'{gr=}')\\n \\n roots = set(s) - nodes\\n #print(f'{roots=}')\\n output = []\\n for root in roots:\\n output.append(s[al[root][0]:al[root][-1] + 1])\\n self.del_tree(gr, root)\\n #print(f'{output=}\\\\n{gr=}')\\n \\n \\n self.clean_tree(gr)\\n #print(f'cleaned {gr=}')\\n \\n while gr:\\n to_go = list(gr.keys())[0:1]\\n st, fin = None, None\\n while to_go:\\n curr = to_go.pop()\\n if curr not in gr:\\n continue\\n if not gr[curr]:\\n del gr[curr]\\n continue\\n to_go.extend(gr[curr])\\n curr_st, curr_fin = al[curr][0], al[curr][-1] + 1\\n st = curr_st if st is None else min(st, curr_st)\\n fin = curr_fin if fin is None else max(fin, curr_fin)\\n del gr[curr]\\n if st is not None:\\n output.append(s[st:fin])\\n \\n return output\\n \\n \\n \\n \",\n \"runtime\": \"961\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Identifica os intervalos válidos para cada caractere\\n intervals = {}\\n for i, char in enumerate(s):\\n if char in intervals:\\n intervals[char][1] = i\\n else:\\n intervals[char] = [i, i]\\n # Em seguida, expandimos os intervalos para atender às condições\\n valid_intervals = []\\n for interval in intervals.values():\\n start, end = interval[0], interval[1]\\n i = start\\n while i <= end:\\n if intervals[s[i]][0] < start:\\n start = intervals[s[i]][0]\\n i = start\\n if intervals[s[i]][1] > end:\\n end = intervals[s[i]][1]\\n i += 1\\n valid_intervals.append([start, end])\\n\\n # Ordenamos os intervalos pelo fim em ordem crescente\\n valid_intervals.sort(key=lambda x: x[1])\\n\\n # Construímos as substrings usando os intervalos válidos\\n result = []\\n prev_end = float('-inf')\\n\\n for start, end in valid_intervals:\\n if start > prev_end:\\n result.append(s[start:end+1])\\n prev_end = end\\n return result\",\n \"runtime\": \"1009\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Identifica os intervalos válidos para cada caractere\\n intervals = {}\\n for i, char in enumerate(s):\\n if char in intervals:\\n intervals[char][1] = i\\n else:\\n intervals[char] = [i, i]\\n # Em seguida, expandimos os intervalos para atender às condições\\n valid_intervals = []\\n for interval in intervals.values():\\n start, end = interval[0], interval[1]\\n i = start\\n while i <= end:\\n if intervals[s[i]][0] < start:\\n start = intervals[s[i]][0]\\n i = start\\n if intervals[s[i]][1] > end:\\n end = intervals[s[i]][1]\\n i += 1\\n valid_intervals.append([start, end])\\n\\n # Ordenamos os intervalos pelo fim em ordem crescente\\n valid_intervals.sort(key=lambda x: x[1])\\n\\n # Construímos as substrings usando os intervalos válidos\\n result = []\\n prev_end = float('-inf')\\n for interval in valid_intervals:\\n start, end = interval[0], interval[1]\\n if start > prev_end:\\n result.append(s[start:end+1])\\n prev_end = end\\n\\n return result\",\n \"runtime\": \"1058\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Primeiro, identificamos os intervalos válidos para cada caractere\\n intervals = {}\\n for i, char in enumerate(s):\\n if char not in intervals:\\n intervals[char] = [i, i]\\n else:\\n intervals[char][1] = i\\n\\n # Em seguida, expandimos os intervalos para atender às condições\\n valid_intervals = []\\n for interval in intervals.values():\\n start, end = interval[0], interval[1]\\n i = start\\n while i <= end:\\n if intervals[s[i]][0] < start:\\n start = intervals[s[i]][0]\\n i = start\\n if intervals[s[i]][1] > end:\\n end = intervals[s[i]][1]\\n i += 1\\n valid_intervals.append([start, end])\\n\\n # Ordenamos os intervalos pelo fim em ordem crescente\\n valid_intervals.sort(key=lambda x: x[1])\\n\\n # Construímos as substrings usando os intervalos válidos\\n result = []\\n prev_end = float('-inf')\\n for interval in valid_intervals:\\n start, end = interval[0], interval[1]\\n if start > prev_end:\\n result.append(s[start:end+1])\\n prev_end = end\\n\\n return result\",\n \"runtime\": \"1058\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, S: str) -> List[str]:\\n mins = [float('inf')]*26\\n maxs = [-1]*26\\n exists = [False]*26\\n prefix_sum = [[0]*26 for _ in range(len(S)+1)]\\n\\n for i,char in enumerate(S):\\n prefix_sum[i+1]=prefix_sum[i][:]\\n prefix_sum[i+1][ord(char)-ord('a')]+=1\\n mins[ord(char)-ord('a')] = min(mins[ord(char)-ord('a')],i)\\n maxs[ord(char)-ord('a')] = max(maxs[ord(char)-ord('a')],i)\\n exists[ord(char)-ord('a')]=True\\n\\n graph = [[False]*26 for _ in range(26)]\\n for i in range(26):\\n if exists[i]:\\n for j in range(26):\\n if prefix_sum[maxs[i]+1][j]-prefix_sum[mins[i]][j]>0:\\n graph[i][j]=True\\n\\n stack = []\\n visited = [False]*26\\n\\n def dfs1(v):\\n if not visited[v]:\\n visited[v]=True\\n for i in range(26):\\n if graph[v][i] and not visited[i]:\\n dfs1(i)\\n stack.append(v)\\n \\n for i in range(26):\\n if exists[i] and not visited[i]:\\n dfs1(i)\\n\\n batch = 0\\n batches = [-1]*26\\n degree = [0]*26\\n\\n def dfs2(v,batch):\\n if batches[v]<0:\\n batches[v]=batch\\n for i in range(26):\\n if graph[i][v]:\\n dfs2(i,batch)\\n else:\\n if batches[v]!=batch:\\n degree[batches[v]]+=1\\n while stack:\\n v = stack.pop()\\n if batches[v]<0:\\n dfs2(v,batch)\\n batch+=1\\n\\n res = []\\n for i in range(batch -1,-1,-1):\\n if degree[i]==0:\\n min_idx = float('inf')\\n max_idx = -1\\n for j in range(26):\\n if batches[j]==i:\\n min_idx = min(mins[j],min_idx)\\n max_idx = max(maxs[j],max_idx)\\n res.append(S[min_idx:max_idx+1])\\n return res\",\n \"runtime\": \"1106\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n # graph = [[] for _ in range((len(s)))]\\n\\n count = Counter(s)\\n\\n original_count = Counter(s)\\n\\n ans = []\\n\\n isDone = [False] * len(s)\\n\\n first_pos = {}\\n\\n parent = -1\\n\\n # graph[len(s)-1].append(0)\\n\\n for i in range(len(s)):\\n count[s[i]] -= 1\\n\\n if s[i] not in first_pos:\\n first_pos[s[i]] = i\\n \\n if count[s[i]] == 0:\\n start = first_pos[s[i]]\\n begin = start\\n\\n while start <= i:\\n if first_pos[s[start]] < begin:\\n start = first_pos[s[start]]\\n begin = start\\n start += 1\\n \\n start = begin\\n temp_count = Counter(s[start : i+1])\\n\\n while start <= i:\\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\\n break\\n start += 1\\n \\n if start > i:\\n isDone[i] = True\\n # print(s[begin : i + 1], isDone, sep = '->')\\n ans.append(s[begin : i + 1])\\n \\n if len(ans) == 0:\\n ans.append(s)\\n print(ans)\\n\\n return ans\",\n \"runtime\": \"1106\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n # graph = [[] for _ in range((len(s)))]\\n\\n count = Counter(s)\\n\\n original_count = Counter(s)\\n\\n ans = []\\n\\n isDone = [False] * len(s)\\n\\n first_pos = {}\\n\\n parent = -1\\n\\n # graph[len(s)-1].append(0)\\n\\n for i in range(len(s)):\\n count[s[i]] -= 1\\n\\n if s[i] not in first_pos:\\n first_pos[s[i]] = i\\n \\n if count[s[i]] == 0:\\n start = first_pos[s[i]]\\n begin = start\\n\\n while start <= i:\\n if first_pos[s[start]] < begin:\\n start = first_pos[s[start]]\\n begin = start\\n start += 1\\n \\n start = begin\\n temp_count = Counter(s[start : i+1])\\n\\n while start <= i:\\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\\n break\\n start += 1\\n \\n if start > i:\\n isDone[i] = True\\n # print(s[begin : i + 1], isDone, sep = '->')\\n ans.append(s[begin : i + 1])\\n \\n if len(ans) == 0:\\n ans.append(s)\\n print(ans)\\n\\n return ans\",\n \"runtime\": \"1154\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n # graph = [[] for _ in range((len(s)))]\\n\\n count = Counter(s)\\n\\n original_count = Counter(s)\\n\\n ans = []\\n\\n isDone = [False] * len(s)\\n\\n first_pos = {}\\n\\n parent = -1\\n\\n # graph[len(s)-1].append(0)\\n\\n for i in range(len(s)):\\n count[s[i]] -= 1\\n\\n if s[i] not in first_pos:\\n first_pos[s[i]] = i\\n \\n if count[s[i]] == 0:\\n start = first_pos[s[i]]\\n begin = start\\n\\n while start <= i:\\n if first_pos[s[start]] < begin:\\n start = first_pos[s[start]]\\n begin = start\\n start += 1\\n \\n start = begin\\n temp_count = Counter(s[start : i+1])\\n\\n while start <= i:\\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\\n break\\n start += 1\\n \\n if start > i:\\n isDone[i] = True\\n # print(s[begin : i + 1], isDone, sep = '->')\\n ans.append(s[begin : i + 1])\\n \\n if len(ans) == 0:\\n ans.append(s)\\n print(ans)\\n\\n return ans\",\n \"runtime\": \"1203\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Step 1: Determine the start and end indices of each character\\n start_idx = {}\\n end_idx = {}\\n for i, c in enumerate(s):\\n if c not in start_idx:\\n start_idx[c] = i\\n end_idx[c] = i\\n \\n # Step 2: Extend the intervals\\n intervals = []\\n for c in start_idx.keys():\\n left = start_idx[c]\\n right = end_idx[c]\\n while True:\\n for i in range(left, right + 1):\\n if start_idx[s[i]] < left:\\n left = start_idx[s[i]]\\n if end_idx[s[i]] > right:\\n right = end_idx[s[i]]\\n if left == start_idx[c] and right == end_idx[c]:\\n break\\n start_idx[c] = left\\n end_idx[c] = right\\n intervals.append((left, right))\\n \\n # Step 3: Merge overlapping intervals\\n intervals.sort(key=lambda x: x[1])\\n result = []\\n current_end = -1\\n for start, end in intervals:\\n if start > current_end:\\n result.append(s[start:end + 1])\\n current_end = end\\n \\n return result\\n\\n# Example usage:\\nsolution = Solution()\\ns = \\\"adefaddaccc\\\"\\nprint(solution.maxNumOfSubstrings(s)) # Output: [\\\"e\\\",\\\"f\\\",\\\"ccc\\\"]\",\n \"runtime\": \"1251\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n chars = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n cache = {}\\n n = len(s)\\n for ch in chars:\\n i = 0\\n start, end = -1, -1\\n while i < n:\\n if s[i] == ch:\\n start = i\\n break\\n i += 1\\n j = n - 1\\n while j >= 0:\\n if s[j] == ch:\\n end = j\\n break\\n j -= 1\\n if start != -1:\\n cache[ch] = [start, end]\\n intervals = []\\n for ch in chars:\\n if ch in cache:\\n seen = set(ch)\\n start = cache[ch][0]\\n end = cache[ch][1]\\n needed = True\\n while needed:\\n needed = False\\n ranges = []\\n for i in range(start, end):\\n if s[i] not in seen:\\n needed = True\\n ranges.append(cache[s[i]])\\n seen.add(s[i])\\n for r in ranges:\\n start = min(start, r[0])\\n end = max(end, r[1])\\n intervals.append([start, end])\\n intervals.sort(key = lambda x: x[1])\\n res = [[] for i in range(len(intervals))]\\n res[0] = [[intervals[0]],(intervals[0][1] - intervals[0][0] + 1) ]\\n for j in range(1, len(intervals)):\\n interval = intervals[j]\\n k = j - 1\\n while k >= 0 and intervals[k][1] > interval[0]:\\n k -= 1\\n count = 1 + (0 if k == -1 else len(res[k][0]))\\n if count > len(res[j - 1][0]):\\n res[j] = [res[k][0] + [interval], res[k][1] + (interval[1] - interval[0] + 1)]\\n elif count <= len(res[j - 1][0]):\\n res[j] = res[j - 1]\\n res.sort(key = lambda x: (len(x[0]), -x[1]))\\n ans = []\\n for r in res[-1][0]:\\n ans.append(s[r[0]: r[1] + 1])\\n return ans\\n \\n\\n\",\n \"runtime\": \"1300\"\n },\n {\n \"code\": \"class Solution:\\n def construct(self,exists,prefixsum,charstarts,charends):\\n graph=[[False for _ in range(26)] for _ in range(26)]\\n for vertex in range(26):\\n if exists[vertex]:\\n charstart,charend=charstarts[vertex],charends[vertex]\\n for nbr in range(26):\\n nbrcount=prefixsum[charend+1][nbr]-prefixsum[charstart][nbr]\\n if nbrcount>0:\\n graph[vertex][nbr] = True\\n return graph\\n \\n def topo(self,graph,exists):\\n st,vis=[],[False for _ in range(26)]\\n def dfs(vertex):\\n vis[vertex]=True\\n for nbr in range(26):\\n if graph[vertex][nbr] and not vis[nbr]:\\n dfs(nbr)\\n st.append(vertex)\\n for vertex in range(26):\\n if exists[vertex] and not vis[vertex]:\\n dfs(vertex)\\n return st\\n \\n def getandbatchesoutdegree(self,graph,st):\\n batches,degree,totalbatches=[-1 for _ in range(26)],[False for _ in range(26)],0\\n def dfs(vertex):\\n vertexbatch=batches[vertex]\\n if vertexbatch<0:\\n batches[vertex]=totalbatches\\n for nbr in range(26):\\n if graph[nbr][vertex]:\\n dfs(nbr)\\n else:\\n if vertexbatch!=totalbatches:\\n degree[vertexbatch]+=1\\n while st:\\n vertex=st.pop()\\n vertexbatch=batches[vertex]\\n if vertexbatch<0:\\n dfs(vertex)\\n totalbatches+=1\\n return batches,degree,totalbatches\\n \\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n length=len(s)\\n charstarts=[float(\\\"inf\\\") for _ in range(26)]\\n charends=[-1 for _ in range(26)]\\n exists=[False for _ in range(26)]\\n prefixsum = [[0 for _ in range(26)] for _ in range(length+1)]\\n for index,char in enumerate(s):\\n prefixsum[index+1]=prefixsum[index][:]\\n charidx=ord(char)-ord('a')\\n exists[charidx]=True\\n charstarts[charidx]=min(charstarts[charidx],index)\\n charends[charidx]=max(charends[charidx],index)\\n prefixsum[index+1][charidx]+=1\\n graph=self.construct(exists,prefixsum,charstarts,charends)\\n st=self.topo(graph,exists)\\n batches,degree,totalbatches=self.getandbatchesoutdegree(graph,st)\\n res=[]\\n for batch in range(totalbatches):\\n if degree[batch]==0:\\n mini,maxi=float(\\\"inf\\\"),-1\\n for vertex in range(26):\\n vertexbatch=batches[vertex]\\n if batch==vertexbatch:\\n mini=min(mini,charstarts[vertex])\\n maxi=max(maxi,charends[vertex])\\n res.append(s[mini:maxi+1])\\n return res\",\n \"runtime\": \"1348\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n map = {}\\n interval = []\\n for i in range(n):\\n if map.get(s[i]):\\n map[s[i]][1] = i\\n else:\\n map[s[i]] = [i,i]\\n\\n for i in range(n):\\n if map[s[i]][0] == i:\\n left = i\\n right = map[s[i]][1]\\n\\n j = left\\n flag = True\\n while j <= right:\\n if map[s[j]][0] < left:\\n flag = False;\\n right = max(right,map[s[j]][1])\\n j+=1\\n if flag:\\n interval.append([left,right])\\n interval.sort(key = lambda x : x[1])\\n ans = []\\n hi = -1\\n for pair in interval:\\n if pair[0] > hi:\\n ans.append(s[pair[0]:pair[1]+1])\\n hi = pair[1]\\n return ans if ans else [s]\\n\\n \",\n \"runtime\": \"1397\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n\\n\\n first_and_last = {}\\n for i in range(len(s)):\\n if s[i] not in first_and_last:\\n for j in range(len(s)-1,i-1,-1):\\n if s[j]==s[i]:\\n first_and_last[s[i]]=(i,j)\\n break\\n\\n letters_in_between = {}\\n for key in first_and_last.keys():\\n t = [False for _ in range(26)]\\n\\n for i in range(first_and_last[key][0],first_and_last[key][1]):\\n t[ord(s[i])-97]=True\\n\\n t[ord(key)-97]=False\\n letters_in_between[key] = set()\\n for i in range(26):\\n if t[i]:\\n letters_in_between[key].add(chr(i+97))\\n\\n\\n\\n intervals = []\\n for key, value in first_and_last.items():\\n intervals.append((value[0], value[1], key))\\n\\n some_change = True\\n while some_change:\\n intervals = sorted(intervals)\\n\\n some_change = False\\n for i in range(len(intervals)):\\n start,end,bukva = intervals[i]\\n\\n for letter in letters_in_between[bukva]:\\n start = min(start,first_and_last[letter][0])\\n end = max(end,first_and_last[letter][1])\\n\\n intervals[i] = [start,end,bukva]\\n if start !=first_and_last[bukva][0] or end!=first_and_last[bukva][1]:\\n some_change = True\\n first_and_last[bukva]=(start,end)\\n\\n for i in range(len(intervals)):\\n intervals[i][0], intervals[i][1] =intervals[i][1],intervals[i][0]\\n for end,start,bukva in intervals:\\n first_and_last[bukva]=(start,end)\\n intervals = sorted(intervals)\\n\\n beginning_intervals = {}\\n ending_intervals = {}\\n\\n d = [[] for _ in s]\\n for i in range(len(intervals)):\\n end,start,bukva = intervals[i]\\n if end not in ending_intervals:\\n ending_intervals[end]=[]\\n if start not in beginning_intervals:\\n beginning_intervals[start]=[]\\n beginning_intervals[start].append((end,bukva))\\n ending_intervals[end].append((start,bukva))\\n\\n if 0 in ending_intervals:\\n d[0]=[[1,1,s[0]]] # howmany strings, total length all combined, which letters\\n\\n for i in range(1,len(s)):\\n best = {}\\n for j in d[i-1]:\\n best[j[0]]=(j[1],j[2])\\n\\n if i in ending_intervals:\\n for start,bukva in ending_intervals[i]:\\n if 1 not in best or best[1][0]>i-start+1:\\n best[1]=(i-start+1,bukva)\\n\\n\\n if start-1>=0:\\n for howmany,totallength,allletters in d[start-1]:\\n if howmany+1 not in best or best[howmany+1][0]>totallength+i-start+1:\\n best[howmany+1]=(totallength+ i-start+1, allletters+bukva)\\n\\n for j in range(1,27):\\n if j in best:\\n d[i].append((j, best[j][0],best[j][1]))\\n else:\\n break\\n\\n\\n\\n t = d[-1][-1][-1] # for the last dp index, take the last one, which is the most letters, and take the last index which can tell you with which letters you need to construct this\\n\\n ans = []\\n for bukva in t:\\n ans.append(s[first_and_last[bukva][0]: first_and_last[bukva][1]+1])\\n\\n return ans\\n\",\n \"runtime\": \"1445\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n map = {}\\n interval = []\\n for i in range(n):\\n if map.get(s[i]):\\n map[s[i]][1] = i\\n else:\\n map[s[i]] = [i,i]\\n\\n for i in range(n):\\n if map[s[i]][0] == i:\\n left = i\\n right = map[s[i]][1]\\n\\n j = left\\n flag = True\\n while j <= right:\\n if map[s[j]][0] < left:\\n flag = False;\\n right = max(right,map[s[j]][1])\\n j+=1\\n if flag:\\n interval.append([left,right])\\n print(interval)\\n interval.sort(key = lambda x : x[1])\\n ans = []\\n hi = -1\\n for pair in interval:\\n if pair[0] > hi:\\n ans.append(s[pair[0]:pair[1]+1])\\n hi = pair[1]\\n return ans if ans else [s]\\n\\n \",\n \"runtime\": \"1494\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Compute occurrency range for each character.\\n occurrence = dict()\\n for i, c in enumerate(s):\\n if c not in occurrence:\\n # New character.\\n occurrence[c] = [i, i]\\n else:\\n # Update last occurrence of seen character.\\n occurrence[c][1] = i\\n \\n # Align interval beginnings.\\n open_intervals = set()\\n for i, c in enumerate(s):\\n # Update all open intervals.\\n for o in open_intervals:\\n if occurrence[o][0] > occurrence[c][0]:\\n occurrence[o][0] = occurrence[c][0]\\n if occurrence[o][1] < occurrence[c][1]:\\n occurrence[o][1] = occurrence[c][1]\\n open_intervals.add(c)\\n open_intervals = {\\n o\\n for o in open_intervals\\n if occurrence[o][1] != i\\n }\\n\\n # Compute adjacency list.\\n intervals = sorted(list(set(tuple(o) for o in occurrence.values())))\\n n = len(intervals)\\n adj_list = [list() for _ in range(n)]\\n for i in range(n):\\n for j in range(i + 1, n):\\n if intervals[i][1] < intervals[j][0]:\\n adj_list[i].append(j)\\n\\n # Compute longest path.\\n HOP = len(s) + 1\\n dist_to = [-float('inf')] * n\\n edge_to = [-1] * n\\n queue = deque()\\n for i in range(n):\\n dist_to[i] = intervals[i][0] - intervals[i][1]\\n queue.append(i)\\n while queue:\\n i = queue.popleft()\\n for nxt in adj_list[i]:\\n dist = dist_to[i] + HOP + (intervals[nxt][0] - intervals[nxt][1])\\n if dist_to[nxt] < dist:\\n dist_to[nxt] = dist\\n edge_to[nxt] = i\\n queue.append(nxt)\\n\\n # Compute result.\\n res = []\\n idx = max(range(n), key=lambda i: dist_to[i])\\n while idx != -1:\\n res.append(s[intervals[idx][0]:intervals[idx][1] + 1])\\n idx = edge_to[idx]\\n return res\",\n \"runtime\": \"1542\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n\\\"cabcccbaa\\\"\\n\\n\\n\\\"bbcacbaba\\\"\\n\\n 0123456789\\n\\\"bbeadcxede\\\" ->[\\\"bb\\\",\\\"a\\\",\\\"c\\\",\\\"x\\\"]\\n\\n\\\"abcdefghijklmnopqrstuvwxyz\\\"\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n def dp(idx, cur_list):\\n if idx == len(condition_1_candidates):\\n num_strs = len(cur_list)\\n all_together_list = [s[x:y + 1] for x, y in cur_list]\\n all_together = \\\"\\\".join(all_together_list)\\n if result:\\n prev_num = result[0]\\n len_prev = result[1]\\n if num_strs > prev_num:\\n result[0] = num_strs\\n result[1] = len(all_together)\\n result[2] = all_together_list\\n elif num_strs == prev_num and len(all_together) < len_prev:\\n result[0] = num_strs\\n result[1] = len(all_together)\\n result[2] = all_together_list\\n else:\\n result.append(num_strs)\\n result.append(len(all_together))\\n result.append(all_together_list)\\n\\n return\\n\\n cur_i, cur_j = condition_1_candidates[idx]\\n \\n # always take it if it's once char\\n if cur_i == cur_j:\\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\\n return\\n\\n is_cur_valid = True\\n for i, j in cur_list:\\n if cur_i <= i <= cur_j:\\n is_cur_valid = False\\n break\\n if cur_i <= j <= cur_j:\\n is_cur_valid = False\\n break\\n\\n if is_cur_valid:\\n # take it\\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\\n # or skip it\\n dp(idx + 1, cur_list.copy())\\n else:\\n # skip it\\n dp(idx + 1, cur_list.copy())\\n\\n char_to_start_end = {}\\n for i, c in enumerate(s):\\n if c in char_to_start_end:\\n char_to_start_end[c][1] = i\\n else:\\n char_to_start_end[c] = [i, i]\\n\\n condition_1_candidates = set()\\n for c, (s_i, e_i) in char_to_start_end.items():\\n min_i = s_i\\n min_j = e_i\\n seen = set()\\n seen.add(c)\\n for j in range(s_i + 1, e_i):\\n next_char = s[j]\\n h = [char_to_start_end[next_char][0]]\\n max_h = [-char_to_start_end[next_char][1]]\\n while h[0] < min_i:\\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\\n min_i = min_i - 1\\n\\n while -max_h[0] > min_j:\\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\\n min_j = min_j + 1\\n\\n while h[0] < min_i:\\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\\n min_i = min_i - 1\\n\\n while -max_h[0] > min_j:\\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\\n min_j = min_j + 1\\n\\n condition_1_candidates.add((min_i, min_j))\\n\\n condition_1_candidates = list(condition_1_candidates)\\n condition_1_candidates.sort(key=lambda x:abs(x[0] - x[1]))\\n print(condition_1_candidates)\\n result = []\\n dp(0, [])\\n\\n return result[2]\",\n \"runtime\": \"1590\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n left = defaultdict(int)\\n right = defaultdict(int)\\n chars = set()\\n n = len(s)\\n for c in s:\\n chars.add(c)\\n for c in chars:\\n for i, c in enumerate(s):\\n if c not in left:\\n left[c] = i\\n else:\\n right[c] = i\\n candidates = list()\\n for c in chars:\\n range_list = [[left[c],right[c]]]\\n start, end = left[c], right[c]\\n visited = set()\\n while range_list:\\n l,r = range_list.pop()\\n next_start, next_end = l, r\\n for i in range(l, r):\\n if s[i] in visited:\\n continue\\n visited.add(s[i])\\n next_end = max(right[s[i]], next_end)\\n next_start = min(left[s[i]], next_start)\\n if next_start != l:\\n range_list.append([next_start, l])\\n if next_end != r:\\n range_list.append([r, next_end])\\n start = min(next_start, start)\\n end = max(end, next_end)\\n candidates.append((start,end))\\n\\n def bisect(interval):\\n if len(result) == 0:\\n return 0\\n l = 0\\n r = len(result)\\n while l < r:\\n mid = l + (r-l)//2\\n if result[mid][0] > interval[1]:\\n r = mid\\n elif result[mid][1] < interval[0]:\\n l = mid + 1\\n else:\\n return -1\\n return l\\n candidates.sort(key=lambda x: x[1]-x[0])\\n result = list()\\n for candidate in candidates: \\n i = bisect(candidate)\\n if i >= 0:\\n result.insert(i, candidate) \\n return [s[l:r+1] for l,r in result]\\n \",\n \"runtime\": \"1639\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n left = defaultdict(int)\\n right = defaultdict(int)\\n chars = set()\\n n = len(s)\\n for c in s:\\n chars.add(c)\\n if len(chars) == 26:\\n break\\n for c in chars:\\n for i, c in enumerate(s):\\n if c not in left:\\n left[c] = i\\n else:\\n right[c] = i\\n candidates = list()\\n for c in chars:\\n range_list = [[left[c],right[c]]]\\n start, end = left[c], right[c]\\n visited = set()\\n while range_list:\\n l,r = range_list.pop()\\n next_start, next_end = l, r\\n for i in range(l, r):\\n if s[i] in visited:\\n continue\\n visited.add(s[i])\\n next_end = max(right[s[i]], next_end)\\n next_start = min(left[s[i]], next_start)\\n if next_start != l:\\n range_list.append([next_start, l])\\n if next_end != r:\\n range_list.append([r, next_end])\\n start = min(next_start, start)\\n end = max(end, next_end)\\n candidates.append((start,end))\\n\\n def bisect(interval):\\n if len(result) == 0:\\n return 0\\n l = 0\\n r = len(result)\\n while l < r:\\n mid = l + (r-l)//2\\n if result[mid][0] > interval[1]:\\n r = mid\\n elif result[mid][1] < interval[0]:\\n l = mid + 1\\n else:\\n return -1\\n return l\\n candidates.sort(key=lambda x: x[1]-x[0])\\n result = list()\\n for candidate in candidates: \\n i = bisect(candidate)\\n if i >= 0:\\n result.insert(i, candidate) \\n return [s[l:r+1] for l,r in result]\\n \",\n \"runtime\": \"1687\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n first = {}\\n last = {}\\n \\n # Find the first and last occurrence of each character\\n for i in range(n):\\n if s[i] not in first:\\n first[s[i]] = i\\n last[s[i]] = i\\n \\n intervals = []\\n \\n # Generate valid intervals for each character\\n for i in range(n):\\n if first[s[i]] == i: # Only consider the first occurrence\\n left = i\\n right = last[s[i]]\\n \\n # Expand the interval to include all characters\\n j = left\\n while j <= right:\\n left = min(left, first[s[j]])\\n right = max(right, last[s[j]])\\n j += 1\\n \\n # Only add the interval if it's still valid (start == first occurrence)\\n if left == i:\\n intervals.append((left, right))\\n \\n # Sort intervals by their end positions\\n intervals.sort(key=lambda x: x[1])\\n \\n ans = []\\n last_end = -1\\n \\n # Select non-overlapping intervals\\n for start, end in intervals:\\n if start > last_end:\\n ans.append(s[start:end+1])\\n last_end = end\\n \\n return ans\\n\",\n \"runtime\": \"1736\"\n },\n {\n \"code\": \"'''\\n\\n'''\\n\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n N = len(s)\\n \\n left = right = 0\\n starts = defaultdict(int)\\n ends = defaultdict(int)\\n for i in range(N):\\n curr = s[i]\\n if curr not in starts:\\n starts[curr] = i\\n for j in range(N-1, -1,- 1):\\n curr = s[j]\\n if curr not in ends:\\n ends[curr] = j\\n \\n letters = set(list(s))\\n ranges = []\\n \\n \\n for i,curr in enumerate(letters):\\n # r = (starts[curr], ends[curr])\\n # ranges.append(r)\\n left = starts[curr]\\n right = ends[curr]\\n new_left = left\\n new_right = right\\n \\n j = left\\n while j <= right:\\n other = s[j]\\n new_left = min(new_left, starts[other])\\n right = new_right = max(new_right, ends[other])\\n j += 1\\n \\n # if left == 2:\\n # print(starts)\\n # print(ends)\\n # print(curr, (left, new_left), (right, new_right), s[new_left:new_right+1])\\n \\n if new_left == left:\\n ranges.append((left,new_right))\\n \\n \\n ranges.sort(key = lambda x:x[1])\\n stack = []\\n for a,b in ranges:\\n if stack:\\n c,d = stack[-1]\\n if a <= c:\\n continue\\n else:\\n stack.append((a,b))\\n else:\\n stack.append((a,b))\\n \\n return [s[i:j+1] for i,j in stack]\\n \\n \",\n \"runtime\": \"1784\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n first = {}\\n last = {}\\n \\n # Record the first and last occurrence of each character\\n for i, c in enumerate(s):\\n if c not in first:\\n first[c] = i\\n last[c] = i\\n \\n intervals = []\\n \\n # Create intervals for each character\\n for c in set(s):\\n start, end = first[c], last[c]\\n j = start\\n while j <= end:\\n start = min(start, first[s[j]])\\n end = max(end, last[s[j]])\\n j += 1\\n intervals.append((start, end))\\n \\n # Sort intervals by end position, then by start position\\n intervals.sort(key=lambda x: (x[1], x[0]))\\n \\n result = []\\n prev_end = -1\\n \\n # Select non-overlapping intervals\\n for start, end in intervals:\\n if start > prev_end:\\n # Check if the current interval is valid\\n valid = True\\n for i in range(start, end + 1):\\n if first[s[i]] < start or last[s[i]] > end:\\n valid = False\\n break\\n if valid:\\n result.append(s[start:end+1])\\n prev_end = end\\n \\n return result\",\n \"runtime\": \"1833\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n curr_count = Counter(s[start:end])\\n for c in s[start:end]:\\n if count[c] != curr_count[c]:\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n return isValid(start, end)\\n return (start, end)\\n\\n for i, c in enumerate(s):\\n if i != ref[c][0]:\\n continue\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1]) \\n \\n res = []\\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\",\n \"runtime\": \"1881\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n \\n charBoundedSubstring = {}\\n\\n for i, c in enumerate(s):\\n\\n if c not in charBoundedSubstring:\\n charBoundedSubstring[c] = [i, i]\\n \\n left = charBoundedSubstring[c][0]\\n right = charBoundedSubstring[c][1]\\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\\n\\n # print(charBoundedSubstring)\\n intervals = []\\n for alpha in set(s):\\n left = charBoundedSubstring[alpha][0]\\n right = charBoundedSubstring[alpha][1]\\n leftMost, rightMost = left, right\\n # print(left, right)\\n i = left\\n while i <= rightMost:\\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\\n i += 1\\n # print(leftMost, rightMost)\\n \\n if leftMost == left:\\n intervals.append((leftMost, rightMost))\\n \\n intervals.sort()\\n res = []\\n curStart, curEnd = intervals[0][0], intervals[0][1]\\n for interval in intervals:\\n start, end = interval\\n \\n if curStart < start < curEnd and curStart < end < curEnd:\\n curStart, curEnd = start, end\\n \\n if start > curEnd and start > curStart:\\n res.append(s[curStart: curEnd + 1])\\n curStart = start\\n curEnd = end\\n print()\\n res.append(s[curStart: curEnd + 1])\\n print(intervals, res)\\n # intervals.sort()\\n return res\\n\\n\\n\",\n \"runtime\": \"1929\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n \\n charBoundedSubstring = {}\\n\\n for i, c in enumerate(s):\\n\\n if c not in charBoundedSubstring:\\n charBoundedSubstring[c] = [i, i]\\n \\n left = charBoundedSubstring[c][0]\\n right = charBoundedSubstring[c][1]\\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\\n\\n # print(charBoundedSubstring)\\n intervals = []\\n for alpha in set(s):\\n left = charBoundedSubstring[alpha][0]\\n right = charBoundedSubstring[alpha][1]\\n leftMost, rightMost = left, right\\n # print(left, right)\\n i = left\\n while i <= rightMost:\\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\\n i += 1\\n # print(leftMost, rightMost)\\n \\n if leftMost == left:\\n intervals.append((leftMost, rightMost))\\n \\n intervals.sort()\\n res = []\\n curStart, curEnd = intervals[0][0], intervals[0][1]\\n for interval in intervals:\\n start, end = interval\\n \\n if curStart < start < curEnd and curStart < end < curEnd:\\n curStart, curEnd = start, end\\n \\n if start > curEnd and start > curStart:\\n res.append(s[curStart: curEnd + 1])\\n curStart = start\\n curEnd = end\\n # print()\\n res.append(s[curStart: curEnd + 1])\\n # print(intervals, res)\\n # intervals.sort()\\n return res\\n\\n\\n\",\n \"runtime\": \"1978\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n curr_count = Counter(s[start:end])\\n #print(s[start:end], curr_count)\\n for c in s[start:end]:\\n if count[c] != curr_count[c]:\\n #print(c, \\\"not it\\\")\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n return isValid(start, end)\\n return (start, end)\\n\\n for i, c in enumerate(s):\\n if i != ref[c][0]:\\n continue\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n #print(\\\"got\\\", start, end, \\\"for\\\", i, c)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1])\\n\\n print(substrs)\\n \\n \\n \\n res = []\\n \\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"2026\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n crange = {}\\n aset = []\\n for i in range(len(s)):\\n if s[i] not in crange:\\n crange[s[i]] = []\\n crange[s[i]].append(i)\\n \\n #print(crange)\\n\\n \\n for p in crange.keys():\\n i = crange[p][0]\\n for _ in crange.keys():\\n j = crange[_][-1]\\n if i > j:\\n continue\\n valid = True\\n #print(s[i],s[j])\\n for k in range(i,j+1):\\n if i <= crange[s[k]][0] and j >= crange[s[k]][-1]:\\n continue\\n else:\\n valid = False\\n break\\n\\n if valid:\\n aset.append(s[i:j+1])\\n\\n aset.sort(key = lambda x : len(x))\\n ansr = set()\\n ans = []\\n for i in aset:\\n val = True\\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\\n if j in ansr:\\n val = False\\n break\\n if val:\\n ans.append(i)\\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\\n ansr.add(j)\\n\\n #print(aset)\\n return ans\",\n \"runtime\": \"2075\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n min_idx, max_idx = [n]*26, [-1]*26\\n base_char_ord = ord(\\\"a\\\")\\n\\n for i in range(n):\\n char_idx = ord(s[i]) - base_char_ord\\n min_idx[char_idx] = min(i, min_idx[char_idx])\\n max_idx[char_idx] = max(i, max_idx[char_idx])\\n\\n # print(*min_idx)\\n # print(*max_idx)\\n \\n for char_idx in range(26):\\n if min_idx[char_idx] == n : continue\\n l = min_idx[char_idx]\\n r = l\\n while min_idx[char_idx] < l or r < max_idx[char_idx]:\\n if min_idx[char_idx] < l:\\n l -= 1\\n new_char_idx = ord(s[l]) - base_char_ord\\n min_idx[char_idx] = min(min_idx[new_char_idx], min_idx[char_idx])\\n max_idx[char_idx] = max(max_idx[new_char_idx], max_idx[char_idx])\\n if r < max_idx[char_idx]:\\n r += 1\\n new_char_idx = ord(s[r]) - base_char_ord\\n min_idx[char_idx] = min(min_idx[new_char_idx], min_idx[char_idx])\\n max_idx[char_idx] = max(max_idx[new_char_idx], max_idx[char_idx])\\n # print(f\\\"for char : {char_idx} {s[min_idx[char_idx]:max_idx[char_idx]+1]}\\\")\\n min_idx\\n\\n # print(min_idx[:10])\\n # print(max_idx[:10])\\n\\n char_idxs_sorted = sorted(list(range(26)), key = lambda idx: (max_idx[idx], min_idx[idx]))\\n ans = []\\n prev_str_idx = -1\\n\\n for char_idx in char_idxs_sorted:\\n l, r = min_idx[char_idx], max_idx[char_idx]\\n if prev_str_idx >= l or l == n : \\n continue\\n ans.append(s[l:r+1])\\n prev_str_idx = r\\n\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"2123\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n arr = [ord(c) - ord('a') for c in s]\\n leftest = [-1] * 26\\n rightest = [-1] * 26\\n prefixsum = [[0 for _ in range(26)] for __ in range(n)]\\n \\n for i in range(n):\\n x = arr[i]\\n if leftest[x] == -1:\\n leftest[x] = i\\n rightest[x] = i\\n prefixsum[i][x] = 1\\n if i - 1 >= 0:\\n for x in range(26):\\n prefixsum[i][x] += prefixsum[i - 1][x]\\n def check_exist(l, r, x):\\n v = prefixsum[r][x]\\n if l - 1 >= 0:\\n v -= prefixsum[l - 1][x]\\n return v > 0\\n\\n dp = [(0, 0, 0, -1, -1)] * n # dp[r2] = (max cnts, min total length at max cnts, l, r, prev r) at r where r <= r2\\n for r in range(n):\\n if r - 1 >= 0:\\n dp[r] = dp[r - 1]\\n \\n l = r\\n # find largest l such that s[l to r] is a valid substring\\n chars = [0] * 26\\n chars[arr[r]] = 1\\n new_chars = [arr[r]]\\n ok = True\\n while new_chars: # This can happen for at most 26 times.\\n x = new_chars.pop()\\n if rightest[x] > r:\\n ok = False\\n break\\n l = min(l, leftest[x])\\n # Check for new characters in O(26)\\n for i in range(26):\\n if check_exist(l, r, i) and chars[i] == 0:\\n new_chars.append(i)\\n chars[i] = 1\\n if ok:\\n if l - 1 >= 0:\\n prev_max_cnts = dp[l - 1][0]\\n prev_total_length = dp[l - 1][1]\\n prev_r = dp[l - 1][3]\\n else:\\n prev_max_cnts = 0\\n prev_total_length = 0\\n prev_r = -1\\n if (prev_max_cnts + 1 > dp[r][0]) or (prev_max_cnts + 1 == dp[r][0] and prev_total_length + r - l + 1 < dp[r][1]):\\n dp[r] = (prev_max_cnts + 1, prev_total_length + r - l + 1, l, r, prev_r)\\n # print(s)\\n # print(dp)\\n ans = []\\n r2 = n - 1\\n while True:\\n l = dp[r2][2]\\n r = dp[r2][3] # best r <= r2\\n # print(f'r2={r2} l={l} r={r} s[l: r + 1]={s[l: r + 1]}')\\n prev_r = dp[r2][4]\\n ans.append(s[l: r + 1])\\n if prev_r == -1:\\n break\\n r2 = prev_r\\n ans.reverse()\\n return ans\",\n \"runtime\": \"2172\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = sorted(char_to_intervals.values())\\n merged_intervals = set()\\n print(\\\"start_ends\\\", start_ends)\\n\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n ret = []\\n # print(merged_intervals)\\n merged_intervals = list(merged_intervals)\\n for i in range(len(merged_intervals)):\\n cur = merged_intervals[i]\\n has_nested = False\\n for j in range(len(merged_intervals)):\\n if i == j:\\n continue\\n inter = merged_intervals[j]\\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\\n has_nested = True\\n break\\n if not has_nested:\\n ret.append(cur)\\n return [s[start:end + 1] for start, end in ret]\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2220\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = sorted(char_to_intervals.values())\\n merged_intervals = set()\\n print(\\\"start_ends\\\", start_ends)\\n\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n ret = []\\n # print(merged_intervals)\\n merged_intervals = list(merged_intervals)\\n for i in range(len(merged_intervals)):\\n cur = merged_intervals[i]\\n has_nested = False\\n for j in range(len(merged_intervals)):\\n if i == j:\\n continue\\n inter = merged_intervals[j]\\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\\n has_nested = True\\n break\\n if not has_nested:\\n ret.append(cur)\\n return [s[start:end + 1] for start, end in ret]\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2269\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = list(char_to_intervals.values())\\n merged_intervals = set()\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n merged_intervals = sorted(list(merged_intervals), key=lambda x:x[1])\\n ret = []\\n last = None\\n for start, end in merged_intervals:\\n if last == None or start >= last:\\n ret.append(s[start:end + 1])\\n last = end\\n return ret\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2317\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = {}\\n for index, char in enumerate(s):\\n if char not in ranges:\\n ranges[char] = [index, index + 1]\\n else:\\n ranges[char][1] = index + 1\\n for char, (first, last) in ranges.items():\\n while True:\\n newFirst, newLast = first, last\\n for otherChar in s[first:last]:\\n newFirst = min(newFirst, ranges[otherChar][0])\\n newLast = max(newLast, ranges[otherChar][1])\\n if (newFirst, newLast) == (first, last):\\n break\\n first, last = newFirst, newLast\\n ranges[char][0], ranges[char][1] = first, last\\n \\n prev = 0\\n res = []\\n for start, end in sorted(ranges.values(), key=lambda x: x[1]):\\n if start >= prev:\\n res.append(s[start:end])\\n prev = end\\n return res\",\n \"runtime\": \"2365\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = sorted(char_to_intervals.values())\\n merged_intervals = set()\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n ret = []\\n merged_intervals = list(merged_intervals)\\n for i in range(len(merged_intervals)):\\n cur = merged_intervals[i]\\n has_nested = False\\n for j in range(len(merged_intervals)):\\n if i == j:\\n continue\\n inter = merged_intervals[j]\\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\\n has_nested = True\\n break\\n if not has_nested:\\n ret.append(cur)\\n return [s[start:end + 1] for start, end in ret]\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2414\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":62,"string":"62"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = {}\n for i in range(len(s)):\n if s[i] in d:\n d[s[i]][1] = i\n else:\n d[s[i]] = [i, i]\n for key in d:\n start, end = d[key]\n q = deque([(start, end)])\n while q:\n scur, ecur = q.popleft()\n for i in range(scur, ecur + 1):\n snew, enew = d[s[i]]\n if snew < start:\n q.append((snew, start - 1))\n start = snew\n if enew > end:\n q.append((end + 1, enew))\n end = enew\n d[key] = [start, end]\n\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\n seen = []\n ans = []\n for start, end in sorted_ranges:\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\n continue\n ans.append(s[start: end + 1])\n seen.append((start, end))\n return ans","memory":"16400"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Primeiro, identificamos os intervalos válidos para cada caractere\n intervals = {}\n for i, char in enumerate(s):\n if char not in intervals:\n intervals[char] = [i, i]\n else:\n intervals[char][1] = i\n\n # Em seguida, expandimos os intervalos para atender às condições\n valid_intervals = []\n for interval in intervals.values():\n start, end = interval[0], interval[1]\n i = start\n while i <= end:\n if intervals[s[i]][0] < start:\n start = intervals[s[i]][0]\n i = start\n if intervals[s[i]][1] > end:\n end = intervals[s[i]][1]\n i += 1\n valid_intervals.append([start, end])\n\n # Ordenamos os intervalos pelo fim em ordem crescente\n valid_intervals.sort(key=lambda x: x[1])\n\n # Construímos as substrings usando os intervalos válidos\n result = []\n prev_end = float('-inf')\n for interval in valid_intervals:\n start, end = interval[0], interval[1]\n if start > prev_end:\n result.append(s[start:end+1])\n prev_end = end\n\n return result","memory":"17400"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n ends = {}\n counter = defaultdict(int)\n for i in range(n-1,-1,-1):\n if s[i] not in ends:\n ends[s[i]] = i\n counter[s[i]] += 1\n ans = []\n seen = set()\n stack = []\n i = 0\n \n included = -1\n while i < n:\n #print(s[i])\n if s[i] not in seen:\n seen.add(s[i])\n stack.append(i)\n if ends[s[i]] == i:\n seen.remove(s[i])\n stack_index = len(stack)-1\n curr = 0\n #print(stack,s[i],included,stack_index,seen)\n while stack[stack_index] > included and s[stack[stack_index]] not in seen:\n curr += counter[s[stack[stack_index]]]\n if i - stack[stack_index] + 1 == curr:\n # shortest segment found\n ans.append(s[stack[stack_index]:i+1])\n included = i\n stack_index -= 1\n \n \n i += 1\n return ans if ans else [s]","memory":"17600"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n \n charBoundedSubstring = {}\n\n for i, c in enumerate(s):\n\n if c not in charBoundedSubstring:\n charBoundedSubstring[c] = [i, i]\n \n left = charBoundedSubstring[c][0]\n right = charBoundedSubstring[c][1]\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\n\n # print(charBoundedSubstring)\n intervals = []\n for alpha in set(s):\n left = charBoundedSubstring[alpha][0]\n right = charBoundedSubstring[alpha][1]\n leftMost, rightMost = left, right\n # print(left, right)\n i = left\n while i <= rightMost:\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\n i += 1\n # print(leftMost, rightMost)\n \n if leftMost == left:\n intervals.append((leftMost, rightMost))\n \n intervals.sort()\n res = []\n curStart, curEnd = intervals[0][0], intervals[0][1]\n for interval in intervals:\n start, end = interval\n \n if curStart < start < curEnd and curStart < end < curEnd:\n curStart, curEnd = start, end\n \n if start > curEnd and start > curStart:\n res.append(s[curStart: curEnd + 1])\n curStart = start\n curEnd = end\n # print()\n res.append(s[curStart: curEnd + 1])\n # print(intervals, res)\n # intervals.sort()\n return res\n\n\n","memory":"17700"},{"code":"class Solution:\n def dfs(self, i):\n if i in self.dfs_store:\n return self.dfs_store[i]\n \n v = self.dfs(i+1)\n \n _, end = self.valid_intervals[i]\n j = i + 1\n while j < self.len and self.valid_intervals[j][0] < end:\n j += 1\n if len(v) >= 1 + len(self.dfs(j)):\n self.dfs_store[i] = v\n else:\n self.dfs_store[i] = [self.valid_intervals[i]] + self.dfs_store[j]\n return self.dfs_store[i]\n \n def maxNumOfSubstrings(self, s: str):\n store = {}\n for i, c in enumerate(s):\n if c not in store:\n store[c] = [i, i]\n else:\n store[c][-1] = i\n valid_intervals = []\n for c in store:\n begin, end = store[c]\n checked = set([c])\n flag = True\n i = begin + 1\n while i <= end:\n d = s[i]\n i += 1\n if d in checked:\n continue\n d_begin, d_end = store[d]\n if d_begin < begin:\n flag = False\n break\n if d_end > end:\n end = d_end\n checked.add(d)\n if flag:\n valid_intervals.append([begin, end])\n valid_intervals.sort()\n \n self.len = len(valid_intervals)\n self.dfs_store = {self.len: []}\n self.valid_intervals = valid_intervals\n self.dfs(0)\n rt = []\n for begin, end in self.dfs_store[0]:\n rt.append(s[begin: end+1])\n \n return rt","memory":"17800"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = dict()\n i = 0\n for char in s:\n if char in ranges:\n ranges[char][1] = i\n else:\n ranges[char] = [i, i]\n i += 1\n\n # print(ranges)\n\n for char in ranges:\n range_min, range_max = ranges[char][0], ranges[char][1]\n while True:\n for other_char in s[range_min: range_max]:\n range_min = min(range_min, ranges[other_char][0])\n range_max = max(range_max, ranges[other_char][1])\n\n if range_min == ranges[char][0] and range_max == ranges[char][1]:\n break\n else:\n ranges[char][0] = range_min\n ranges[char][1] = range_max\n\n # print(ranges)\n\n ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n\n # print(ranges)\n\n answer = []\n prev = 0\n\n for start, end in ranges:\n if start >= prev:\n answer.append(s[start: end + 1])\n prev = end\n return answer\n\n\n \n \n\n \n\n ","memory":"17800"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n d = {}\n for i in range(len(s)):\n if s[i] in d:\n d[s[i]][1] = i\n else:\n d[s[i]] = [i, i]\n for key in d:\n start, end = d[key]\n q = deque([(start, end)])\n while q:\n scur, ecur = q.popleft()\n for i in range(scur, ecur + 1):\n snew, enew = d[s[i]]\n if snew < start:\n q.append((snew, start - 1))\n start = snew\n if enew > end:\n q.append((end + 1, enew))\n end = enew\n d[key] = [start, end]\n\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\n seen = []\n ans = []\n for start, end in sorted_ranges:\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\n continue\n ans.append(s[start: end + 1])\n seen.append((start, end))\n return ans","memory":"17900"},{"code":"\"\"\"\nadefaddaccc\na: 0, 7\nc: 8, 10\nd: 1, 6\ne: 2, 2\nf: 3, 3\n\na: [d: [a, e, f], e: [], f: []]\nc: []\n\nabhahbccd\n\na: [b]\nb: [a]\nh: [a]\nc: []\nd: []\n\n\"\"\"\n\nclass Solution:\n def make_alphabet(self, s: str) -> dict[str, list[int]]:\n alpha = {}\n for i, ch in enumerate(s):\n if ch not in alpha:\n alpha[ch] = [i]\n continue\n if len(alpha[ch]) == 1:\n alpha[ch].append(i)\n else:\n alpha[ch][-1] = i\n return alpha\n \n def del_tree(self, graph: dict, root: str):\n if root not in graph:\n return\n children = graph[root]\n del graph[root]\n for child in children:\n self.del_tree(graph, child)\n \n def clean_tree(self, graph: dict):\n keys = list(graph.keys())\n for k in keys:\n if not graph[k]:\n for v in graph.values():\n v.discard(k)\n del graph[k]\n self.clean_tree(graph)\n return\n \n def maxNumOfSubstrings(self, s: str) -> List[str]:\n al = self.make_alphabet(s)\n #print(f'{al=}')\n gr = {ch: set() for ch in set(s)}\n nodes = set()\n for ch in set(s):\n for i in range(al[ch][0], al[ch][-1] + 1):\n if s[i] != ch:\n gr[s[i]].add(ch)\n nodes.add(ch)\n #print(f'{gr=}')\n \n roots = set(s) - nodes\n #print(f'{roots=}')\n output = []\n for root in roots:\n output.append(s[al[root][0]:al[root][-1] + 1])\n self.del_tree(gr, root)\n #print(f'{output=}\\n{gr=}')\n \n \n self.clean_tree(gr)\n #print(f'cleaned {gr=}')\n \n while gr:\n to_go = list(gr.keys())[0:1]\n st, fin = None, None\n while to_go:\n curr = to_go.pop()\n if curr not in gr:\n continue\n if not gr[curr]:\n del gr[curr]\n continue\n to_go.extend(gr[curr])\n curr_st, curr_fin = al[curr][0], al[curr][-1] + 1\n st = curr_st if st is None else min(st, curr_st)\n fin = curr_fin if fin is None else max(fin, curr_fin)\n del gr[curr]\n if st is not None:\n output.append(s[st:fin])\n \n return output\n \n \n \n ","memory":"18000"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n\n \n dicto = {}\n\n for idx, el in enumerate(s):\n if el not in dicto:\n dicto[el] = [+inf, -inf]\n dicto[el][0] = min(dicto[el][0], idx)\n dicto[el][1] = max(dicto[el][1], idx)\n \n\n conns = {el: set(newel for newel in dicto if newel != el) for el in dicto}\n\n for idx, el in enumerate(s):\n for newel in conns[el]:\n if dicto[newel][0] < idx < dicto[newel][1]:\n dicto[newel][0] = min(dicto[newel][0], dicto[el][0])\n dicto[newel][1] = max(dicto[newel][1], dicto[el][1])\n\n \n arr = sorted(set([ tuple(el) for el in dicto.values()]))\n\n\n stack = []\n for el in arr:\n while stack and stack[-1][0] < el[0] and stack[-1][1] > el[1]:\n stack.pop()\n stack.append(el)\n\n #print(stack)\n\n\n return [s[el[0]:el[1]+1] for el in stack]","memory":"18100"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n indices = char_indices(s)\n merge_indices(s, indices)\n for c in indices:\n print(c, \": \", s[indices[c][0]:indices[c][1]])\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\n result = []\n for substring in substrings:\n if not contains_substring(result, substring):\n result.append(substring)\n return result\n\n\ndef substring_chars(s: str) -> Set[str]:\n return set(c for c in s)\n\ndef char_indices(s: str) -> Dict[str, List[int]]:\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\n\ndef contains_substring(ls: List[str], ss: str):\n for s in ls:\n if s in ss:\n return True\n return False\n\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\n for c in indices:\n changed = True\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\n prev_chars.discard(c)\n while changed:\n for other_c in prev_chars:\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\n chars.discard(c)\n changed = prev_chars != chars\n prev_chars = chars","memory":"18200"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n indices = char_indices(s)\n merge_indices(s, indices)\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\n result = []\n for substring in substrings:\n if not contains_substring(result, substring):\n result.append(substring)\n return result\n\n\ndef substring_chars(s: str) -> Set[str]:\n return set(c for c in s)\n\ndef char_indices(s: str) -> Dict[str, List[int]]:\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\n\ndef contains_substring(ls: List[str], ss: str):\n for s in ls:\n if s in ss:\n return True\n return False\n\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\n for c in indices:\n changed = True\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\n prev_chars.discard(c)\n while changed:\n for other_c in prev_chars:\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\n chars.discard(c)\n changed = prev_chars != chars\n prev_chars = chars","memory":"18200"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # Compute occurrency range for each character.\n occurrence = dict()\n for i, c in enumerate(s):\n if c not in occurrence:\n # New character.\n occurrence[c] = [i, i]\n else:\n # Update last occurrence of seen character.\n occurrence[c][1] = i\n \n # Align interval beginnings.\n open_intervals = set()\n for i, c in enumerate(s):\n # Update all open intervals.\n for o in open_intervals:\n if occurrence[o][0] > occurrence[c][0]:\n occurrence[o][0] = occurrence[c][0]\n if occurrence[o][1] < occurrence[c][1]:\n occurrence[o][1] = occurrence[c][1]\n open_intervals.add(c)\n open_intervals = {\n o\n for o in open_intervals\n if occurrence[o][1] != i\n }\n\n # Compute adjacency list.\n intervals = sorted(list(set(tuple(o) for o in occurrence.values())))\n n = len(intervals)\n adj_list = [list() for _ in range(n)]\n for i in range(n):\n for j in range(i + 1, n):\n if intervals[i][1] < intervals[j][0]:\n adj_list[i].append(j)\n\n # Compute longest path.\n HOP = len(s) + 1\n dist_to = [-float('inf')] * n\n edge_to = [-1] * n\n queue = deque()\n for i in range(n):\n dist_to[i] = intervals[i][0] - intervals[i][1]\n queue.append(i)\n while queue:\n i = queue.popleft()\n for nxt in adj_list[i]:\n dist = dist_to[i] + HOP + (intervals[nxt][0] - intervals[nxt][1])\n if dist_to[nxt] < dist:\n dist_to[nxt] = dist\n edge_to[nxt] = i\n queue.append(nxt)\n\n # Compute result.\n res = []\n idx = max(range(n), key=lambda i: dist_to[i])\n while idx != -1:\n res.append(s[intervals[idx][0]:intervals[idx][1] + 1])\n idx = edge_to[idx]\n return res","memory":"18300"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n first = {}\n last = {}\n for i,c in enumerate(s):\n if c not in first:\n first[c] = i\n last[c] = i\n best = [()]*(len(s)+1)\n next = {}\n for i in reversed(range(len(s))):\n next[s[i]] = i\n best[i] = best[i+1]\n if first[s[i]] == i:\n good = True\n for c in first:\n if first[s[i]] < first[c] < last[s[i]]:\n last[s[i]] = max(last[s[i]],last[c])\n for c in first:\n if c in next and first[c] < first[s[i]] < next[c] < last[s[i]]:\n good = False\n j = last[s[i]]+1\n if good and len(best[i]) < len(best[j])+1 or (len(best[i]) == len(best[j])+1 and sum(len(t) for t in best[i]) > sum(len(t) for t in best[j])+j-i):\n best[i] = best[j]+(s[i:j],)\n return best[0]","memory":"18400"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n arr = [ord(c) - ord('a') for c in s]\n leftest = [-1] * 26\n rightest = [-1] * 26\n \n for i in range(n):\n x = arr[i]\n if leftest[x] == -1:\n leftest[x] = i\n rightest[x] = i\n\n # find all valid ranges\n ranges = []\n for x in range(26):\n if leftest[x] != -1:\n st = [x]\n vi = {x}\n l = r = -1\n while st:\n y = st.pop()\n l2, r2 = leftest[y], rightest[y]\n if l == -1:\n l = r = l2\n while l > l2:\n l -= 1\n if arr[l] not in vi:\n st.append(arr[l])\n vi.add(arr[l])\n while r < r2:\n r += 1\n if arr[r] not in vi:\n st.append(arr[r])\n vi.add(arr[r])\n ranges.append((l, r))\n \n ranges = list(set(ranges))\n \n m = len(ranges) # at most 26\n ranges.sort(key=lambda arr: arr[1]) # sort by r asc\n def calc_total_length(arr):\n total_length = 0\n for s in arr:\n total_length += len(s)\n return total_length\n def compare(arr1, arr2):\n \"\"\" return if arr1 is better \"\"\"\n if len(arr1) > len(arr2):\n return True\n elif len(arr1) == len(arr2):\n return calc_total_length(arr1) <= calc_total_length(arr2)\n return False\n \n dp = [[] for _ in range(m)]\n for i in range(m):\n if i - 1 >= 0:\n dp[i] = dp[i - 1]\n \n l, r = ranges[i]\n substring = s[l: r + 1]\n for j in range(i - 1, -2, -1):\n if j == -1 or ranges[j][1] < l:\n if j == -1:\n arr = []\n else:\n arr = dp[j].copy()\n arr.append(substring)\n if compare(arr, dp[i]):\n dp[i] = arr\n break\n ans = dp[m - 1]\n # print(ans)\n return ans","memory":"18500"},{"code":"from collections import Counter\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n # graph = [[] for _ in range((len(s)))]\n\n count = Counter(s)\n\n original_count = Counter(s)\n\n ans = []\n\n isDone = [False] * len(s)\n\n first_pos = {}\n\n parent = -1\n\n # graph[len(s)-1].append(0)\n\n for i in range(len(s)):\n count[s[i]] -= 1\n\n if s[i] not in first_pos:\n first_pos[s[i]] = i\n \n if count[s[i]] == 0:\n start = first_pos[s[i]]\n begin = start\n\n while start <= i:\n if first_pos[s[start]] < begin:\n start = first_pos[s[start]]\n begin = start\n start += 1\n \n start = begin\n temp_count = Counter(s[start : i+1])\n\n while start <= i:\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\n break\n start += 1\n \n if start > i:\n isDone[i] = True\n # print(s[begin : i + 1], isDone, sep = '->')\n ans.append(s[begin : i + 1])\n \n if len(ans) == 0:\n ans.append(s)\n print(ans)\n\n return ans","memory":"18600"},{"code":"from collections import Counter\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n # graph = [[] for _ in range((len(s)))]\n\n count = Counter(s)\n\n original_count = Counter(s)\n\n ans = []\n\n isDone = [False] * len(s)\n\n first_pos = {}\n\n parent = -1\n\n # graph[len(s)-1].append(0)\n\n for i in range(len(s)):\n count[s[i]] -= 1\n\n if s[i] not in first_pos:\n first_pos[s[i]] = i\n \n if count[s[i]] == 0:\n start = first_pos[s[i]]\n begin = start\n\n while start <= i:\n if first_pos[s[start]] < begin:\n start = first_pos[s[start]]\n begin = start\n start += 1\n \n start = begin\n temp_count = Counter(s[start : i+1])\n\n while start <= i:\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\n break\n start += 1\n \n if start > i:\n isDone[i] = True\n # print(s[begin : i + 1], isDone, sep = '->')\n ans.append(s[begin : i + 1])\n \n if len(ans) == 0:\n ans.append(s)\n print(ans)\n\n return ans","memory":"18600"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = sorted(char_to_intervals.values())\n merged_intervals = set()\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n ret = []\n merged_intervals = list(merged_intervals)\n for i in range(len(merged_intervals)):\n cur = merged_intervals[i]\n has_nested = False\n for j in range(len(merged_intervals)):\n if i == j:\n continue\n inter = merged_intervals[j]\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\n has_nested = True\n break\n if not has_nested:\n ret.append(cur)\n return [s[start:end + 1] for start, end in ret]\n\n\n \n\n\n\n\n\n \n \n ","memory":"18700"},{"code":"from collections import defaultdict\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n char_to_intervals = {}\n for i, c in enumerate(s):\n if c not in char_to_intervals:\n char_to_intervals[c] = [i, i]\n else:\n char_to_intervals[c][-1] = i\n \n start_ends = list(char_to_intervals.values())\n merged_intervals = set()\n def get_min_start_max_end(start, end):\n min_start, max_end = start, end\n for j in range(start, end + 1):\n inter_start, inter_end = char_to_intervals[s[j]]\n min_start = min(min_start, inter_start)\n max_end = max(max_end, inter_end)\n if start == min_start and end == max_end:\n return start, end\n return get_min_start_max_end(min_start, max_end)\n\n for i in range(len(start_ends)):\n start, end = start_ends[i]\n merge = start_ends[i]\n merge = get_min_start_max_end(start, end)\n merged_intervals.add(tuple(merge))\n \n ret = []\n merged_intervals = list(merged_intervals)\n for i in range(len(merged_intervals)):\n cur = merged_intervals[i]\n has_nested = False\n for j in range(len(merged_intervals)):\n if i == j:\n continue\n inter = merged_intervals[j]\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\n has_nested = True\n break\n if not has_nested:\n ret.append(cur)\n return [s[start:end + 1] for start, end in ret]\n\n\n \n\n\n\n\n\n \n \n ","memory":"18700"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n last, interval = {}, {}\n for i, c in enumerate(s):\n last[c] = i + 1\n if c not in interval:\n interval[c] = set(''.join(s.split(c)[1:-1]))\n \n parent = {c: c for c in s}\n \n def find(x):\n if parent[x] != x:\n parent[x] = find(parent[x])\n return parent[x]\n \n def union(x, y):\n parent[find(x)] = find(y)\n return\n \n for c in interval:\n for n in interval[c]:\n if c in interval[n]:\n union(c, n)\n \n splits, max_splits = [(s, 0)], []\n \n while splits:\n \n splits_cut = []\n for string, start in splits:\n left = right = 0 \n for i, c in enumerate(string):\n right = max(right, last[c] - start)\n if i == right - 1:\n splits_cut.append((string[left:right], start + left))\n left = right\n \n splits_rem = []\n for string, start in splits_cut:\n len_splits_rem = len(splits_rem)\n redundant = find(string[0])\n \n left = 0\n while left < len(string):\n if find(string[left]) == redundant:\n left += 1\n else:\n right = left\n while right < len(string) and find(string[right]) != redundant:\n right += 1\n splits_rem.append((string[left:right], start + left))\n left = right\n\n if len_splits_rem == len(splits_rem):\n max_splits.append(string)\n\n splits = splits_rem\n \n return max_splits","memory":"18800"},{"code":"class Solution:\n def create_graph(self, s, dic):\n graph = {}\n for k in dic.keys():\n graph[k] = set()\n\n for k, v in dic.items():\n i, j = v\n\n for c in s[i : j + 1]:\n if c != k:\n graph[c].add(k)\n \n return graph\n \n def reverse_graph(self, graph):\n graph2 = {}\n for k in graph.keys():\n graph2[k] = set()\n\n for u, vs in graph.items():\n\n for v in vs:\n graph2[v].add(u)\n \n return graph2\n \n\n def topological_sort(self, graph):\n def dfs(u):\n visited.add(u)\n\n if u in graph:\n for v in graph[u]:\n if v not in visited:\n dfs(v)\n \n topo.append(u)\n\n topo = []\n visited = set()\n for u in graph.keys():\n if u not in visited:\n dfs(u)\n \n topo.reverse()\n return topo\n \n\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\n visited2.add(u)\n mmin[0] = min(mmin[0], dic[u][0])\n mmax[0] = max(mmax[0], dic[u][1])\n\n for v in graph[u]:\n if v in visited:\n return False\n \n if v in visited2:\n continue\n \n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\n return False\n \n return True\n\n \n\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n dic = {}\n for i, c in enumerate(s):\n if c not in dic:\n dic[c] = [i, i]\n else:\n dic[c][1] = i\n\n graph = self.create_graph(s, dic)\n topo = self.topological_sort(graph)\n\n graph_rev = self.reverse_graph(graph)\n visited = set()\n ans = []\n for u in topo:\n if u in visited:\n continue\n \n visited2 = set()\n mmin = [math.inf]\n mmax = [-math.inf]\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\n if is_possible:\n visited = visited.union(visited2)\n ans.append(s[mmin[0] : mmax[0] + 1])\n \n return ans\n ","memory":"18900"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # step 1: \n start_end = collections.defaultdict(list)\n # find the (start, end) positions for each character\n for i, char in enumerate(s): \n if char not in start_end: \n # update (start, end) position\n start_end[char] = [i, i]\n else: \n # update end position \n start_end[char][-1] = i\n \n # step 2: \n # if the input string only contains one character: directly return s\n if len(start_end)==1: return [s]\n \n # step 3: \n # find the non_overlapping substring of each character\n # chars = [[non_overlapping substring, right_edge]]\n chars = [[-1, -1]]*26 \n \n for char in start_end: \n left, right = start_end[char]\n layer = set([s[i] for i in range(left, right+1)])\n seen = set()\n while layer: \n seen.update(layer)\n nxtlayer = set()\n for char2 in layer: \n left2, right2 = start_end[char2]\n if left2<=right and right2>=left: \n if left2<left: \n for i in range(left2, left): \n if s[i] in seen: continue\n nxtlayer.add(s[i])\n left = left2 \n if right2>right: \n for i in range(right+1, right2+1): \n if s[i] in seen: continue\n nxtlayer.add(s[i])\n right = right2\n layer = nxtlayer \n chars[ord(char)-ord('a')] = [left, right]\n \n # remove characters that don't appear \n chars = [elem for elem in chars if elem[0]!=-1]\n # sort by the right boundary \n chars.sort(key = lambda i:i[-1])\n # non-overlapping string, right_edge, curLen\n dp = [ [[''], -1, 0] ]\n def binary_search(dp, start):\n left, right = 0, len(dp)-1\n while left<=right: \n mid = (left+right)//2\n if dp[mid][1]>=start: \n right = mid-1\n else: \n left = mid+1\n return left-1\n # step 4: \n print(chars)\n for start, end in chars: \n if start>dp[-1][1]: \n dp.append([ dp[-1][0] +[s[start:end+1]], end, dp[-1][-1]+end-start+1 ])\n else: \n pos = binary_search(dp, start)\n cur = [ dp[pos][0] +[s[start:end+1]], end, dp[pos][-1]+end-start+1 ]\n if len(cur[0])>len(dp[-1][0]) or (len(cur[0])==len(dp[-1][0]) and cur[2]<dp[-1][2] ): \n dp.append(cur) \n \n dp[-1][0].pop(0)\n return dp[-1][0]","memory":"19000"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n n = len(s)\n arr = [ord(c) - ord('a') for c in s]\n leftest = [-1] * 26\n rightest = [-1] * 26\n \n for i in range(n):\n x = arr[i]\n if leftest[x] == -1:\n leftest[x] = i\n rightest[x] = i\n\n # find all valid ranges\n ranges = []\n for x in range(26):\n if leftest[x] != -1:\n st = [x]\n vi = {x}\n l = r = -1\n while st:\n y = st.pop()\n l2, r2 = leftest[y], rightest[y]\n if l == -1:\n l = r = l2\n while l > l2:\n l -= 1\n if arr[l] not in vi:\n st.append(arr[l])\n vi.add(arr[l])\n while r < r2:\n r += 1\n if arr[r] not in vi:\n st.append(arr[r])\n vi.add(arr[r])\n ranges.append((l, r))\n left = [-1] * n\n for l, r in ranges:\n if left[r] == -1:\n left[r] = l\n else:\n assert left[r] == l\n \n m = len(ranges) # at most 26\n ranges.sort(key=lambda arr: arr[1]) # sort by r asc\n def calc_total_length(arr):\n total_length = 0\n for s in arr:\n total_length += len(s)\n return total_length\n def compare(arr1, arr2):\n \"\"\" return if arr1 is better \"\"\"\n if len(arr1) > len(arr2):\n return True\n elif len(arr1) == len(arr2):\n return calc_total_length(arr1) <= calc_total_length(arr2)\n return False\n \n dp = [[] for _ in range(m)]\n for i in range(m):\n if i - 1 >= 0:\n dp[i] = dp[i - 1]\n \n l, r = ranges[i]\n substring = s[l: r + 1]\n for j in range(i - 1, -2, -1):\n if j == -1 or ranges[j][1] < l:\n if j == -1:\n arr = []\n else:\n arr = dp[j].copy()\n arr.append(substring)\n if compare(arr, dp[i]):\n dp[i] = arr\n break\n ans = dp[m - 1]\n # print(ans)\n return ans","memory":"19500"},{"code":"class Solution:\n def create_graph(self, s, dic):\n graph = {}\n for k in dic.keys():\n graph[k] = set()\n\n for k, v in dic.items():\n i, j = v\n\n for c in s[i : j + 1]:\n if c != k:\n graph[c].add(k)\n \n return graph\n \n def reverse_graph(self, graph):\n graph2 = {}\n for k in graph.keys():\n graph2[k] = set()\n\n for u, vs in graph.items():\n\n for v in vs:\n graph2[v].add(u)\n \n return graph2\n \n\n def topological_sort(self, graph):\n def dfs(u):\n visited.add(u)\n\n if u in graph:\n for v in graph[u]:\n if v not in visited:\n dfs(v)\n \n topo.append(u)\n\n topo = []\n visited = set()\n for u in graph.keys():\n if u not in visited:\n dfs(u)\n \n topo.reverse()\n return topo\n \n\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\n visited2.add(u)\n mmin[0] = min(mmin[0], dic[u][0])\n mmax[0] = max(mmax[0], dic[u][1])\n\n for v in graph[u]:\n if v in visited:\n return False\n \n if v in visited2:\n continue\n \n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\n return False\n \n return True\n\n \n\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n dic = {}\n for i, c in enumerate(s):\n if c not in dic:\n dic[c] = [i, i]\n else:\n dic[c][1] = i\n\n graph = self.create_graph(s, dic)\n print(graph)\n topo = self.topological_sort(graph)\n print(topo)\n\n graph_rev = self.reverse_graph(graph)\n print(\"reverse graph\", graph_rev)\n visited = set()\n ans = []\n for u in topo:\n if u in visited:\n continue\n \n visited2 = set()\n mmin = [math.inf]\n mmax = [-math.inf]\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\n if is_possible:\n visited = visited.union(visited2)\n ans.append(s[mmin[0] : mmax[0] + 1])\n \n return ans\n ","memory":"19700"},{"code":"\"\"\"\n\"cabcccbaa\"\n\n\n\"bbcacbaba\"\n\n 0123456789\n\"bbeadcxede\" ->[\"bb\",\"a\",\"c\",\"x\"]\n\n\"abcdefghijklmnopqrstuvwxyz\"\n\n\"\"\"\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n def dp(idx, cur_list):\n if idx == len(condition_1_candidates):\n num_strs = len(cur_list)\n all_together_list = [s[x:y + 1] for x, y in cur_list]\n all_together = \"\".join(all_together_list)\n if result:\n prev_num = result[0]\n len_prev = result[1]\n if num_strs > prev_num:\n result[0] = num_strs\n result[1] = len(all_together)\n result[2] = all_together_list\n elif num_strs == prev_num and len(all_together) < len_prev:\n result[0] = num_strs\n result[1] = len(all_together)\n result[2] = all_together_list\n else:\n result.append(num_strs)\n result.append(len(all_together))\n result.append(all_together_list)\n\n return\n\n cur_i, cur_j = condition_1_candidates[idx]\n \n # always take it if it's once char\n if cur_i == cur_j:\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\n return\n\n is_cur_valid = True\n for i, j in cur_list:\n if cur_i <= i <= cur_j:\n is_cur_valid = False\n break\n if cur_i <= j <= cur_j:\n is_cur_valid = False\n break\n\n if is_cur_valid:\n # take it\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\n # or skip it\n dp(idx + 1, cur_list.copy())\n else:\n # skip it\n dp(idx + 1, cur_list.copy())\n\n char_to_start_end = {}\n for i, c in enumerate(s):\n if c in char_to_start_end:\n char_to_start_end[c][1] = i\n else:\n char_to_start_end[c] = [i, i]\n\n condition_1_candidates = set()\n for c, (s_i, e_i) in char_to_start_end.items():\n min_i = s_i\n min_j = e_i\n seen = set()\n seen.add(c)\n for j in range(s_i + 1, e_i):\n next_char = s[j]\n h = [char_to_start_end[next_char][0]]\n max_h = [-char_to_start_end[next_char][1]]\n while h[0] < min_i:\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\n min_i = min_i - 1\n\n while -max_h[0] > min_j:\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\n min_j = min_j + 1\n\n while h[0] < min_i:\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\n min_i = min_i - 1\n\n while -max_h[0] > min_j:\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\n min_j = min_j + 1\n\n condition_1_candidates.add((min_i, min_j))\n\n condition_1_candidates = list(condition_1_candidates)\n condition_1_candidates.sort(key=lambda x:abs(x[0] - x[1]))\n print(condition_1_candidates)\n result = []\n dp(0, [])\n\n return result[2]","memory":"19900"},{"code":"\nclass Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = collections.defaultdict(list)\n \n # Step 1: Find all occurrences of each character\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n \n # Step 2: Expand ranges to include all occurrences of each character\n for r in ranges:\n left, right = ranges[r][0], ranges[r][-1]+1\n templ, tempr = left, right\n while True:\n for ch in set(s[templ:tempr]):\n templ = min(templ, ranges[ch][0])\n tempr = max(tempr, ranges[ch][-1]+1)\n if (templ, tempr) == (left, right):\n break\n left, right = templ, tempr\n ranges[r] = (templ, tempr)\n \n # Step 3: Greedily select non-overlapping ranges\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end])\n prev = end\n \n return ans","memory":"21500"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n ranges = collections.defaultdict(list)\n # 1\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n # 2\n for r in ranges:\n left, right = ranges[r][0], ranges[r][-1]+1\n templ, tempr = left, right\n while True:\n for ch in set(s[templ:tempr]):\n templ = min(templ, ranges[ch][0])\n tempr = max(tempr, ranges[ch][-1]+1)\n if (templ, tempr) == (left, right): break\n left, right = templ, tempr\n ranges[r] = (templ, tempr)\n # 3\t\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end])\n prev = end\n return ans","memory":"21600"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # 1. 记录每个字符的第一次和最后一次出现位置\n ranges = defaultdict(list)\n for idx, ch in enumerate(s):\n ranges[ch].append(idx)\n\n # 2. 扩展每个字符的区间，确保包含所有相关字符的所有位置\n for ch in ranges:\n left, right = ranges[ch][0], ranges[ch][-1] + 1\n templ, tempr = left, right\n while True:\n for c in set(s[templ:tempr]):\n templ = min(templ, ranges[c][0])\n tempr = max(tempr, ranges[c][-1] + 1)\n if (templ, tempr) == (left, right):\n break\n left, right = templ, tempr\n ranges[ch] = (templ, tempr)\n\n # 3. 按照右边界排序并选择不重叠的区间\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\n ans, prev = [], 0\n for start, end in sorted_ranges:\n if start >= prev:\n ans.append(s[start:end])\n prev = end\n\n return ans ","memory":"21700"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n os = s\n s = list(s)\n beDict = defaultdict(list)\n root={}\n for i,c in enumerate(s):\n if c in beDict:\n beDict[c][1]=i\n else:\n root[c]=c\n beDict[c]=[i,i] \n grpDict=defaultdict(list)\n def findBE(st):\n low = min([beDict[x][0] for x in st])\n high = max([beDict[x][1] for x in st])\n nxSt = set(s[low:high+1])\n if nxSt==st:\n return low,high\n else:\n return findBE(nxSt)\n #print(f\"beDict:{beDict}\")\n for c in beDict:\n # #print(f\"for {c} in beDict, b:{beDict[c][0]}, e:{beDict[c][1]+1}\")\n [low,high]= findBE(set(s[beDict[c][0]:beDict[c][1]+1]))\n grpDict[c] = high-low,low,high\n #print(f\"grpDict:{grpDict}\")\n grps = sorted(set(grpDict.values()))\n lb,le,res=[],[],[]\n for _,b,e in grps:\n bi = bisect.bisect(lb,b)\n ei = bisect.bisect(le,e)\n if bi==ei:\n res.append(os[b:e+1])\n lb.insert(bi,b)\n le.insert(ei,e)\n return res","memory":"25800"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n \n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n intervals = []\n for c in set(s):\n b, e = fst[c], lst[c]\n i = b\n while i <= e and b == fst[c]:\n b = min(b, fst[s[i]])\n e = max(e, lst[s[i]])\n i += 1\n if b == fst[c]:\n intervals.append((e, b))\n \n intervals.sort()\n ans, prev = [], -1\n for e, b in intervals:\n if b > prev:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","memory":"27700"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n ans, prev = [], -1\n for i in sorted(lst.values()):\n b, e = fst[s[i]], lst[s[i]]\n j = e\n while j >= b and b > prev and e == i:\n b = min(b, fst[s[j]])\n e = max(e, lst[s[j]])\n j -= 1\n if b > prev and e == i:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","memory":"27900"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n # print(fst, lst)\n intervals = []\n for c in set(s):\n b, e = fst[c], lst[c]\n i = b\n while i <= e and b == fst[c]:\n b = min(b, fst[s[i]])\n e = max(e, lst[s[i]])\n i += 1\n if b == fst[c]:\n intervals.append((e, b))\n # x\n intervals.sort()\n # print(intervals)\n ans, prev = [], -1\n for e, b in intervals:\n if b > prev:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","memory":"28000"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s):\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\n lst = { c : i for i, c in enumerate(s) }\n \n ans, prev = [], -1\n for i in sorted(lst.values()):\n b, e = fst[s[i]], lst[s[i]]\n j = e\n while j >= b and b > prev and e == i:\n b = min(b, fst[s[j]])\n e = max(e, lst[s[j]])\n j -= 1\n if b > prev and e == i:\n ans.append(s[b:e + 1])\n prev = e\n \n return ans","memory":"28100"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n crange = {}\n aset = []\n for i in range(len(s)):\n if s[i] not in crange:\n crange[s[i]] = []\n crange[s[i]].append(i)\n \n #print(crange)\n\n \n for p in crange.keys():\n i = crange[p][0]\n for _ in crange.keys():\n j = crange[_][-1]\n if i > j:\n continue\n valid = True\n #print(s[i],s[j])\n for k in range(i,j+1):\n if i <= crange[s[k]][0] and j >= crange[s[k]][-1]:\n continue\n else:\n valid = False\n break\n\n if valid:\n aset.append(s[i:j+1])\n\n aset.sort(key = lambda x : len(x))\n ansr = set()\n ans = []\n for i in aset:\n val = True\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\n if j in ansr:\n val = False\n break\n if val:\n ans.append(i)\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\n ansr.add(j)\n\n #print(aset)\n return ans","memory":"32900"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n # get the starting and ending indexes of all the chars\n ref = defaultdict(list)\n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n # for each start, end, return a valid window by extending \n # start and end until window is valid\n def isValid(start, end):\n start_i, end_i = start, end\n for c in set(s[start:end]):\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n if (start, end) != (start_i, end_i):\n return isValid(start, end)\n return (start, end)\n\n # get window for each unique char\n for c in set(s):\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n substrs.add((start, end))\n \n #substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1]) \n\n res = []\n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]\n \n \n \n \n \n \n \n ","memory":"45000"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n curr_count = Counter(s[start:end])\n #print(s[start:end], curr_count)\n for c in s[start:end]:\n if count[c] != curr_count[c]:\n #print(c, \"not it\")\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n return isValid(start, end)\n return (start, end)\n\n for i, c in enumerate(s):\n if i != ref[c][0]:\n continue\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n #print(\"got\", start, end, \"for\", i, c)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1])\n\n print(substrs)\n \n \n \n res = []\n \n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]\n \n \n \n \n \n \n \n ","memory":"45700"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n curr_count = Counter(s[start:end])\n for c in s[start:end]:\n if count[c] != curr_count[c]:\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n return isValid(start, end)\n return (start, end)\n\n for i, c in enumerate(s):\n if i != ref[c][0]:\n continue\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1]) \n \n res = []\n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]","memory":"45700"},{"code":"class Solution:\n def maxNumOfSubstrings(self, S: str) -> List[str]:\n mins = [float('inf')]*26\n maxs = [-1]*26\n exists = [False]*26\n prefix_sum = [[0]*26 for _ in range(len(S)+1)]\n\n for i,char in enumerate(S):\n prefix_sum[i+1]=prefix_sum[i][:]\n prefix_sum[i+1][ord(char)-ord('a')]+=1\n mins[ord(char)-ord('a')] = min(mins[ord(char)-ord('a')],i)\n maxs[ord(char)-ord('a')] = max(maxs[ord(char)-ord('a')],i)\n exists[ord(char)-ord('a')]=True\n\n graph = [[False]*26 for _ in range(26)]\n for i in range(26):\n if exists[i]:\n for j in range(26):\n if prefix_sum[maxs[i]+1][j]-prefix_sum[mins[i]][j]>0:\n graph[i][j]=True\n\n stack = []\n visited = [False]*26\n\n def dfs1(v):\n if not visited[v]:\n visited[v]=True\n for i in range(26):\n if graph[v][i] and not visited[i]:\n dfs1(i)\n stack.append(v)\n \n for i in range(26):\n if exists[i] and not visited[i]:\n dfs1(i)\n\n batch = 0\n batches = [-1]*26\n degree = [0]*26\n\n def dfs2(v,batch):\n if batches[v]<0:\n batches[v]=batch\n for i in range(26):\n if graph[i][v]:\n dfs2(i,batch)\n else:\n if batches[v]!=batch:\n degree[batches[v]]+=1\n while stack:\n v = stack.pop()\n if batches[v]<0:\n dfs2(v,batch)\n batch+=1\n\n res = []\n for i in range(batch -1,-1,-1):\n if degree[i]==0:\n min_idx = float('inf')\n max_idx = -1\n for j in range(26):\n if batches[j]==i:\n min_idx = min(mins[j],min_idx)\n max_idx = max(maxs[j],max_idx)\n res.append(S[min_idx:max_idx+1])\n return res","memory":"48200"},{"code":"class Solution:\n def maxNumOfSubstrings(self, s: str) -> List[str]:\n count = Counter(s)\n ref = defaultdict(list)\n \n for i, c in enumerate(s):\n ref[c].append(i)\n \n substrs = set()\n \n def isValid(start, end):\n start_i, end_i = start, end\n for c in set(s[start:end]):\n print(\"for \", c, ref[c][0], ref[c][-1])\n start = min(ref[c][0], start)\n end = max(end, ref[c][-1] + 1)\n if (start, end) != (start_i, end_i):\n return isValid(start, end)\n return (start, end)\n\n for c in set(s):\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\n substrs.add((start, end))\n \n substrs.add((0, len(s)))\n\n substrs = sorted(substrs, key=lambda x: x[1]) \n print(substrs)\n res = []\n for r in substrs:\n if not res:\n res.append(r)\n if res[-1][1] <= r[0]:\n res.append(r)\n \n return [s[i:j] for (i, j) in res]\n \n \n \n \n \n \n \n ","memory":"49100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = {}\\n for i in range(len(s)):\\n if s[i] in d:\\n d[s[i]][1] = i\\n else:\\n d[s[i]] = [i, i]\\n for key in d:\\n start, end = d[key]\\n q = deque([(start, end)])\\n while q:\\n scur, ecur = q.popleft()\\n for i in range(scur, ecur + 1):\\n snew, enew = d[s[i]]\\n if snew < start:\\n q.append((snew, start - 1))\\n start = snew\\n if enew > end:\\n q.append((end + 1, enew))\\n end = enew\\n d[key] = [start, end]\\n\\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\\n seen = []\\n ans = []\\n for start, end in sorted_ranges:\\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\\n continue\\n ans.append(s[start: end + 1])\\n seen.append((start, end))\\n return ans\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Primeiro, identificamos os intervalos válidos para cada caractere\\n intervals = {}\\n for i, char in enumerate(s):\\n if char not in intervals:\\n intervals[char] = [i, i]\\n else:\\n intervals[char][1] = i\\n\\n # Em seguida, expandimos os intervalos para atender às condições\\n valid_intervals = []\\n for interval in intervals.values():\\n start, end = interval[0], interval[1]\\n i = start\\n while i <= end:\\n if intervals[s[i]][0] < start:\\n start = intervals[s[i]][0]\\n i = start\\n if intervals[s[i]][1] > end:\\n end = intervals[s[i]][1]\\n i += 1\\n valid_intervals.append([start, end])\\n\\n # Ordenamos os intervalos pelo fim em ordem crescente\\n valid_intervals.sort(key=lambda x: x[1])\\n\\n # Construímos as substrings usando os intervalos válidos\\n result = []\\n prev_end = float('-inf')\\n for interval in valid_intervals:\\n start, end = interval[0], interval[1]\\n if start > prev_end:\\n result.append(s[start:end+1])\\n prev_end = end\\n\\n return result\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n ends = {}\\n counter = defaultdict(int)\\n for i in range(n-1,-1,-1):\\n if s[i] not in ends:\\n ends[s[i]] = i\\n counter[s[i]] += 1\\n ans = []\\n seen = set()\\n stack = []\\n i = 0\\n \\n included = -1\\n while i < n:\\n #print(s[i])\\n if s[i] not in seen:\\n seen.add(s[i])\\n stack.append(i)\\n if ends[s[i]] == i:\\n seen.remove(s[i])\\n stack_index = len(stack)-1\\n curr = 0\\n #print(stack,s[i],included,stack_index,seen)\\n while stack[stack_index] > included and s[stack[stack_index]] not in seen:\\n curr += counter[s[stack[stack_index]]]\\n if i - stack[stack_index] + 1 == curr:\\n # shortest segment found\\n ans.append(s[stack[stack_index]:i+1])\\n included = i\\n stack_index -= 1\\n \\n \\n i += 1\\n return ans if ans else [s]\",\n \"memory\": \"17600\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n \\n charBoundedSubstring = {}\\n\\n for i, c in enumerate(s):\\n\\n if c not in charBoundedSubstring:\\n charBoundedSubstring[c] = [i, i]\\n \\n left = charBoundedSubstring[c][0]\\n right = charBoundedSubstring[c][1]\\n charBoundedSubstring[c] = [min(i, left), max(i, right)]\\n\\n # print(charBoundedSubstring)\\n intervals = []\\n for alpha in set(s):\\n left = charBoundedSubstring[alpha][0]\\n right = charBoundedSubstring[alpha][1]\\n leftMost, rightMost = left, right\\n # print(left, right)\\n i = left\\n while i <= rightMost:\\n leftMost = min(leftMost, charBoundedSubstring[s[i]][0])\\n rightMost = max(rightMost, charBoundedSubstring[s[i]][1])\\n i += 1\\n # print(leftMost, rightMost)\\n \\n if leftMost == left:\\n intervals.append((leftMost, rightMost))\\n \\n intervals.sort()\\n res = []\\n curStart, curEnd = intervals[0][0], intervals[0][1]\\n for interval in intervals:\\n start, end = interval\\n \\n if curStart < start < curEnd and curStart < end < curEnd:\\n curStart, curEnd = start, end\\n \\n if start > curEnd and start > curStart:\\n res.append(s[curStart: curEnd + 1])\\n curStart = start\\n curEnd = end\\n # print()\\n res.append(s[curStart: curEnd + 1])\\n # print(intervals, res)\\n # intervals.sort()\\n return res\\n\\n\\n\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def dfs(self, i):\\n if i in self.dfs_store:\\n return self.dfs_store[i]\\n \\n v = self.dfs(i+1)\\n \\n _, end = self.valid_intervals[i]\\n j = i + 1\\n while j < self.len and self.valid_intervals[j][0] < end:\\n j += 1\\n if len(v) >= 1 + len(self.dfs(j)):\\n self.dfs_store[i] = v\\n else:\\n self.dfs_store[i] = [self.valid_intervals[i]] + self.dfs_store[j]\\n return self.dfs_store[i]\\n \\n def maxNumOfSubstrings(self, s: str):\\n store = {}\\n for i, c in enumerate(s):\\n if c not in store:\\n store[c] = [i, i]\\n else:\\n store[c][-1] = i\\n valid_intervals = []\\n for c in store:\\n begin, end = store[c]\\n checked = set([c])\\n flag = True\\n i = begin + 1\\n while i <= end:\\n d = s[i]\\n i += 1\\n if d in checked:\\n continue\\n d_begin, d_end = store[d]\\n if d_begin < begin:\\n flag = False\\n break\\n if d_end > end:\\n end = d_end\\n checked.add(d)\\n if flag:\\n valid_intervals.append([begin, end])\\n valid_intervals.sort()\\n \\n self.len = len(valid_intervals)\\n self.dfs_store = {self.len: []}\\n self.valid_intervals = valid_intervals\\n self.dfs(0)\\n rt = []\\n for begin, end in self.dfs_store[0]:\\n rt.append(s[begin: end+1])\\n \\n return rt\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = dict()\\n i = 0\\n for char in s:\\n if char in ranges:\\n ranges[char][1] = i\\n else:\\n ranges[char] = [i, i]\\n i += 1\\n\\n # print(ranges)\\n\\n for char in ranges:\\n range_min, range_max = ranges[char][0], ranges[char][1]\\n while True:\\n for other_char in s[range_min: range_max]:\\n range_min = min(range_min, ranges[other_char][0])\\n range_max = max(range_max, ranges[other_char][1])\\n\\n if range_min == ranges[char][0] and range_max == ranges[char][1]:\\n break\\n else:\\n ranges[char][0] = range_min\\n ranges[char][1] = range_max\\n\\n # print(ranges)\\n\\n ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n\\n # print(ranges)\\n\\n answer = []\\n prev = 0\\n\\n for start, end in ranges:\\n if start >= prev:\\n answer.append(s[start: end + 1])\\n prev = end\\n return answer\\n\\n\\n \\n \\n\\n \\n\\n \",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n d = {}\\n for i in range(len(s)):\\n if s[i] in d:\\n d[s[i]][1] = i\\n else:\\n d[s[i]] = [i, i]\\n for key in d:\\n start, end = d[key]\\n q = deque([(start, end)])\\n while q:\\n scur, ecur = q.popleft()\\n for i in range(scur, ecur + 1):\\n snew, enew = d[s[i]]\\n if snew < start:\\n q.append((snew, start - 1))\\n start = snew\\n if enew > end:\\n q.append((end + 1, enew))\\n end = enew\\n d[key] = [start, end]\\n\\n sorted_ranges = sorted(d.values(), key=lambda x: x[1] - x[0])\\n seen = []\\n ans = []\\n for start, end in sorted_ranges:\\n if any(end >= s1 and e1 >= start for s1, e1 in seen): # if the substring overlapps with a seen substring\\n continue\\n ans.append(s[start: end + 1])\\n seen.append((start, end))\\n return ans\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nadefaddaccc\\na: 0, 7\\nc: 8, 10\\nd: 1, 6\\ne: 2, 2\\nf: 3, 3\\n\\na: [d: [a, e, f], e: [], f: []]\\nc: []\\n\\nabhahbccd\\n\\na: [b]\\nb: [a]\\nh: [a]\\nc: []\\nd: []\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def make_alphabet(self, s: str) -> dict[str, list[int]]:\\n alpha = {}\\n for i, ch in enumerate(s):\\n if ch not in alpha:\\n alpha[ch] = [i]\\n continue\\n if len(alpha[ch]) == 1:\\n alpha[ch].append(i)\\n else:\\n alpha[ch][-1] = i\\n return alpha\\n \\n def del_tree(self, graph: dict, root: str):\\n if root not in graph:\\n return\\n children = graph[root]\\n del graph[root]\\n for child in children:\\n self.del_tree(graph, child)\\n \\n def clean_tree(self, graph: dict):\\n keys = list(graph.keys())\\n for k in keys:\\n if not graph[k]:\\n for v in graph.values():\\n v.discard(k)\\n del graph[k]\\n self.clean_tree(graph)\\n return\\n \\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n al = self.make_alphabet(s)\\n #print(f'{al=}')\\n gr = {ch: set() for ch in set(s)}\\n nodes = set()\\n for ch in set(s):\\n for i in range(al[ch][0], al[ch][-1] + 1):\\n if s[i] != ch:\\n gr[s[i]].add(ch)\\n nodes.add(ch)\\n #print(f'{gr=}')\\n \\n roots = set(s) - nodes\\n #print(f'{roots=}')\\n output = []\\n for root in roots:\\n output.append(s[al[root][0]:al[root][-1] + 1])\\n self.del_tree(gr, root)\\n #print(f'{output=}\\\\n{gr=}')\\n \\n \\n self.clean_tree(gr)\\n #print(f'cleaned {gr=}')\\n \\n while gr:\\n to_go = list(gr.keys())[0:1]\\n st, fin = None, None\\n while to_go:\\n curr = to_go.pop()\\n if curr not in gr:\\n continue\\n if not gr[curr]:\\n del gr[curr]\\n continue\\n to_go.extend(gr[curr])\\n curr_st, curr_fin = al[curr][0], al[curr][-1] + 1\\n st = curr_st if st is None else min(st, curr_st)\\n fin = curr_fin if fin is None else max(fin, curr_fin)\\n del gr[curr]\\n if st is not None:\\n output.append(s[st:fin])\\n \\n return output\\n \\n \\n \\n \",\n \"memory\": \"18000\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n\\n \\n dicto = {}\\n\\n for idx, el in enumerate(s):\\n if el not in dicto:\\n dicto[el] = [+inf, -inf]\\n dicto[el][0] = min(dicto[el][0], idx)\\n dicto[el][1] = max(dicto[el][1], idx)\\n \\n\\n conns = {el: set(newel for newel in dicto if newel != el) for el in dicto}\\n\\n for idx, el in enumerate(s):\\n for newel in conns[el]:\\n if dicto[newel][0] < idx < dicto[newel][1]:\\n dicto[newel][0] = min(dicto[newel][0], dicto[el][0])\\n dicto[newel][1] = max(dicto[newel][1], dicto[el][1])\\n\\n \\n arr = sorted(set([ tuple(el) for el in dicto.values()]))\\n\\n\\n stack = []\\n for el in arr:\\n while stack and stack[-1][0] < el[0] and stack[-1][1] > el[1]:\\n stack.pop()\\n stack.append(el)\\n\\n #print(stack)\\n\\n\\n return [s[el[0]:el[1]+1] for el in stack]\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n indices = char_indices(s)\\n merge_indices(s, indices)\\n for c in indices:\\n print(c, \\\": \\\", s[indices[c][0]:indices[c][1]])\\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\\n result = []\\n for substring in substrings:\\n if not contains_substring(result, substring):\\n result.append(substring)\\n return result\\n\\n\\ndef substring_chars(s: str) -> Set[str]:\\n return set(c for c in s)\\n\\ndef char_indices(s: str) -> Dict[str, List[int]]:\\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\\n\\ndef contains_substring(ls: List[str], ss: str):\\n for s in ls:\\n if s in ss:\\n return True\\n return False\\n\\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\\n for c in indices:\\n changed = True\\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n prev_chars.discard(c)\\n while changed:\\n for other_c in prev_chars:\\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n chars.discard(c)\\n changed = prev_chars != chars\\n prev_chars = chars\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n indices = char_indices(s)\\n merge_indices(s, indices)\\n substrings = sorted([s[indices[c][0]:indices[c][1]] for c in indices], key=len)\\n result = []\\n for substring in substrings:\\n if not contains_substring(result, substring):\\n result.append(substring)\\n return result\\n\\n\\ndef substring_chars(s: str) -> Set[str]:\\n return set(c for c in s)\\n\\ndef char_indices(s: str) -> Dict[str, List[int]]:\\n return {c: [s.find(c), len(s) - s[::-1].find(c)] for c in substring_chars(s)}\\n\\ndef contains_substring(ls: List[str], ss: str):\\n for s in ls:\\n if s in ss:\\n return True\\n return False\\n\\ndef merge_indices(s: str, indices: Dict[str, List[int]]) -> None:\\n for c in indices:\\n changed = True\\n prev_chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n prev_chars.discard(c)\\n while changed:\\n for other_c in prev_chars:\\n indices[c] = [min(indices[c][0], indices[other_c][0]), max(indices[c][1], indices[other_c][1])]\\n chars = substring_chars(s[indices[c][0]:indices[c][1]])\\n chars.discard(c)\\n changed = prev_chars != chars\\n prev_chars = chars\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # Compute occurrency range for each character.\\n occurrence = dict()\\n for i, c in enumerate(s):\\n if c not in occurrence:\\n # New character.\\n occurrence[c] = [i, i]\\n else:\\n # Update last occurrence of seen character.\\n occurrence[c][1] = i\\n \\n # Align interval beginnings.\\n open_intervals = set()\\n for i, c in enumerate(s):\\n # Update all open intervals.\\n for o in open_intervals:\\n if occurrence[o][0] > occurrence[c][0]:\\n occurrence[o][0] = occurrence[c][0]\\n if occurrence[o][1] < occurrence[c][1]:\\n occurrence[o][1] = occurrence[c][1]\\n open_intervals.add(c)\\n open_intervals = {\\n o\\n for o in open_intervals\\n if occurrence[o][1] != i\\n }\\n\\n # Compute adjacency list.\\n intervals = sorted(list(set(tuple(o) for o in occurrence.values())))\\n n = len(intervals)\\n adj_list = [list() for _ in range(n)]\\n for i in range(n):\\n for j in range(i + 1, n):\\n if intervals[i][1] < intervals[j][0]:\\n adj_list[i].append(j)\\n\\n # Compute longest path.\\n HOP = len(s) + 1\\n dist_to = [-float('inf')] * n\\n edge_to = [-1] * n\\n queue = deque()\\n for i in range(n):\\n dist_to[i] = intervals[i][0] - intervals[i][1]\\n queue.append(i)\\n while queue:\\n i = queue.popleft()\\n for nxt in adj_list[i]:\\n dist = dist_to[i] + HOP + (intervals[nxt][0] - intervals[nxt][1])\\n if dist_to[nxt] < dist:\\n dist_to[nxt] = dist\\n edge_to[nxt] = i\\n queue.append(nxt)\\n\\n # Compute result.\\n res = []\\n idx = max(range(n), key=lambda i: dist_to[i])\\n while idx != -1:\\n res.append(s[intervals[idx][0]:intervals[idx][1] + 1])\\n idx = edge_to[idx]\\n return res\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n first = {}\\n last = {}\\n for i,c in enumerate(s):\\n if c not in first:\\n first[c] = i\\n last[c] = i\\n best = [()]*(len(s)+1)\\n next = {}\\n for i in reversed(range(len(s))):\\n next[s[i]] = i\\n best[i] = best[i+1]\\n if first[s[i]] == i:\\n good = True\\n for c in first:\\n if first[s[i]] < first[c] < last[s[i]]:\\n last[s[i]] = max(last[s[i]],last[c])\\n for c in first:\\n if c in next and first[c] < first[s[i]] < next[c] < last[s[i]]:\\n good = False\\n j = last[s[i]]+1\\n if good and len(best[i]) < len(best[j])+1 or (len(best[i]) == len(best[j])+1 and sum(len(t) for t in best[i]) > sum(len(t) for t in best[j])+j-i):\\n best[i] = best[j]+(s[i:j],)\\n return best[0]\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n arr = [ord(c) - ord('a') for c in s]\\n leftest = [-1] * 26\\n rightest = [-1] * 26\\n \\n for i in range(n):\\n x = arr[i]\\n if leftest[x] == -1:\\n leftest[x] = i\\n rightest[x] = i\\n\\n # find all valid ranges\\n ranges = []\\n for x in range(26):\\n if leftest[x] != -1:\\n st = [x]\\n vi = {x}\\n l = r = -1\\n while st:\\n y = st.pop()\\n l2, r2 = leftest[y], rightest[y]\\n if l == -1:\\n l = r = l2\\n while l > l2:\\n l -= 1\\n if arr[l] not in vi:\\n st.append(arr[l])\\n vi.add(arr[l])\\n while r < r2:\\n r += 1\\n if arr[r] not in vi:\\n st.append(arr[r])\\n vi.add(arr[r])\\n ranges.append((l, r))\\n \\n ranges = list(set(ranges))\\n \\n m = len(ranges) # at most 26\\n ranges.sort(key=lambda arr: arr[1]) # sort by r asc\\n def calc_total_length(arr):\\n total_length = 0\\n for s in arr:\\n total_length += len(s)\\n return total_length\\n def compare(arr1, arr2):\\n \\\"\\\"\\\" return if arr1 is better \\\"\\\"\\\"\\n if len(arr1) > len(arr2):\\n return True\\n elif len(arr1) == len(arr2):\\n return calc_total_length(arr1) <= calc_total_length(arr2)\\n return False\\n \\n dp = [[] for _ in range(m)]\\n for i in range(m):\\n if i - 1 >= 0:\\n dp[i] = dp[i - 1]\\n \\n l, r = ranges[i]\\n substring = s[l: r + 1]\\n for j in range(i - 1, -2, -1):\\n if j == -1 or ranges[j][1] < l:\\n if j == -1:\\n arr = []\\n else:\\n arr = dp[j].copy()\\n arr.append(substring)\\n if compare(arr, dp[i]):\\n dp[i] = arr\\n break\\n ans = dp[m - 1]\\n # print(ans)\\n return ans\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n # graph = [[] for _ in range((len(s)))]\\n\\n count = Counter(s)\\n\\n original_count = Counter(s)\\n\\n ans = []\\n\\n isDone = [False] * len(s)\\n\\n first_pos = {}\\n\\n parent = -1\\n\\n # graph[len(s)-1].append(0)\\n\\n for i in range(len(s)):\\n count[s[i]] -= 1\\n\\n if s[i] not in first_pos:\\n first_pos[s[i]] = i\\n \\n if count[s[i]] == 0:\\n start = first_pos[s[i]]\\n begin = start\\n\\n while start <= i:\\n if first_pos[s[start]] < begin:\\n start = first_pos[s[start]]\\n begin = start\\n start += 1\\n \\n start = begin\\n temp_count = Counter(s[start : i+1])\\n\\n while start <= i:\\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\\n break\\n start += 1\\n \\n if start > i:\\n isDone[i] = True\\n # print(s[begin : i + 1], isDone, sep = '->')\\n ans.append(s[begin : i + 1])\\n \\n if len(ans) == 0:\\n ans.append(s)\\n print(ans)\\n\\n return ans\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n # graph = [[] for _ in range((len(s)))]\\n\\n count = Counter(s)\\n\\n original_count = Counter(s)\\n\\n ans = []\\n\\n isDone = [False] * len(s)\\n\\n first_pos = {}\\n\\n parent = -1\\n\\n # graph[len(s)-1].append(0)\\n\\n for i in range(len(s)):\\n count[s[i]] -= 1\\n\\n if s[i] not in first_pos:\\n first_pos[s[i]] = i\\n \\n if count[s[i]] == 0:\\n start = first_pos[s[i]]\\n begin = start\\n\\n while start <= i:\\n if first_pos[s[start]] < begin:\\n start = first_pos[s[start]]\\n begin = start\\n start += 1\\n \\n start = begin\\n temp_count = Counter(s[start : i+1])\\n\\n while start <= i:\\n if isDone[start] or temp_count[s[start]] != original_count[s[start]]:\\n break\\n start += 1\\n \\n if start > i:\\n isDone[i] = True\\n # print(s[begin : i + 1], isDone, sep = '->')\\n ans.append(s[begin : i + 1])\\n \\n if len(ans) == 0:\\n ans.append(s)\\n print(ans)\\n\\n return ans\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = sorted(char_to_intervals.values())\\n merged_intervals = set()\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n ret = []\\n merged_intervals = list(merged_intervals)\\n for i in range(len(merged_intervals)):\\n cur = merged_intervals[i]\\n has_nested = False\\n for j in range(len(merged_intervals)):\\n if i == j:\\n continue\\n inter = merged_intervals[j]\\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\\n has_nested = True\\n break\\n if not has_nested:\\n ret.append(cur)\\n return [s[start:end + 1] for start, end in ret]\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n char_to_intervals = {}\\n for i, c in enumerate(s):\\n if c not in char_to_intervals:\\n char_to_intervals[c] = [i, i]\\n else:\\n char_to_intervals[c][-1] = i\\n \\n start_ends = list(char_to_intervals.values())\\n merged_intervals = set()\\n def get_min_start_max_end(start, end):\\n min_start, max_end = start, end\\n for j in range(start, end + 1):\\n inter_start, inter_end = char_to_intervals[s[j]]\\n min_start = min(min_start, inter_start)\\n max_end = max(max_end, inter_end)\\n if start == min_start and end == max_end:\\n return start, end\\n return get_min_start_max_end(min_start, max_end)\\n\\n for i in range(len(start_ends)):\\n start, end = start_ends[i]\\n merge = start_ends[i]\\n merge = get_min_start_max_end(start, end)\\n merged_intervals.add(tuple(merge))\\n \\n ret = []\\n merged_intervals = list(merged_intervals)\\n for i in range(len(merged_intervals)):\\n cur = merged_intervals[i]\\n has_nested = False\\n for j in range(len(merged_intervals)):\\n if i == j:\\n continue\\n inter = merged_intervals[j]\\n if cur[0] <= inter[0] and inter[1] <= cur[1]:\\n has_nested = True\\n break\\n if not has_nested:\\n ret.append(cur)\\n return [s[start:end + 1] for start, end in ret]\\n\\n\\n \\n\\n\\n\\n\\n\\n \\n \\n \",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n last, interval = {}, {}\\n for i, c in enumerate(s):\\n last[c] = i + 1\\n if c not in interval:\\n interval[c] = set(''.join(s.split(c)[1:-1]))\\n \\n parent = {c: c for c in s}\\n \\n def find(x):\\n if parent[x] != x:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n parent[find(x)] = find(y)\\n return\\n \\n for c in interval:\\n for n in interval[c]:\\n if c in interval[n]:\\n union(c, n)\\n \\n splits, max_splits = [(s, 0)], []\\n \\n while splits:\\n \\n splits_cut = []\\n for string, start in splits:\\n left = right = 0 \\n for i, c in enumerate(string):\\n right = max(right, last[c] - start)\\n if i == right - 1:\\n splits_cut.append((string[left:right], start + left))\\n left = right\\n \\n splits_rem = []\\n for string, start in splits_cut:\\n len_splits_rem = len(splits_rem)\\n redundant = find(string[0])\\n \\n left = 0\\n while left < len(string):\\n if find(string[left]) == redundant:\\n left += 1\\n else:\\n right = left\\n while right < len(string) and find(string[right]) != redundant:\\n right += 1\\n splits_rem.append((string[left:right], start + left))\\n left = right\\n\\n if len_splits_rem == len(splits_rem):\\n max_splits.append(string)\\n\\n splits = splits_rem\\n \\n return max_splits\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n def create_graph(self, s, dic):\\n graph = {}\\n for k in dic.keys():\\n graph[k] = set()\\n\\n for k, v in dic.items():\\n i, j = v\\n\\n for c in s[i : j + 1]:\\n if c != k:\\n graph[c].add(k)\\n \\n return graph\\n \\n def reverse_graph(self, graph):\\n graph2 = {}\\n for k in graph.keys():\\n graph2[k] = set()\\n\\n for u, vs in graph.items():\\n\\n for v in vs:\\n graph2[v].add(u)\\n \\n return graph2\\n \\n\\n def topological_sort(self, graph):\\n def dfs(u):\\n visited.add(u)\\n\\n if u in graph:\\n for v in graph[u]:\\n if v not in visited:\\n dfs(v)\\n \\n topo.append(u)\\n\\n topo = []\\n visited = set()\\n for u in graph.keys():\\n if u not in visited:\\n dfs(u)\\n \\n topo.reverse()\\n return topo\\n \\n\\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\\n visited2.add(u)\\n mmin[0] = min(mmin[0], dic[u][0])\\n mmax[0] = max(mmax[0], dic[u][1])\\n\\n for v in graph[u]:\\n if v in visited:\\n return False\\n \\n if v in visited2:\\n continue\\n \\n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\\n return False\\n \\n return True\\n\\n \\n\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n dic = {}\\n for i, c in enumerate(s):\\n if c not in dic:\\n dic[c] = [i, i]\\n else:\\n dic[c][1] = i\\n\\n graph = self.create_graph(s, dic)\\n topo = self.topological_sort(graph)\\n\\n graph_rev = self.reverse_graph(graph)\\n visited = set()\\n ans = []\\n for u in topo:\\n if u in visited:\\n continue\\n \\n visited2 = set()\\n mmin = [math.inf]\\n mmax = [-math.inf]\\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\\n if is_possible:\\n visited = visited.union(visited2)\\n ans.append(s[mmin[0] : mmax[0] + 1])\\n \\n return ans\\n \",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # step 1: \\n start_end = collections.defaultdict(list)\\n # find the (start, end) positions for each character\\n for i, char in enumerate(s): \\n if char not in start_end: \\n # update (start, end) position\\n start_end[char] = [i, i]\\n else: \\n # update end position \\n start_end[char][-1] = i\\n \\n # step 2: \\n # if the input string only contains one character: directly return s\\n if len(start_end)==1: return [s]\\n \\n # step 3: \\n # find the non_overlapping substring of each character\\n # chars = [[non_overlapping substring, right_edge]]\\n chars = [[-1, -1]]*26 \\n \\n for char in start_end: \\n left, right = start_end[char]\\n layer = set([s[i] for i in range(left, right+1)])\\n seen = set()\\n while layer: \\n seen.update(layer)\\n nxtlayer = set()\\n for char2 in layer: \\n left2, right2 = start_end[char2]\\n if left2<=right and right2>=left: \\n if left2<left: \\n for i in range(left2, left): \\n if s[i] in seen: continue\\n nxtlayer.add(s[i])\\n left = left2 \\n if right2>right: \\n for i in range(right+1, right2+1): \\n if s[i] in seen: continue\\n nxtlayer.add(s[i])\\n right = right2\\n layer = nxtlayer \\n chars[ord(char)-ord('a')] = [left, right]\\n \\n # remove characters that don't appear \\n chars = [elem for elem in chars if elem[0]!=-1]\\n # sort by the right boundary \\n chars.sort(key = lambda i:i[-1])\\n # non-overlapping string, right_edge, curLen\\n dp = [ [[''], -1, 0] ]\\n def binary_search(dp, start):\\n left, right = 0, len(dp)-1\\n while left<=right: \\n mid = (left+right)//2\\n if dp[mid][1]>=start: \\n right = mid-1\\n else: \\n left = mid+1\\n return left-1\\n # step 4: \\n print(chars)\\n for start, end in chars: \\n if start>dp[-1][1]: \\n dp.append([ dp[-1][0] +[s[start:end+1]], end, dp[-1][-1]+end-start+1 ])\\n else: \\n pos = binary_search(dp, start)\\n cur = [ dp[pos][0] +[s[start:end+1]], end, dp[pos][-1]+end-start+1 ]\\n if len(cur[0])>len(dp[-1][0]) or (len(cur[0])==len(dp[-1][0]) and cur[2]<dp[-1][2] ): \\n dp.append(cur) \\n \\n dp[-1][0].pop(0)\\n return dp[-1][0]\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n n = len(s)\\n arr = [ord(c) - ord('a') for c in s]\\n leftest = [-1] * 26\\n rightest = [-1] * 26\\n \\n for i in range(n):\\n x = arr[i]\\n if leftest[x] == -1:\\n leftest[x] = i\\n rightest[x] = i\\n\\n # find all valid ranges\\n ranges = []\\n for x in range(26):\\n if leftest[x] != -1:\\n st = [x]\\n vi = {x}\\n l = r = -1\\n while st:\\n y = st.pop()\\n l2, r2 = leftest[y], rightest[y]\\n if l == -1:\\n l = r = l2\\n while l > l2:\\n l -= 1\\n if arr[l] not in vi:\\n st.append(arr[l])\\n vi.add(arr[l])\\n while r < r2:\\n r += 1\\n if arr[r] not in vi:\\n st.append(arr[r])\\n vi.add(arr[r])\\n ranges.append((l, r))\\n left = [-1] * n\\n for l, r in ranges:\\n if left[r] == -1:\\n left[r] = l\\n else:\\n assert left[r] == l\\n \\n m = len(ranges) # at most 26\\n ranges.sort(key=lambda arr: arr[1]) # sort by r asc\\n def calc_total_length(arr):\\n total_length = 0\\n for s in arr:\\n total_length += len(s)\\n return total_length\\n def compare(arr1, arr2):\\n \\\"\\\"\\\" return if arr1 is better \\\"\\\"\\\"\\n if len(arr1) > len(arr2):\\n return True\\n elif len(arr1) == len(arr2):\\n return calc_total_length(arr1) <= calc_total_length(arr2)\\n return False\\n \\n dp = [[] for _ in range(m)]\\n for i in range(m):\\n if i - 1 >= 0:\\n dp[i] = dp[i - 1]\\n \\n l, r = ranges[i]\\n substring = s[l: r + 1]\\n for j in range(i - 1, -2, -1):\\n if j == -1 or ranges[j][1] < l:\\n if j == -1:\\n arr = []\\n else:\\n arr = dp[j].copy()\\n arr.append(substring)\\n if compare(arr, dp[i]):\\n dp[i] = arr\\n break\\n ans = dp[m - 1]\\n # print(ans)\\n return ans\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def create_graph(self, s, dic):\\n graph = {}\\n for k in dic.keys():\\n graph[k] = set()\\n\\n for k, v in dic.items():\\n i, j = v\\n\\n for c in s[i : j + 1]:\\n if c != k:\\n graph[c].add(k)\\n \\n return graph\\n \\n def reverse_graph(self, graph):\\n graph2 = {}\\n for k in graph.keys():\\n graph2[k] = set()\\n\\n for u, vs in graph.items():\\n\\n for v in vs:\\n graph2[v].add(u)\\n \\n return graph2\\n \\n\\n def topological_sort(self, graph):\\n def dfs(u):\\n visited.add(u)\\n\\n if u in graph:\\n for v in graph[u]:\\n if v not in visited:\\n dfs(v)\\n \\n topo.append(u)\\n\\n topo = []\\n visited = set()\\n for u in graph.keys():\\n if u not in visited:\\n dfs(u)\\n \\n topo.reverse()\\n return topo\\n \\n\\n def dfs(self, u, graph, visited, visited2, mmin, mmax, dic):\\n visited2.add(u)\\n mmin[0] = min(mmin[0], dic[u][0])\\n mmax[0] = max(mmax[0], dic[u][1])\\n\\n for v in graph[u]:\\n if v in visited:\\n return False\\n \\n if v in visited2:\\n continue\\n \\n if not self.dfs(v, graph, visited, visited2, mmin, mmax, dic):\\n return False\\n \\n return True\\n\\n \\n\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n dic = {}\\n for i, c in enumerate(s):\\n if c not in dic:\\n dic[c] = [i, i]\\n else:\\n dic[c][1] = i\\n\\n graph = self.create_graph(s, dic)\\n print(graph)\\n topo = self.topological_sort(graph)\\n print(topo)\\n\\n graph_rev = self.reverse_graph(graph)\\n print(\\\"reverse graph\\\", graph_rev)\\n visited = set()\\n ans = []\\n for u in topo:\\n if u in visited:\\n continue\\n \\n visited2 = set()\\n mmin = [math.inf]\\n mmax = [-math.inf]\\n is_possible = self.dfs(u, graph_rev, visited, visited2, mmin, mmax, dic)\\n if is_possible:\\n visited = visited.union(visited2)\\n ans.append(s[mmin[0] : mmax[0] + 1])\\n \\n return ans\\n \",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n\\\"cabcccbaa\\\"\\n\\n\\n\\\"bbcacbaba\\\"\\n\\n 0123456789\\n\\\"bbeadcxede\\\" ->[\\\"bb\\\",\\\"a\\\",\\\"c\\\",\\\"x\\\"]\\n\\n\\\"abcdefghijklmnopqrstuvwxyz\\\"\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n def dp(idx, cur_list):\\n if idx == len(condition_1_candidates):\\n num_strs = len(cur_list)\\n all_together_list = [s[x:y + 1] for x, y in cur_list]\\n all_together = \\\"\\\".join(all_together_list)\\n if result:\\n prev_num = result[0]\\n len_prev = result[1]\\n if num_strs > prev_num:\\n result[0] = num_strs\\n result[1] = len(all_together)\\n result[2] = all_together_list\\n elif num_strs == prev_num and len(all_together) < len_prev:\\n result[0] = num_strs\\n result[1] = len(all_together)\\n result[2] = all_together_list\\n else:\\n result.append(num_strs)\\n result.append(len(all_together))\\n result.append(all_together_list)\\n\\n return\\n\\n cur_i, cur_j = condition_1_candidates[idx]\\n \\n # always take it if it's once char\\n if cur_i == cur_j:\\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\\n return\\n\\n is_cur_valid = True\\n for i, j in cur_list:\\n if cur_i <= i <= cur_j:\\n is_cur_valid = False\\n break\\n if cur_i <= j <= cur_j:\\n is_cur_valid = False\\n break\\n\\n if is_cur_valid:\\n # take it\\n dp(idx + 1, cur_list.copy() + [(cur_i, cur_j)])\\n # or skip it\\n dp(idx + 1, cur_list.copy())\\n else:\\n # skip it\\n dp(idx + 1, cur_list.copy())\\n\\n char_to_start_end = {}\\n for i, c in enumerate(s):\\n if c in char_to_start_end:\\n char_to_start_end[c][1] = i\\n else:\\n char_to_start_end[c] = [i, i]\\n\\n condition_1_candidates = set()\\n for c, (s_i, e_i) in char_to_start_end.items():\\n min_i = s_i\\n min_j = e_i\\n seen = set()\\n seen.add(c)\\n for j in range(s_i + 1, e_i):\\n next_char = s[j]\\n h = [char_to_start_end[next_char][0]]\\n max_h = [-char_to_start_end[next_char][1]]\\n while h[0] < min_i:\\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\\n min_i = min_i - 1\\n\\n while -max_h[0] > min_j:\\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\\n min_j = min_j + 1\\n\\n while h[0] < min_i:\\n heapq.heappush(h, char_to_start_end[s[min_i]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_i]][1])\\n min_i = min_i - 1\\n\\n while -max_h[0] > min_j:\\n heapq.heappush(h, char_to_start_end[s[min_j]][0])\\n heapq.heappush(max_h, -char_to_start_end[s[min_j]][1])\\n min_j = min_j + 1\\n\\n condition_1_candidates.add((min_i, min_j))\\n\\n condition_1_candidates = list(condition_1_candidates)\\n condition_1_candidates.sort(key=lambda x:abs(x[0] - x[1]))\\n print(condition_1_candidates)\\n result = []\\n dp(0, [])\\n\\n return result[2]\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = collections.defaultdict(list)\\n \\n # Step 1: Find all occurrences of each character\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n \\n # Step 2: Expand ranges to include all occurrences of each character\\n for r in ranges:\\n left, right = ranges[r][0], ranges[r][-1]+1\\n templ, tempr = left, right\\n while True:\\n for ch in set(s[templ:tempr]):\\n templ = min(templ, ranges[ch][0])\\n tempr = max(tempr, ranges[ch][-1]+1)\\n if (templ, tempr) == (left, right):\\n break\\n left, right = templ, tempr\\n ranges[r] = (templ, tempr)\\n \\n # Step 3: Greedily select non-overlapping ranges\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end])\\n prev = end\\n \\n return ans\",\n \"memory\": \"21500\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n ranges = collections.defaultdict(list)\\n # 1\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n # 2\\n for r in ranges:\\n left, right = ranges[r][0], ranges[r][-1]+1\\n templ, tempr = left, right\\n while True:\\n for ch in set(s[templ:tempr]):\\n templ = min(templ, ranges[ch][0])\\n tempr = max(tempr, ranges[ch][-1]+1)\\n if (templ, tempr) == (left, right): break\\n left, right = templ, tempr\\n ranges[r] = (templ, tempr)\\n # 3\\t\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end])\\n prev = end\\n return ans\",\n \"memory\": \"21600\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # 1. 记录每个字符的第一次和最后一次出现位置\\n ranges = defaultdict(list)\\n for idx, ch in enumerate(s):\\n ranges[ch].append(idx)\\n\\n # 2. 扩展每个字符的区间，确保包含所有相关字符的所有位置\\n for ch in ranges:\\n left, right = ranges[ch][0], ranges[ch][-1] + 1\\n templ, tempr = left, right\\n while True:\\n for c in set(s[templ:tempr]):\\n templ = min(templ, ranges[c][0])\\n tempr = max(tempr, ranges[c][-1] + 1)\\n if (templ, tempr) == (left, right):\\n break\\n left, right = templ, tempr\\n ranges[ch] = (templ, tempr)\\n\\n # 3. 按照右边界排序并选择不重叠的区间\\n sorted_ranges = sorted(ranges.values(), key=lambda pair: pair[1])\\n ans, prev = [], 0\\n for start, end in sorted_ranges:\\n if start >= prev:\\n ans.append(s[start:end])\\n prev = end\\n\\n return ans \",\n \"memory\": \"21700\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n os = s\\n s = list(s)\\n beDict = defaultdict(list)\\n root={}\\n for i,c in enumerate(s):\\n if c in beDict:\\n beDict[c][1]=i\\n else:\\n root[c]=c\\n beDict[c]=[i,i] \\n grpDict=defaultdict(list)\\n def findBE(st):\\n low = min([beDict[x][0] for x in st])\\n high = max([beDict[x][1] for x in st])\\n nxSt = set(s[low:high+1])\\n if nxSt==st:\\n return low,high\\n else:\\n return findBE(nxSt)\\n #print(f\\\"beDict:{beDict}\\\")\\n for c in beDict:\\n # #print(f\\\"for {c} in beDict, b:{beDict[c][0]}, e:{beDict[c][1]+1}\\\")\\n [low,high]= findBE(set(s[beDict[c][0]:beDict[c][1]+1]))\\n grpDict[c] = high-low,low,high\\n #print(f\\\"grpDict:{grpDict}\\\")\\n grps = sorted(set(grpDict.values()))\\n lb,le,res=[],[],[]\\n for _,b,e in grps:\\n bi = bisect.bisect(lb,b)\\n ei = bisect.bisect(le,e)\\n if bi==ei:\\n res.append(os[b:e+1])\\n lb.insert(bi,b)\\n le.insert(ei,e)\\n return res\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n \\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n intervals = []\\n for c in set(s):\\n b, e = fst[c], lst[c]\\n i = b\\n while i <= e and b == fst[c]:\\n b = min(b, fst[s[i]])\\n e = max(e, lst[s[i]])\\n i += 1\\n if b == fst[c]:\\n intervals.append((e, b))\\n \\n intervals.sort()\\n ans, prev = [], -1\\n for e, b in intervals:\\n if b > prev:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n ans, prev = [], -1\\n for i in sorted(lst.values()):\\n b, e = fst[s[i]], lst[s[i]]\\n j = e\\n while j >= b and b > prev and e == i:\\n b = min(b, fst[s[j]])\\n e = max(e, lst[s[j]])\\n j -= 1\\n if b > prev and e == i:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"memory\": \"27900\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n # print(fst, lst)\\n intervals = []\\n for c in set(s):\\n b, e = fst[c], lst[c]\\n i = b\\n while i <= e and b == fst[c]:\\n b = min(b, fst[s[i]])\\n e = max(e, lst[s[i]])\\n i += 1\\n if b == fst[c]:\\n intervals.append((e, b))\\n # x\\n intervals.sort()\\n # print(intervals)\\n ans, prev = [], -1\\n for e, b in intervals:\\n if b > prev:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"memory\": \"28000\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s):\\n fst = { c : i for i, c in reversed(list(enumerate(s))) }\\n lst = { c : i for i, c in enumerate(s) }\\n \\n ans, prev = [], -1\\n for i in sorted(lst.values()):\\n b, e = fst[s[i]], lst[s[i]]\\n j = e\\n while j >= b and b > prev and e == i:\\n b = min(b, fst[s[j]])\\n e = max(e, lst[s[j]])\\n j -= 1\\n if b > prev and e == i:\\n ans.append(s[b:e + 1])\\n prev = e\\n \\n return ans\",\n \"memory\": \"28100\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n crange = {}\\n aset = []\\n for i in range(len(s)):\\n if s[i] not in crange:\\n crange[s[i]] = []\\n crange[s[i]].append(i)\\n \\n #print(crange)\\n\\n \\n for p in crange.keys():\\n i = crange[p][0]\\n for _ in crange.keys():\\n j = crange[_][-1]\\n if i > j:\\n continue\\n valid = True\\n #print(s[i],s[j])\\n for k in range(i,j+1):\\n if i <= crange[s[k]][0] and j >= crange[s[k]][-1]:\\n continue\\n else:\\n valid = False\\n break\\n\\n if valid:\\n aset.append(s[i:j+1])\\n\\n aset.sort(key = lambda x : len(x))\\n ansr = set()\\n ans = []\\n for i in aset:\\n val = True\\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\\n if j in ansr:\\n val = False\\n break\\n if val:\\n ans.append(i)\\n for j in range(crange[i[0]][0],crange[i[-1]][-1]+1):\\n ansr.add(j)\\n\\n #print(aset)\\n return ans\",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n # get the starting and ending indexes of all the chars\\n ref = defaultdict(list)\\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n # for each start, end, return a valid window by extending \\n # start and end until window is valid\\n def isValid(start, end):\\n start_i, end_i = start, end\\n for c in set(s[start:end]):\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n if (start, end) != (start_i, end_i):\\n return isValid(start, end)\\n return (start, end)\\n\\n # get window for each unique char\\n for c in set(s):\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n substrs.add((start, end))\\n \\n #substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1]) \\n\\n res = []\\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\\n \\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"45000\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n curr_count = Counter(s[start:end])\\n #print(s[start:end], curr_count)\\n for c in s[start:end]:\\n if count[c] != curr_count[c]:\\n #print(c, \\\"not it\\\")\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n return isValid(start, end)\\n return (start, end)\\n\\n for i, c in enumerate(s):\\n if i != ref[c][0]:\\n continue\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n #print(\\\"got\\\", start, end, \\\"for\\\", i, c)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1])\\n\\n print(substrs)\\n \\n \\n \\n res = []\\n \\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\\n \\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"45700\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n curr_count = Counter(s[start:end])\\n for c in s[start:end]:\\n if count[c] != curr_count[c]:\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n return isValid(start, end)\\n return (start, end)\\n\\n for i, c in enumerate(s):\\n if i != ref[c][0]:\\n continue\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1]) \\n \\n res = []\\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\",\n \"memory\": \"45700\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, S: str) -> List[str]:\\n mins = [float('inf')]*26\\n maxs = [-1]*26\\n exists = [False]*26\\n prefix_sum = [[0]*26 for _ in range(len(S)+1)]\\n\\n for i,char in enumerate(S):\\n prefix_sum[i+1]=prefix_sum[i][:]\\n prefix_sum[i+1][ord(char)-ord('a')]+=1\\n mins[ord(char)-ord('a')] = min(mins[ord(char)-ord('a')],i)\\n maxs[ord(char)-ord('a')] = max(maxs[ord(char)-ord('a')],i)\\n exists[ord(char)-ord('a')]=True\\n\\n graph = [[False]*26 for _ in range(26)]\\n for i in range(26):\\n if exists[i]:\\n for j in range(26):\\n if prefix_sum[maxs[i]+1][j]-prefix_sum[mins[i]][j]>0:\\n graph[i][j]=True\\n\\n stack = []\\n visited = [False]*26\\n\\n def dfs1(v):\\n if not visited[v]:\\n visited[v]=True\\n for i in range(26):\\n if graph[v][i] and not visited[i]:\\n dfs1(i)\\n stack.append(v)\\n \\n for i in range(26):\\n if exists[i] and not visited[i]:\\n dfs1(i)\\n\\n batch = 0\\n batches = [-1]*26\\n degree = [0]*26\\n\\n def dfs2(v,batch):\\n if batches[v]<0:\\n batches[v]=batch\\n for i in range(26):\\n if graph[i][v]:\\n dfs2(i,batch)\\n else:\\n if batches[v]!=batch:\\n degree[batches[v]]+=1\\n while stack:\\n v = stack.pop()\\n if batches[v]<0:\\n dfs2(v,batch)\\n batch+=1\\n\\n res = []\\n for i in range(batch -1,-1,-1):\\n if degree[i]==0:\\n min_idx = float('inf')\\n max_idx = -1\\n for j in range(26):\\n if batches[j]==i:\\n min_idx = min(mins[j],min_idx)\\n max_idx = max(maxs[j],max_idx)\\n res.append(S[min_idx:max_idx+1])\\n return res\",\n \"memory\": \"48200\"\n },\n {\n \"code\": \"class Solution:\\n def maxNumOfSubstrings(self, s: str) -> List[str]:\\n count = Counter(s)\\n ref = defaultdict(list)\\n \\n for i, c in enumerate(s):\\n ref[c].append(i)\\n \\n substrs = set()\\n \\n def isValid(start, end):\\n start_i, end_i = start, end\\n for c in set(s[start:end]):\\n print(\\\"for \\\", c, ref[c][0], ref[c][-1])\\n start = min(ref[c][0], start)\\n end = max(end, ref[c][-1] + 1)\\n if (start, end) != (start_i, end_i):\\n return isValid(start, end)\\n return (start, end)\\n\\n for c in set(s):\\n start, end = isValid(ref[c][0], ref[c][-1] + 1)\\n substrs.add((start, end))\\n \\n substrs.add((0, len(s)))\\n\\n substrs = sorted(substrs, key=lambda x: x[1]) \\n print(substrs)\\n res = []\\n for r in substrs:\\n if not res:\\n res.append(r)\\n if res[-1][1] <= r[0]:\\n res.append(r)\\n \\n return [s[i:j] for (i, j) in res]\\n \\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"49100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":38,"string":"38"}}},{"rowIdx":2450,"cells":{"question_id":{"kind":"number","value":2837,"string":"2,837"},"name":{"kind":"string","value":"minimum-operations-to-make-the-integer-zero"},"content":{"kind":"string","value":"<p>You are given two integers <code>num1</code> and <code>num2</code>.</p>\n\n<p>In one operation, you can choose integer <code>i</code> in the range <code>[0, 60]</code> and subtract <code>2<sup>i</sup> + num2</code> from <code>num1</code>.</p>\n\n<p>Return <em>the integer denoting the <strong>minimum</strong> number of operations needed to make</em> <code>num1</code> <em>equal to</em> <code>0</code>.</p>\n\n<p>If it is impossible to make <code>num1</code> equal to <code>0</code>, return <code>-1</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> num1 = 3, num2 = -2\n<strong>Output:</strong> 3\n<strong>Explanation:</strong> We can make 3 equal to 0 with the following operations:\n- We choose i = 2 and substract 2<sup>2</sup> + (-2) from 3, 3 - (4 + (-2)) = 1.\n- We choose i = 2 and substract 2<sup>2</sup> + (-2) from 1, 1 - (4 + (-2)) = -1.\n- We choose i = 0 and substract 2<sup>0</sup> + (-2) from -1, (-1) - (1 + (-2)) = 0.\nIt can be proven, that 3 is the minimum number of operations that we need to perform.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> num1 = 5, num2 = 7\n<strong>Output:</strong> -1\n<strong>Explanation:</strong> It can be proven, that it is impossible to make 5 equal to 0 with the given operation.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= num1 <= 10<sup>9</sup></code></li>\n\t<li><code><font face=\"monospace\">-10<sup>9</sup> <= num2 <= 10<sup>9</sup></font></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":30.31391772980544,"string":"30.313918"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["bit-manipulation","brainteaser"],"string":"[\n \"bit-manipulation\",\n \"brainteaser\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"21\", 0.6098], [\"23\", 1.2195], [\"24\", 1.2195], [\"25\", 0.6098], [\"26\", 0.6098], [\"27\", 3.6585], [\"28\", 1.2195], [\"29\", 1.8293], [\"30\", 0.6098], [\"31\", 4.878], [\"32\", 5.4878], [\"33\", 4.878], [\"34\", 6.7073], [\"35\", 10.3659], [\"36\", 7.3171], [\"37\", 2.439], [\"38\", 3.6585], [\"39\", 4.2683], [\"40\", 6.7073], [\"41\", 5.4878], [\"42\", 4.878], [\"43\", 6.7073], [\"44\", 3.6585], [\"45\", 3.0488], [\"46\", 1.8293]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16300\", 4.878], [\"16400\", 18.2927], [\"16500\", 39.0244]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n \"\"\"\n if we pick integers a, b, c, ... in our operations, then the sum is\n\n num1 - num2 * len(ops) - (2**a + 2**b + 2**c + ...)\n\n \"\"\"\n\n ops = 1\n while True:\n # num1 - ops * nums2 - p2sum = 0\n # p2sum = num1 - ops * nums2\n # \n # Q: can p2sum be expressed as the sum of `ops` powers of 2?\n # A: Yes iff the number of bits in a binary representation of p2sum is\n # less than or equal to ops AND p2sum is greater than or equal to ops\n # (such that breaking down p2sum into 2^0=1 elements is sufficient)\n p2sum = num1 - ops * num2\n if p2sum <= 0:\n return -1\n if p2sum >= ops and p2sum.bit_count() <= ops:\n return ops\n \n ops += 1","runtime":"21"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and target.bit_count() <= k <= target:\n return k\n return -1","runtime":"23"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n ans = 0\n while bin(num1).count('1') > ans:\n ans += 1\n num1 -= num2\n if num1 < ans and num2 > 0:\n return -1\n return ans","runtime":"24"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and target.bit_count() <= k <= target:\n return k\n return -1","runtime":"25"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n if num1 <= num2:\n return -1\n \n moves = 0\n while True:\n if num1 - num2 < moves + 1:\n return -1\n num1 -= num2\n moves += 1\n if bin(num1)[2:].count('1') <= moves:\n break\n\n return moves","runtime":"26"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and target.bit_count() <= k <= target:\n return k\n return -1","runtime":"27"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and bin(target).count('1') <= k and k <= target:\n return k\n return -1","runtime":"28"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n # If num1 is less than num2 or num1 is negative, it's impossible\n if num1 < num2 or num1 < 0:\n return -1\n\n # Iterate over possible values of i\n for k in range(61):\n # Calculate the result of subtracting 2^i + num2 from num1 k times\n result = num1 - k * num2\n # Check if the result is non-negative and has at least k set bits\n if result >= 0 and result.bit_count() <= k <= result:\n return k\n\n # If no valid number of operations found, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1","runtime":"29"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and target.bit_count() <= k <= target:\n return k\n return -1","runtime":"30"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for i in range(1,61):\n num=num1-i*num2\n if(num<0):\n return -1\n x=bin(num).count(\"1\")\n if(x<=i and num>=i):\n return i\n return -1","runtime":"31"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(1, 61): # We iterate over possible number of operations\n target = num1 - k * num2\n if target < 0:\n continue\n # Check if target can be represented as a sum of k distinct powers of two\n if bin(target).count('1') <= k and target >= k:\n return k\n return -1","runtime":"32"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for i in count(1): \n num1 -= num2\n if num1 <= 0: return -1 \n lo = num1.bit_count()\n if lo <= i <= num1: return i","runtime":"32"},{"code":"class Solution:\n def makeTheIntegerZero(self, x: int, y: int) -> int:\n for k in range(1, 61):\n if (x - k * y).bit_count() <= k <= x - k * y:\n return k\n return -1","runtime":"33"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n # num1 - (2^i0 + num2) - (2^i1 + num2) - ... = 0\n # num1 = 2^i0 + ... + 2^ik + k*num2\n # num1 - k*num2 = 2^i0 + ... + 2^ik\n def bits(x):\n b = 0\n while x:\n b += (x&1)\n x //= 2\n return b\n\n for k in range(61):\n targ = num1 - k*num2\n if targ < k: continue\n # print(k, targ, bits(targ))\n if bits(targ) <= k: return k\n return -1","runtime":"34"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n # We'll test different numbers of operations k\n for k in range(1, 61):\n # Calculate the remainder after considering num2's impact\n rem = num1 - num2 * k\n # If rem is at least as large as k (the count of times we can use 2^i), and\n # if rem has enough set bits to cover all the operations (<= k), it's possible\n if rem >= k and bin(rem).count('1') <= k:\n return k\n # If no valid k is found, return -1 meaning impossible\n return -1","runtime":"35"},{"code":"class Solution:\r\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\r\n for k in range(1, 61):\r\n S = num1 - k * num2\r\n if S < 0:\r\n break # Further increasing k will not help\r\n num_ones = bin(S).count('1')\r\n if num_ones <= k and S >= k:\r\n return k\r\n return -1\r\n","runtime":"36"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for count in range(1, 60):\n num1 -= num2\n\n # assume each time substract 2^0=1, < 0\n if num1 < count: \n return -1\n\n # allow < because combination will reduce bit count\n # like 2^2 + 2^2 = 2^3 \n if num1.bit_count() <= count : \n return count\n\n\n return -1","runtime":"37"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n # If num1 is less than num2, it's impossible to make num1 equal to 0\n if num1 < num2:\n return -1\n \n # Iterate over possible values of k (number of operations)\n for k in range(61):\n # Calculate the value after subtracting num2 k times\n val = num1 - k * num2\n \n # If the value is less than k, it's impossible to make num1 equal to 0\n if val < k:\n break\n \n # Count the number of set bits in val\n set_bits = bin(val).count('1')\n \n # If the number of set bits is less than or equal to k, return k\n if set_bits <= k:\n return k\n \n # If no valid k is found, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1","runtime":"38"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n ans=-1\n for i in range(1,61):\n num=num1-i*num2\n if(num<0):\n break\n x=bin(num).count(\"1\")\n if(x and x<=i and num>=i):\n ans=i\n break\n return ans","runtime":"39"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n # For a number of operations `k`, check if it's feasible.\n for k in range(61):\n # Calculate the adjusted target after using k operations.\n target = num1 - k * num2\n # Check if the target can be constructed using `k` numbers of form 2^i.\n if target >= 0 and bin(target).count('1') <= k <= target:\n return k\n return -1","runtime":"40"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and bin(target).count('1') <= k and target >= k:\n return k\n return -1","runtime":"41"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(1, 61):\n # Calculate the modified number we need to express with `k` powers of 2\n target = num1 - k * num2\n \n if target < 0:\n continue\n \n # Count set bits in the target\n num_set_bits = bin(target).count('1')\n \n # Check if the number of set bits is <= k and target is at least k\n if num_set_bits <= k and target >= k:\n return k\n \n return -1\n\n# Example usage:\n# solution = Solution()\n# print(solution.makeTheIntegerZero(3, -2)) # Should output 3\n# print(solution.makeTheIntegerZero(5, 7)) # Should output -1","runtime":"42"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for k in range(61):\n target = num1 - k * num2\n if target >= 0 and target.bit_count() <= k <= target:\n return k\n return -1","runtime":"43"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for i in count(1): \n num1 -= num2\n if num1 <= 0: return -1 \n if num1.bit_count() <= i <= num1: return i","runtime":"43"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n if num1 - num2 < 1: return -1\n def check(x):\n # if can make in x steps\n num = num1 - x * num2\n if num < 1: return False\n k = 0\n for b in range(61):\n if ((num>>b)&1) != 0: k += 1\n return k <= x and x <= num\n \n for x in range(61):\n if check(x): return x\n return -1","runtime":"44"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n k = 1\n while True:\n num1 -= num2\n if num1 < k:\n return -1\n\n if num1.bit_count() <= k:\n return k\n k += 1\n return -1\n\n","runtime":"45"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n \n ans = 100\n for step in range(1, 100):\n num = num1 - step * num2\n ones = bin(num).count('1')\n if num >= step and ones <= step:\n ans = min(ans, step)\n \n if ans == 100:\n return -1\n else: \n return ans\n ","runtime":"46"}],"string":"[\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n \\\"\\\"\\\"\\n if we pick integers a, b, c, ... in our operations, then the sum is\\n\\n num1 - num2 * len(ops) - (2**a + 2**b + 2**c + ...)\\n\\n \\\"\\\"\\\"\\n\\n ops = 1\\n while True:\\n # num1 - ops * nums2 - p2sum = 0\\n # p2sum = num1 - ops * nums2\\n # \\n # Q: can p2sum be expressed as the sum of `ops` powers of 2?\\n # A: Yes iff the number of bits in a binary representation of p2sum is\\n # less than or equal to ops AND p2sum is greater than or equal to ops\\n # (such that breaking down p2sum into 2^0=1 elements is sufficient)\\n p2sum = num1 - ops * num2\\n if p2sum <= 0:\\n return -1\\n if p2sum >= ops and p2sum.bit_count() <= ops:\\n return ops\\n \\n ops += 1\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and target.bit_count() <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n ans = 0\\n while bin(num1).count('1') > ans:\\n ans += 1\\n num1 -= num2\\n if num1 < ans and num2 > 0:\\n return -1\\n return ans\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and target.bit_count() <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n if num1 <= num2:\\n return -1\\n \\n moves = 0\\n while True:\\n if num1 - num2 < moves + 1:\\n return -1\\n num1 -= num2\\n moves += 1\\n if bin(num1)[2:].count('1') <= moves:\\n break\\n\\n return moves\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and target.bit_count() <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and bin(target).count('1') <= k and k <= target:\\n return k\\n return -1\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n # If num1 is less than num2 or num1 is negative, it's impossible\\n if num1 < num2 or num1 < 0:\\n return -1\\n\\n # Iterate over possible values of i\\n for k in range(61):\\n # Calculate the result of subtracting 2^i + num2 from num1 k times\\n result = num1 - k * num2\\n # Check if the result is non-negative and has at least k set bits\\n if result >= 0 and result.bit_count() <= k <= result:\\n return k\\n\\n # If no valid number of operations found, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and target.bit_count() <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for i in range(1,61):\\n num=num1-i*num2\\n if(num<0):\\n return -1\\n x=bin(num).count(\\\"1\\\")\\n if(x<=i and num>=i):\\n return i\\n return -1\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(1, 61): # We iterate over possible number of operations\\n target = num1 - k * num2\\n if target < 0:\\n continue\\n # Check if target can be represented as a sum of k distinct powers of two\\n if bin(target).count('1') <= k and target >= k:\\n return k\\n return -1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for i in count(1): \\n num1 -= num2\\n if num1 <= 0: return -1 \\n lo = num1.bit_count()\\n if lo <= i <= num1: return i\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, x: int, y: int) -> int:\\n for k in range(1, 61):\\n if (x - k * y).bit_count() <= k <= x - k * y:\\n return k\\n return -1\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n # num1 - (2^i0 + num2) - (2^i1 + num2) - ... = 0\\n # num1 = 2^i0 + ... + 2^ik + k*num2\\n # num1 - k*num2 = 2^i0 + ... + 2^ik\\n def bits(x):\\n b = 0\\n while x:\\n b += (x&1)\\n x //= 2\\n return b\\n\\n for k in range(61):\\n targ = num1 - k*num2\\n if targ < k: continue\\n # print(k, targ, bits(targ))\\n if bits(targ) <= k: return k\\n return -1\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n # We'll test different numbers of operations k\\n for k in range(1, 61):\\n # Calculate the remainder after considering num2's impact\\n rem = num1 - num2 * k\\n # If rem is at least as large as k (the count of times we can use 2^i), and\\n # if rem has enough set bits to cover all the operations (<= k), it's possible\\n if rem >= k and bin(rem).count('1') <= k:\\n return k\\n # If no valid k is found, return -1 meaning impossible\\n return -1\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\r\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\r\\n for k in range(1, 61):\\r\\n S = num1 - k * num2\\r\\n if S < 0:\\r\\n break # Further increasing k will not help\\r\\n num_ones = bin(S).count('1')\\r\\n if num_ones <= k and S >= k:\\r\\n return k\\r\\n return -1\\r\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for count in range(1, 60):\\n num1 -= num2\\n\\n # assume each time substract 2^0=1, < 0\\n if num1 < count: \\n return -1\\n\\n # allow < because combination will reduce bit count\\n # like 2^2 + 2^2 = 2^3 \\n if num1.bit_count() <= count : \\n return count\\n\\n\\n return -1\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n # If num1 is less than num2, it's impossible to make num1 equal to 0\\n if num1 < num2:\\n return -1\\n \\n # Iterate over possible values of k (number of operations)\\n for k in range(61):\\n # Calculate the value after subtracting num2 k times\\n val = num1 - k * num2\\n \\n # If the value is less than k, it's impossible to make num1 equal to 0\\n if val < k:\\n break\\n \\n # Count the number of set bits in val\\n set_bits = bin(val).count('1')\\n \\n # If the number of set bits is less than or equal to k, return k\\n if set_bits <= k:\\n return k\\n \\n # If no valid k is found, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n ans=-1\\n for i in range(1,61):\\n num=num1-i*num2\\n if(num<0):\\n break\\n x=bin(num).count(\\\"1\\\")\\n if(x and x<=i and num>=i):\\n ans=i\\n break\\n return ans\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n # For a number of operations `k`, check if it's feasible.\\n for k in range(61):\\n # Calculate the adjusted target after using k operations.\\n target = num1 - k * num2\\n # Check if the target can be constructed using `k` numbers of form 2^i.\\n if target >= 0 and bin(target).count('1') <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and bin(target).count('1') <= k and target >= k:\\n return k\\n return -1\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(1, 61):\\n # Calculate the modified number we need to express with `k` powers of 2\\n target = num1 - k * num2\\n \\n if target < 0:\\n continue\\n \\n # Count set bits in the target\\n num_set_bits = bin(target).count('1')\\n \\n # Check if the number of set bits is <= k and target is at least k\\n if num_set_bits <= k and target >= k:\\n return k\\n \\n return -1\\n\\n# Example usage:\\n# solution = Solution()\\n# print(solution.makeTheIntegerZero(3, -2)) # Should output 3\\n# print(solution.makeTheIntegerZero(5, 7)) # Should output -1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for k in range(61):\\n target = num1 - k * num2\\n if target >= 0 and target.bit_count() <= k <= target:\\n return k\\n return -1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for i in count(1): \\n num1 -= num2\\n if num1 <= 0: return -1 \\n if num1.bit_count() <= i <= num1: return i\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n if num1 - num2 < 1: return -1\\n def check(x):\\n # if can make in x steps\\n num = num1 - x * num2\\n if num < 1: return False\\n k = 0\\n for b in range(61):\\n if ((num>>b)&1) != 0: k += 1\\n return k <= x and x <= num\\n \\n for x in range(61):\\n if check(x): return x\\n return -1\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n k = 1\\n while True:\\n num1 -= num2\\n if num1 < k:\\n return -1\\n\\n if num1.bit_count() <= k:\\n return k\\n k += 1\\n return -1\\n\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n \\n ans = 100\\n for step in range(1, 100):\\n num = num1 - step * num2\\n ones = bin(num).count('1')\\n if num >= step and ones <= step:\\n ans = min(ans, step)\\n \\n if ans == 100:\\n return -1\\n else: \\n return ans\\n \",\n \"runtime\": \"46\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":27,"string":"27"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n if num1 < num2:\n return -1\n for k in range(61):\n if num1 - k * num2 < 0:\n break\n target = num1 - k * num2\n if target.bit_count() <= k <= target:\n return k\n return -1\n\n# Example usage:\nsolution = Solution()\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1","memory":"16300"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n ans=-1\n for i in range(1,61):\n num=num1-i*num2\n if(num<0):\n break\n x=bin(num).count(\"1\")\n if(x and x<=i and num>=i):\n ans=i\n break\n return ans","memory":"16400"},{"code":"class Solution:\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\n for i in range(1,61):\n num=num1-i*num2\n if(num<0):\n return -1\n x=bin(num).count(\"1\")\n if(x<=i and num>=i):\n return i\n return -1","memory":"16500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n if num1 < num2:\\n return -1\\n for k in range(61):\\n if num1 - k * num2 < 0:\\n break\\n target = num1 - k * num2\\n if target.bit_count() <= k <= target:\\n return k\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.makeTheIntegerZero(3, -2)) # Output: 3\\nprint(solution.makeTheIntegerZero(5, 7)) # Output: -1\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n ans=-1\\n for i in range(1,61):\\n num=num1-i*num2\\n if(num<0):\\n break\\n x=bin(num).count(\\\"1\\\")\\n if(x and x<=i and num>=i):\\n ans=i\\n break\\n return ans\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def makeTheIntegerZero(self, num1: int, num2: int) -> int:\\n for i in range(1,61):\\n num=num1-i*num2\\n if(num<0):\\n return -1\\n x=bin(num).count(\\\"1\\\")\\n if(x<=i and num>=i):\\n return i\\n return -1\",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":3,"string":"3"}}},{"rowIdx":2451,"cells":{"question_id":{"kind":"number","value":2873,"string":"2,873"},"name":{"kind":"string","value":"prime-pairs-with-target-sum"},"content":{"kind":"string","value":"<p>You are given an integer <code>n</code>. We say that two integers <code>x</code> and <code>y</code> form a prime number pair if:</p>\n\n<ul>\n\t<li><code>1 <= x <= y <= n</code></li>\n\t<li><code>x + y == n</code></li>\n\t<li><code>x</code> and <code>y</code> are prime numbers</li>\n</ul>\n\n<p>Return <em>the 2D sorted list of prime number pairs</em> <code>[x<sub>i</sub>, y<sub>i</sub>]</code>. The list should be sorted in <strong>increasing</strong> order of <code>x<sub>i</sub></code>. If there are no prime number pairs at all, return <em>an empty array</em>.</p>\n\n<p><strong>Note:</strong> A prime number is a natural number greater than <code>1</code> with only two factors, itself and <code>1</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 10\n<strong>Output:</strong> [[3,7],[5,5]]\n<strong>Explanation:</strong> In this example, there are two prime pairs that satisfy the criteria. \nThese pairs are [3,7] and [5,5], and we return them in the sorted order as described in the problem statement.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 2\n<strong>Output:</strong> []\n<strong>Explanation:</strong> We can show that there is no prime number pair that gives a sum of 2, so we return an empty array. \n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 10<sup>6</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":34.553092077184,"string":"34.553092"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","math","enumeration","number-theory"],"string":"[\n \"array\",\n \"math\",\n \"enumeration\",\n \"number-theory\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"381\", 3.6584999999999996], [\"466\", 0.4065], [\"552\", 0.4065], [\"637\", 0.4065], [\"722\", 0.4065], [\"808\", 0.4065], [\"893\", 0.4065], [\"978\", 0.813], [\"1064\", 2.0324999999999998], [\"1149\", 0.4065], [\"1234\", 0.4065], [\"1320\", 0.4065], [\"1405\", 0.4065], [\"1490\", 0.4065], [\"1576\", 0.4065], [\"1661\", 0.4065], [\"1746\", 0.4065], [\"1832\", 0.4065], [\"1917\", 0.4065], [\"2002\", 0.4065], [\"2088\", 6.910500000000002], [\"2173\", 8.536500000000002], [\"2258\", 2.4389999999999996], [\"2344\", 1.2195], [\"2429\", 0.813], [\"2514\", 2.0324999999999998], [\"2600\", 1.626], [\"2685\", 4.0649999999999995], [\"2770\", 6.5040000000000004], [\"2856\", 3.658499999999999], [\"2941\", 2.8454999999999995], [\"3026\", 1.2195], [\"3112\", 2.8454999999999995], [\"3197\", 1.2195], [\"3282\", 1.626], [\"3368\", 2.8455], [\"3453\", 3.2519999999999993], [\"3538\", 0.4065], [\"3624\", 3.2519999999999993], [\"3709\", 0.4065], [\"3794\", 1.2195], [\"3879\", 2.4389999999999996], [\"3965\", 1.2195], [\"4050\", 0.813], [\"4135\", 0.4065], [\"4221\", 1.2195], [\"4306\", 1.2195], [\"4391\", 1.2195], [\"4477\", 0.4065], [\"4562\", 1.626], [\"4647\", 0.4065], [\"4733\", 0.4065], [\"4818\", 0.4065], [\"4903\", 0.4065], [\"4989\", 0.4065], [\"5074\", 0.4065], [\"5159\", 0.4065], [\"5245\", 0.4065], [\"5330\", 0.4065], [\"5415\", 0.4065], [\"5501\", 0.4065], [\"5586\", 0.4065], [\"5671\", 0.813], [\"5757\", 0.4065], [\"5842\", 0.4065], [\"5927\", 0.4065], [\"6013\", 0.4065], [\"6098\", 0.4065], [\"6183\", 0.4065], [\"6269\", 0.4065], [\"6354\", 0.4065], [\"6439\", 0.4065], [\"6525\", 0.4065], [\"6610\", 0.4065], [\"6695\", 0.4065], [\"6781\", 0.4065], [\"6866\", 0.4065], [\"6951\", 0.4065]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"20700\", 0.4065], [\"20800\", 0.4065], [\"25200\", 0.4065], [\"25800\", 0.4065], [\"26600\", 0.4065], [\"26700\", 0.4065], [\"28400\", 0.4065], [\"28600\", 0.4065], [\"28700\", 0.4065], [\"29000\", 0.4065], [\"29700\", 0.4065], [\"30200\", 1.2195], [\"30300\", 0.4065], [\"30400\", 0.4065], [\"30500\", 0.813], [\"30700\", 2.0325], [\"30800\", 3.252], [\"30900\", 1.2195], [\"31000\", 1.626], [\"31100\", 2.0325], [\"31300\", 0.4065], [\"31700\", 1.2195], [\"31800\", 1.626], [\"32500\", 0.4065], [\"32900\", 0.4065], [\"33100\", 0.4065], [\"33200\", 0.4065], [\"33300\", 1.626], [\"33400\", 2.0325], [\"33500\", 1.2195], [\"33600\", 5.2846], [\"33700\", 21.1382], [\"33800\", 17.4797], [\"33900\", 2.439], [\"34300\", 0.4065], [\"34600\", 0.4065], [\"34700\", 0.813], [\"35100\", 0.4065], [\"35400\", 0.4065], [\"35500\", 2.8455], [\"35600\", 2.8455], [\"35700\", 1.2195], [\"35800\", 2.439], [\"35900\", 0.4065], [\"36000\", 0.813], [\"36100\", 0.4065], [\"36200\", 0.4065], [\"36300\", 1.626], [\"36400\", 0.4065], [\"36900\", 0.4065], [\"37100\", 0.4065], [\"37200\", 0.4065], [\"37300\", 0.4065], [\"37400\", 0.4065], [\"37500\", 0.4065], [\"37600\", 0.4065], [\"37700\", 0.4065], [\"37900\", 0.4065], [\"38000\", 0.813], [\"38100\", 0.4065]]}"},"rt_list":{"kind":"list like","value":[{"code":"def getSieve(n: int) -> int:\n sqrt_n = int(sqrt(n))\n # print('srqrt_n: ', sqrt_n)\n sieve = [0, 0] + [1]*(n - 2)\n\n k = 2\n while k <= sqrt_n:\n if sieve[k]:\n multiple = k * k\n # print('k: ', k, ' multiple: ', multiple)\n while multiple < n:\n sieve[multiple] = 0\n multiple += k\n k += 1 if k == 2 else 2\n\n # print(self.sieve)\n return sieve \nprimes = [i for i,val in enumerate(getSieve(1000000)) if val == 1]\nprime_set = set(primes)\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res = []\n search_limit = n // 2\n for prime in primes:\n if prime > search_limit: break\n if n - prime in prime_set:\n res.append([prime, n - prime])\n return res","runtime":"381"},{"code":"import array\ndef sieve_of_eratosthenes(n):\n if n < 2:\n return []\n is_prime = bytearray((1,))*(n+1)\n is_prime[0] = is_prime[1] = 0\n for i in range(2, int(n**0.5) + 1):\n if is_prime[i]:\n for j in range(i * i, n + 1, i):\n is_prime[j] = 0\n primes = array.array('i',(i for i in range(n + 1) if is_prime[i]))\n return primes\n\nPRIMES = sieve_of_eratosthenes(1000000)\n\nPS = set(PRIMES)\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n out = []\n for p in PRIMES:\n np=n-p\n if p<=np and np in PS:\n out.append((p,np))\n if p >= np:\n return out","runtime":"381"},{"code":"pr = [1 for i in range(10**6+1)]\np = 2\nwhile p*p<10**6+1:\n if pr[p]:\n for i in range(2*p, 10**6+1, p):\n pr[i] = 0\n p +=1\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n for i in range(2, n//2+1):\n if pr[i] and pr[n-i]:\n ans.append([i, n-i])\n return ans","runtime":"466"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n def is_prime(num):\n if num <= 2 or num % 2 == 0:\n return num == 2\n for d in range(3, isqrt(num) + 1, 2):\n if num % d == 0:\n return False\n return True\n\n def find_primes(num):\n num += 1 # to include 0\n primes = [True] * num\n primes[0] = primes[1] = False\n for p in range(2, max(3, isqrt(num) + 1)):\n if not primes[p]:\n continue\n for kp in range(p * p, num, p):\n primes[kp] = False\n return primes\n\n ans = []\n if 1 <= 2 <= n - 2 <= n:\n if is_prime(n - 2):\n ans.append([2, n - 2])\n\n if n % 2 == 1:\n return ans\n\n primes = find_primes(n)\n\n for x in range(3, n // 2 + 1, 2):\n y = n - x\n #if x <= y and is_prime(x) and is_prime(y):\n if x <= y and primes[x] and primes[y]:\n ans.append([x, y])\n return ans\n","runtime":"552"},{"code":"def get_primes(num):\n primes = [True] * (num + 1)\n for x in range(2, num + 1):\n if primes[x]:\n for y in range(x*x, num + 1, x):\n primes[y] = False\n return primes\n\nprimes = get_primes(1000000)\n \n \nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n res = []\n for left in range(2, n // 2 + 1):\n right = n - left\n if primes[left] and primes[right]:\n res.append([left, right])\n return res\n ","runtime":"637"},{"code":"class Solution:\n\n def eratosthenes_sieve(self, n):\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\n for p in range(3, sqrt_n, 2):\n if prime[p]:\n result.append(p)\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\n\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes_list = self.eratosthenes_sieve(n + 1)\n primes_set = set(primes_list)\n res = []\n for p in primes_list:\n if p > n - p:\n break\n if n - p in primes_set:\n res.append([p, n - p])\n return res","runtime":"722"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n \n if n % 2 == 1:\n n -= 2\n for p in range(2, round(n ** 0.5) + 1):\n if n % p == 0:\n return []\n return [[2, n]]\n \n def get_all_primes(m):\n is_primes = [True] * (m + 1)\n is_primes[0] = is_primes[1] = False\n for i in range(2, round(m ** 0.5) + 1):\n if is_primes[i]:\n step = 2 if i == 2 else 2 * i\n for j in range(i ** 2, m + 1, step):\n is_primes[j] = False\n return [\n i\n for i, is_prime in enumerate(is_primes)\n if is_prime\n ]\n \n primes = get_all_primes(n)\n j = len(primes) - 1\n\n result = []\n for i, prime in enumerate(primes):\n if 2 * prime > n:\n break\n while i <= j and prime + primes[j] > n:\n j -= 1\n if prime + primes[j] == n:\n result.append([prime, primes[j]])\n return result","runtime":"808"},{"code":"class Solution:\n\n def eratosthenes_sieve(self, n):\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\n for p in range(3, sqrt_n, 2):\n if prime[p]:\n result.append(p)\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\n\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes_list = self.eratosthenes_sieve(n + 1)\n primes_set = set(primes_list)\n res = []\n for p in primes_list:\n if p > n - p:\n break\n if n - p in primes_set:\n res.append([p, n - p])\n return res","runtime":"893"},{"code":"limit = 10 ** 6\nprimes = [True] * (limit + 1)\n\nprimes[0] = False\nprimes[1] = False\n\nfor i in range(2, limit + 1):\n if primes[i]:\n nextNum = 2 * i\n while nextNum <= limit:\n primes[nextNum] = False\n nextNum += i\n\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n global primes\n\n res = []\n for x in range(1, n // 2 + 1):\n if not primes[x]:\n continue\n \n y = n - x\n\n if not primes[y]:\n continue\n \n res.append([x, y])\n\n return res\n ","runtime":"978"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n result = []\n allPrimes = get_primes_numpy(n) \n left = 0\n right = len(allPrimes) - 1\n\n while left <= right:\n sm = allPrimes[left] + allPrimes[right] \n if sm > n:\n right -= 1\n elif sm == n:\n result.append([allPrimes[left], allPrimes[right]])\n left += 1\n else:\n left += 1\n\n\n return result","runtime":"978"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n result = []\n allPrimes = get_primes_numpy(n) \n left = 0\n right = len(allPrimes) - 1\n\n while left <= right:\n sm = allPrimes[left] + allPrimes[right] \n if sm > n:\n right -= 1\n elif sm == n:\n result.append([allPrimes[left], allPrimes[right]])\n left += 1\n else:\n left += 1\n\n\n return result","runtime":"1064"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n # these two functions are from IterTools Recipes:\n # https://docs.python.org/3/library/itertools.html\n\n import contextlib\n\n def iter_index(iterable, value, start=0, stop=None):\n \"Return indices where a value occurs in a sequence or iterable.\"\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\n seq_index = getattr(iterable, 'index', None)\n if seq_index is None:\n iterator = islice(iterable, start, stop)\n for i, element in enumerate(iterator, start):\n if element is value or element == value:\n yield i\n else:\n stop = len(iterable) if stop is None else stop\n i = start\n with contextlib.suppress(ValueError):\n while True:\n yield (i := seq_index(value, i, stop))\n i += 1\n\n def sieve(n):\n \"Primes less than n.\"\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n if n > 2:\n yield 2\n data = bytearray((0, 1)) * (n // 2)\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n yield from iter_index(data, 1, start=3)\n\n primes = set(sieve(n))\n\n return [\n [P, n - P]\n for P in sorted(primes)\n if P <= (n - P) and (n - P) in primes\n ]\n","runtime":"1064"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True] * (n+1)\n primes[0] = primes[1] = False\n\n for i in range(2, 1+floor(sqrt(n))):\n if primes[i]:\n for j in range(i*i, n+1, i):\n primes[j] = False\n \n if n%2==1:\n if primes[n-2]:\n return [[2,n-2]]\n else:\n return []\n result = []\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i] and i<=n-i:\n result.append([i, n-i])\n return result","runtime":"1149"},{"code":"from typing import List\nimport math\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num + 1)\n isPrime[0] = isPrime[1] = False\n for p in range(math.isqrt(num) + 1):\n if isPrime[p]:\n for j in range(p * p, num + 1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2, n // 2 + 1):\n if isPrime[i] and isPrime[n - i]:\n a.append([i, n - i])\n return a\n","runtime":"1234"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"1320"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n is_prime = self.sieveOfEratosthenes(n) # Generate prime numbers up to n\n res = []\n\n for p in range(2, n // 2 + 1):\n if is_prime[p] and is_prime[n - p]:\n res.append([p, n - p])\n\n return res\n\n def sieveOfEratosthenes(self, n: int) -> List[bool]:\n is_prime = [True] * (n + 1)\n is_prime[0] = is_prime[1] = False\n\n p = 2\n while p * p <= n:\n if is_prime[p]:\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n p += 1\n\n return is_prime","runtime":"1405"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"1490"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n \n def get_primes(n):\n p = 3\n sieve = [1 for _ in range(n+1)]\n while p*p <= n:\n if sieve[p]:\n for x in range(p*p, n+1, 2*p):\n sieve[x] = 0\n p += 2\n ret = [2]\n for i in range(3, n+1, 2):\n if sieve[i]:\n ret.append(i)\n return ret\n PRIMES = get_primes(n)\n \n output = []\n\n i = 0\n j = len(PRIMES) - 1\n\n while i <= j:\n if PRIMES[i] + PRIMES[j] > n:\n j -= 1\n elif PRIMES[i] + PRIMES[j] < n:\n i += 1\n else:\n output.append([PRIMES[i], PRIMES[j]])\n i += 1\n j -= 1\n return output","runtime":"1576"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n dp = [True] * (n + 1)\n dp[0] = dp[1] = False \n for i in range(2, int(n**0.5) + 1):\n if dp[i]: # If i is a prime\n for j in range(i*i, n + 1, i): \n dp[j] = False\n val = n//2\n ans = []\n for i in range(2,val+1):\n if (dp[i] and dp[n-i]):\n ans.append([i,n-i])\n return ans\n ","runtime":"1661"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"1746"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"1832"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def sieve(num):\n prime = [True]*(num+1)\n prime[0] = prime[1] = False\n for p in range(isqrt(num)+1):\n if prime[p]:\n for j in range(p*p, num+1, p):\n prime[j] = False\n \n return prime\n \n prime = sieve(n)\n res = []\n for i in range(2, n//2+1):\n if prime[i] and prime[n-i]:\n res.append([i, n-i])\n \n return res","runtime":"1917"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"2002"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def SOE(num):\n isPrime = [True] * (num+1)\n isPrime[0] = isPrime[1] = False\n for p in range(isqrt(num)+1):\n if isPrime[p]:\n for j in range(p*p, num+1, p):\n isPrime[j] = False\n return isPrime\n\n isPrime = SOE(n)\n\n a = []\n for i in range(2,n//2+1):\n if isPrime[i] and isPrime[n-i]:\n a.append([i, n-i])\n return a","runtime":"2088"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n is_prime = [True] * (n + 1)\n is_prime[0] = is_prime[1] = False\n for i in range(2, int(n**0.5) + 1):\n if is_prime[i]:\n for j in range(i*i, n + 1, i):\n is_prime[j] = False\n \n prime_pairs = []\n for x in range(2, n // 2 + 1):\n if is_prime[x] and is_prime[n - x]:\n prime_pairs.append([x, n - x])\n \n return prime_pairs","runtime":"2088"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n is_prime = [True] * (n + 1)\n is_prime[0] = is_prime[1] = False\n\n for i in range(2, int(n ** 0.5) + 1):\n if is_prime[i]:\n for j in range(i * i, n + 1, i):\n is_prime[j] = False\n\n pairs = []\n mid = len(is_prime) // 2\n for i in range(mid):\n if is_prime[i] and is_prime[n - i]:\n pairs.append([i, n - i])\n \n if is_prime[mid] and mid + mid == n:\n pairs.append([mid, mid])\n \n return pairs","runtime":"2173"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n i = 2\n while i ** 2 <= n:\n if primes[i]:\n for j in range(i*2, n+1, i):\n primes[j] = 0\n i += 1\n \n ans = []\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i]:\n ans.append([i, n-i])\n return ans\n","runtime":"2173"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def sieve(n):\n is_prime = [True] * (n + 1)\n is_prime[0] = is_prime[1] = False\n for i in range(2, int(n**0.5) + 1):\n if is_prime[i]:\n for j in range(i*i, n+1, i):\n is_prime[j] = False\n return is_prime\n\n is_prime = sieve(n)\n result = []\n for x in range(2, n//2 + 1):\n y = n - x\n if is_prime[x] and is_prime[y] and x <= y:\n result.append([x, y])\n return result","runtime":"2344"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n + 1)\n primes[0] = primes[1] = 0\n\n for i in range(2, int(n**0.5) + 1):\n if primes[i]:\n for j in range(i*i, n+1, i):\n primes[j] = 0\n \n ans = []\n for i in range(len(primes)):\n if i > n-i:\n break\n if primes[i] and primes[n - i]:\n ans.append([i, n-i])\n \n return ans\n ","runtime":"2344"},{"code":"def sieveErastothenes(n: int):\n sieve = [True for i in range(n+1)]\n sieve[0] = False\n sieve[1] = False\n p = 2\n while p*p <= n:\n if sieve[p]:\n for i in range(p*p, n+1, p):\n sieve[i] = False\n p += 1\n return sieve\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1 or n==2: return []\n sieve = sieveErastothenes(n)\n if n%2 == 1:\n if sieve[n-2]: return [[2,n-2]]\n else:\n res = []\n for x in range(2,n//2+1):\n if sieve[x] and sieve[n-x]:\n res.append([x,n-x])\n return res","runtime":"2429"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n # 利用 Eratosthenes Algorithm 篩選質數\n primes = [1] * (n+1) # 先將所有數字設為 1，表示質數\n primes[0] = primes[1] = 0 # 將索引 0, 1 設為 0，表示非質數\n for i in range(2, ceil(sqrt(n))): # 從 2 開始計算，計算到目前數字平方 > n 停止\n if primes[i]: # 若目前數字為質數，將其倍數全部設為 0\n for j in range(i*2, n+1, i):\n primes[j] = 0\n \n ans = [] # 製作答案\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i]:\n ans.append([i, n-i])\n return ans\n","runtime":"2429"},{"code":"from typing import List\n\ndef sieve_of_eratosthenes(max_num):\n is_prime = [True] * (max_num + 1)\n p = 2\n while (p * p <= max_num):\n if (is_prime[p] == True):\n for i in range(p * p, max_num + 1, p):\n is_prime[i] = False\n p += 1\n is_prime[0], is_prime[1] = False, False\n return is_prime\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime_pairs = []\n is_prime = sieve_of_eratosthenes(n)\n for x in range(2, n // 2 + 1):\n y = n - x\n if x <= y and is_prime[x] and is_prime[y]:\n prime_pairs.append([x, y])\n return prime_pairs","runtime":"2514"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n sieve = [True] * (n+1)\n\n sieve[0] = sieve[1] = False\n\n for cur in range(2, int(math.sqrt(n+1)+1)):\n if sieve[cur]:\n for m in range(cur*cur, n+1, cur):\n sieve[m] = False\n\n arr = set()\n\n for i in range(2, n-2+1):\n if sieve[i] and sieve[n-i]:\n if tuple(sorted((i, n-i))) not in arr:\n arr.add((i, n-i))\n\n return sorted(arr)","runtime":"2514"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime=[0]*(n+1)\n p=2\n while p*p<=n:\n if prime[p]==0:\n for i in range(p*p,n+1,p):\n prime[i]=1\n p+=1\n ans=[]\n for i in range(2,n+1):\n if prime[i]==0 and prime[n-i]==0 and i<=n-i and n-i>0:\n ans.append([i,n-i])\n return ans","runtime":"2600"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res = []\n \n primes = [1 for _ in range(n + 1)]\n primes[0] = primes[1] = 0\n p = 2\n while p ** 2 <= n:\n if primes[p]:\n for i in range(p ** 2, n + 1, p): primes[i] = 0\n p += 1\n \n for p in range(2, n // 2 + 1):\n if primes[p] and primes[n - p]:\n res.append([p, n - p])\n return res\n","runtime":"2600"},{"code":"class Solution:\n def sieve(self, n):\n primes = [1] * (n + 1)\n primes[0] = primes[1] = 0\n\n for i in range(2, int(sqrt(n) + 1)):\n if primes[i] == 1:\n j = i * i\n while(j < n):\n primes[j] = 0\n j += i\n \n return primes\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n primes = self.sieve(n)\n for i in range(2, n//2 + 1):\n if primes[i] == 1 and primes[n - i] == 1:\n ans.append([i, n - i])\n\n return ans","runtime":"2685"},{"code":"class Solution:\n def primeList(self, n) -> List[int]:\n primes = [True for i in range(n+1)]\n p = 2\n while (p*p <= n):\n if (primes[p]):\n for i in range(p*p, n+1, p):\n primes[i] = False\n p += 1\n primes[0] = primes[1] = False\n return(primes)\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = self.primeList(n)\n pL = []\n for i in range(2, n//2 + 1):\n if (primes[i] and primes[n-i]):\n pL.append([i, n-i])\n return pL","runtime":"2685"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n s=set()\n l1=[]\n primes=[True]*(n+1)\n prime_num=set()\n primes[0]=primes[1]=False\n p=2\n while p*p<=n:\n if primes[p]:\n for i in range(p*p,n+1,p):\n primes[i]=False\n\n p+=1\n \n for p in range(2,n+1):\n if primes[p]:\n prime_num.add(p)\n\n for num in prime_num:\n if n-num in prime_num:\n l1=[num,n-num]\n l1.sort()\n s.add(tuple(l1))\n\n if s:\n return sorted(list(s))\n else:\n return []\n\n\n \n\n \n\n \n ","runtime":"2770"},{"code":"class Solution:\n import math\n def is_prime(self,num):\n res=[True]*(num+1)\n res[0]=res[1]=False\n for i in range(int(math.sqrt(num))+1):\n if res[i]:\n for j in range(i*i,num+1,i):\n res[j]=False\n return res\n\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res=[]\n if n<=3:\n return res\n x=2\n prime_list=self.is_prime(n)\n while x<=n//2:\n y=n-x\n if prime_list[x] and prime_list[y]:\n res.append([x,y])\n x+=1\n return res\n ","runtime":"2770"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n # Helper function to find prime numbers using the Sieve of Eratosthenes\n def sieve_of_eratosthenes(limit):\n is_prime = [True] * (limit + 1)\n is_prime[0] = is_prime[1] = False\n for i in range(2, int(limit**0.5) + 1):\n if is_prime[i]:\n for j in range(i*i, limit + 1, i):\n is_prime[j] = False\n return [i for i in range(limit + 1) if is_prime[i]]\n \n # Find all prime numbers up to n\n primes = sieve_of_eratosthenes(n)\n \n # Create a set for efficient lookup\n prime_set = set(primes)\n \n # Collect valid prime pairs\n prime_pairs = []\n for prime in primes:\n complement = n - prime\n if complement in prime_set and complement >= prime:\n prime_pairs.append([prime, complement])\n \n return prime_pairs\n\n# Example usage:\nsolution = Solution()\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [5, 5]]\nprint(solution.findPrimePairs(2)) # Output: []","runtime":"2856"},{"code":"from typing import List\nfrom math import isqrt\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 2:\n return []\n\n def primenumber(n):\n is_prime = [True] * n\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, isqrt(n) + 1):\n if is_prime[i]:\n for x in range(i * i, n, i):\n is_prime[x] = False\n primes = [i for i in range(n) if is_prime[i]]\n return primes\n \n primes = primenumber(n)\n target = n\n dic = {}\n res = []\n \n # Add all primes to the dictionary for fast lookup\n for prime in primes:\n dic[prime] = True\n \n # Find pairs\n for prime in primes:\n complement = target - prime\n if complement in dic and complement >= prime:\n res.append([prime, complement])\n \n return res\n\n# Example usage\nsolution = Solution()\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [7, 3]]\n","runtime":"2856"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n is_prime = [True] * (n + 1)\n p = 2\n # 找到最大可能的质数，只需到p^2\n while p * p <= n:\n if is_prime[p]:\n # 标记所有倍数\n for i in range(p * p, n + 1, p):\n is_prime[i] = False\n p += 1\n \n # 获得primes\n primes = [i for i in range(2, n + 1) if is_prime[i]]\n # 写进set in method O1\n prime_set = set(primes)\n \n res = []\n for i in primes:\n if i > n // 2:\n break\n if n - i in prime_set:\n res.append([i, n - i])\n \n return res","runtime":"2941"},{"code":"import math\nfrom typing import List\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4: # the smallest sum of two primes is 2 + 2 = 4\n return []\n \n # Sieve of Eratosthenes\n is_prime = [True] * n\n is_prime[0] = is_prime[1] = False\n \n for i in range(2, int(math.sqrt(n)) + 1):\n if is_prime[i]:\n for j in range(i * i, n, i):\n is_prime[j] = False\n \n # Collecting all primes less than n\n primes = [i for i in range(n) if is_prime[i]]\n \n # Using a set for fast lookup\n prime_set = set(primes)\n ans = []\n \n for p in primes:\n if (n - p) in prime_set and (p <= (n - p)):\n ans.append([p, n - p])\n \n return ans\n","runtime":"2941"},{"code":"def is_prime(n):\n isPrime = [True] * (n + 1)\n isPrime[0] = False\n isPrime[1] = False\n for i in range(n + 1):\n if isPrime[i]:\n for j in range(i*i, n+1,i):\n isPrime[j] = False\n return isPrime\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 3:\n return []\n isPrime = is_prime(n)\n L = []\n for i in range(2, n//2 + 1):\n if isPrime[i] and isPrime[n - i]:\n L.append([i,n - i])\n return L\n \n ","runtime":"3026"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrimes=[True]*(n+1)\n isPrimes[0]=False\n if n>=1:\n isPrimes[1]=False\n res=[]\n for i in range(2,math.ceil(math.sqrt(n))+1):\n if isPrimes[i]:\n for j in range(i*i,n+1,i):\n if isPrimes[j]:\n isPrimes[j]=False\n primes=set()\n for i in range(len(isPrimes)):\n if isPrimes[i]:\n primes.add(i)\n res=set()\n for i in primes:\n if n-i<=i and n-i in primes:\n res.add((n-i,i))\n x=sorted(res)\n return x\n\n\n ","runtime":"3026"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n prime_numbers = [True] * (n + 1)\n\n for i in range(2, n + 1):\n if prime_numbers[i]:\n for j in range(i ** 2, n + 1, i):\n prime_numbers[j] = False\n\n prime_pairs = []\n\n for x in range(2, n // 2 + 1):\n if prime_numbers[x] and prime_numbers[n - x]:\n prime_pairs.append([x, n - x])\n return prime_pairs","runtime":"3112"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True] * (n+1)\n res = []\n for i in range(2, (n // 2) + 1):\n if primes[i]:\n for j in range(i*2, n+1, i):\n primes[j] = False\n #print(primes)\n for i in range(2, (n // 2) + 1):\n if primes[i] and primes[n-i]:\n res.append([i, n-i])\n \n return res\n ","runtime":"3112"},{"code":"class Solution:\n def sieve(self, n):\n primes = [1] * (n + 1)\n primes[0] = primes[1] = 0\n\n for i in range(2, int(sqrt(n) + 1)):\n if primes[i] == 1:\n j = i * i\n while(j < n):\n primes[j] = 0\n j += i\n \n return primes\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n primes = self.sieve(n)\n for i in range(2, n//2 + 1):\n if primes[i] == 1 and primes[n - i] == 1:\n ans.append([i, n - i])\n\n return ans","runtime":"3197"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def sieveOfEratosthenes(limit):\n ret, is_prime = [], [True] * (limit + 1)\n is_prime[0] = is_prime[1] = False\n p = 2\n while p <= limit:\n if is_prime[p]:\n ret.append(p)\n for i in range(p * p, limit + 1, p): is_prime[i] = False\n p += 1\n return ret\n ans, primes = [], sieveOfEratosthenes(n)\n s = set(primes)\n for v in primes:\n if v * 2 > n: break\n if n - v in s: ans.append([v, n - v])\n return ans","runtime":"3197"},{"code":"class Solution:\n def findPrimePairs(self, n):\n #решето Эратосфена\n простое = [1] * (n + 1)\n простое[0] = 0\n\n for i in range(2, n // 2 +1):\n if простое[i]:\n for j in range(2 * i, n + 1, i):\n простое[j] = 0\n\n рез = []\n for x in range(2, n // 2 + 1):\n if простое[x] and простое[n - x]:\n рез.append([x, n - x])\n\n return рез\n","runtime":"3282"},{"code":"class Solution:\n def findPrimePairs(self, n):\n #решето Эратосфена\n # if n> 10:\n # return [[0, 0])\n\n простое = [1] * (n + 1)\n простое[0] = 0\n\n\n for i in range(2, n // 2 + 1):\n if простое[i]:\n for j in range(2 * i, n + 1, i):\n простое[j] = 0\n\n рез = []\n for x in range(2, n // 2 + 1):\n if простое[x] and простое[n - x]:\n рез.append([x, n - x])\n\n return рез\n","runtime":"3282"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def sieve_of_eratosthenes(n):\n prime = [True for _ in range(n+1)]\n p = 2\n\n while p * p <= n:\n if prime[p]:\n for i in range(p * p, n + 1, p):\n prime[i] = False\n p += 1\n\n primes = [p for p in range(2, n) if prime[p]]\n return primes\n\n primes = sieve_of_eratosthenes(n)\n set_primes = set(primes)\n pairs = []\n\n for prime in primes:\n if n-prime in set_primes and n-prime>=prime:\n pairs.append([prime, n-prime])\n return pairs","runtime":"3368"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def ip(n):\n p=[1]*(n+1)\n i=2\n while i*i<=n:\n if p[i]==1:\n j=i*i\n while j<=n:\n p[j]=0\n j+=i\n i+=1\n return p\n\n b=[]\n pp=ip(n)\n for i in range(2,n):\n if pp[i]==1:\n b.append(i)\n \n a=[]\n l=0\n le=len(b)\n r=le-1\n while l<=r:\n s=b[l]+b[r]\n if s<n:\n l+=1\n elif s>n:\n r-=1\n else:\n a.append([b[l],b[r]])\n l+=1\n r-=1\n return a\n ","runtime":"3368"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def primes(n):\n primes = [False, False] + [True for e in range(0, n - 2)]\n for i in range(2, int(n**0.5) + 1):\n if primes[i]:\n for j in range(i**2, n, i):\n primes[j] = False\n return [i for i, e in enumerate(primes) if e]\n ps = set(primes(n))\n rets = []\n for e in ps:\n if n < 2 * e:\n continue\n if n - e in ps:\n rets.append([e, n - e])\n return sorted(rets)","runtime":"3453"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = self.sieve(n + 1)\n res = []\n for i in range(len(primes)):\n p = primes[i]\n target = n - p\n if target == p:\n res.append([p, p])\n continue\n index = bisect.bisect_left(primes, target, i + 1)\n if index < len(primes) and primes[index] == target:\n res.append([p, primes[index]])\n return res\n\n def sieve(self, n: int) -> list[int]:\n if n <= 1:\n return []\n primes = [True] * n\n primes[0], primes[1] = False, False\n for i in range(2, int(n**0.5) + 1):\n if primes[i]:\n for j in range(i + i, n, i):\n primes[j] = False\n return [i for i, v in enumerate(primes) if v]","runtime":"3453"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ps = [True for _ in range(n)]\n\n p = 2\n while p * p < n:\n if ps[p]:\n for pn in range(p * 2, n, p):\n ps[pn] = False\n p += 1\n \n primes = set([i for (i, p) in enumerate(ps) if p and i > 1])\n\n res = set()\n for p in primes:\n if n - p in primes:\n if (p, n - p) not in res and (n - p, p) not in res:\n res.add((p, n - p))\n \n return sorted([sorted([one, two]) for (one, two) in res])\n","runtime":"3538"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime = [True] * (n + 1)\n prime[0], prime[1] = False, False\n for i in range(1, int(sqrt(n)) + 1):\n if prime[i]:\n for j in range(i * i, n + 1, i):\n prime[j] = False\n \n i, j = 2, len(prime) - 1\n ans = []\n while i <= j:\n if prime[i] and prime[j] and i + j == n:\n ans.append([i, j])\n i += 1\n j -= 1\n elif i + j < n:\n i += 1\n else:\n j -= 1\n return ans","runtime":"3624"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ip = [True] * (n+1)\n for i in range(2, n+1):\n if ip[i]:\n for j in range(i+i, n+1, i):\n ip[j] = False\n \n\n res = []\n for i in range(2, n // 2 + 1):\n if ip[i] and ip[n - i]:\n res.append((i, n-i))\n \n return res","runtime":"3624"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True for _ in range(n+1)]\n primes[0] = primes[1] = False\n\n for i in range(int(sqrt(n)) + 1):\n if primes[i]:\n j = i*i\n while j <= n:\n primes[j] = False\n j += i\n\n primes = [i for i in range(len(primes)) if primes[i]]\n ps = set(primes)\n res = []\n\n for k in primes:\n if k > n // 2: break\n if n - k in ps:\n res.append((k, n - k))\n return res\n ","runtime":"3709"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True] * n\n p = 2\n while p < n:\n if primes[p]:\n for i in range(p * p, n, p):\n primes[i] = False\n p += 1\n \n result = []\n for i in range(2, n // 2 + 1):\n if primes[i] and primes[n - i]:\n result.append([i, n - i])\n return result","runtime":"3794"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n for i in range(2, n+1):\n if primes[i]:\n for j in range(i*2, n+1, i):\n primes[j] = 0\n \n ans = []\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i]:\n ans.append([i, n-i])\n return ans\n","runtime":"3794"},{"code":"class Solution:\n def findPrimePairs(self, n):\n #решето Эратосфена\n простое = [1] * (n + 1)\n простое[0] = 0\n\n for i in range(2, n + 1):\n if простое[i]:\n for j in range(2 * i, n + 1, i):\n простое[j] = 0\n\n рез = []\n for x in range(2, n // 2 + 1):\n if простое[x] and простое[n - x]:\n рез.append([x, n - x])\n\n return рез\n","runtime":"3879"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True] * n\n for i in range(2, n):\n if primes[i]:\n for j in range(i + i, n, i):\n primes[j] = False\n ans = []\n for x in range(2, n // 2 + 1):\n y = n - x\n if primes[x] and primes[y]:\n ans.append([x, y])\n return ans","runtime":"3879"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime_pairs = []\n for i in range(2,n//2+1):\n if is_prime(n-i) and is_prime(i):\n prime_pairs.append([i,n-i])\n return prime_pairs\nfrom functools import cache\nimport math \n\n@cache\ndef is_prime(n):\n if n <= 1:\n return False\n\n for i in range(2,int(math.sqrt(n))+1):\n if n % i == 0:\n return False\n\n return True\n\n ","runtime":"3965"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primelist = [True]*(n+1)\n for i in range(2,n):\n if primelist[i]:\n for i in range(2*i,n+1,i):\n primelist[i]=False\n start = 2\n end = n-2\n result = []\n while(start<=end):\n if primelist[start] and primelist[end]:\n result.append([start,end])\n start+=1\n end-=1\n return result","runtime":"3965"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n if p <= n//2:\n sub[n-p] = p\n test = sub.get(p)\n if test is not None:\n res.insert(0,[test, p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","runtime":"4050"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n sub[n-p] = p\n test = sub.get(p)\n if test is not None:\n res.insert(0,[test, p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","runtime":"4050"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n if p <= n//2:\n sub[n-p] = p\n test = sub.get(p)\n if test is not None:\n res.insert(0,[test, p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","runtime":"4135"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n sub[n-p] = p\n if sub.get(p) is not None:\n res.insert(0,[sub.get(p), p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","runtime":"4221"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime = [i for i in range(n + 1)]\n p = 2\n while (p * p <= n):\n if prime[p] > 0:\n for i in range(p * p, n + 1, p):\n prime[i] = 0\n p += 1\n ans = []\n for i in range(2, n // 2 + 1):\n if prime[i] and prime[n - i]:\n ans.append([prime[i], prime[n - i]])\n return ans","runtime":"4221"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True] * (n+1)\n for x in range(2,n+1):\n if primes[x]:\n cur = 2*x\n while cur <= n:\n primes[cur] = False\n cur += x\n ans = [[x, n-x] for x in range(2,n//2+1) if primes[x] and primes[n-x]]\n return ans","runtime":"4306"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = set()\n nums = [True for _ in range(n)]\n p = 2\n while p < n:\n if nums[p]:\n primes.add(p)\n for i in range(p * p, n, p):\n nums[i] = False\n p += 1\n \n result = []\n for i in range(2, n // 2 + 1):\n if i in primes and n - i in primes:\n result.append([i, n - i])\n return result","runtime":"4306"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n def sieve_of_eratosthenes(n):\n \"\"\"\n Helper function to generate all primes <= n\n \"\"\"\n\n ub = math.ceil(n**0.5)\n is_prime = [True for _ in range(n+1)]\n\n for i in range(2, ub+1):\n if is_prime[i]:\n for p in range(2*i, n+1, i):\n is_prime[p] = False\n \n primes = set()\n for i in range(2, n+1):\n if is_prime[i]:\n primes.add(i)\n \n return primes\n \n primes = sieve_of_eratosthenes(n)\n answer = []\n for i in range(n+1):\n if i in primes and n - i in primes:\n primes.remove(n-i)\n answer.append([i, n-i])\n \n return answer","runtime":"4391"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n \n prime = [True for _ in range(n+1)]\n prime[0] = prime[1] = False\n \n for i in range(2, n+1):\n if prime[i]:\n j = i*i\n \n while j<=n:\n prime[j] = False\n j += i\n for i in range(2,n):\n if i+i>n: break\n if prime[i] and prime[n-i]:\n ans.append([i,n-i])\n return ans","runtime":"4391"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n def sieve_of_eratosthenes(n):\n is_prime = [True for _ in range(n+1)]\n is_prime[1] = False\n primes = set()\n for i in range(1, n+1):\n if (not is_prime[i]):\n continue\n primes.add(i)\n for j in range(i, n+1, i):\n is_prime[j] = False\n return primes\n \n primes = sieve_of_eratosthenes(n)\n pairs = list()\n seen = set()\n primes_ordered = sorted(primes)\n for prime in primes_ordered:\n diff = (n - prime)\n if (not diff in primes):\n continue\n elif (prime in seen):\n continue\n seen.add(diff)\n pairs.append([prime, diff])\n return pairs\n","runtime":"4477"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primeRange = [1]*(n+1)\n primeStart = 2\n while primeStart*primeStart <= n+1:\n for i in range(primeStart*primeStart,n+1,primeStart):\n primeRange[i] = 0\n primeStart += 1\n result = []\n for i in range(2,n//2+1):\n if primeRange[i] and primeRange[n-i]:\n result.append([i,n-i])\n return result","runtime":"4562"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n if n == 4:\n return [[2, 2]]\n\n # need to know whether 2 ~ n-2 is prime.\n is_prime = [False, False] + [True] * (n - 3)\n for div in itertools.chain([2], range(3, n - 1, 2)):\n for i in range(div**2, n - 1, div):\n is_prime[i] = False\n\n if n % 2:\n # odd = even + odd\n # 2 and n - 2\n if is_prime[n - 2]:\n return [[2, n - 2]]\n else:\n return []\n\n # n >= 6 , even = odd + odd\n res = []\n for x in range(3, n // 2 + 1, 2):\n if is_prime[x] and is_prime[n - x]:\n res.append([x, n - x])\n\n return res","runtime":"4562"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primeRange = [1]*(n+1)\n primeStart = 2\n while primeStart*primeStart <= n+1:\n for i in range(primeStart*primeStart,n+1,primeStart):\n primeRange[i] = 0\n primeStart += 1\n result = []\n for i in range(2,n//2+1):\n if primeRange[i] and primeRange[n-i]:\n result.append([i,n-i])\n return result","runtime":"4647"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrime = [True for _ in range(n+1)]\n for i in range(2, int(math.sqrt(n))+1):\n if isPrime[i]:\n num = i\n while i*num <= n:\n isPrime[i*num] = False\n num += 1\n result = []\n for i in range(2, n//2+1):\n if isPrime[i] and isPrime[n-i]:\n result.append([i, n-i])\n return result","runtime":"4733"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n arr = [1 for i in range(n+1)]\n arr[0] = 0\n arr[1] = 0\n ans = []\n for p in range(2,n+1):\n if arr[p]==1:\n ans.append(p)\n k = p*p\n while k<(n+1):\n arr[k]=0\n k+=p\n # print(ans)\n i = 0 \n j = len(ans)-1\n fin = []\n while i<=j:\n ct = ans[i]+ans[j]\n if ct==n:\n fin.append([ans[i],ans[j]])\n i+=1\n j-=1\n elif ct < n:\n i+=1\n else:\n j-=1\n return fin\n ","runtime":"4818"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def findprimes():\n primes = [0 for i in range(n+1)]\n for i in range(2,n+1):\n if primes[i]==0:\n for j in range(i*2,n+1,i):\n primes[j] = 1\n res = []\n for i in range(2,n+1):\n if primes[i]==0:\n res.append(i)\n return res\n primes = findprimes()\n ans = []\n s = set()\n p = len(primes)\n for i in range(p):\n num = primes[i]\n s.add(num)\n target = n-num\n if(target in s):\n ans.append([min(target,num),max(target,num)])\n ans.sort(key = lambda x:x[0])\n return ans\n\n\n ","runtime":"4903"},{"code":"class Solution:\n def get_prime(self,n):\n dp=[True]*(n)\n dp[0]=False\n dp[1]=False\n for i in range(2,int((n)**0.5)+1):\n for j in range(i*i,n,i):\n dp[j]=False\n l=[]\n for i in range(n):\n if dp[i]:\n l.append(i)\n return l\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n \n # Get all primes less than n\n primes = self.get_prime(n)\n ans = []\n \n # Use two-pointer technique to find pairs\n left, right = 0, len(primes) - 1\n while left <= right:\n current_sum = primes[left] + primes[right]\n if current_sum == n:\n ans.append([primes[left], primes[right]])\n left += 1\n right -= 1\n elif current_sum < n:\n left += 1\n else:\n right -= 1\n \n return ans\n ","runtime":"4989"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n s=set()\n l1=[]\n primes=[True]*(n+1)\n prime_num=set()\n primes[0]=primes[1]=False\n p=2\n while p*p<=n:\n #if primes[p]:\n for i in range(p*p,n+1,p):\n primes[i]=False\n\n p+=1\n for p in range(2,n+1):\n if primes[p]:\n prime_num.add(p)\n\n for num in prime_num:\n if n-num in prime_num:\n l1=[num,n-num]\n l1.sort()\n s.add(tuple(l1))\n\n if s:\n return sorted(list(s))\n else:\n return []\n\n\n \n\n \n\n \n ","runtime":"5074"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n for i in range(2, int(sqrt(n) + 1)):\n for j in range(i * i, n + 1, i):\n primes[j] = 0\n \n ans = []\n l = 0\n r = len(primes) - 1\n # 00110101000\n # l\n # r\n # 012345678910\n while l <= r:\n while r < n and not primes[r]:\n r -= 1\n while l <= r and not primes[l]:\n l += 1\n total = l + r\n if total > n:\n r -= 1\n elif total < n:\n l += 1\n else:\n ans.append((l, r))\n l += 1\n r -= 1\n return ans","runtime":"5159"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n for i in range(2, int(sqrt(n) + 1)):\n for j in range(i * i, n + 1, i):\n primes[j] = 0\n \n ans = []\n l = 0\n r = len(primes) - 1\n\n while l <= r:\n while r < n and not primes[r]:\n r -= 1\n while l <= r and not primes[l]:\n l += 1\n total = l + r\n if total > n:\n r -= 1\n elif total < n:\n l += 1\n else:\n ans.append((l, r))\n l += 1\n r -= 1\n return ans","runtime":"5245"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n #optimales approach \n #using actual Sieve of Eratosthenes\n sieve = [i for i in range(n)]\n #sieve[0] = None\n #sieve[1] = None\n final = []\n for i in range(2,int(math.sqrt(n))+1):\n if sieve[i] == i:\n j = i**2\n while j < n:\n if sieve[j] == j:\n sieve[j] = i\n j += i\n #print(\"sieve be like :\")\n #print(sieve)\n #now from smallest prime 2 to n//2+1 lmit,\n #check which ones yield n by summaticon\n # or i'll be like\n # if x is prime and n-x is also prime \n # then they be the pair we want\n for i in range(2,n//2+1):\n #print(f'i is {i} and n-x = {n-i}')\n if i == sieve[i] and n-i == sieve[n-i]:\n final.append([i,n-i])\n return final\n\n \"\"\"\n #full haarami Brute force\n # Tc - O(N*sqrt(N) + len(sieve)**2)\n final = []\n def is_prime(number):\n count = 0\n for i in range(2,int(math.sqrt(number))+1):\n if number%i == 0:\n count += 1\n if not count:\n return True\n return False\n #print(is_prime(49))\n sieve = []\n for i in range(2,n):\n if is_prime(i):\n sieve.append(i)\n #print(\"Sieve of Erastothenes :\",sieve)\n #Now traverse the sieve to get those numas whose sumaticon be n\n for i in range(len(sieve)):\n for j in range(i,len(sieve)):\n if sieve[i] + sieve[j] == n:\n final.append([sieve[i],sieve[j]])\n return final\n \"\"\"\n\n\n\n\n\n\n ","runtime":"5330"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = []\n allNumbers =[True]*(n+1)\n allNumbers[0] = False\n allNumbers[1] = False\n index = 2\n while index <= n:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex <= n):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.insert(0, [n-index, index])\n\n index+=1\n\n return toReturn\n\n\n\n\n ","runtime":"5415"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n is_prime = [True] * (n + 1)\n is_prime[0] = False\n is_prime[1] = False\n for p in range(2, n // 2 + 1):\n if not is_prime[p]:\n continue\n x = p + p\n while x < len(is_prime):\n is_prime[x] = False\n x += p\n\n all_primes = {i for i, x in enumerate(is_prime) if x}\n result = []\n for p in sorted(all_primes):\n comp = n - p\n if comp < p:\n break\n if comp in all_primes:\n result.append([p, comp])\n return result\n","runtime":"5757"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = []\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex <= n):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.insert(0, [n-index, index])\n\n index+=1\n\n return toReturn\n\n\n\n\n ","runtime":"5842"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime=[0]*(n+1)\n prime[0]=1\n prime[1]=1\n for x in range(2,n+1):\n if prime[x]==0:\n i=x\n while x*i<=n:\n if prime[x*i]==0:\n prime[x*i]=1\n i+=1\n result=[]\n for x in range(2,((n//2)+1)):\n if prime[x]==0 and prime[n-x]==0:\n result.append([x,n-x])\n return result","runtime":"5927"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 1:\n return []\n \n primes = [True for _ in range(n + 1)] # 0 indexed, ignore 0\n primes[0] = False\n primes[1] = False # 1 is not a prime\n primes[2] = True # 2 is a prime\n for i in range(2, n):\n if primes[i]:\n itr = 2\n start = i * itr\n while start <= n:\n primes[start] = False\n itr += 1\n start = i * itr\n res = []\n for int1 in range(1, n//2 + 1):\n if primes[int1] and primes[n - int1]:\n res.append([int1, n - int1])\n return res\n\n\n\n ","runtime":"6013"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n for i in range(2, n+1):\n if primes[i]:\n m = 2\n while i * m <= n:\n primes[i*m] = 0\n m += 1\n \n ans = []\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i]:\n ans.append([i, n-i])\n return ans\n","runtime":"6098"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n p = [True]*(n+2)\n p[0]=False\n p[1]=False\n for i in range(2,len(p)):\n if p[i]==True:\n j=2*i\n while j<len(p):\n p[j]=False\n j+=i\n ans=[]\n for i in range(len(p)//2):\n if i>=2 and n-i>=2 and p[i] and p[n-i]:\n ans.append([i,n-i])\n \n return ans\n \n ","runtime":"6183"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n # list all prime numbers up to sqrt n\n def gcd(a, b):\n if a < b:\n a,b = b,a\n while b > 0:\n a,b = b, a%b\n return a\n prod, primes = 1, []\n for i in range(2, int(sqrt(n)) + 1):\n if gcd(i, prod) == 1:\n primes.append(i)\n prod *= i\n def isPrime(n):\n for prime in primes:\n if prime > sqrt(n):\n return True\n if not n % prime:\n return False\n return True\n \n if n%2:\n # there are only one way two prime numbers could have odd sum i.e. 2 and another prime number\n if n < 5:\n return False\n if isPrime(n-2):\n return [[2,n-2]]\n else:\n return []\n\n\n pairs = []\n for prime in primes:\n if isPrime(n-prime):\n pairs.append([prime, n-prime])\n if primes[-1] == 2:\n start = 3\n else:\n start = primes[-1] +2\n for nn in range(start, n//2 + 1, 2):\n if isPrime(nn) and isPrime(n-nn):\n pairs.append([nn,n-nn])\n return pairs\n\n\n ","runtime":"6269"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def isPrime(v):\n upper = math.floor(math.sqrt(v)) + 1\n if v < 2:\n return False\n if v == 2:\n return True\n if v % 2 == 0:\n return False\n for c in range(3, upper, 2):\n if v%c == 0:\n return False\n \n return True\n if n <=2:\n return []\n\n if n % 2 == 1:\n if isPrime(n-2):\n return [[2, n-2]]\n return []\n\n upper = n//2 + 1\n res = []\n for i in range(2,upper):\n # print(i)\n if isPrime(i) and isPrime(n-i):\n res.append([i, n-i])\n # print(res)\n return res\n \n \n ","runtime":"6354"},{"code":"from collections import deque\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = deque()\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex <= n):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.appendleft([n-index, index])\n\n index+=1\n\n return list(toReturn)\n\n\n\n\n ","runtime":"6439"},{"code":"class Solution:\r\n def findPrimePairs(self, n: int) -> List[List[int]]:\r\n prime = [True] * (n+1)\r\n prime[0], prime[1] = False, False\r\n \r\n for i in range(2, n+1):\r\n if prime[i]:\r\n j = 2\r\n while i * j <= n:\r\n prime[i*j] = False\r\n j += 1\r\n \r\n ans = []\r\n lf, rh = 2, n-2\r\n while lf <= rh:\r\n if prime[lf] and prime[rh]:\r\n ans.append([lf, rh])\r\n lf += 1\r\n rh -= 1\r\n return ans","runtime":"6525"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n self.primeSet = self.es(n)\n ans = []\n for x in range(2, n // 2 + 1):\n y = n - x\n if self.primeSet[x] and self.primeSet[y]:\n ans.append([x, y])\n \n return ans\n \n def es(self, n):\n ps = [1] * (n + 1)\n \n for f in range(2, n // 2 + 1):\n num = 2\n prod = f * num\n while ps[f] and prod <= n:\n ps[prod] = 0\n num += 1\n prod = num * f\n\n return ps\n ","runtime":"6610"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n composite_set = set()\n prime_set = {2}\n for i in range(3, n + 1, 2):\n if i in composite_set:\n continue\n prime_set.add(i)\n cur = i * i\n while cur <= n:\n composite_set.add(cur)\n cur += i\n\n pairs = []\n for i in range(2, n // 2 + 1):\n if i in prime_set and n - i in prime_set:\n pairs.append([i, n - i])\n return pairs\n","runtime":"6695"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrime = [1] * n\n for i in range(2, n):\n if isPrime[i] == 0:\n continue\n j = 2\n while i * j < n:\n isPrime[i * j] = 0\n j += 1\n \n result = []\n for i in range(2, n):\n j = n - i\n if j < i:\n return result\n if isPrime[j] and isPrime[i]:\n result.append([i, j])\n return result","runtime":"6781"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n #toReturn = deque()\n toReturn = []\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex < n - 1):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n #toReturn.appendleft([n-index, index])\n toReturn.append([n-index, index])\n\n index+=1\n reversed_list = toReturn[::-1]\n return reversed_list\n\n\n\n\n ","runtime":"6866"},{"code":"from collections import deque\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = deque()\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex < n - 1):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.appendleft([n-index, index])\n\n index+=1\n\n return list(toReturn)\n\n\n\n\n ","runtime":"6951"}],"string":"[\n {\n \"code\": \"def getSieve(n: int) -> int:\\n sqrt_n = int(sqrt(n))\\n # print('srqrt_n: ', sqrt_n)\\n sieve = [0, 0] + [1]*(n - 2)\\n\\n k = 2\\n while k <= sqrt_n:\\n if sieve[k]:\\n multiple = k * k\\n # print('k: ', k, ' multiple: ', multiple)\\n while multiple < n:\\n sieve[multiple] = 0\\n multiple += k\\n k += 1 if k == 2 else 2\\n\\n # print(self.sieve)\\n return sieve \\nprimes = [i for i,val in enumerate(getSieve(1000000)) if val == 1]\\nprime_set = set(primes)\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res = []\\n search_limit = n // 2\\n for prime in primes:\\n if prime > search_limit: break\\n if n - prime in prime_set:\\n res.append([prime, n - prime])\\n return res\",\n \"runtime\": \"381\"\n },\n {\n \"code\": \"import array\\ndef sieve_of_eratosthenes(n):\\n if n < 2:\\n return []\\n is_prime = bytearray((1,))*(n+1)\\n is_prime[0] = is_prime[1] = 0\\n for i in range(2, int(n**0.5) + 1):\\n if is_prime[i]:\\n for j in range(i * i, n + 1, i):\\n is_prime[j] = 0\\n primes = array.array('i',(i for i in range(n + 1) if is_prime[i]))\\n return primes\\n\\nPRIMES = sieve_of_eratosthenes(1000000)\\n\\nPS = set(PRIMES)\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n out = []\\n for p in PRIMES:\\n np=n-p\\n if p<=np and np in PS:\\n out.append((p,np))\\n if p >= np:\\n return out\",\n \"runtime\": \"381\"\n },\n {\n \"code\": \"pr = [1 for i in range(10**6+1)]\\np = 2\\nwhile p*p<10**6+1:\\n if pr[p]:\\n for i in range(2*p, 10**6+1, p):\\n pr[i] = 0\\n p +=1\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n for i in range(2, n//2+1):\\n if pr[i] and pr[n-i]:\\n ans.append([i, n-i])\\n return ans\",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n def is_prime(num):\\n if num <= 2 or num % 2 == 0:\\n return num == 2\\n for d in range(3, isqrt(num) + 1, 2):\\n if num % d == 0:\\n return False\\n return True\\n\\n def find_primes(num):\\n num += 1 # to include 0\\n primes = [True] * num\\n primes[0] = primes[1] = False\\n for p in range(2, max(3, isqrt(num) + 1)):\\n if not primes[p]:\\n continue\\n for kp in range(p * p, num, p):\\n primes[kp] = False\\n return primes\\n\\n ans = []\\n if 1 <= 2 <= n - 2 <= n:\\n if is_prime(n - 2):\\n ans.append([2, n - 2])\\n\\n if n % 2 == 1:\\n return ans\\n\\n primes = find_primes(n)\\n\\n for x in range(3, n // 2 + 1, 2):\\n y = n - x\\n #if x <= y and is_prime(x) and is_prime(y):\\n if x <= y and primes[x] and primes[y]:\\n ans.append([x, y])\\n return ans\\n\",\n \"runtime\": \"552\"\n },\n {\n \"code\": \"def get_primes(num):\\n primes = [True] * (num + 1)\\n for x in range(2, num + 1):\\n if primes[x]:\\n for y in range(x*x, num + 1, x):\\n primes[y] = False\\n return primes\\n\\nprimes = get_primes(1000000)\\n \\n \\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n res = []\\n for left in range(2, n // 2 + 1):\\n right = n - left\\n if primes[left] and primes[right]:\\n res.append([left, right])\\n return res\\n \",\n \"runtime\": \"637\"\n },\n {\n \"code\": \"class Solution:\\n\\n def eratosthenes_sieve(self, n):\\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\\n for p in range(3, sqrt_n, 2):\\n if prime[p]:\\n result.append(p)\\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\\n\\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes_list = self.eratosthenes_sieve(n + 1)\\n primes_set = set(primes_list)\\n res = []\\n for p in primes_list:\\n if p > n - p:\\n break\\n if n - p in primes_set:\\n res.append([p, n - p])\\n return res\",\n \"runtime\": \"722\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n \\n if n % 2 == 1:\\n n -= 2\\n for p in range(2, round(n ** 0.5) + 1):\\n if n % p == 0:\\n return []\\n return [[2, n]]\\n \\n def get_all_primes(m):\\n is_primes = [True] * (m + 1)\\n is_primes[0] = is_primes[1] = False\\n for i in range(2, round(m ** 0.5) + 1):\\n if is_primes[i]:\\n step = 2 if i == 2 else 2 * i\\n for j in range(i ** 2, m + 1, step):\\n is_primes[j] = False\\n return [\\n i\\n for i, is_prime in enumerate(is_primes)\\n if is_prime\\n ]\\n \\n primes = get_all_primes(n)\\n j = len(primes) - 1\\n\\n result = []\\n for i, prime in enumerate(primes):\\n if 2 * prime > n:\\n break\\n while i <= j and prime + primes[j] > n:\\n j -= 1\\n if prime + primes[j] == n:\\n result.append([prime, primes[j]])\\n return result\",\n \"runtime\": \"808\"\n },\n {\n \"code\": \"class Solution:\\n\\n def eratosthenes_sieve(self, n):\\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\\n for p in range(3, sqrt_n, 2):\\n if prime[p]:\\n result.append(p)\\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\\n\\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes_list = self.eratosthenes_sieve(n + 1)\\n primes_set = set(primes_list)\\n res = []\\n for p in primes_list:\\n if p > n - p:\\n break\\n if n - p in primes_set:\\n res.append([p, n - p])\\n return res\",\n \"runtime\": \"893\"\n },\n {\n \"code\": \"limit = 10 ** 6\\nprimes = [True] * (limit + 1)\\n\\nprimes[0] = False\\nprimes[1] = False\\n\\nfor i in range(2, limit + 1):\\n if primes[i]:\\n nextNum = 2 * i\\n while nextNum <= limit:\\n primes[nextNum] = False\\n nextNum += i\\n\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n global primes\\n\\n res = []\\n for x in range(1, n // 2 + 1):\\n if not primes[x]:\\n continue\\n \\n y = n - x\\n\\n if not primes[y]:\\n continue\\n \\n res.append([x, y])\\n\\n return res\\n \",\n \"runtime\": \"978\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n result = []\\n allPrimes = get_primes_numpy(n) \\n left = 0\\n right = len(allPrimes) - 1\\n\\n while left <= right:\\n sm = allPrimes[left] + allPrimes[right] \\n if sm > n:\\n right -= 1\\n elif sm == n:\\n result.append([allPrimes[left], allPrimes[right]])\\n left += 1\\n else:\\n left += 1\\n\\n\\n return result\",\n \"runtime\": \"978\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n result = []\\n allPrimes = get_primes_numpy(n) \\n left = 0\\n right = len(allPrimes) - 1\\n\\n while left <= right:\\n sm = allPrimes[left] + allPrimes[right] \\n if sm > n:\\n right -= 1\\n elif sm == n:\\n result.append([allPrimes[left], allPrimes[right]])\\n left += 1\\n else:\\n left += 1\\n\\n\\n return result\",\n \"runtime\": \"1064\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n # these two functions are from IterTools Recipes:\\n # https://docs.python.org/3/library/itertools.html\\n\\n import contextlib\\n\\n def iter_index(iterable, value, start=0, stop=None):\\n \\\"Return indices where a value occurs in a sequence or iterable.\\\"\\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\\n seq_index = getattr(iterable, 'index', None)\\n if seq_index is None:\\n iterator = islice(iterable, start, stop)\\n for i, element in enumerate(iterator, start):\\n if element is value or element == value:\\n yield i\\n else:\\n stop = len(iterable) if stop is None else stop\\n i = start\\n with contextlib.suppress(ValueError):\\n while True:\\n yield (i := seq_index(value, i, stop))\\n i += 1\\n\\n def sieve(n):\\n \\\"Primes less than n.\\\"\\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\\n if n > 2:\\n yield 2\\n data = bytearray((0, 1)) * (n // 2)\\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\\n yield from iter_index(data, 1, start=3)\\n\\n primes = set(sieve(n))\\n\\n return [\\n [P, n - P]\\n for P in sorted(primes)\\n if P <= (n - P) and (n - P) in primes\\n ]\\n\",\n \"runtime\": \"1064\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True] * (n+1)\\n primes[0] = primes[1] = False\\n\\n for i in range(2, 1+floor(sqrt(n))):\\n if primes[i]:\\n for j in range(i*i, n+1, i):\\n primes[j] = False\\n \\n if n%2==1:\\n if primes[n-2]:\\n return [[2,n-2]]\\n else:\\n return []\\n result = []\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i] and i<=n-i:\\n result.append([i, n-i])\\n return result\",\n \"runtime\": \"1149\"\n },\n {\n \"code\": \"from typing import List\\nimport math\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num + 1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(math.isqrt(num) + 1):\\n if isPrime[p]:\\n for j in range(p * p, num + 1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2, n // 2 + 1):\\n if isPrime[i] and isPrime[n - i]:\\n a.append([i, n - i])\\n return a\\n\",\n \"runtime\": \"1234\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"1320\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n is_prime = self.sieveOfEratosthenes(n) # Generate prime numbers up to n\\n res = []\\n\\n for p in range(2, n // 2 + 1):\\n if is_prime[p] and is_prime[n - p]:\\n res.append([p, n - p])\\n\\n return res\\n\\n def sieveOfEratosthenes(self, n: int) -> List[bool]:\\n is_prime = [True] * (n + 1)\\n is_prime[0] = is_prime[1] = False\\n\\n p = 2\\n while p * p <= n:\\n if is_prime[p]:\\n for i in range(p * p, n + 1, p):\\n is_prime[i] = False\\n p += 1\\n\\n return is_prime\",\n \"runtime\": \"1405\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"1490\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n \\n def get_primes(n):\\n p = 3\\n sieve = [1 for _ in range(n+1)]\\n while p*p <= n:\\n if sieve[p]:\\n for x in range(p*p, n+1, 2*p):\\n sieve[x] = 0\\n p += 2\\n ret = [2]\\n for i in range(3, n+1, 2):\\n if sieve[i]:\\n ret.append(i)\\n return ret\\n PRIMES = get_primes(n)\\n \\n output = []\\n\\n i = 0\\n j = len(PRIMES) - 1\\n\\n while i <= j:\\n if PRIMES[i] + PRIMES[j] > n:\\n j -= 1\\n elif PRIMES[i] + PRIMES[j] < n:\\n i += 1\\n else:\\n output.append([PRIMES[i], PRIMES[j]])\\n i += 1\\n j -= 1\\n return output\",\n \"runtime\": \"1576\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n dp = [True] * (n + 1)\\n dp[0] = dp[1] = False \\n for i in range(2, int(n**0.5) + 1):\\n if dp[i]: # If i is a prime\\n for j in range(i*i, n + 1, i): \\n dp[j] = False\\n val = n//2\\n ans = []\\n for i in range(2,val+1):\\n if (dp[i] and dp[n-i]):\\n ans.append([i,n-i])\\n return ans\\n \",\n \"runtime\": \"1661\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"1746\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"1832\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def sieve(num):\\n prime = [True]*(num+1)\\n prime[0] = prime[1] = False\\n for p in range(isqrt(num)+1):\\n if prime[p]:\\n for j in range(p*p, num+1, p):\\n prime[j] = False\\n \\n return prime\\n \\n prime = sieve(n)\\n res = []\\n for i in range(2, n//2+1):\\n if prime[i] and prime[n-i]:\\n res.append([i, n-i])\\n \\n return res\",\n \"runtime\": \"1917\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"2002\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def SOE(num):\\n isPrime = [True] * (num+1)\\n isPrime[0] = isPrime[1] = False\\n for p in range(isqrt(num)+1):\\n if isPrime[p]:\\n for j in range(p*p, num+1, p):\\n isPrime[j] = False\\n return isPrime\\n\\n isPrime = SOE(n)\\n\\n a = []\\n for i in range(2,n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n a.append([i, n-i])\\n return a\",\n \"runtime\": \"2088\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n is_prime = [True] * (n + 1)\\n is_prime[0] = is_prime[1] = False\\n for i in range(2, int(n**0.5) + 1):\\n if is_prime[i]:\\n for j in range(i*i, n + 1, i):\\n is_prime[j] = False\\n \\n prime_pairs = []\\n for x in range(2, n // 2 + 1):\\n if is_prime[x] and is_prime[n - x]:\\n prime_pairs.append([x, n - x])\\n \\n return prime_pairs\",\n \"runtime\": \"2088\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n is_prime = [True] * (n + 1)\\n is_prime[0] = is_prime[1] = False\\n\\n for i in range(2, int(n ** 0.5) + 1):\\n if is_prime[i]:\\n for j in range(i * i, n + 1, i):\\n is_prime[j] = False\\n\\n pairs = []\\n mid = len(is_prime) // 2\\n for i in range(mid):\\n if is_prime[i] and is_prime[n - i]:\\n pairs.append([i, n - i])\\n \\n if is_prime[mid] and mid + mid == n:\\n pairs.append([mid, mid])\\n \\n return pairs\",\n \"runtime\": \"2173\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n i = 2\\n while i ** 2 <= n:\\n if primes[i]:\\n for j in range(i*2, n+1, i):\\n primes[j] = 0\\n i += 1\\n \\n ans = []\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i]:\\n ans.append([i, n-i])\\n return ans\\n\",\n \"runtime\": \"2173\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def sieve(n):\\n is_prime = [True] * (n + 1)\\n is_prime[0] = is_prime[1] = False\\n for i in range(2, int(n**0.5) + 1):\\n if is_prime[i]:\\n for j in range(i*i, n+1, i):\\n is_prime[j] = False\\n return is_prime\\n\\n is_prime = sieve(n)\\n result = []\\n for x in range(2, n//2 + 1):\\n y = n - x\\n if is_prime[x] and is_prime[y] and x <= y:\\n result.append([x, y])\\n return result\",\n \"runtime\": \"2344\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n + 1)\\n primes[0] = primes[1] = 0\\n\\n for i in range(2, int(n**0.5) + 1):\\n if primes[i]:\\n for j in range(i*i, n+1, i):\\n primes[j] = 0\\n \\n ans = []\\n for i in range(len(primes)):\\n if i > n-i:\\n break\\n if primes[i] and primes[n - i]:\\n ans.append([i, n-i])\\n \\n return ans\\n \",\n \"runtime\": \"2344\"\n },\n {\n \"code\": \"def sieveErastothenes(n: int):\\n sieve = [True for i in range(n+1)]\\n sieve[0] = False\\n sieve[1] = False\\n p = 2\\n while p*p <= n:\\n if sieve[p]:\\n for i in range(p*p, n+1, p):\\n sieve[i] = False\\n p += 1\\n return sieve\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1 or n==2: return []\\n sieve = sieveErastothenes(n)\\n if n%2 == 1:\\n if sieve[n-2]: return [[2,n-2]]\\n else:\\n res = []\\n for x in range(2,n//2+1):\\n if sieve[x] and sieve[n-x]:\\n res.append([x,n-x])\\n return res\",\n \"runtime\": \"2429\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n # 利用 Eratosthenes Algorithm 篩選質數\\n primes = [1] * (n+1) # 先將所有數字設為 1，表示質數\\n primes[0] = primes[1] = 0 # 將索引 0, 1 設為 0，表示非質數\\n for i in range(2, ceil(sqrt(n))): # 從 2 開始計算，計算到目前數字平方 > n 停止\\n if primes[i]: # 若目前數字為質數，將其倍數全部設為 0\\n for j in range(i*2, n+1, i):\\n primes[j] = 0\\n \\n ans = [] # 製作答案\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i]:\\n ans.append([i, n-i])\\n return ans\\n\",\n \"runtime\": \"2429\"\n },\n {\n \"code\": \"from typing import List\\n\\ndef sieve_of_eratosthenes(max_num):\\n is_prime = [True] * (max_num + 1)\\n p = 2\\n while (p * p <= max_num):\\n if (is_prime[p] == True):\\n for i in range(p * p, max_num + 1, p):\\n is_prime[i] = False\\n p += 1\\n is_prime[0], is_prime[1] = False, False\\n return is_prime\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime_pairs = []\\n is_prime = sieve_of_eratosthenes(n)\\n for x in range(2, n // 2 + 1):\\n y = n - x\\n if x <= y and is_prime[x] and is_prime[y]:\\n prime_pairs.append([x, y])\\n return prime_pairs\",\n \"runtime\": \"2514\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n sieve = [True] * (n+1)\\n\\n sieve[0] = sieve[1] = False\\n\\n for cur in range(2, int(math.sqrt(n+1)+1)):\\n if sieve[cur]:\\n for m in range(cur*cur, n+1, cur):\\n sieve[m] = False\\n\\n arr = set()\\n\\n for i in range(2, n-2+1):\\n if sieve[i] and sieve[n-i]:\\n if tuple(sorted((i, n-i))) not in arr:\\n arr.add((i, n-i))\\n\\n return sorted(arr)\",\n \"runtime\": \"2514\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime=[0]*(n+1)\\n p=2\\n while p*p<=n:\\n if prime[p]==0:\\n for i in range(p*p,n+1,p):\\n prime[i]=1\\n p+=1\\n ans=[]\\n for i in range(2,n+1):\\n if prime[i]==0 and prime[n-i]==0 and i<=n-i and n-i>0:\\n ans.append([i,n-i])\\n return ans\",\n \"runtime\": \"2600\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res = []\\n \\n primes = [1 for _ in range(n + 1)]\\n primes[0] = primes[1] = 0\\n p = 2\\n while p ** 2 <= n:\\n if primes[p]:\\n for i in range(p ** 2, n + 1, p): primes[i] = 0\\n p += 1\\n \\n for p in range(2, n // 2 + 1):\\n if primes[p] and primes[n - p]:\\n res.append([p, n - p])\\n return res\\n\",\n \"runtime\": \"2600\"\n },\n {\n \"code\": \"class Solution:\\n def sieve(self, n):\\n primes = [1] * (n + 1)\\n primes[0] = primes[1] = 0\\n\\n for i in range(2, int(sqrt(n) + 1)):\\n if primes[i] == 1:\\n j = i * i\\n while(j < n):\\n primes[j] = 0\\n j += i\\n \\n return primes\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n primes = self.sieve(n)\\n for i in range(2, n//2 + 1):\\n if primes[i] == 1 and primes[n - i] == 1:\\n ans.append([i, n - i])\\n\\n return ans\",\n \"runtime\": \"2685\"\n },\n {\n \"code\": \"class Solution:\\n def primeList(self, n) -> List[int]:\\n primes = [True for i in range(n+1)]\\n p = 2\\n while (p*p <= n):\\n if (primes[p]):\\n for i in range(p*p, n+1, p):\\n primes[i] = False\\n p += 1\\n primes[0] = primes[1] = False\\n return(primes)\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = self.primeList(n)\\n pL = []\\n for i in range(2, n//2 + 1):\\n if (primes[i] and primes[n-i]):\\n pL.append([i, n-i])\\n return pL\",\n \"runtime\": \"2685\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n s=set()\\n l1=[]\\n primes=[True]*(n+1)\\n prime_num=set()\\n primes[0]=primes[1]=False\\n p=2\\n while p*p<=n:\\n if primes[p]:\\n for i in range(p*p,n+1,p):\\n primes[i]=False\\n\\n p+=1\\n \\n for p in range(2,n+1):\\n if primes[p]:\\n prime_num.add(p)\\n\\n for num in prime_num:\\n if n-num in prime_num:\\n l1=[num,n-num]\\n l1.sort()\\n s.add(tuple(l1))\\n\\n if s:\\n return sorted(list(s))\\n else:\\n return []\\n\\n\\n \\n\\n \\n\\n \\n \",\n \"runtime\": \"2770\"\n },\n {\n \"code\": \"class Solution:\\n import math\\n def is_prime(self,num):\\n res=[True]*(num+1)\\n res[0]=res[1]=False\\n for i in range(int(math.sqrt(num))+1):\\n if res[i]:\\n for j in range(i*i,num+1,i):\\n res[j]=False\\n return res\\n\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res=[]\\n if n<=3:\\n return res\\n x=2\\n prime_list=self.is_prime(n)\\n while x<=n//2:\\n y=n-x\\n if prime_list[x] and prime_list[y]:\\n res.append([x,y])\\n x+=1\\n return res\\n \",\n \"runtime\": \"2770\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n # Helper function to find prime numbers using the Sieve of Eratosthenes\\n def sieve_of_eratosthenes(limit):\\n is_prime = [True] * (limit + 1)\\n is_prime[0] = is_prime[1] = False\\n for i in range(2, int(limit**0.5) + 1):\\n if is_prime[i]:\\n for j in range(i*i, limit + 1, i):\\n is_prime[j] = False\\n return [i for i in range(limit + 1) if is_prime[i]]\\n \\n # Find all prime numbers up to n\\n primes = sieve_of_eratosthenes(n)\\n \\n # Create a set for efficient lookup\\n prime_set = set(primes)\\n \\n # Collect valid prime pairs\\n prime_pairs = []\\n for prime in primes:\\n complement = n - prime\\n if complement in prime_set and complement >= prime:\\n prime_pairs.append([prime, complement])\\n \\n return prime_pairs\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [5, 5]]\\nprint(solution.findPrimePairs(2)) # Output: []\",\n \"runtime\": \"2856\"\n },\n {\n \"code\": \"from typing import List\\nfrom math import isqrt\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 2:\\n return []\\n\\n def primenumber(n):\\n is_prime = [True] * n\\n is_prime[0] = False\\n is_prime[1] = False\\n for i in range(2, isqrt(n) + 1):\\n if is_prime[i]:\\n for x in range(i * i, n, i):\\n is_prime[x] = False\\n primes = [i for i in range(n) if is_prime[i]]\\n return primes\\n \\n primes = primenumber(n)\\n target = n\\n dic = {}\\n res = []\\n \\n # Add all primes to the dictionary for fast lookup\\n for prime in primes:\\n dic[prime] = True\\n \\n # Find pairs\\n for prime in primes:\\n complement = target - prime\\n if complement in dic and complement >= prime:\\n res.append([prime, complement])\\n \\n return res\\n\\n# Example usage\\nsolution = Solution()\\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [7, 3]]\\n\",\n \"runtime\": \"2856\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n is_prime = [True] * (n + 1)\\n p = 2\\n # 找到最大可能的质数，只需到p^2\\n while p * p <= n:\\n if is_prime[p]:\\n # 标记所有倍数\\n for i in range(p * p, n + 1, p):\\n is_prime[i] = False\\n p += 1\\n \\n # 获得primes\\n primes = [i for i in range(2, n + 1) if is_prime[i]]\\n # 写进set in method O1\\n prime_set = set(primes)\\n \\n res = []\\n for i in primes:\\n if i > n // 2:\\n break\\n if n - i in prime_set:\\n res.append([i, n - i])\\n \\n return res\",\n \"runtime\": \"2941\"\n },\n {\n \"code\": \"import math\\nfrom typing import List\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4: # the smallest sum of two primes is 2 + 2 = 4\\n return []\\n \\n # Sieve of Eratosthenes\\n is_prime = [True] * n\\n is_prime[0] = is_prime[1] = False\\n \\n for i in range(2, int(math.sqrt(n)) + 1):\\n if is_prime[i]:\\n for j in range(i * i, n, i):\\n is_prime[j] = False\\n \\n # Collecting all primes less than n\\n primes = [i for i in range(n) if is_prime[i]]\\n \\n # Using a set for fast lookup\\n prime_set = set(primes)\\n ans = []\\n \\n for p in primes:\\n if (n - p) in prime_set and (p <= (n - p)):\\n ans.append([p, n - p])\\n \\n return ans\\n\",\n \"runtime\": \"2941\"\n },\n {\n \"code\": \"def is_prime(n):\\n isPrime = [True] * (n + 1)\\n isPrime[0] = False\\n isPrime[1] = False\\n for i in range(n + 1):\\n if isPrime[i]:\\n for j in range(i*i, n+1,i):\\n isPrime[j] = False\\n return isPrime\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 3:\\n return []\\n isPrime = is_prime(n)\\n L = []\\n for i in range(2, n//2 + 1):\\n if isPrime[i] and isPrime[n - i]:\\n L.append([i,n - i])\\n return L\\n \\n \",\n \"runtime\": \"3026\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrimes=[True]*(n+1)\\n isPrimes[0]=False\\n if n>=1:\\n isPrimes[1]=False\\n res=[]\\n for i in range(2,math.ceil(math.sqrt(n))+1):\\n if isPrimes[i]:\\n for j in range(i*i,n+1,i):\\n if isPrimes[j]:\\n isPrimes[j]=False\\n primes=set()\\n for i in range(len(isPrimes)):\\n if isPrimes[i]:\\n primes.add(i)\\n res=set()\\n for i in primes:\\n if n-i<=i and n-i in primes:\\n res.add((n-i,i))\\n x=sorted(res)\\n return x\\n\\n\\n \",\n \"runtime\": \"3026\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n prime_numbers = [True] * (n + 1)\\n\\n for i in range(2, n + 1):\\n if prime_numbers[i]:\\n for j in range(i ** 2, n + 1, i):\\n prime_numbers[j] = False\\n\\n prime_pairs = []\\n\\n for x in range(2, n // 2 + 1):\\n if prime_numbers[x] and prime_numbers[n - x]:\\n prime_pairs.append([x, n - x])\\n return prime_pairs\",\n \"runtime\": \"3112\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True] * (n+1)\\n res = []\\n for i in range(2, (n // 2) + 1):\\n if primes[i]:\\n for j in range(i*2, n+1, i):\\n primes[j] = False\\n #print(primes)\\n for i in range(2, (n // 2) + 1):\\n if primes[i] and primes[n-i]:\\n res.append([i, n-i])\\n \\n return res\\n \",\n \"runtime\": \"3112\"\n },\n {\n \"code\": \"class Solution:\\n def sieve(self, n):\\n primes = [1] * (n + 1)\\n primes[0] = primes[1] = 0\\n\\n for i in range(2, int(sqrt(n) + 1)):\\n if primes[i] == 1:\\n j = i * i\\n while(j < n):\\n primes[j] = 0\\n j += i\\n \\n return primes\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n primes = self.sieve(n)\\n for i in range(2, n//2 + 1):\\n if primes[i] == 1 and primes[n - i] == 1:\\n ans.append([i, n - i])\\n\\n return ans\",\n \"runtime\": \"3197\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def sieveOfEratosthenes(limit):\\n ret, is_prime = [], [True] * (limit + 1)\\n is_prime[0] = is_prime[1] = False\\n p = 2\\n while p <= limit:\\n if is_prime[p]:\\n ret.append(p)\\n for i in range(p * p, limit + 1, p): is_prime[i] = False\\n p += 1\\n return ret\\n ans, primes = [], sieveOfEratosthenes(n)\\n s = set(primes)\\n for v in primes:\\n if v * 2 > n: break\\n if n - v in s: ans.append([v, n - v])\\n return ans\",\n \"runtime\": \"3197\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n):\\n #решето Эратосфена\\n простое = [1] * (n + 1)\\n простое[0] = 0\\n\\n for i in range(2, n // 2 +1):\\n if простое[i]:\\n for j in range(2 * i, n + 1, i):\\n простое[j] = 0\\n\\n рез = []\\n for x in range(2, n // 2 + 1):\\n if простое[x] and простое[n - x]:\\n рез.append([x, n - x])\\n\\n return рез\\n\",\n \"runtime\": \"3282\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n):\\n #решето Эратосфена\\n # if n> 10:\\n # return [[0, 0])\\n\\n простое = [1] * (n + 1)\\n простое[0] = 0\\n\\n\\n for i in range(2, n // 2 + 1):\\n if простое[i]:\\n for j in range(2 * i, n + 1, i):\\n простое[j] = 0\\n\\n рез = []\\n for x in range(2, n // 2 + 1):\\n if простое[x] and простое[n - x]:\\n рез.append([x, n - x])\\n\\n return рез\\n\",\n \"runtime\": \"3282\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def sieve_of_eratosthenes(n):\\n prime = [True for _ in range(n+1)]\\n p = 2\\n\\n while p * p <= n:\\n if prime[p]:\\n for i in range(p * p, n + 1, p):\\n prime[i] = False\\n p += 1\\n\\n primes = [p for p in range(2, n) if prime[p]]\\n return primes\\n\\n primes = sieve_of_eratosthenes(n)\\n set_primes = set(primes)\\n pairs = []\\n\\n for prime in primes:\\n if n-prime in set_primes and n-prime>=prime:\\n pairs.append([prime, n-prime])\\n return pairs\",\n \"runtime\": \"3368\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def ip(n):\\n p=[1]*(n+1)\\n i=2\\n while i*i<=n:\\n if p[i]==1:\\n j=i*i\\n while j<=n:\\n p[j]=0\\n j+=i\\n i+=1\\n return p\\n\\n b=[]\\n pp=ip(n)\\n for i in range(2,n):\\n if pp[i]==1:\\n b.append(i)\\n \\n a=[]\\n l=0\\n le=len(b)\\n r=le-1\\n while l<=r:\\n s=b[l]+b[r]\\n if s<n:\\n l+=1\\n elif s>n:\\n r-=1\\n else:\\n a.append([b[l],b[r]])\\n l+=1\\n r-=1\\n return a\\n \",\n \"runtime\": \"3368\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def primes(n):\\n primes = [False, False] + [True for e in range(0, n - 2)]\\n for i in range(2, int(n**0.5) + 1):\\n if primes[i]:\\n for j in range(i**2, n, i):\\n primes[j] = False\\n return [i for i, e in enumerate(primes) if e]\\n ps = set(primes(n))\\n rets = []\\n for e in ps:\\n if n < 2 * e:\\n continue\\n if n - e in ps:\\n rets.append([e, n - e])\\n return sorted(rets)\",\n \"runtime\": \"3453\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = self.sieve(n + 1)\\n res = []\\n for i in range(len(primes)):\\n p = primes[i]\\n target = n - p\\n if target == p:\\n res.append([p, p])\\n continue\\n index = bisect.bisect_left(primes, target, i + 1)\\n if index < len(primes) and primes[index] == target:\\n res.append([p, primes[index]])\\n return res\\n\\n def sieve(self, n: int) -> list[int]:\\n if n <= 1:\\n return []\\n primes = [True] * n\\n primes[0], primes[1] = False, False\\n for i in range(2, int(n**0.5) + 1):\\n if primes[i]:\\n for j in range(i + i, n, i):\\n primes[j] = False\\n return [i for i, v in enumerate(primes) if v]\",\n \"runtime\": \"3453\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ps = [True for _ in range(n)]\\n\\n p = 2\\n while p * p < n:\\n if ps[p]:\\n for pn in range(p * 2, n, p):\\n ps[pn] = False\\n p += 1\\n \\n primes = set([i for (i, p) in enumerate(ps) if p and i > 1])\\n\\n res = set()\\n for p in primes:\\n if n - p in primes:\\n if (p, n - p) not in res and (n - p, p) not in res:\\n res.add((p, n - p))\\n \\n return sorted([sorted([one, two]) for (one, two) in res])\\n\",\n \"runtime\": \"3538\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime = [True] * (n + 1)\\n prime[0], prime[1] = False, False\\n for i in range(1, int(sqrt(n)) + 1):\\n if prime[i]:\\n for j in range(i * i, n + 1, i):\\n prime[j] = False\\n \\n i, j = 2, len(prime) - 1\\n ans = []\\n while i <= j:\\n if prime[i] and prime[j] and i + j == n:\\n ans.append([i, j])\\n i += 1\\n j -= 1\\n elif i + j < n:\\n i += 1\\n else:\\n j -= 1\\n return ans\",\n \"runtime\": \"3624\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ip = [True] * (n+1)\\n for i in range(2, n+1):\\n if ip[i]:\\n for j in range(i+i, n+1, i):\\n ip[j] = False\\n \\n\\n res = []\\n for i in range(2, n // 2 + 1):\\n if ip[i] and ip[n - i]:\\n res.append((i, n-i))\\n \\n return res\",\n \"runtime\": \"3624\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True for _ in range(n+1)]\\n primes[0] = primes[1] = False\\n\\n for i in range(int(sqrt(n)) + 1):\\n if primes[i]:\\n j = i*i\\n while j <= n:\\n primes[j] = False\\n j += i\\n\\n primes = [i for i in range(len(primes)) if primes[i]]\\n ps = set(primes)\\n res = []\\n\\n for k in primes:\\n if k > n // 2: break\\n if n - k in ps:\\n res.append((k, n - k))\\n return res\\n \",\n \"runtime\": \"3709\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True] * n\\n p = 2\\n while p < n:\\n if primes[p]:\\n for i in range(p * p, n, p):\\n primes[i] = False\\n p += 1\\n \\n result = []\\n for i in range(2, n // 2 + 1):\\n if primes[i] and primes[n - i]:\\n result.append([i, n - i])\\n return result\",\n \"runtime\": \"3794\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n for i in range(2, n+1):\\n if primes[i]:\\n for j in range(i*2, n+1, i):\\n primes[j] = 0\\n \\n ans = []\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i]:\\n ans.append([i, n-i])\\n return ans\\n\",\n \"runtime\": \"3794\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n):\\n #решето Эратосфена\\n простое = [1] * (n + 1)\\n простое[0] = 0\\n\\n for i in range(2, n + 1):\\n if простое[i]:\\n for j in range(2 * i, n + 1, i):\\n простое[j] = 0\\n\\n рез = []\\n for x in range(2, n // 2 + 1):\\n if простое[x] and простое[n - x]:\\n рез.append([x, n - x])\\n\\n return рез\\n\",\n \"runtime\": \"3879\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True] * n\\n for i in range(2, n):\\n if primes[i]:\\n for j in range(i + i, n, i):\\n primes[j] = False\\n ans = []\\n for x in range(2, n // 2 + 1):\\n y = n - x\\n if primes[x] and primes[y]:\\n ans.append([x, y])\\n return ans\",\n \"runtime\": \"3879\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime_pairs = []\\n for i in range(2,n//2+1):\\n if is_prime(n-i) and is_prime(i):\\n prime_pairs.append([i,n-i])\\n return prime_pairs\\nfrom functools import cache\\nimport math \\n\\n@cache\\ndef is_prime(n):\\n if n <= 1:\\n return False\\n\\n for i in range(2,int(math.sqrt(n))+1):\\n if n % i == 0:\\n return False\\n\\n return True\\n\\n \",\n \"runtime\": \"3965\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primelist = [True]*(n+1)\\n for i in range(2,n):\\n if primelist[i]:\\n for i in range(2*i,n+1,i):\\n primelist[i]=False\\n start = 2\\n end = n-2\\n result = []\\n while(start<=end):\\n if primelist[start] and primelist[end]:\\n result.append([start,end])\\n start+=1\\n end-=1\\n return result\",\n \"runtime\": \"3965\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n if p <= n//2:\\n sub[n-p] = p\\n test = sub.get(p)\\n if test is not None:\\n res.insert(0,[test, p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"runtime\": \"4050\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n sub[n-p] = p\\n test = sub.get(p)\\n if test is not None:\\n res.insert(0,[test, p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"runtime\": \"4050\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n if p <= n//2:\\n sub[n-p] = p\\n test = sub.get(p)\\n if test is not None:\\n res.insert(0,[test, p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"runtime\": \"4135\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n sub[n-p] = p\\n if sub.get(p) is not None:\\n res.insert(0,[sub.get(p), p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"runtime\": \"4221\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime = [i for i in range(n + 1)]\\n p = 2\\n while (p * p <= n):\\n if prime[p] > 0:\\n for i in range(p * p, n + 1, p):\\n prime[i] = 0\\n p += 1\\n ans = []\\n for i in range(2, n // 2 + 1):\\n if prime[i] and prime[n - i]:\\n ans.append([prime[i], prime[n - i]])\\n return ans\",\n \"runtime\": \"4221\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True] * (n+1)\\n for x in range(2,n+1):\\n if primes[x]:\\n cur = 2*x\\n while cur <= n:\\n primes[cur] = False\\n cur += x\\n ans = [[x, n-x] for x in range(2,n//2+1) if primes[x] and primes[n-x]]\\n return ans\",\n \"runtime\": \"4306\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = set()\\n nums = [True for _ in range(n)]\\n p = 2\\n while p < n:\\n if nums[p]:\\n primes.add(p)\\n for i in range(p * p, n, p):\\n nums[i] = False\\n p += 1\\n \\n result = []\\n for i in range(2, n // 2 + 1):\\n if i in primes and n - i in primes:\\n result.append([i, n - i])\\n return result\",\n \"runtime\": \"4306\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n def sieve_of_eratosthenes(n):\\n \\\"\\\"\\\"\\n Helper function to generate all primes <= n\\n \\\"\\\"\\\"\\n\\n ub = math.ceil(n**0.5)\\n is_prime = [True for _ in range(n+1)]\\n\\n for i in range(2, ub+1):\\n if is_prime[i]:\\n for p in range(2*i, n+1, i):\\n is_prime[p] = False\\n \\n primes = set()\\n for i in range(2, n+1):\\n if is_prime[i]:\\n primes.add(i)\\n \\n return primes\\n \\n primes = sieve_of_eratosthenes(n)\\n answer = []\\n for i in range(n+1):\\n if i in primes and n - i in primes:\\n primes.remove(n-i)\\n answer.append([i, n-i])\\n \\n return answer\",\n \"runtime\": \"4391\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n \\n prime = [True for _ in range(n+1)]\\n prime[0] = prime[1] = False\\n \\n for i in range(2, n+1):\\n if prime[i]:\\n j = i*i\\n \\n while j<=n:\\n prime[j] = False\\n j += i\\n for i in range(2,n):\\n if i+i>n: break\\n if prime[i] and prime[n-i]:\\n ans.append([i,n-i])\\n return ans\",\n \"runtime\": \"4391\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n def sieve_of_eratosthenes(n):\\n is_prime = [True for _ in range(n+1)]\\n is_prime[1] = False\\n primes = set()\\n for i in range(1, n+1):\\n if (not is_prime[i]):\\n continue\\n primes.add(i)\\n for j in range(i, n+1, i):\\n is_prime[j] = False\\n return primes\\n \\n primes = sieve_of_eratosthenes(n)\\n pairs = list()\\n seen = set()\\n primes_ordered = sorted(primes)\\n for prime in primes_ordered:\\n diff = (n - prime)\\n if (not diff in primes):\\n continue\\n elif (prime in seen):\\n continue\\n seen.add(diff)\\n pairs.append([prime, diff])\\n return pairs\\n\",\n \"runtime\": \"4477\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primeRange = [1]*(n+1)\\n primeStart = 2\\n while primeStart*primeStart <= n+1:\\n for i in range(primeStart*primeStart,n+1,primeStart):\\n primeRange[i] = 0\\n primeStart += 1\\n result = []\\n for i in range(2,n//2+1):\\n if primeRange[i] and primeRange[n-i]:\\n result.append([i,n-i])\\n return result\",\n \"runtime\": \"4562\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n if n == 4:\\n return [[2, 2]]\\n\\n # need to know whether 2 ~ n-2 is prime.\\n is_prime = [False, False] + [True] * (n - 3)\\n for div in itertools.chain([2], range(3, n - 1, 2)):\\n for i in range(div**2, n - 1, div):\\n is_prime[i] = False\\n\\n if n % 2:\\n # odd = even + odd\\n # 2 and n - 2\\n if is_prime[n - 2]:\\n return [[2, n - 2]]\\n else:\\n return []\\n\\n # n >= 6 , even = odd + odd\\n res = []\\n for x in range(3, n // 2 + 1, 2):\\n if is_prime[x] and is_prime[n - x]:\\n res.append([x, n - x])\\n\\n return res\",\n \"runtime\": \"4562\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primeRange = [1]*(n+1)\\n primeStart = 2\\n while primeStart*primeStart <= n+1:\\n for i in range(primeStart*primeStart,n+1,primeStart):\\n primeRange[i] = 0\\n primeStart += 1\\n result = []\\n for i in range(2,n//2+1):\\n if primeRange[i] and primeRange[n-i]:\\n result.append([i,n-i])\\n return result\",\n \"runtime\": \"4647\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrime = [True for _ in range(n+1)]\\n for i in range(2, int(math.sqrt(n))+1):\\n if isPrime[i]:\\n num = i\\n while i*num <= n:\\n isPrime[i*num] = False\\n num += 1\\n result = []\\n for i in range(2, n//2+1):\\n if isPrime[i] and isPrime[n-i]:\\n result.append([i, n-i])\\n return result\",\n \"runtime\": \"4733\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n arr = [1 for i in range(n+1)]\\n arr[0] = 0\\n arr[1] = 0\\n ans = []\\n for p in range(2,n+1):\\n if arr[p]==1:\\n ans.append(p)\\n k = p*p\\n while k<(n+1):\\n arr[k]=0\\n k+=p\\n # print(ans)\\n i = 0 \\n j = len(ans)-1\\n fin = []\\n while i<=j:\\n ct = ans[i]+ans[j]\\n if ct==n:\\n fin.append([ans[i],ans[j]])\\n i+=1\\n j-=1\\n elif ct < n:\\n i+=1\\n else:\\n j-=1\\n return fin\\n \",\n \"runtime\": \"4818\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def findprimes():\\n primes = [0 for i in range(n+1)]\\n for i in range(2,n+1):\\n if primes[i]==0:\\n for j in range(i*2,n+1,i):\\n primes[j] = 1\\n res = []\\n for i in range(2,n+1):\\n if primes[i]==0:\\n res.append(i)\\n return res\\n primes = findprimes()\\n ans = []\\n s = set()\\n p = len(primes)\\n for i in range(p):\\n num = primes[i]\\n s.add(num)\\n target = n-num\\n if(target in s):\\n ans.append([min(target,num),max(target,num)])\\n ans.sort(key = lambda x:x[0])\\n return ans\\n\\n\\n \",\n \"runtime\": \"4903\"\n },\n {\n \"code\": \"class Solution:\\n def get_prime(self,n):\\n dp=[True]*(n)\\n dp[0]=False\\n dp[1]=False\\n for i in range(2,int((n)**0.5)+1):\\n for j in range(i*i,n,i):\\n dp[j]=False\\n l=[]\\n for i in range(n):\\n if dp[i]:\\n l.append(i)\\n return l\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n \\n # Get all primes less than n\\n primes = self.get_prime(n)\\n ans = []\\n \\n # Use two-pointer technique to find pairs\\n left, right = 0, len(primes) - 1\\n while left <= right:\\n current_sum = primes[left] + primes[right]\\n if current_sum == n:\\n ans.append([primes[left], primes[right]])\\n left += 1\\n right -= 1\\n elif current_sum < n:\\n left += 1\\n else:\\n right -= 1\\n \\n return ans\\n \",\n \"runtime\": \"4989\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n s=set()\\n l1=[]\\n primes=[True]*(n+1)\\n prime_num=set()\\n primes[0]=primes[1]=False\\n p=2\\n while p*p<=n:\\n #if primes[p]:\\n for i in range(p*p,n+1,p):\\n primes[i]=False\\n\\n p+=1\\n for p in range(2,n+1):\\n if primes[p]:\\n prime_num.add(p)\\n\\n for num in prime_num:\\n if n-num in prime_num:\\n l1=[num,n-num]\\n l1.sort()\\n s.add(tuple(l1))\\n\\n if s:\\n return sorted(list(s))\\n else:\\n return []\\n\\n\\n \\n\\n \\n\\n \\n \",\n \"runtime\": \"5074\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n for i in range(2, int(sqrt(n) + 1)):\\n for j in range(i * i, n + 1, i):\\n primes[j] = 0\\n \\n ans = []\\n l = 0\\n r = len(primes) - 1\\n # 00110101000\\n # l\\n # r\\n # 012345678910\\n while l <= r:\\n while r < n and not primes[r]:\\n r -= 1\\n while l <= r and not primes[l]:\\n l += 1\\n total = l + r\\n if total > n:\\n r -= 1\\n elif total < n:\\n l += 1\\n else:\\n ans.append((l, r))\\n l += 1\\n r -= 1\\n return ans\",\n \"runtime\": \"5159\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n for i in range(2, int(sqrt(n) + 1)):\\n for j in range(i * i, n + 1, i):\\n primes[j] = 0\\n \\n ans = []\\n l = 0\\n r = len(primes) - 1\\n\\n while l <= r:\\n while r < n and not primes[r]:\\n r -= 1\\n while l <= r and not primes[l]:\\n l += 1\\n total = l + r\\n if total > n:\\n r -= 1\\n elif total < n:\\n l += 1\\n else:\\n ans.append((l, r))\\n l += 1\\n r -= 1\\n return ans\",\n \"runtime\": \"5245\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n #optimales approach \\n #using actual Sieve of Eratosthenes\\n sieve = [i for i in range(n)]\\n #sieve[0] = None\\n #sieve[1] = None\\n final = []\\n for i in range(2,int(math.sqrt(n))+1):\\n if sieve[i] == i:\\n j = i**2\\n while j < n:\\n if sieve[j] == j:\\n sieve[j] = i\\n j += i\\n #print(\\\"sieve be like :\\\")\\n #print(sieve)\\n #now from smallest prime 2 to n//2+1 lmit,\\n #check which ones yield n by summaticon\\n # or i'll be like\\n # if x is prime and n-x is also prime \\n # then they be the pair we want\\n for i in range(2,n//2+1):\\n #print(f'i is {i} and n-x = {n-i}')\\n if i == sieve[i] and n-i == sieve[n-i]:\\n final.append([i,n-i])\\n return final\\n\\n \\\"\\\"\\\"\\n #full haarami Brute force\\n # Tc - O(N*sqrt(N) + len(sieve)**2)\\n final = []\\n def is_prime(number):\\n count = 0\\n for i in range(2,int(math.sqrt(number))+1):\\n if number%i == 0:\\n count += 1\\n if not count:\\n return True\\n return False\\n #print(is_prime(49))\\n sieve = []\\n for i in range(2,n):\\n if is_prime(i):\\n sieve.append(i)\\n #print(\\\"Sieve of Erastothenes :\\\",sieve)\\n #Now traverse the sieve to get those numas whose sumaticon be n\\n for i in range(len(sieve)):\\n for j in range(i,len(sieve)):\\n if sieve[i] + sieve[j] == n:\\n final.append([sieve[i],sieve[j]])\\n return final\\n \\\"\\\"\\\"\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"5330\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = []\\n allNumbers =[True]*(n+1)\\n allNumbers[0] = False\\n allNumbers[1] = False\\n index = 2\\n while index <= n:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex <= n):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.insert(0, [n-index, index])\\n\\n index+=1\\n\\n return toReturn\\n\\n\\n\\n\\n \",\n \"runtime\": \"5415\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n is_prime = [True] * (n + 1)\\n is_prime[0] = False\\n is_prime[1] = False\\n for p in range(2, n // 2 + 1):\\n if not is_prime[p]:\\n continue\\n x = p + p\\n while x < len(is_prime):\\n is_prime[x] = False\\n x += p\\n\\n all_primes = {i for i, x in enumerate(is_prime) if x}\\n result = []\\n for p in sorted(all_primes):\\n comp = n - p\\n if comp < p:\\n break\\n if comp in all_primes:\\n result.append([p, comp])\\n return result\\n\",\n \"runtime\": \"5757\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = []\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex <= n):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.insert(0, [n-index, index])\\n\\n index+=1\\n\\n return toReturn\\n\\n\\n\\n\\n \",\n \"runtime\": \"5842\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime=[0]*(n+1)\\n prime[0]=1\\n prime[1]=1\\n for x in range(2,n+1):\\n if prime[x]==0:\\n i=x\\n while x*i<=n:\\n if prime[x*i]==0:\\n prime[x*i]=1\\n i+=1\\n result=[]\\n for x in range(2,((n//2)+1)):\\n if prime[x]==0 and prime[n-x]==0:\\n result.append([x,n-x])\\n return result\",\n \"runtime\": \"5927\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 1:\\n return []\\n \\n primes = [True for _ in range(n + 1)] # 0 indexed, ignore 0\\n primes[0] = False\\n primes[1] = False # 1 is not a prime\\n primes[2] = True # 2 is a prime\\n for i in range(2, n):\\n if primes[i]:\\n itr = 2\\n start = i * itr\\n while start <= n:\\n primes[start] = False\\n itr += 1\\n start = i * itr\\n res = []\\n for int1 in range(1, n//2 + 1):\\n if primes[int1] and primes[n - int1]:\\n res.append([int1, n - int1])\\n return res\\n\\n\\n\\n \",\n \"runtime\": \"6013\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n for i in range(2, n+1):\\n if primes[i]:\\n m = 2\\n while i * m <= n:\\n primes[i*m] = 0\\n m += 1\\n \\n ans = []\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i]:\\n ans.append([i, n-i])\\n return ans\\n\",\n \"runtime\": \"6098\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n p = [True]*(n+2)\\n p[0]=False\\n p[1]=False\\n for i in range(2,len(p)):\\n if p[i]==True:\\n j=2*i\\n while j<len(p):\\n p[j]=False\\n j+=i\\n ans=[]\\n for i in range(len(p)//2):\\n if i>=2 and n-i>=2 and p[i] and p[n-i]:\\n ans.append([i,n-i])\\n \\n return ans\\n \\n \",\n \"runtime\": \"6183\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n # list all prime numbers up to sqrt n\\n def gcd(a, b):\\n if a < b:\\n a,b = b,a\\n while b > 0:\\n a,b = b, a%b\\n return a\\n prod, primes = 1, []\\n for i in range(2, int(sqrt(n)) + 1):\\n if gcd(i, prod) == 1:\\n primes.append(i)\\n prod *= i\\n def isPrime(n):\\n for prime in primes:\\n if prime > sqrt(n):\\n return True\\n if not n % prime:\\n return False\\n return True\\n \\n if n%2:\\n # there are only one way two prime numbers could have odd sum i.e. 2 and another prime number\\n if n < 5:\\n return False\\n if isPrime(n-2):\\n return [[2,n-2]]\\n else:\\n return []\\n\\n\\n pairs = []\\n for prime in primes:\\n if isPrime(n-prime):\\n pairs.append([prime, n-prime])\\n if primes[-1] == 2:\\n start = 3\\n else:\\n start = primes[-1] +2\\n for nn in range(start, n//2 + 1, 2):\\n if isPrime(nn) and isPrime(n-nn):\\n pairs.append([nn,n-nn])\\n return pairs\\n\\n\\n \",\n \"runtime\": \"6269\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def isPrime(v):\\n upper = math.floor(math.sqrt(v)) + 1\\n if v < 2:\\n return False\\n if v == 2:\\n return True\\n if v % 2 == 0:\\n return False\\n for c in range(3, upper, 2):\\n if v%c == 0:\\n return False\\n \\n return True\\n if n <=2:\\n return []\\n\\n if n % 2 == 1:\\n if isPrime(n-2):\\n return [[2, n-2]]\\n return []\\n\\n upper = n//2 + 1\\n res = []\\n for i in range(2,upper):\\n # print(i)\\n if isPrime(i) and isPrime(n-i):\\n res.append([i, n-i])\\n # print(res)\\n return res\\n \\n \\n \",\n \"runtime\": \"6354\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = deque()\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex <= n):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.appendleft([n-index, index])\\n\\n index+=1\\n\\n return list(toReturn)\\n\\n\\n\\n\\n \",\n \"runtime\": \"6439\"\n },\n {\n \"code\": \"class Solution:\\r\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\r\\n prime = [True] * (n+1)\\r\\n prime[0], prime[1] = False, False\\r\\n \\r\\n for i in range(2, n+1):\\r\\n if prime[i]:\\r\\n j = 2\\r\\n while i * j <= n:\\r\\n prime[i*j] = False\\r\\n j += 1\\r\\n \\r\\n ans = []\\r\\n lf, rh = 2, n-2\\r\\n while lf <= rh:\\r\\n if prime[lf] and prime[rh]:\\r\\n ans.append([lf, rh])\\r\\n lf += 1\\r\\n rh -= 1\\r\\n return ans\",\n \"runtime\": \"6525\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n self.primeSet = self.es(n)\\n ans = []\\n for x in range(2, n // 2 + 1):\\n y = n - x\\n if self.primeSet[x] and self.primeSet[y]:\\n ans.append([x, y])\\n \\n return ans\\n \\n def es(self, n):\\n ps = [1] * (n + 1)\\n \\n for f in range(2, n // 2 + 1):\\n num = 2\\n prod = f * num\\n while ps[f] and prod <= n:\\n ps[prod] = 0\\n num += 1\\n prod = num * f\\n\\n return ps\\n \",\n \"runtime\": \"6610\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n composite_set = set()\\n prime_set = {2}\\n for i in range(3, n + 1, 2):\\n if i in composite_set:\\n continue\\n prime_set.add(i)\\n cur = i * i\\n while cur <= n:\\n composite_set.add(cur)\\n cur += i\\n\\n pairs = []\\n for i in range(2, n // 2 + 1):\\n if i in prime_set and n - i in prime_set:\\n pairs.append([i, n - i])\\n return pairs\\n\",\n \"runtime\": \"6695\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrime = [1] * n\\n for i in range(2, n):\\n if isPrime[i] == 0:\\n continue\\n j = 2\\n while i * j < n:\\n isPrime[i * j] = 0\\n j += 1\\n \\n result = []\\n for i in range(2, n):\\n j = n - i\\n if j < i:\\n return result\\n if isPrime[j] and isPrime[i]:\\n result.append([i, j])\\n return result\",\n \"runtime\": \"6781\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n #toReturn = deque()\\n toReturn = []\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex < n - 1):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n #toReturn.appendleft([n-index, index])\\n toReturn.append([n-index, index])\\n\\n index+=1\\n reversed_list = toReturn[::-1]\\n return reversed_list\\n\\n\\n\\n\\n \",\n \"runtime\": \"6866\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = deque()\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex < n - 1):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.appendleft([n-index, index])\\n\\n index+=1\\n\\n return list(toReturn)\\n\\n\\n\\n\\n \",\n \"runtime\": \"6951\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":102,"string":"102"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def isPrime(v):\n upper = math.floor(math.sqrt(v)) + 1\n if v < 2:\n return False\n if v == 2:\n return True\n if v % 2 == 0:\n return False\n for c in range(3, upper, 2):\n if v%c == 0:\n return False\n \n return True\n if n <=2:\n return []\n\n if n % 2 == 1:\n if isPrime(n-2):\n return [[2, n-2]]\n return []\n\n upper = n//2 + 1\n res = []\n for i in range(2,upper):\n # print(i)\n if isPrime(i) and isPrime(n-i):\n res.append([i, n-i])\n # print(res)\n return res\n \n \n ","memory":"20700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n # list all prime numbers up to sqrt n\n def gcd(a, b):\n if a < b:\n a,b = b,a\n while b > 0:\n a,b = b, a%b\n return a\n prod, primes = 1, []\n for i in range(2, int(sqrt(n)) + 1):\n if gcd(i, prod) == 1:\n primes.append(i)\n prod *= i\n def isPrime(n):\n for prime in primes:\n if prime > sqrt(n):\n return True\n if not n % prime:\n return False\n return True\n \n if n%2:\n # there are only one way two prime numbers could have odd sum i.e. 2 and another prime number\n if n < 5:\n return False\n if isPrime(n-2):\n return [[2,n-2]]\n else:\n return []\n\n\n pairs = []\n for prime in primes:\n if isPrime(n-prime):\n pairs.append([prime, n-prime])\n if primes[-1] == 2:\n start = 3\n else:\n start = primes[-1] +2\n for nn in range(start, n//2 + 1, 2):\n if isPrime(nn) and isPrime(n-nn):\n pairs.append([nn,n-nn])\n return pairs\n\n\n ","memory":"20800"},{"code":"import array\ndef sieve_of_eratosthenes(n):\n if n < 2:\n return []\n is_prime = bytearray((1,))*(n+1)\n is_prime[0] = is_prime[1] = 0\n for i in range(2, int(n**0.5) + 1):\n if is_prime[i]:\n for j in range(i * i, n + 1, i):\n is_prime[j] = 0\n primes = array.array('i',(i for i in range(n + 1) if is_prime[i]))\n return primes\n\nPRIMES = sieve_of_eratosthenes(1000000)\n\nPS = set(PRIMES)\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n out = []\n for p in PRIMES:\n np=n-p\n if p<=np and np in PS:\n out.append((p,np))\n if p >= np:\n return out","memory":"25200"},{"code":"def is_prime(n):\n if n == 2 or n == 3: return True\n if n < 2 or n%2 == 0: return False\n if n < 9: return True\n if n%3 == 0: return False\n if (n - 1) % 6 != 0 and (n+1) % 6 !=0:\n return False\n r = int(n**0.5)\n # since all primes > 3 are of the form 6n ± 1\n # start with f=5 (which is prime)\n # and test f, f+2 for being prime\n # then loop by 6. \n f = 5\n while f <= r:\n\n if n % f == 0: return False\n if n % (f+2) == 0: return False\n f += 6\n return True \ndef sieve_of_eratosthenes(n):\n primes = [True] * (n+1)\n p = 2\n while (p * p <= n):\n if (primes[p] == True):\n for i in range(p * p, n+1, p):\n primes[i] = False\n p += 1\n prime_numbers = [p for p in range(2, n) if primes[p]]\n return prime_numbers\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 2:\n return []\n # Find all prime numbers\n # Iterate list and see if its mirror is present in the prime list\n #when you do n - x\n\n #primes = [x for x in range(1, n//2+1) if is_prime(x)]\n primes = sieve_of_eratosthenes(n//2+1)\n \"\"\"hold = [x for x in range(2, n//2+1)][::-1]\n primes = []\n while len(hold) > 0:\n x = hold.pop()\n primes.append(x)\n hold = [y for y in hold if y % x != 0]\"\"\"\n\n out = []\n for x in primes:\n a = n-x\n if is_prime(a):\n out.append([x, a])\n return out","memory":"25800"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n # these two functions are from IterTools Recipes:\n # https://docs.python.org/3/library/itertools.html\n\n import contextlib\n\n def iter_index(iterable, value, start=0, stop=None):\n \"Return indices where a value occurs in a sequence or iterable.\"\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\n seq_index = getattr(iterable, 'index', None)\n if seq_index is None:\n iterator = islice(iterable, start, stop)\n for i, element in enumerate(iterator, start):\n if element is value or element == value:\n yield i\n else:\n stop = len(iterable) if stop is None else stop\n i = start\n with contextlib.suppress(ValueError):\n while True:\n yield (i := seq_index(value, i, stop))\n i += 1\n\n def sieve(n):\n \"Primes less than n.\"\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n if n > 2:\n yield 2\n data = bytearray((0, 1)) * (n // 2)\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n yield from iter_index(data, 1, start=3)\n\n primes = set(sieve(n))\n\n return [\n [P, n - P]\n for P in sorted(primes)\n if P <= (n - P) and (n - P) in primes\n ]\n","memory":"26600"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n # these two functions are from IterTools Recipes:\n # https://docs.python.org/3/library/itertools.html\n\n import contextlib\n\n def iter_index(iterable, value, start=0, stop=None):\n \"Return indices where a value occurs in a sequence or iterable.\"\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\n seq_index = getattr(iterable, 'index', None)\n if seq_index is None:\n iterator = islice(iterable, start, stop)\n for i, element in enumerate(iterator, start):\n if element is value or element == value:\n yield i\n else:\n stop = len(iterable) if stop is None else stop\n i = start\n with contextlib.suppress(ValueError):\n while True:\n yield (i := seq_index(value, i, stop))\n i += 1\n\n def sieve(n):\n \"Primes less than n.\"\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\n if n > 2:\n yield 2\n data = bytearray((0, 1)) * (n // 2)\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\n yield from iter_index(data, 1, start=3)\n\n primes = set(sieve(n))\n\n return [\n [P, n - P]\n for P in sorted(primes)\n if P <= (n - P) and (n - P) in primes\n ]\n","memory":"26700"},{"code":"def get_primes(num):\n primes = [True] * (num + 1)\n for x in range(2, num + 1):\n if primes[x]:\n for y in range(x*x, num + 1, x):\n primes[y] = False\n return primes\n\nprimes = get_primes(1000000)\n \n \nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n res = []\n for left in range(2, n // 2 + 1):\n right = n - left\n if primes[left] and primes[right]:\n res.append([left, right])\n return res\n ","memory":"28400"},{"code":"pr = [1 for i in range(10**6+1)]\np = 2\nwhile p*p<10**6+1:\n if pr[p]:\n for i in range(2*p, 10**6+1, p):\n pr[i] = 0\n p +=1\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n for i in range(2, n//2+1):\n if pr[i] and pr[n-i]:\n ans.append([i, n-i])\n return ans","memory":"28600"},{"code":"limit = 10 ** 6\nprimes = [True] * (limit + 1)\n\nprimes[0] = False\nprimes[1] = False\n\nfor i in range(2, limit + 1):\n if primes[i]:\n nextNum = 2 * i\n while nextNum <= limit:\n primes[nextNum] = False\n nextNum += i\n\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n global primes\n\n res = []\n for x in range(1, n // 2 + 1):\n if not primes[x]:\n continue\n \n y = n - x\n\n if not primes[y]:\n continue\n \n res.append([x, y])\n\n return res\n ","memory":"28700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def generate_primes(n):\n isprime = [True] * (n + 1)\n isprime[0] = isprime[1] = False\n \n for i in range(2, int(n ** 0.5) + 1):\n if isprime[i]:\n for j in range(i * i, n + 1, i):\n isprime[j] = False\n\n primes = [i for i in range(2, n + 1) if isprime[i]]\n return primes\n \n prime = generate_primes(n)\n l,r=0,len(prime)-1\n ans =[]\n while(l<=r):\n if prime[l]+ prime[r] == n:\n ans.append([prime[l],prime[r]])\n l+=1\n r-=1\n elif prime[l]+ prime[r] <n:\n l+=1\n else:\n r-=1\n return ans","memory":"29000"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n def is_prime(num):\n if num <= 2 or num % 2 == 0:\n return num == 2\n for d in range(3, isqrt(num) + 1, 2):\n if num % d == 0:\n return False\n return True\n\n def find_primes(num):\n num += 1 # to include 0\n primes = [True] * num\n primes[0] = primes[1] = False\n for p in range(2, max(3, isqrt(num) + 1)):\n if not primes[p]:\n continue\n for kp in range(p * p, num, p):\n primes[kp] = False\n return primes\n\n ans = []\n if 1 <= 2 <= n - 2 <= n:\n if is_prime(n - 2):\n ans.append([2, n - 2])\n\n if n % 2 == 1:\n return ans\n\n primes = find_primes(n)\n\n for x in range(3, n // 2 + 1, 2):\n y = n - x\n #if x <= y and is_prime(x) and is_prime(y):\n if x <= y and primes[x] and primes[y]:\n ans.append([x, y])\n return ans\n","memory":"29700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def generate_primes(n):\n prime = [True]*(n+1)\n prime[0] = prime[1] = False\n p = 2\n while p*p<=n:\n if prime[p]:\n for num in range(p*p,n+1,p):\n prime[num] = False \n p+=1\n \n ans = []\n for i in range(2,n+1):\n if prime[i]:\n ans.append(i)\n return ans\n \n prime = generate_primes(n)\n l,r=0,len(prime)-1\n ans =[]\n while(l<=r):\n if prime[l]+ prime[r] == n:\n ans.append([prime[l],prime[r]])\n l+=1\n r-=1\n elif prime[l]+ prime[r] <n:\n l+=1\n else:\n r-=1\n return ans","memory":"30200"},{"code":"class Solution:\n def get_prime(self,n):\n dp=[True]*(n)\n dp[0]=False\n dp[1]=False\n for i in range(2,int((n)**0.5)+1):\n for j in range(i*i,n,i):\n dp[j]=False\n l=[]\n for i in range(n):\n if dp[i]:\n l.append(i)\n return l\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n \n # Get all primes less than n\n primes = self.get_prime(n)\n ans = []\n \n # Use two-pointer technique to find pairs\n left, right = 0, len(primes) - 1\n while left <= right:\n current_sum = primes[left] + primes[right]\n if current_sum == n:\n ans.append([primes[left], primes[right]])\n left += 1\n right -= 1\n elif current_sum < n:\n left += 1\n else:\n right -= 1\n \n return ans\n ","memory":"30300"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n < 4:\n return []\n \n if n % 2 == 1:\n n -= 2\n for p in range(2, round(n ** 0.5) + 1):\n if n % p == 0:\n return []\n return [[2, n]]\n \n def get_all_primes(m):\n is_primes = [True] * (m + 1)\n is_primes[0] = is_primes[1] = False\n for i in range(2, round(m ** 0.5) + 1):\n if is_primes[i]:\n step = 2 if i == 2 else 2 * i\n for j in range(i ** 2, m + 1, step):\n is_primes[j] = False\n return [\n i\n for i, is_prime in enumerate(is_primes)\n if is_prime\n ]\n \n primes = get_all_primes(n)\n j = len(primes) - 1\n\n result = []\n for i, prime in enumerate(primes):\n if 2 * prime > n:\n break\n while i <= j and prime + primes[j] > n:\n j -= 1\n if prime + primes[j] == n:\n result.append([prime, primes[j]])\n return result","memory":"30400"},{"code":"isPrime = [True for i in range(10**6+5)]\nprimes = []\nfor i in range(2, len(isPrime)):\n if isPrime[i]:\n primes.append(i)\n for j in range(2*i, len(isPrime), i):\n isPrime[j] = False\n\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n for p in primes:\n if p > n//2:\n break\n if isPrime[n-p]:\n ans.append((p, n-p))\n return ans","memory":"30500"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n \n def get_primes(n):\n p = 3\n sieve = [1 for _ in range(n+1)]\n while p*p <= n:\n if sieve[p]:\n for x in range(p*p, n+1, 2*p):\n sieve[x] = 0\n p += 2\n ret = [2]\n for i in range(3, n+1, 2):\n if sieve[i]:\n ret.append(i)\n return ret\n PRIMES = get_primes(n)\n \n output = []\n\n i = 0\n j = len(PRIMES) - 1\n\n while i <= j:\n if PRIMES[i] + PRIMES[j] > n:\n j -= 1\n elif PRIMES[i] + PRIMES[j] < n:\n i += 1\n else:\n output.append([PRIMES[i], PRIMES[j]])\n i += 1\n j -= 1\n return output","memory":"30700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n l = 1 \n r = n - 1\n res = []\n\n def sieve_of_eratosthenes(n):\n primes = [True] * (n + 1)\n primes[0] = primes[1] = False # 0 and 1 are not prime numbers\n\n p = 2\n while p * p <= n:\n if primes[p]:\n for i in range(p * p, n + 1, p):\n primes[i] = False\n p += 1\n\n result = [p for p in range(2, n + 1) if primes[p]]\n return result\n\n dic = set(sieve_of_eratosthenes(n))\n while l <= (n//2):\n if l in dic and n - l in dic:\n res.append([l, n - l])\n l += 1 \n return res \n\n ","memory":"30800"},{"code":"from typing import List\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = self.sieve_of_eratosthenes(n)\n prime_set = set(primes)\n prime_pairs = []\n\n for prime in primes:\n if prime > n // 2:\n break\n if n - prime in prime_set:\n prime_pairs.append([prime, n - prime])\n \n return prime_pairs\n\n def sieve_of_eratosthenes(self, limit: int) -> List[int]:\n is_prime = [True] * (limit + 1)\n is_prime[0] = is_prime[1] = False\n for number in range(2, int(limit ** 0.5) + 1):\n if is_prime[number]:\n for multiple in range(number * number, limit + 1, number):\n is_prime[multiple] = False\n return [num for num, prime in enumerate(is_prime) if prime]\n","memory":"30900"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n def sieve_of_eratosthenes(limit):\n prime = [True] * (limit + 1)\n p = 2\n while (p * p <= limit):\n if prime[p]:\n for i in range(p * p, limit + 1, p):\n prime[i] = False\n p += 1\n prime_numbers = [p for p in range(2, limit + 1) if prime[p]]\n return prime_numbers\n \n if n < 4:\n return []\n \n primes = sieve_of_eratosthenes(n)\n prime_set = set(primes)\n pairs = []\n \n for x in primes:\n y = n - x\n if y in prime_set and x <= y:\n pairs.append([x, y])\n \n return pairs\n\n# Example usage:\nsolution = Solution()\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [5, 5]]\nprint(solution.findPrimePairs(2)) # Output: []","memory":"31000"},{"code":"from typing import List\nfrom math import isqrt\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 2:\n return []\n\n def primenumber(n):\n is_prime = [True] * n\n is_prime[0] = False\n is_prime[1] = False\n for i in range(2, isqrt(n) + 1):\n if is_prime[i]:\n for x in range(i * i, n, i):\n is_prime[x] = False\n primes = [i for i in range(n) if is_prime[i]]\n return primes\n \n primes = primenumber(n)\n target = n\n dic = {}\n res = []\n \n # Add all primes to the dictionary for fast lookup\n for prime in primes:\n dic[prime] = True\n \n # Find pairs\n for prime in primes:\n complement = target - prime\n if complement in dic and complement >= prime:\n res.append([prime, complement])\n \n return res\n\n# Example usage\nsolution = Solution()\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [7, 3]]\n","memory":"31100"},{"code":"mx = 10**6 + 1\nprimes = []\nis_prime = [True]*mx\nfor i in range(2, mx):\n if is_prime[i]:\n primes.append(i)\n for j in range(i*i, mx, i):\n is_prime[j] = False\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n % 2:\n return [[2, n-2]] if n > 4 and is_prime[n-2] else []\n ans = []\n for x in primes:\n y = n-x\n if y < x:\n break\n if is_prime[y]:\n ans.append([x, y])\n return ans\n ","memory":"31300"},{"code":"# Step 1: Construct a Sieve of Eratosthenes to identify prime numbers up to 1,000,000.\n# This will help us quickly check if a number is prime.\n\nprimes = [False, False] + [True] * 999_999 # Initialize a list where index represents the number.\n # False means not prime, True means prime.\n\n# Step 2: Implement the Sieve of Eratosthenes.\nfor i in range(2, 1001): # Only need to check up to the square root of 1,000,000.\n if primes[i]: # If i is a prime number,\n for j in range(i * i, 1_000_000, i): # Mark all multiples of i as not prime.\n primes[j] = False\n\n# Step 3: Define the solution class and method to find prime pairs.\nfrom typing import List\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n # Step 4: Handle edge cases.\n if n < 4: # If n is less than 4, no prime pairs can exist.\n return []\n\n # Step 5: Handle specific cases where n is even or n equals 4.\n if n % 2 or n == 4: # If n is odd or n is exactly 4,\n return [[2, n - 2]] if primes[n - 2] else [] # Check if n-2 is prime and return the pair [2, n-2].\n\n # Step 6: Find all prime pairs [x, y] such that x + y = n.\n return [[i, n - i] for i in range(3, (n + 3) // 2) # Iterate over possible x values.\n if primes[i] and primes[n - i]] # Check if both x and n-x are prime.\n\n# Explanation:\n# - We first create a list `primes` to determine the primality of numbers up to 1,000,000 using the Sieve of Eratosthenes.\n# - The `findPrimePairs` method checks for edge cases and then finds pairs of prime numbers that sum to n.\n# - The list comprehension iterates over possible values of x, checking if both x and n-x are prime.\n# - The solution efficiently finds prime pairs by leveraging the precomputed list of prime numbers.","memory":"31700"},{"code":"def getSieve(n: int) -> int:\n sqrt_n = int(sqrt(n))\n # print('srqrt_n: ', sqrt_n)\n sieve = [0, 0] + [1]*(n - 2)\n\n k = 2\n while k <= sqrt_n:\n if sieve[k]:\n multiple = k * k\n # print('k: ', k, ' multiple: ', multiple)\n while multiple < n:\n sieve[multiple] = 0\n multiple += k\n k += 1 if k == 2 else 2\n\n # print(self.sieve)\n return sieve \nprimes = [i for i,val in enumerate(getSieve(1000000)) if val == 1]\nprime_set = set(primes)\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res = []\n search_limit = n // 2\n for prime in primes:\n if prime > search_limit: break\n if n - prime in prime_set:\n res.append([prime, n - prime])\n return res","memory":"31800"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n def sieve_of_eratosthenes(n):\n is_prime = [True for _ in range(n+1)]\n is_prime[1] = False\n primes = set()\n for i in range(1, n+1):\n if (not is_prime[i]):\n continue\n primes.add(i)\n for j in range(i, n+1, i):\n is_prime[j] = False\n return primes\n \n primes = sieve_of_eratosthenes(n)\n pairs = list()\n seen = set()\n primes_ordered = sorted(primes)\n for prime in primes_ordered:\n diff = (n - prime)\n if (not diff in primes):\n continue\n elif (prime in seen):\n continue\n seen.add(diff)\n pairs.append([prime, diff])\n return pairs\n","memory":"32500"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n\n def sieve_of_eratosthenes(n):\n \"\"\"\n Helper function to generate all primes <= n\n \"\"\"\n\n ub = math.ceil(n**0.5)\n is_prime = [True for _ in range(n+1)]\n\n for i in range(2, ub+1):\n if is_prime[i]:\n for p in range(2*i, n+1, i):\n is_prime[p] = False\n \n primes = set()\n for i in range(2, n+1):\n if is_prime[i]:\n primes.add(i)\n \n return primes\n \n primes = sieve_of_eratosthenes(n)\n answer = []\n for i in range(n+1):\n if i in primes and n - i in primes:\n primes.remove(n-i)\n answer.append([i, n-i])\n \n return answer","memory":"32900"},{"code":"import math\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n def create_set(num):\n prime_numbers = set()\n prime = [True for i in range(num + 1)]\n sqrt_num = math.floor(math.sqrt(num))\n \n for multip in range(2, sqrt_num + 1):\n if prime[multip]:\n for i in range(multip**2, num + 1, multip):\n prime[i] = False\n \n for i in range(2, num + 1):\n if prime[i]: prime_numbers.add(i)\n \n return prime_numbers\n \n prime_set = create_set(n)\n results = []\n for i in range(2, n // 2 + 1):\n complement = n - i\n if i in prime_set and complement in prime_set:\n results.append([i, complement])\n \n return results\n \n \n \n \n ","memory":"33100"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n def isPrime(n):\n if n <= 1:\n return False\n elif n == 2:\n return True\n elif n % 2 == 0:\n return False\n else:\n for i in range(3, int(n**0.5)+1, 2):\n if n % i == 0:\n return False\n return True\n\n\n result = []\n \n for div in get_primes_numpy(n // 2 + 1):\n \n if isPrime(n - div): result.append([div, n - div])\n\n\n return result","memory":"33200"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n res = []\n primes = self.sieve_of_eratosthenes(n)\n for i in range(2, n//2+1):\n if i in primes and n-i in primes:\n res.append([i, n-i])\n return res\n\n def sieve_of_eratosthenes(self, n):\n prime = [True for _ in range(n + 1)]\n p = 2\n while p * p <= n:\n if prime[p]:\n for i in range(p * p, n + 1, p):\n prime[i] = False\n p += 1\n primes = set(p for p in range(2, n + 1) if prime[p])\n return primes\n ","memory":"33300"},{"code":"import math\nclass Solution:\n \n def get_primes(self,n):\n primes=[1]*(n+1)\n \n primes[0]=0\n primes[1]=0\n \n end=math.ceil(math.sqrt(n))\n for i in range(2,end+1):\n if primes[i]==1:\n for k in range(i*2,n,i):\n primes[k]=0\n\n return primes\n\n \n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes=self.get_primes(n)\n result=[]\n for i in range(2,(n//2)+1):\n \n if primes[i]==1:\n if n-i>=i :\n if primes[n-i]==1:\n result.append((i,n-i))\n else:\n break\n \n return result","memory":"33400"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [1] * (n+1)\n primes[0] = primes[1] = 0\n i = 2\n while i ** 2 <= n:\n if primes[i]:\n for j in range(i*2, n+1, i):\n primes[j] = 0\n i += 1\n \n ans = []\n for i in range(2, n//2+1):\n if primes[i] and primes[n-i]:\n ans.append([i, n-i])\n return ans\n","memory":"33500"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n dp = [True] * (n + 1)\n dp[0] = dp[1] = False \n for i in range(2, int(n**0.5) + 1):\n if dp[i]: # If i is a prime\n for j in range(i*i, n + 1, i): \n dp[j] = False\n val = n//2\n ans = []\n for i in range(2,val+1):\n if (dp[i] and dp[n-i]):\n ans.append([i,n-i])\n return ans\n ","memory":"33600"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = []\n allNumbers =[True]*(n+1)\n allNumbers[0] = False\n allNumbers[1] = False\n index = 2\n while index <= n:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex <= n):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.insert(0, [n-index, index])\n\n index+=1\n\n return toReturn\n\n\n\n\n ","memory":"33700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n #toReturn = deque()\n toReturn = []\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex < n - 1):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n #toReturn.appendleft([n-index, index])\n toReturn.append([n-index, index])\n\n index+=1\n reversed_list = toReturn[::-1]\n return reversed_list\n\n\n\n\n ","memory":"33700"},{"code":"class Solution:\n def findPrimePairs(self, n: int):\n if n <= 3:\n return []\n\n # Step 1: Use the Sieve of Eratosthenes to find all primes <= n\n primes = [True] * (n + 1)\n primes[0] = primes[1] = False\n\n for i in range(2, int(n**0.5) + 1):\n if primes[i]:\n for j in range(i * i, n + 1, i):\n primes[j] = False\n\n # Step 2: Find all prime pairs that sum to n\n result = []\n for i in range(2, n // 2 + 1):\n if primes[i] and primes[n - i]:\n result.append([i, n - i])\n\n return result\n","memory":"33800"},{"code":"def sieveErastothenes(n: int):\n sieve = [True for i in range(n+1)]\n sieve[0] = False\n sieve[1] = False\n p = 2\n while p*p <= n:\n if sieve[p]:\n for i in range(p*p, n+1, p):\n sieve[i] = False\n p += 1\n return sieve\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1 or n==2: return []\n if n == 4: return [[2,2]]\n sieve = sieveErastothenes(n)\n if n%2 == 1:\n if sieve[n-2]: return [[2,n-2]]\n else:\n res = []\n for x in range(3,n//2+1):\n if sieve[x] and sieve[n-x]:\n res.append([x,n-x])\n return res","memory":"33900"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n result = []\n allPrimes = get_primes_numpy(n) \n left = 0\n right = len(allPrimes) - 1\n\n while left <= right:\n sm = allPrimes[left] + allPrimes[right] \n if sm > n:\n right -= 1\n elif sm == n:\n result.append([allPrimes[left], allPrimes[right]])\n left += 1\n else:\n left += 1\n\n\n return result","memory":"34300"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n result = []\n allPrimes = get_primes_numpy(n) \n left = 0\n right = len(allPrimes) - 1\n\n while left <= right:\n sm = allPrimes[left] + allPrimes[right] \n if sm > n:\n right -= 1\n elif sm == n:\n result.append([allPrimes[left], allPrimes[right]])\n left += 1\n else:\n left += 1\n\n\n return result","memory":"34600"},{"code":"import numpy\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n\n def get_primes_numpy(n):\n sieve = numpy.ones(n // 2, dtype=bool)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if sieve[i // 2]:\n sieve[i * i // 2::i] = False\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\n\n\n result = []\n allPrimes = get_primes_numpy(n) \n left = 0\n right = len(allPrimes) - 1\n\n while left <= right:\n sm = allPrimes[left] + allPrimes[right] \n if sm > n:\n right -= 1\n elif sm == n:\n result.append([allPrimes[left], allPrimes[right]])\n left += 1\n else:\n left += 1\n\n\n return result","memory":"34700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prime = [False, False] + [True]*(n-1)\n for i in range(2, n+1):\n if prime[i]:\n for j in range(i*i, n+1, i):\n prime[j] = False\n \n res = []\n for i in range(2, 1+(n//2)):\n if prime[i] and prime[n-i]:\n res.append((i,n-i))\n return res","memory":"35100"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n prm={}\n def SieveOfEratosthenes(num):\n prime = [True for i in range(num+1)]\n # boolean array\n p = 2\n while (p * p <= num):\n \n # If prime[p] is not\n # changed, then it is a prime\n if (prime[p] == True):\n \n # Updating all multiples of p\n for i in range(p * p, num+1, p):\n prime[i] = False\n p += 1\n \n # Print all prime numbers\n for p in range(2, num+1):\n if prime[p]:\n prm[p]=1\n SieveOfEratosthenes(n)\n ans=[]\n used={}\n for i in prm:\n if n-i in prm:\n if i not in used and n-i not in used:\n x=[i,n-i]\n ans.append(x)\n used[i]=1\n used[n-i]=1 \n return ans\n\n ","memory":"35400"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = [True for _ in range(n+1)]\n\n\n primes[0] = primes[1] = False\n\n nums = []\n for i in range(2,int(n**0.5)+1):\n if primes[i]==True:\n for j in range(i*i,n+1,i):\n primes[j] = False\n \n for i in range(len(primes)):\n if primes[i]==True:\n nums.append(i)\n \n res = []\n\n l = 0\n r = len(nums)-1\n\n while l<=r:\n if nums[l] + nums[r]==n:\n res.append([nums[l],nums[r]])\n l += 1\n r -= 1\n elif nums[l] + nums[r] < n:\n l += 1\n else:\n r -= 1\n\n #print(nums)\n\n return res","memory":"35500"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n primes = []\n template = [0] * n\n for p in range(2, n+1):\n if template[p-1] == 0:\n primes.append(p)\n for m in range(p-1, n, p):\n template[m] = 1\n\n res = []\n\n l, r = 0, len(primes)-1\n\n while l <= r:\n if primes[l] + primes[r] > n:\n r -= 1\n elif primes[l] + primes[r] < n:\n l += 1\n else:\n res.append([primes[l], primes[r]])\n l += 1\n r -= 1\n\n return res ","memory":"35600"},{"code":"from collections import deque\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n toReturn = deque()\n allNumbers =[True]*(n+1)\n index = 2\n while index < n - 1:\n if allNumbers[index]:\n multiplier = 2\n subindex = index*multiplier\n while(subindex < n - 1):\n allNumbers[subindex] = False\n multiplier+=1\n subindex = index*multiplier\n if index >= n/2 and allNumbers[n-index]:\n toReturn.appendleft([n-index, index])\n\n index+=1\n\n return list(toReturn)\n\n\n\n\n ","memory":"35700"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n \n if n==1 or n==2:\n return []\n \n isprime=[True]*(n)\n isprime[0]=isprime[1]=False\n \n for i in range(2,n):\n if isprime:\n for j in range(i*i,n,i):\n isprime[j]=False\n \n \n c=0\n l=[]\n for i in range(n):\n if isprime[i]:\n l.append(i)\n l1=[]\n d={}\n for i,x in enumerate(l):\n # example 5*5=10 right, it should not be like that\n if (2*l[i])!=n:\n if n-x in d:\n l1.append([n-x,x])\n else:\n d[x]=x\n else:\n l1.append([x,n-x])\n l1.sort(key=lambda x:x[0])\n return l1\n ","memory":"35800"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n arr = [1 for i in range(n+1)]\n arr[0] = 0\n arr[1] = 0\n ans = []\n for p in range(2,n+1):\n if arr[p]==1:\n ans.append(p)\n k = p*p\n while k<(n+1):\n arr[k]=0\n k+=p\n # print(ans)\n i = 0 \n j = len(ans)-1\n fin = []\n while i<=j:\n ct = ans[i]+ans[j]\n if ct==n:\n fin.append([ans[i],ans[j]])\n i+=1\n j-=1\n elif ct < n:\n i+=1\n else:\n j-=1\n return fin\n ","memory":"35900"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n s=set()\n l1=[]\n primes=[True]*(n+1)\n prime_num=set()\n primes[0]=primes[1]=False\n p=2\n while p*p<=n:\n if primes[p]:\n for i in range(p*p,n+1,p):\n primes[i]=False\n\n p+=1\n \n for p in range(2,n+1):\n if primes[p]:\n prime_num.add(p)\n\n for num in prime_num:\n if n-num in prime_num:\n l1=[num,n-num]\n l1.sort()\n s.add(tuple(l1))\n\n if s:\n return sorted(list(s))\n else:\n return []\n\n\n \n\n \n\n \n ","memory":"36300"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes = set()\n nums = [True for _ in range(n)]\n p = 2\n while p < n:\n if nums[p]:\n primes.add(p)\n for i in range(p * p, n, p):\n nums[i] = False\n p += 1\n \n result = []\n for i in range(2, n // 2 + 1):\n if i in primes and n - i in primes:\n result.append([i, n - i])\n return result","memory":"36400"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n s=set()\n l1=[]\n primes=[True]*(n+1)\n prime_num=set()\n primes[0]=primes[1]=False\n p=2\n while p*p<=n:\n if primes[p]:\n for i in range(p*p,n+1,p):\n primes[i]=False\n\n p+=1\n for p in range(2,n+1):\n if primes[p]:\n prime_num.add(p)\n\n for num in prime_num:\n if n-num in prime_num:\n l1=[num,n-num]\n l1.sort()\n s.add(tuple(l1))\n\n if s:\n return sorted(list(s))\n else:\n return []\n\n\n \n\n \n\n \n ","memory":"36900"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrime = [False, False] + [True] * (n - 2)\n\n for p in range(2, int(sqrt(n)) + 1):\n if not isPrime[p]:\n continue\n\n for multiple in range(p**2, n, p):\n isPrime[multiple] = False\n \n primes = set([i for i in range(n) if isPrime[i]])\n res = set()\n for p in primes:\n if n - p in primes:\n pair = tuple(sorted([p, n-p]))\n res.add(pair)\n return sorted(list(res))\n ","memory":"37100"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrime = [False, False] + [True] * (n - 2)\n\n for p in range(2, int(sqrt(n)) + 1):\n if not isPrime[p]:\n continue\n\n for multiple in range(p**2, n, p):\n isPrime[multiple] = False\n \n primes = [i for i in range(n) if isPrime[i]]\n l, r, = 0, len(primes) - 1\n res = []\n\n while l <= r:\n if primes[l] + primes[r] > n:\n r -= 1\n elif primes[l] + primes[r] < n:\n l += 1\n else:\n res.append([primes[l], primes[r]])\n l += 1\n r -= 1\n return res\n ","memory":"37200"},{"code":"class Solution:\n\n def eratosthenes_sieve(self, n):\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\n for p in range(3, sqrt_n, 2):\n if prime[p]:\n result.append(p)\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\n\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes_list = self.eratosthenes_sieve(n + 1)\n primes_set = set(primes_list)\n res = []\n for p in primes_list:\n if p > n - p:\n break\n if n - p in primes_set:\n res.append([p, n - p])\n return res","memory":"37300"},{"code":"class Solution:\n\n def eratosthenes_sieve(self, n):\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\n for p in range(3, sqrt_n, 2):\n if prime[p]:\n result.append(p)\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\n\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\n\n def findPrimePairs(self, n: int) -> List[List[int]]:\n primes_list = self.eratosthenes_sieve(n + 1)\n primes_set = set(primes_list)\n res = []\n for p in primes_list:\n if p > n - p:\n break\n if n - p in primes_set:\n res.append([p, n - p])\n return res","memory":"37400"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrimes=[True]*(n+1)\n isPrimes[0]=False\n if n>=1:\n isPrimes[1]=False\n res=[]\n for i in range(2,math.ceil(math.sqrt(n))+1):\n if isPrimes[i]:\n for j in range(i*i,n+1,i):\n if isPrimes[j]:\n isPrimes[j]=False\n\n primes=set() #stores all prime numbers less than n\n for i in range(len(isPrimes)):\n if isPrimes[i]:\n primes.add(i)\n\n res=set()\n for i in primes:\n # through this logic we are not making duplicates\n if n-i<=i and n-i in primes: \n res.add((n-i,i))\n x=sorted(res)\n return x\n\n\n ","memory":"37500"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n isPrimes=[True]*(n+1)\n isPrimes[0]=False\n if n>=1:\n isPrimes[1]=False\n res=[]\n for i in range(2,math.ceil(math.sqrt(n))+1):\n if isPrimes[i]:\n for j in range(i*i,n+1,i):\n if isPrimes[j]:\n isPrimes[j]=False\n primes=set()\n for i in range(len(isPrimes)):\n if isPrimes[i]:\n primes.add(i)\n res=set()\n for i in primes:\n if n-i<=i and n-i in primes:\n res.add((n-i,i))\n x=sorted(res)\n return x\n\n\n ","memory":"37600"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n s=set()\n l1=[]\n primes=[True]*(n+1)\n prime_num=set()\n primes[0]=primes[1]=False\n p=2\n while p*p<=n:\n #if primes[p]:\n for i in range(p*p,n+1,p):\n primes[i]=False\n\n p+=1\n for p in range(2,n+1):\n if primes[p]:\n prime_num.add(p)\n\n for num in prime_num:\n if n-num in prime_num:\n l1=[num,n-num]\n l1.sort()\n s.add(tuple(l1))\n\n if s:\n return sorted(list(s))\n else:\n return []\n\n\n \n\n \n\n \n ","memory":"37700"},{"code":"def sieve(n):\n primes = []\n nums = [0, 0] + [1] * (n-2)\n\n i = 2\n while i * i < n:\n if nums[i]:\n for j in range(2*i, n, i):\n nums[j] = 0\n i += 1\n \n for i in range(n):\n if nums[i] == 1:\n primes.append(i)\n\n return primes\n\nclass Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n ans = []\n primes = sieve(n)\n p = set(primes)\n \n \n for i in range(2, n//2 + 1):\n if (i in p) and (n-i) in p:\n ans.append([i, n-i])\n \n return ans\n \n \n \n ","memory":"37900"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n sub[n-p] = p\n if sub.get(p) is not None:\n res.insert(0,[sub.get(p), p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","memory":"38000"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n == 1:\n return []\n res = []\n sub = {}\n template = [0] * n\n for p in range(2, n + 1):\n if template[p - 1] == 0:\n sub[n-p] = p\n test = sub.get(p)\n if test is not None:\n res.insert(0,[test, p])\n for m in range(p - 1, n, p):\n template[m] = 1\n\n return res ","memory":"38000"},{"code":"class Solution:\n def findPrimePairs(self, n: int) -> List[List[int]]:\n if n <= 3:\n return []\n primes = [True] * n\n i = 2\n while i * i < n:\n if primes[i]:\n for j in range(i * i, n, i):\n primes[j] = False\n i += 1\n ps = [i for i, e in enumerate(primes) if e and i > 1]\n primes = set(ps)\n # print(primes)\n res = []\n for p in primes:\n if p <= n - p and n - p in primes:\n res.append([p, n - p])\n return sorted(res)","memory":"38100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def isPrime(v):\\n upper = math.floor(math.sqrt(v)) + 1\\n if v < 2:\\n return False\\n if v == 2:\\n return True\\n if v % 2 == 0:\\n return False\\n for c in range(3, upper, 2):\\n if v%c == 0:\\n return False\\n \\n return True\\n if n <=2:\\n return []\\n\\n if n % 2 == 1:\\n if isPrime(n-2):\\n return [[2, n-2]]\\n return []\\n\\n upper = n//2 + 1\\n res = []\\n for i in range(2,upper):\\n # print(i)\\n if isPrime(i) and isPrime(n-i):\\n res.append([i, n-i])\\n # print(res)\\n return res\\n \\n \\n \",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n # list all prime numbers up to sqrt n\\n def gcd(a, b):\\n if a < b:\\n a,b = b,a\\n while b > 0:\\n a,b = b, a%b\\n return a\\n prod, primes = 1, []\\n for i in range(2, int(sqrt(n)) + 1):\\n if gcd(i, prod) == 1:\\n primes.append(i)\\n prod *= i\\n def isPrime(n):\\n for prime in primes:\\n if prime > sqrt(n):\\n return True\\n if not n % prime:\\n return False\\n return True\\n \\n if n%2:\\n # there are only one way two prime numbers could have odd sum i.e. 2 and another prime number\\n if n < 5:\\n return False\\n if isPrime(n-2):\\n return [[2,n-2]]\\n else:\\n return []\\n\\n\\n pairs = []\\n for prime in primes:\\n if isPrime(n-prime):\\n pairs.append([prime, n-prime])\\n if primes[-1] == 2:\\n start = 3\\n else:\\n start = primes[-1] +2\\n for nn in range(start, n//2 + 1, 2):\\n if isPrime(nn) and isPrime(n-nn):\\n pairs.append([nn,n-nn])\\n return pairs\\n\\n\\n \",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"import array\\ndef sieve_of_eratosthenes(n):\\n if n < 2:\\n return []\\n is_prime = bytearray((1,))*(n+1)\\n is_prime[0] = is_prime[1] = 0\\n for i in range(2, int(n**0.5) + 1):\\n if is_prime[i]:\\n for j in range(i * i, n + 1, i):\\n is_prime[j] = 0\\n primes = array.array('i',(i for i in range(n + 1) if is_prime[i]))\\n return primes\\n\\nPRIMES = sieve_of_eratosthenes(1000000)\\n\\nPS = set(PRIMES)\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n out = []\\n for p in PRIMES:\\n np=n-p\\n if p<=np and np in PS:\\n out.append((p,np))\\n if p >= np:\\n return out\",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"def is_prime(n):\\n if n == 2 or n == 3: return True\\n if n < 2 or n%2 == 0: return False\\n if n < 9: return True\\n if n%3 == 0: return False\\n if (n - 1) % 6 != 0 and (n+1) % 6 !=0:\\n return False\\n r = int(n**0.5)\\n # since all primes > 3 are of the form 6n ± 1\\n # start with f=5 (which is prime)\\n # and test f, f+2 for being prime\\n # then loop by 6. \\n f = 5\\n while f <= r:\\n\\n if n % f == 0: return False\\n if n % (f+2) == 0: return False\\n f += 6\\n return True \\ndef sieve_of_eratosthenes(n):\\n primes = [True] * (n+1)\\n p = 2\\n while (p * p <= n):\\n if (primes[p] == True):\\n for i in range(p * p, n+1, p):\\n primes[i] = False\\n p += 1\\n prime_numbers = [p for p in range(2, n) if primes[p]]\\n return prime_numbers\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 2:\\n return []\\n # Find all prime numbers\\n # Iterate list and see if its mirror is present in the prime list\\n #when you do n - x\\n\\n #primes = [x for x in range(1, n//2+1) if is_prime(x)]\\n primes = sieve_of_eratosthenes(n//2+1)\\n \\\"\\\"\\\"hold = [x for x in range(2, n//2+1)][::-1]\\n primes = []\\n while len(hold) > 0:\\n x = hold.pop()\\n primes.append(x)\\n hold = [y for y in hold if y % x != 0]\\\"\\\"\\\"\\n\\n out = []\\n for x in primes:\\n a = n-x\\n if is_prime(a):\\n out.append([x, a])\\n return out\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n # these two functions are from IterTools Recipes:\\n # https://docs.python.org/3/library/itertools.html\\n\\n import contextlib\\n\\n def iter_index(iterable, value, start=0, stop=None):\\n \\\"Return indices where a value occurs in a sequence or iterable.\\\"\\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\\n seq_index = getattr(iterable, 'index', None)\\n if seq_index is None:\\n iterator = islice(iterable, start, stop)\\n for i, element in enumerate(iterator, start):\\n if element is value or element == value:\\n yield i\\n else:\\n stop = len(iterable) if stop is None else stop\\n i = start\\n with contextlib.suppress(ValueError):\\n while True:\\n yield (i := seq_index(value, i, stop))\\n i += 1\\n\\n def sieve(n):\\n \\\"Primes less than n.\\\"\\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\\n if n > 2:\\n yield 2\\n data = bytearray((0, 1)) * (n // 2)\\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\\n yield from iter_index(data, 1, start=3)\\n\\n primes = set(sieve(n))\\n\\n return [\\n [P, n - P]\\n for P in sorted(primes)\\n if P <= (n - P) and (n - P) in primes\\n ]\\n\",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n # these two functions are from IterTools Recipes:\\n # https://docs.python.org/3/library/itertools.html\\n\\n import contextlib\\n\\n def iter_index(iterable, value, start=0, stop=None):\\n \\\"Return indices where a value occurs in a sequence or iterable.\\\"\\n # iter_index('AABCADEAF', 'A') → 0 1 4 7\\n seq_index = getattr(iterable, 'index', None)\\n if seq_index is None:\\n iterator = islice(iterable, start, stop)\\n for i, element in enumerate(iterator, start):\\n if element is value or element == value:\\n yield i\\n else:\\n stop = len(iterable) if stop is None else stop\\n i = start\\n with contextlib.suppress(ValueError):\\n while True:\\n yield (i := seq_index(value, i, stop))\\n i += 1\\n\\n def sieve(n):\\n \\\"Primes less than n.\\\"\\n # sieve(30) → 2 3 5 7 11 13 17 19 23 29\\n if n > 2:\\n yield 2\\n data = bytearray((0, 1)) * (n // 2)\\n for p in iter_index(data, 1, start=3, stop=math.isqrt(n) + 1):\\n data[p*p : n : p+p] = bytes(len(range(p*p, n, p+p)))\\n yield from iter_index(data, 1, start=3)\\n\\n primes = set(sieve(n))\\n\\n return [\\n [P, n - P]\\n for P in sorted(primes)\\n if P <= (n - P) and (n - P) in primes\\n ]\\n\",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"def get_primes(num):\\n primes = [True] * (num + 1)\\n for x in range(2, num + 1):\\n if primes[x]:\\n for y in range(x*x, num + 1, x):\\n primes[y] = False\\n return primes\\n\\nprimes = get_primes(1000000)\\n \\n \\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n res = []\\n for left in range(2, n // 2 + 1):\\n right = n - left\\n if primes[left] and primes[right]:\\n res.append([left, right])\\n return res\\n \",\n \"memory\": \"28400\"\n },\n {\n \"code\": \"pr = [1 for i in range(10**6+1)]\\np = 2\\nwhile p*p<10**6+1:\\n if pr[p]:\\n for i in range(2*p, 10**6+1, p):\\n pr[i] = 0\\n p +=1\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n for i in range(2, n//2+1):\\n if pr[i] and pr[n-i]:\\n ans.append([i, n-i])\\n return ans\",\n \"memory\": \"28600\"\n },\n {\n \"code\": \"limit = 10 ** 6\\nprimes = [True] * (limit + 1)\\n\\nprimes[0] = False\\nprimes[1] = False\\n\\nfor i in range(2, limit + 1):\\n if primes[i]:\\n nextNum = 2 * i\\n while nextNum <= limit:\\n primes[nextNum] = False\\n nextNum += i\\n\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n global primes\\n\\n res = []\\n for x in range(1, n // 2 + 1):\\n if not primes[x]:\\n continue\\n \\n y = n - x\\n\\n if not primes[y]:\\n continue\\n \\n res.append([x, y])\\n\\n return res\\n \",\n \"memory\": \"28700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def generate_primes(n):\\n isprime = [True] * (n + 1)\\n isprime[0] = isprime[1] = False\\n \\n for i in range(2, int(n ** 0.5) + 1):\\n if isprime[i]:\\n for j in range(i * i, n + 1, i):\\n isprime[j] = False\\n\\n primes = [i for i in range(2, n + 1) if isprime[i]]\\n return primes\\n \\n prime = generate_primes(n)\\n l,r=0,len(prime)-1\\n ans =[]\\n while(l<=r):\\n if prime[l]+ prime[r] == n:\\n ans.append([prime[l],prime[r]])\\n l+=1\\n r-=1\\n elif prime[l]+ prime[r] <n:\\n l+=1\\n else:\\n r-=1\\n return ans\",\n \"memory\": \"29000\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n def is_prime(num):\\n if num <= 2 or num % 2 == 0:\\n return num == 2\\n for d in range(3, isqrt(num) + 1, 2):\\n if num % d == 0:\\n return False\\n return True\\n\\n def find_primes(num):\\n num += 1 # to include 0\\n primes = [True] * num\\n primes[0] = primes[1] = False\\n for p in range(2, max(3, isqrt(num) + 1)):\\n if not primes[p]:\\n continue\\n for kp in range(p * p, num, p):\\n primes[kp] = False\\n return primes\\n\\n ans = []\\n if 1 <= 2 <= n - 2 <= n:\\n if is_prime(n - 2):\\n ans.append([2, n - 2])\\n\\n if n % 2 == 1:\\n return ans\\n\\n primes = find_primes(n)\\n\\n for x in range(3, n // 2 + 1, 2):\\n y = n - x\\n #if x <= y and is_prime(x) and is_prime(y):\\n if x <= y and primes[x] and primes[y]:\\n ans.append([x, y])\\n return ans\\n\",\n \"memory\": \"29700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def generate_primes(n):\\n prime = [True]*(n+1)\\n prime[0] = prime[1] = False\\n p = 2\\n while p*p<=n:\\n if prime[p]:\\n for num in range(p*p,n+1,p):\\n prime[num] = False \\n p+=1\\n \\n ans = []\\n for i in range(2,n+1):\\n if prime[i]:\\n ans.append(i)\\n return ans\\n \\n prime = generate_primes(n)\\n l,r=0,len(prime)-1\\n ans =[]\\n while(l<=r):\\n if prime[l]+ prime[r] == n:\\n ans.append([prime[l],prime[r]])\\n l+=1\\n r-=1\\n elif prime[l]+ prime[r] <n:\\n l+=1\\n else:\\n r-=1\\n return ans\",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def get_prime(self,n):\\n dp=[True]*(n)\\n dp[0]=False\\n dp[1]=False\\n for i in range(2,int((n)**0.5)+1):\\n for j in range(i*i,n,i):\\n dp[j]=False\\n l=[]\\n for i in range(n):\\n if dp[i]:\\n l.append(i)\\n return l\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n \\n # Get all primes less than n\\n primes = self.get_prime(n)\\n ans = []\\n \\n # Use two-pointer technique to find pairs\\n left, right = 0, len(primes) - 1\\n while left <= right:\\n current_sum = primes[left] + primes[right]\\n if current_sum == n:\\n ans.append([primes[left], primes[right]])\\n left += 1\\n right -= 1\\n elif current_sum < n:\\n left += 1\\n else:\\n right -= 1\\n \\n return ans\\n \",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n < 4:\\n return []\\n \\n if n % 2 == 1:\\n n -= 2\\n for p in range(2, round(n ** 0.5) + 1):\\n if n % p == 0:\\n return []\\n return [[2, n]]\\n \\n def get_all_primes(m):\\n is_primes = [True] * (m + 1)\\n is_primes[0] = is_primes[1] = False\\n for i in range(2, round(m ** 0.5) + 1):\\n if is_primes[i]:\\n step = 2 if i == 2 else 2 * i\\n for j in range(i ** 2, m + 1, step):\\n is_primes[j] = False\\n return [\\n i\\n for i, is_prime in enumerate(is_primes)\\n if is_prime\\n ]\\n \\n primes = get_all_primes(n)\\n j = len(primes) - 1\\n\\n result = []\\n for i, prime in enumerate(primes):\\n if 2 * prime > n:\\n break\\n while i <= j and prime + primes[j] > n:\\n j -= 1\\n if prime + primes[j] == n:\\n result.append([prime, primes[j]])\\n return result\",\n \"memory\": \"30400\"\n },\n {\n \"code\": \"isPrime = [True for i in range(10**6+5)]\\nprimes = []\\nfor i in range(2, len(isPrime)):\\n if isPrime[i]:\\n primes.append(i)\\n for j in range(2*i, len(isPrime), i):\\n isPrime[j] = False\\n\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n for p in primes:\\n if p > n//2:\\n break\\n if isPrime[n-p]:\\n ans.append((p, n-p))\\n return ans\",\n \"memory\": \"30500\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n \\n def get_primes(n):\\n p = 3\\n sieve = [1 for _ in range(n+1)]\\n while p*p <= n:\\n if sieve[p]:\\n for x in range(p*p, n+1, 2*p):\\n sieve[x] = 0\\n p += 2\\n ret = [2]\\n for i in range(3, n+1, 2):\\n if sieve[i]:\\n ret.append(i)\\n return ret\\n PRIMES = get_primes(n)\\n \\n output = []\\n\\n i = 0\\n j = len(PRIMES) - 1\\n\\n while i <= j:\\n if PRIMES[i] + PRIMES[j] > n:\\n j -= 1\\n elif PRIMES[i] + PRIMES[j] < n:\\n i += 1\\n else:\\n output.append([PRIMES[i], PRIMES[j]])\\n i += 1\\n j -= 1\\n return output\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n l = 1 \\n r = n - 1\\n res = []\\n\\n def sieve_of_eratosthenes(n):\\n primes = [True] * (n + 1)\\n primes[0] = primes[1] = False # 0 and 1 are not prime numbers\\n\\n p = 2\\n while p * p <= n:\\n if primes[p]:\\n for i in range(p * p, n + 1, p):\\n primes[i] = False\\n p += 1\\n\\n result = [p for p in range(2, n + 1) if primes[p]]\\n return result\\n\\n dic = set(sieve_of_eratosthenes(n))\\n while l <= (n//2):\\n if l in dic and n - l in dic:\\n res.append([l, n - l])\\n l += 1 \\n return res \\n\\n \",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = self.sieve_of_eratosthenes(n)\\n prime_set = set(primes)\\n prime_pairs = []\\n\\n for prime in primes:\\n if prime > n // 2:\\n break\\n if n - prime in prime_set:\\n prime_pairs.append([prime, n - prime])\\n \\n return prime_pairs\\n\\n def sieve_of_eratosthenes(self, limit: int) -> List[int]:\\n is_prime = [True] * (limit + 1)\\n is_prime[0] = is_prime[1] = False\\n for number in range(2, int(limit ** 0.5) + 1):\\n if is_prime[number]:\\n for multiple in range(number * number, limit + 1, number):\\n is_prime[multiple] = False\\n return [num for num, prime in enumerate(is_prime) if prime]\\n\",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n def sieve_of_eratosthenes(limit):\\n prime = [True] * (limit + 1)\\n p = 2\\n while (p * p <= limit):\\n if prime[p]:\\n for i in range(p * p, limit + 1, p):\\n prime[i] = False\\n p += 1\\n prime_numbers = [p for p in range(2, limit + 1) if prime[p]]\\n return prime_numbers\\n \\n if n < 4:\\n return []\\n \\n primes = sieve_of_eratosthenes(n)\\n prime_set = set(primes)\\n pairs = []\\n \\n for x in primes:\\n y = n - x\\n if y in prime_set and x <= y:\\n pairs.append([x, y])\\n \\n return pairs\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [5, 5]]\\nprint(solution.findPrimePairs(2)) # Output: []\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"from typing import List\\nfrom math import isqrt\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 2:\\n return []\\n\\n def primenumber(n):\\n is_prime = [True] * n\\n is_prime[0] = False\\n is_prime[1] = False\\n for i in range(2, isqrt(n) + 1):\\n if is_prime[i]:\\n for x in range(i * i, n, i):\\n is_prime[x] = False\\n primes = [i for i in range(n) if is_prime[i]]\\n return primes\\n \\n primes = primenumber(n)\\n target = n\\n dic = {}\\n res = []\\n \\n # Add all primes to the dictionary for fast lookup\\n for prime in primes:\\n dic[prime] = True\\n \\n # Find pairs\\n for prime in primes:\\n complement = target - prime\\n if complement in dic and complement >= prime:\\n res.append([prime, complement])\\n \\n return res\\n\\n# Example usage\\nsolution = Solution()\\nprint(solution.findPrimePairs(10)) # Output: [[3, 7], [7, 3]]\\n\",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"mx = 10**6 + 1\\nprimes = []\\nis_prime = [True]*mx\\nfor i in range(2, mx):\\n if is_prime[i]:\\n primes.append(i)\\n for j in range(i*i, mx, i):\\n is_prime[j] = False\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n % 2:\\n return [[2, n-2]] if n > 4 and is_prime[n-2] else []\\n ans = []\\n for x in primes:\\n y = n-x\\n if y < x:\\n break\\n if is_prime[y]:\\n ans.append([x, y])\\n return ans\\n \",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"# Step 1: Construct a Sieve of Eratosthenes to identify prime numbers up to 1,000,000.\\n# This will help us quickly check if a number is prime.\\n\\nprimes = [False, False] + [True] * 999_999 # Initialize a list where index represents the number.\\n # False means not prime, True means prime.\\n\\n# Step 2: Implement the Sieve of Eratosthenes.\\nfor i in range(2, 1001): # Only need to check up to the square root of 1,000,000.\\n if primes[i]: # If i is a prime number,\\n for j in range(i * i, 1_000_000, i): # Mark all multiples of i as not prime.\\n primes[j] = False\\n\\n# Step 3: Define the solution class and method to find prime pairs.\\nfrom typing import List\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n # Step 4: Handle edge cases.\\n if n < 4: # If n is less than 4, no prime pairs can exist.\\n return []\\n\\n # Step 5: Handle specific cases where n is even or n equals 4.\\n if n % 2 or n == 4: # If n is odd or n is exactly 4,\\n return [[2, n - 2]] if primes[n - 2] else [] # Check if n-2 is prime and return the pair [2, n-2].\\n\\n # Step 6: Find all prime pairs [x, y] such that x + y = n.\\n return [[i, n - i] for i in range(3, (n + 3) // 2) # Iterate over possible x values.\\n if primes[i] and primes[n - i]] # Check if both x and n-x are prime.\\n\\n# Explanation:\\n# - We first create a list `primes` to determine the primality of numbers up to 1,000,000 using the Sieve of Eratosthenes.\\n# - The `findPrimePairs` method checks for edge cases and then finds pairs of prime numbers that sum to n.\\n# - The list comprehension iterates over possible values of x, checking if both x and n-x are prime.\\n# - The solution efficiently finds prime pairs by leveraging the precomputed list of prime numbers.\",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"def getSieve(n: int) -> int:\\n sqrt_n = int(sqrt(n))\\n # print('srqrt_n: ', sqrt_n)\\n sieve = [0, 0] + [1]*(n - 2)\\n\\n k = 2\\n while k <= sqrt_n:\\n if sieve[k]:\\n multiple = k * k\\n # print('k: ', k, ' multiple: ', multiple)\\n while multiple < n:\\n sieve[multiple] = 0\\n multiple += k\\n k += 1 if k == 2 else 2\\n\\n # print(self.sieve)\\n return sieve \\nprimes = [i for i,val in enumerate(getSieve(1000000)) if val == 1]\\nprime_set = set(primes)\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res = []\\n search_limit = n // 2\\n for prime in primes:\\n if prime > search_limit: break\\n if n - prime in prime_set:\\n res.append([prime, n - prime])\\n return res\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n def sieve_of_eratosthenes(n):\\n is_prime = [True for _ in range(n+1)]\\n is_prime[1] = False\\n primes = set()\\n for i in range(1, n+1):\\n if (not is_prime[i]):\\n continue\\n primes.add(i)\\n for j in range(i, n+1, i):\\n is_prime[j] = False\\n return primes\\n \\n primes = sieve_of_eratosthenes(n)\\n pairs = list()\\n seen = set()\\n primes_ordered = sorted(primes)\\n for prime in primes_ordered:\\n diff = (n - prime)\\n if (not diff in primes):\\n continue\\n elif (prime in seen):\\n continue\\n seen.add(diff)\\n pairs.append([prime, diff])\\n return pairs\\n\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n\\n def sieve_of_eratosthenes(n):\\n \\\"\\\"\\\"\\n Helper function to generate all primes <= n\\n \\\"\\\"\\\"\\n\\n ub = math.ceil(n**0.5)\\n is_prime = [True for _ in range(n+1)]\\n\\n for i in range(2, ub+1):\\n if is_prime[i]:\\n for p in range(2*i, n+1, i):\\n is_prime[p] = False\\n \\n primes = set()\\n for i in range(2, n+1):\\n if is_prime[i]:\\n primes.add(i)\\n \\n return primes\\n \\n primes = sieve_of_eratosthenes(n)\\n answer = []\\n for i in range(n+1):\\n if i in primes and n - i in primes:\\n primes.remove(n-i)\\n answer.append([i, n-i])\\n \\n return answer\",\n \"memory\": \"32900\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n def create_set(num):\\n prime_numbers = set()\\n prime = [True for i in range(num + 1)]\\n sqrt_num = math.floor(math.sqrt(num))\\n \\n for multip in range(2, sqrt_num + 1):\\n if prime[multip]:\\n for i in range(multip**2, num + 1, multip):\\n prime[i] = False\\n \\n for i in range(2, num + 1):\\n if prime[i]: prime_numbers.add(i)\\n \\n return prime_numbers\\n \\n prime_set = create_set(n)\\n results = []\\n for i in range(2, n // 2 + 1):\\n complement = n - i\\n if i in prime_set and complement in prime_set:\\n results.append([i, complement])\\n \\n return results\\n \\n \\n \\n \\n \",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n def isPrime(n):\\n if n <= 1:\\n return False\\n elif n == 2:\\n return True\\n elif n % 2 == 0:\\n return False\\n else:\\n for i in range(3, int(n**0.5)+1, 2):\\n if n % i == 0:\\n return False\\n return True\\n\\n\\n result = []\\n \\n for div in get_primes_numpy(n // 2 + 1):\\n \\n if isPrime(n - div): result.append([div, n - div])\\n\\n\\n return result\",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n res = []\\n primes = self.sieve_of_eratosthenes(n)\\n for i in range(2, n//2+1):\\n if i in primes and n-i in primes:\\n res.append([i, n-i])\\n return res\\n\\n def sieve_of_eratosthenes(self, n):\\n prime = [True for _ in range(n + 1)]\\n p = 2\\n while p * p <= n:\\n if prime[p]:\\n for i in range(p * p, n + 1, p):\\n prime[i] = False\\n p += 1\\n primes = set(p for p in range(2, n + 1) if prime[p])\\n return primes\\n \",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n \\n def get_primes(self,n):\\n primes=[1]*(n+1)\\n \\n primes[0]=0\\n primes[1]=0\\n \\n end=math.ceil(math.sqrt(n))\\n for i in range(2,end+1):\\n if primes[i]==1:\\n for k in range(i*2,n,i):\\n primes[k]=0\\n\\n return primes\\n\\n \\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes=self.get_primes(n)\\n result=[]\\n for i in range(2,(n//2)+1):\\n \\n if primes[i]==1:\\n if n-i>=i :\\n if primes[n-i]==1:\\n result.append((i,n-i))\\n else:\\n break\\n \\n return result\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [1] * (n+1)\\n primes[0] = primes[1] = 0\\n i = 2\\n while i ** 2 <= n:\\n if primes[i]:\\n for j in range(i*2, n+1, i):\\n primes[j] = 0\\n i += 1\\n \\n ans = []\\n for i in range(2, n//2+1):\\n if primes[i] and primes[n-i]:\\n ans.append([i, n-i])\\n return ans\\n\",\n \"memory\": \"33500\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n dp = [True] * (n + 1)\\n dp[0] = dp[1] = False \\n for i in range(2, int(n**0.5) + 1):\\n if dp[i]: # If i is a prime\\n for j in range(i*i, n + 1, i): \\n dp[j] = False\\n val = n//2\\n ans = []\\n for i in range(2,val+1):\\n if (dp[i] and dp[n-i]):\\n ans.append([i,n-i])\\n return ans\\n \",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = []\\n allNumbers =[True]*(n+1)\\n allNumbers[0] = False\\n allNumbers[1] = False\\n index = 2\\n while index <= n:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex <= n):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.insert(0, [n-index, index])\\n\\n index+=1\\n\\n return toReturn\\n\\n\\n\\n\\n \",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n #toReturn = deque()\\n toReturn = []\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex < n - 1):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n #toReturn.appendleft([n-index, index])\\n toReturn.append([n-index, index])\\n\\n index+=1\\n reversed_list = toReturn[::-1]\\n return reversed_list\\n\\n\\n\\n\\n \",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int):\\n if n <= 3:\\n return []\\n\\n # Step 1: Use the Sieve of Eratosthenes to find all primes <= n\\n primes = [True] * (n + 1)\\n primes[0] = primes[1] = False\\n\\n for i in range(2, int(n**0.5) + 1):\\n if primes[i]:\\n for j in range(i * i, n + 1, i):\\n primes[j] = False\\n\\n # Step 2: Find all prime pairs that sum to n\\n result = []\\n for i in range(2, n // 2 + 1):\\n if primes[i] and primes[n - i]:\\n result.append([i, n - i])\\n\\n return result\\n\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"def sieveErastothenes(n: int):\\n sieve = [True for i in range(n+1)]\\n sieve[0] = False\\n sieve[1] = False\\n p = 2\\n while p*p <= n:\\n if sieve[p]:\\n for i in range(p*p, n+1, p):\\n sieve[i] = False\\n p += 1\\n return sieve\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1 or n==2: return []\\n if n == 4: return [[2,2]]\\n sieve = sieveErastothenes(n)\\n if n%2 == 1:\\n if sieve[n-2]: return [[2,n-2]]\\n else:\\n res = []\\n for x in range(3,n//2+1):\\n if sieve[x] and sieve[n-x]:\\n res.append([x,n-x])\\n return res\",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n result = []\\n allPrimes = get_primes_numpy(n) \\n left = 0\\n right = len(allPrimes) - 1\\n\\n while left <= right:\\n sm = allPrimes[left] + allPrimes[right] \\n if sm > n:\\n right -= 1\\n elif sm == n:\\n result.append([allPrimes[left], allPrimes[right]])\\n left += 1\\n else:\\n left += 1\\n\\n\\n return result\",\n \"memory\": \"34300\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n result = []\\n allPrimes = get_primes_numpy(n) \\n left = 0\\n right = len(allPrimes) - 1\\n\\n while left <= right:\\n sm = allPrimes[left] + allPrimes[right] \\n if sm > n:\\n right -= 1\\n elif sm == n:\\n result.append([allPrimes[left], allPrimes[right]])\\n left += 1\\n else:\\n left += 1\\n\\n\\n return result\",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"import numpy\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n\\n def get_primes_numpy(n):\\n sieve = numpy.ones(n // 2, dtype=bool)\\n for i in range(3, int(n ** 0.5) + 1, 2):\\n if sieve[i // 2]:\\n sieve[i * i // 2::i] = False\\n return numpy.r_[2, 2 * numpy.nonzero(sieve)[0][1::] + 1]\\n\\n\\n result = []\\n allPrimes = get_primes_numpy(n) \\n left = 0\\n right = len(allPrimes) - 1\\n\\n while left <= right:\\n sm = allPrimes[left] + allPrimes[right] \\n if sm > n:\\n right -= 1\\n elif sm == n:\\n result.append([allPrimes[left], allPrimes[right]])\\n left += 1\\n else:\\n left += 1\\n\\n\\n return result\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prime = [False, False] + [True]*(n-1)\\n for i in range(2, n+1):\\n if prime[i]:\\n for j in range(i*i, n+1, i):\\n prime[j] = False\\n \\n res = []\\n for i in range(2, 1+(n//2)):\\n if prime[i] and prime[n-i]:\\n res.append((i,n-i))\\n return res\",\n \"memory\": \"35100\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n prm={}\\n def SieveOfEratosthenes(num):\\n prime = [True for i in range(num+1)]\\n # boolean array\\n p = 2\\n while (p * p <= num):\\n \\n # If prime[p] is not\\n # changed, then it is a prime\\n if (prime[p] == True):\\n \\n # Updating all multiples of p\\n for i in range(p * p, num+1, p):\\n prime[i] = False\\n p += 1\\n \\n # Print all prime numbers\\n for p in range(2, num+1):\\n if prime[p]:\\n prm[p]=1\\n SieveOfEratosthenes(n)\\n ans=[]\\n used={}\\n for i in prm:\\n if n-i in prm:\\n if i not in used and n-i not in used:\\n x=[i,n-i]\\n ans.append(x)\\n used[i]=1\\n used[n-i]=1 \\n return ans\\n\\n \",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = [True for _ in range(n+1)]\\n\\n\\n primes[0] = primes[1] = False\\n\\n nums = []\\n for i in range(2,int(n**0.5)+1):\\n if primes[i]==True:\\n for j in range(i*i,n+1,i):\\n primes[j] = False\\n \\n for i in range(len(primes)):\\n if primes[i]==True:\\n nums.append(i)\\n \\n res = []\\n\\n l = 0\\n r = len(nums)-1\\n\\n while l<=r:\\n if nums[l] + nums[r]==n:\\n res.append([nums[l],nums[r]])\\n l += 1\\n r -= 1\\n elif nums[l] + nums[r] < n:\\n l += 1\\n else:\\n r -= 1\\n\\n #print(nums)\\n\\n return res\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n primes = []\\n template = [0] * n\\n for p in range(2, n+1):\\n if template[p-1] == 0:\\n primes.append(p)\\n for m in range(p-1, n, p):\\n template[m] = 1\\n\\n res = []\\n\\n l, r = 0, len(primes)-1\\n\\n while l <= r:\\n if primes[l] + primes[r] > n:\\n r -= 1\\n elif primes[l] + primes[r] < n:\\n l += 1\\n else:\\n res.append([primes[l], primes[r]])\\n l += 1\\n r -= 1\\n\\n return res \",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n toReturn = deque()\\n allNumbers =[True]*(n+1)\\n index = 2\\n while index < n - 1:\\n if allNumbers[index]:\\n multiplier = 2\\n subindex = index*multiplier\\n while(subindex < n - 1):\\n allNumbers[subindex] = False\\n multiplier+=1\\n subindex = index*multiplier\\n if index >= n/2 and allNumbers[n-index]:\\n toReturn.appendleft([n-index, index])\\n\\n index+=1\\n\\n return list(toReturn)\\n\\n\\n\\n\\n \",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n \\n if n==1 or n==2:\\n return []\\n \\n isprime=[True]*(n)\\n isprime[0]=isprime[1]=False\\n \\n for i in range(2,n):\\n if isprime:\\n for j in range(i*i,n,i):\\n isprime[j]=False\\n \\n \\n c=0\\n l=[]\\n for i in range(n):\\n if isprime[i]:\\n l.append(i)\\n l1=[]\\n d={}\\n for i,x in enumerate(l):\\n # example 5*5=10 right, it should not be like that\\n if (2*l[i])!=n:\\n if n-x in d:\\n l1.append([n-x,x])\\n else:\\n d[x]=x\\n else:\\n l1.append([x,n-x])\\n l1.sort(key=lambda x:x[0])\\n return l1\\n \",\n \"memory\": \"35800\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n arr = [1 for i in range(n+1)]\\n arr[0] = 0\\n arr[1] = 0\\n ans = []\\n for p in range(2,n+1):\\n if arr[p]==1:\\n ans.append(p)\\n k = p*p\\n while k<(n+1):\\n arr[k]=0\\n k+=p\\n # print(ans)\\n i = 0 \\n j = len(ans)-1\\n fin = []\\n while i<=j:\\n ct = ans[i]+ans[j]\\n if ct==n:\\n fin.append([ans[i],ans[j]])\\n i+=1\\n j-=1\\n elif ct < n:\\n i+=1\\n else:\\n j-=1\\n return fin\\n \",\n \"memory\": \"35900\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n s=set()\\n l1=[]\\n primes=[True]*(n+1)\\n prime_num=set()\\n primes[0]=primes[1]=False\\n p=2\\n while p*p<=n:\\n if primes[p]:\\n for i in range(p*p,n+1,p):\\n primes[i]=False\\n\\n p+=1\\n \\n for p in range(2,n+1):\\n if primes[p]:\\n prime_num.add(p)\\n\\n for num in prime_num:\\n if n-num in prime_num:\\n l1=[num,n-num]\\n l1.sort()\\n s.add(tuple(l1))\\n\\n if s:\\n return sorted(list(s))\\n else:\\n return []\\n\\n\\n \\n\\n \\n\\n \\n \",\n \"memory\": \"36300\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes = set()\\n nums = [True for _ in range(n)]\\n p = 2\\n while p < n:\\n if nums[p]:\\n primes.add(p)\\n for i in range(p * p, n, p):\\n nums[i] = False\\n p += 1\\n \\n result = []\\n for i in range(2, n // 2 + 1):\\n if i in primes and n - i in primes:\\n result.append([i, n - i])\\n return result\",\n \"memory\": \"36400\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n s=set()\\n l1=[]\\n primes=[True]*(n+1)\\n prime_num=set()\\n primes[0]=primes[1]=False\\n p=2\\n while p*p<=n:\\n if primes[p]:\\n for i in range(p*p,n+1,p):\\n primes[i]=False\\n\\n p+=1\\n for p in range(2,n+1):\\n if primes[p]:\\n prime_num.add(p)\\n\\n for num in prime_num:\\n if n-num in prime_num:\\n l1=[num,n-num]\\n l1.sort()\\n s.add(tuple(l1))\\n\\n if s:\\n return sorted(list(s))\\n else:\\n return []\\n\\n\\n \\n\\n \\n\\n \\n \",\n \"memory\": \"36900\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrime = [False, False] + [True] * (n - 2)\\n\\n for p in range(2, int(sqrt(n)) + 1):\\n if not isPrime[p]:\\n continue\\n\\n for multiple in range(p**2, n, p):\\n isPrime[multiple] = False\\n \\n primes = set([i for i in range(n) if isPrime[i]])\\n res = set()\\n for p in primes:\\n if n - p in primes:\\n pair = tuple(sorted([p, n-p]))\\n res.add(pair)\\n return sorted(list(res))\\n \",\n \"memory\": \"37100\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrime = [False, False] + [True] * (n - 2)\\n\\n for p in range(2, int(sqrt(n)) + 1):\\n if not isPrime[p]:\\n continue\\n\\n for multiple in range(p**2, n, p):\\n isPrime[multiple] = False\\n \\n primes = [i for i in range(n) if isPrime[i]]\\n l, r, = 0, len(primes) - 1\\n res = []\\n\\n while l <= r:\\n if primes[l] + primes[r] > n:\\n r -= 1\\n elif primes[l] + primes[r] < n:\\n l += 1\\n else:\\n res.append([primes[l], primes[r]])\\n l += 1\\n r -= 1\\n return res\\n \",\n \"memory\": \"37200\"\n },\n {\n \"code\": \"class Solution:\\n\\n def eratosthenes_sieve(self, n):\\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\\n for p in range(3, sqrt_n, 2):\\n if prime[p]:\\n result.append(p)\\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\\n\\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes_list = self.eratosthenes_sieve(n + 1)\\n primes_set = set(primes_list)\\n res = []\\n for p in primes_list:\\n if p > n - p:\\n break\\n if n - p in primes_set:\\n res.append([p, n - p])\\n return res\",\n \"memory\": \"37300\"\n },\n {\n \"code\": \"class Solution:\\n\\n def eratosthenes_sieve(self, n):\\n prime, result, sqrt_n = [True] * n, [2], (int(n ** .5) + 1) | 1\\n for p in range(3, sqrt_n, 2):\\n if prime[p]:\\n result.append(p)\\n prime[p * p::p << 1] = [False] * ((n - p * p - 1) // (p << 1) + 1)\\n\\n return result + [p for p in range(sqrt_n, n, 2) if prime[p]]\\n\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n primes_list = self.eratosthenes_sieve(n + 1)\\n primes_set = set(primes_list)\\n res = []\\n for p in primes_list:\\n if p > n - p:\\n break\\n if n - p in primes_set:\\n res.append([p, n - p])\\n return res\",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrimes=[True]*(n+1)\\n isPrimes[0]=False\\n if n>=1:\\n isPrimes[1]=False\\n res=[]\\n for i in range(2,math.ceil(math.sqrt(n))+1):\\n if isPrimes[i]:\\n for j in range(i*i,n+1,i):\\n if isPrimes[j]:\\n isPrimes[j]=False\\n\\n primes=set() #stores all prime numbers less than n\\n for i in range(len(isPrimes)):\\n if isPrimes[i]:\\n primes.add(i)\\n\\n res=set()\\n for i in primes:\\n # through this logic we are not making duplicates\\n if n-i<=i and n-i in primes: \\n res.add((n-i,i))\\n x=sorted(res)\\n return x\\n\\n\\n \",\n \"memory\": \"37500\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n isPrimes=[True]*(n+1)\\n isPrimes[0]=False\\n if n>=1:\\n isPrimes[1]=False\\n res=[]\\n for i in range(2,math.ceil(math.sqrt(n))+1):\\n if isPrimes[i]:\\n for j in range(i*i,n+1,i):\\n if isPrimes[j]:\\n isPrimes[j]=False\\n primes=set()\\n for i in range(len(isPrimes)):\\n if isPrimes[i]:\\n primes.add(i)\\n res=set()\\n for i in primes:\\n if n-i<=i and n-i in primes:\\n res.add((n-i,i))\\n x=sorted(res)\\n return x\\n\\n\\n \",\n \"memory\": \"37600\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n s=set()\\n l1=[]\\n primes=[True]*(n+1)\\n prime_num=set()\\n primes[0]=primes[1]=False\\n p=2\\n while p*p<=n:\\n #if primes[p]:\\n for i in range(p*p,n+1,p):\\n primes[i]=False\\n\\n p+=1\\n for p in range(2,n+1):\\n if primes[p]:\\n prime_num.add(p)\\n\\n for num in prime_num:\\n if n-num in prime_num:\\n l1=[num,n-num]\\n l1.sort()\\n s.add(tuple(l1))\\n\\n if s:\\n return sorted(list(s))\\n else:\\n return []\\n\\n\\n \\n\\n \\n\\n \\n \",\n \"memory\": \"37700\"\n },\n {\n \"code\": \"def sieve(n):\\n primes = []\\n nums = [0, 0] + [1] * (n-2)\\n\\n i = 2\\n while i * i < n:\\n if nums[i]:\\n for j in range(2*i, n, i):\\n nums[j] = 0\\n i += 1\\n \\n for i in range(n):\\n if nums[i] == 1:\\n primes.append(i)\\n\\n return primes\\n\\nclass Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n ans = []\\n primes = sieve(n)\\n p = set(primes)\\n \\n \\n for i in range(2, n//2 + 1):\\n if (i in p) and (n-i) in p:\\n ans.append([i, n-i])\\n \\n return ans\\n \\n \\n \\n \",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n sub[n-p] = p\\n if sub.get(p) is not None:\\n res.insert(0,[sub.get(p), p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"memory\": \"38000\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n == 1:\\n return []\\n res = []\\n sub = {}\\n template = [0] * n\\n for p in range(2, n + 1):\\n if template[p - 1] == 0:\\n sub[n-p] = p\\n test = sub.get(p)\\n if test is not None:\\n res.insert(0,[test, p])\\n for m in range(p - 1, n, p):\\n template[m] = 1\\n\\n return res \",\n \"memory\": \"38000\"\n },\n {\n \"code\": \"class Solution:\\n def findPrimePairs(self, n: int) -> List[List[int]]:\\n if n <= 3:\\n return []\\n primes = [True] * n\\n i = 2\\n while i * i < n:\\n if primes[i]:\\n for j in range(i * i, n, i):\\n primes[j] = False\\n i += 1\\n ps = [i for i, e in enumerate(primes) if e and i > 1]\\n primes = set(ps)\\n # print(primes)\\n res = []\\n for p in primes:\\n if p <= n - p and n - p in primes:\\n res.append([p, n - p])\\n return sorted(res)\",\n \"memory\": \"38100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":59,"string":"59"}}},{"rowIdx":2452,"cells":{"question_id":{"kind":"number","value":2849,"string":"2,849"},"name":{"kind":"string","value":"sum-of-imbalance-numbers-of-all-subarrays"},"content":{"kind":"string","value":"<p>The <strong>imbalance number</strong> of a <strong>0-indexed</strong> integer array <code>arr</code> of length <code>n</code> is defined as the number of indices in <code>sarr = sorted(arr)</code> such that:</p>\n\n<ul>\n\t<li><code>0 <= i < n - 1</code>, and</li>\n\t<li><code>sarr[i+1] - sarr[i] > 1</code></li>\n</ul>\n\n<p>Here, <code>sorted(arr)</code> is the function that returns the sorted version of <code>arr</code>.</p>\n\n<p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, return <em>the <strong>sum of imbalance numbers</strong> of all its <strong>subarrays</strong></em>.</p>\n\n<p>A <strong>subarray</strong> is a contiguous <strong>non-empty</strong> sequence of elements within an array.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [2,3,1,4]\n<strong>Output:</strong> 3\n<strong>Explanation:</strong> There are 3 subarrays with non-zero<strong> </strong>imbalance numbers:\n- Subarray [3, 1] with an imbalance number of 1.\n- Subarray [3, 1, 4] with an imbalance number of 1.\n- Subarray [1, 4] with an imbalance number of 1.\nThe imbalance number of all other subarrays is 0. Hence, the sum of imbalance numbers of all the subarrays of nums is 3. \n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [1,3,3,3,5]\n<strong>Output:</strong> 8\n<strong>Explanation:</strong> There are 7 subarrays with non-zero imbalance numbers:\n- Subarray [1, 3] with an imbalance number of 1.\n- Subarray [1, 3, 3] with an imbalance number of 1.\n- Subarray [1, 3, 3, 3] with an imbalance number of 1.\n- Subarray [1, 3, 3, 3, 5] with an imbalance number of 2. \n- Subarray [3, 3, 3, 5] with an imbalance number of 1. \n- Subarray [3, 3, 5] with an imbalance number of 1.\n- Subarray [3, 5] with an imbalance number of 1.\nThe imbalance number of all other subarrays is 0. Hence, the sum of imbalance numbers of all the subarrays of nums is 8. </pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 1000</code></li>\n\t<li><code>1 <= nums[i] <= nums.length</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":47.09658593522031,"string":"47.096586"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","ordered-set"],"string":"[\n \"array\",\n \"hash-table\",\n \"ordered-set\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"66\", 24.792699999999993], [\"110\", 1.6529], [\"155\", 0.8264], [\"199\", 0.8264], [\"244\", 3.3056], [\"288\", 16.528299999999998], [\"333\", 18.1814], [\"377\", 4.958500000000001], [\"421\", 2.4792], [\"466\", 0.8264], [\"510\", 0.8264], [\"555\", 0.8264], [\"599\", 0.8264], [\"644\", 0.8264], [\"688\", 0.8264], [\"733\", 0.8264], [\"777\", 0.8264], [\"822\", 0.8264], [\"866\", 0.8264], [\"911\", 0.8264], [\"955\", 0.8264], [\"999\", 0.8264], [\"1044\", 0.8264], [\"1088\", 0.8264], [\"1133\", 0.8264], [\"1177\", 0.8264], [\"1222\", 0.8264], [\"1266\", 0.8264], [\"1311\", 0.8264], [\"1355\", 0.8264], [\"1400\", 0.8264], [\"1444\", 0.8264], [\"1489\", 0.8264], [\"1533\", 0.8264]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16500\", 4.9587], [\"16600\", 17.3554], [\"16700\", 33.8843], [\"16800\", 15.7025], [\"16900\", 6.6116], [\"17000\", 2.4793], [\"17100\", 4.1322], [\"17200\", 8.2645]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def sumImbalanceNumbers(self, A: List[int]) -> int:\n n = len(A)\n left = [-1] * n\n last = [-1] * (n + 2)\n for i in range(n):\n left[i] = last[A[i] + 1]\n last[A[i]] = i\n\n right = [n] * n\n last = [n] * (n + 2)\n for i in range(n - 1, -1, -1):\n right[i] = min(last[A[i]], last[A[i] + 1])\n last[A[i]] = i\n\n ans = 0\n for i in range(n):\n ans += (i - left[i]) * (right[i] - i)\n return ans - n * (n + 1) // 2\n","runtime":"66"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n right = [0] * n \n idx = [n] * (n + 1)\n for i in range(n - 1, -1, -1):\n x = nums[i]\n right[i] = min(idx[x], idx[x - 1])\n idx[x] = i\n\n ans = 0\n idx = [-1] * (n + 1)\n for i, (x, r) in enumerate(zip(nums, right)):\n ans += (i - idx[x - 1]) * (r - i) \n idx[x] = i\n return ans - n * (n + 1) // 2\n\n","runtime":"66"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ret = 0\n \n for i in range(n):\n prev_invalid = -1\n prev_larger_than_one = -1\n for j in range(i - 1, -1, -1):\n if nums[j] == nums[i] + 1:\n prev_invalid = j\n break\n if nums[j] > nums[i] + 1 and prev_larger_than_one == -1:\n prev_larger_than_one = j\n\n after_invalid = n\n after_larger_than_one = n\n for j in range(i + 1, n):\n if nums[j] == nums[i] + 1 or nums[j] == nums[i]:\n after_invalid = j\n break\n if nums[j] > nums[i] + 1 and after_larger_than_one == n:\n after_larger_than_one = j\n\n a = i - prev_invalid\n b = after_invalid - i\n c = i - max(prev_invalid, prev_larger_than_one)\n d = min(after_invalid, after_larger_than_one) - i\n\n ret += max(0, a * b - c * d)\n \n return ret","runtime":"110"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n res, n = 0, len(nums)\n for i, x in enumerate(nums):\n aux = [False] * (n + 2)\n aux[x] = True\n cnt = 0\n for j in range(i + 1, n):\n x = nums[j]\n if not aux[x]:\n cnt += 1 - aux[x - 1] - aux[x + 1]\n aux[x] = True\n res += cnt\n return res\n ","runtime":"110"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n ans, n = 0, len(nums)\n for i, x in enumerate(nums):\n vis = [False] * (n + 2)\n vis[x] = True\n cnt = 0\n for j in range(i + 1, n):\n x = nums[j]\n if not vis[x]:\n cnt += 1 - vis[x - 1] - vis[x + 1]\n vis[x] = True\n ans += cnt\n return ans\n ","runtime":"155"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n ans, n = 0, len(nums)\n for i, x in enumerate(nums):\n vis = [False] * (n + 2)\n vis[x] = True\n cnt = 0\n for j in range(i + 1, n):\n x = nums[j]\n if not vis[x]:\n cnt += 1 - vis[x - 1] - vis[x + 1]\n vis[x] = True\n ans += cnt\n return ans","runtime":"199"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n\n n, ans = len(nums), 0\n\n for i, num1 in enumerate(nums):\n\n s, cnt = {num1}, 0\n\n for num2 in nums[i+1:]:\n\n if num2 not in s:\n s.add(num2)\n cnt+= 1 - (num2-1 in s) - (num2+1 in s)\n\n ans+= cnt\n \n return ans","runtime":"244"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n ans, n = 0, len(nums)\n for i, x in enumerate(nums):\n vis = [False] * (n + 2)\n vis[x] = True\n cnt = 0\n for j in range(i + 1, n):\n x = nums[j]\n if not vis[x]:\n cnt += 1 - vis[x - 1] - vis[x + 1]\n vis[x] = True\n ans += cnt\n return ans\n","runtime":"244"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n for i in range(n-1):\n s = set([nums[i]])\n cur = 0\n for j in range(i+1,n):\n if not (nums[j] in s):\n cur += (1 - (nums[j]+1 in s) - (nums[j]-1 in s))\n s.add(nums[j])\n res += cur\n return res","runtime":"288"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n \"\"\"\n - imbalance number\n - index of sorted(arr) when sarr[i + 1] - sarr[i] > 1\n - imbalance when non-consecutive\n - subarrays of length 1 have an imbalance number of 0\n - O(n ^ 2)\n - go through each subarray\n - maintain a ordered set of the numbers\n - imbalance is the number of breaks in the set\n - i.e. 1 _ 3 is a break\n \"\"\"\n n = len(nums)\n res = 0\n for i in range(n):\n subset = set()\n nonconsecutive = 0\n for j in range(i, n):\n if nums[j] in subset:\n res += nonconsecutive - 1\n continue\n subset.add(nums[j])\n if nums[j] - 1 in subset:\n nonconsecutive -= 1\n if nums[j] + 1 not in subset:\n nonconsecutive += 1\n res += nonconsecutive - 1\n return res","runtime":"288"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n for i in range(n):\n s = set()\n cur = -1\n for j in range(i,n):\n if nums[j] not in s:\n d = 1\n if nums[j] - 1 in s:\n d -= 1\n if nums[j] + 1 in s:\n d -= 1\n cur += d\n s.add(nums[j])\n res += cur\n return res","runtime":"333"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n for i in range(n):\n prefix = set()\n prefix.add(nums[i])\n cur_min = nums[i]\n cur_max = nums[i]\n cur_imba = 0\n for j in range(i + 1, n):\n v = nums[j]\n if v in prefix:\n pass\n elif v > cur_max:\n cur_max = v\n if v - 1 not in prefix:\n cur_imba += 1\n\n elif v < cur_min:\n cur_min = v\n if v + 1 not in prefix:\n cur_imba += 1\n else:\n cur_imba += 1\n if v + 1 in prefix:\n cur_imba -= 1\n if v - 1 in prefix:\n cur_imba -= 1\n \n res += cur_imba\n prefix.add(v)\n \n return res","runtime":"333"},{"code":"class Solution:\n def sumImbalanceNumbers(self, A: List[int]) -> int:\n n = len(A)\n res = 0\n for i in range(n):\n s = set()\n cur = -1\n for j in range(i, n):\n cur += 0 if A[j] in s else 1 - (A[j] + 1 in s) - (A[j] - 1 in s)\n s.add(A[j])\n res += cur\n return res","runtime":"377"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n imbalance = 0\n \n for i,start in enumerate(nums):\n d = {}\n d[start] = 1\n c = 0\n \n for j in range(i+1, len(nums)):\n n = nums[j]\n if n in d:\n pass\n else:\n if n+1 in d and n-1 in d:\n c -= 1\n elif n+1 not in d and n-1 not in d:\n c += 1\n d[n] = 1\n imbalance += c\n \n return imbalance ","runtime":"377"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n imbalance = 0\n currSet = set()\n for j in range(i, n):\n if nums[j] not in currSet and nums[j] - 1 in currSet and nums[j] + 1 in currSet:\n imbalance -= 1\n if j - i > 0 and nums[j] not in currSet and nums[j] - 1 not in currSet and nums[j] + 1 not in currSet:\n imbalance += 1\n currSet.add(nums[j])\n ans += imbalance\n \n return ans\n","runtime":"421"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n=len(nums); res=0\n for i in range(n):\n j=i; imbalance=0; _set=set()\n while j<n:\n if nums[j] not in _set and nums[j]-1 in _set and nums[j]+1 in _set:\n imbalance-=1\n if j-i>0 and nums[j] not in _set and nums[j]-1 not in _set and nums[j]+1 not in _set:\n imbalance+=1\n _set.add(nums[j])\n res+=imbalance\n j+=1\n return res","runtime":"421"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n from sortedcontainers import SortedList\n ret = 0\n for i in range(len(nums)):\n cur = 0\n ma = - inf\n seen = set()\n for j in range(i, len(nums)):\n if nums[j] not in seen:\n if nums[j] + 1 not in seen and nums[j] < ma:\n cur += 1\n if seen and nums[j] > ma and nums[j] - 1 not in seen:\n cur += 1\n if nums[j] < ma and nums[j] - 1 in seen:\n cur -= 1\n seen.add(nums[j])\n ma = max(ma, nums[j])\n ret += cur\n # print(i, j, seen, ma, cur, ret)\n return ret\n","runtime":"466"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n total = 0\n N = len(nums)\n\n for s in range(N):\n count = [0] * 1002\n maxVal = nums[s]\n minVal = nums[s]\n imbalance = 0\n count[nums[s]] = 1\n for e in range(s + 1, N):\n x = nums[e]\n if x > maxVal:\n if count[x - 1] == 0:\n imbalance += 1\n elif x < minVal:\n if count[x + 1] == 0:\n imbalance += 1\n else:\n if count[x] == 0:\n imbalance -= 1\n if count[x + 1] > 0:\n imbalance += 0\n else:\n imbalance += 1\n\n if count[x - 1] > 0:\n imbalance += 0\n else:\n imbalance += 1\n\n total += imbalance\n count[x] += 1\n minVal = min(minVal, x)\n maxVal = max(maxVal, x) \n\n\n # 1 10 20 40 70 300\n\n return total","runtime":"510"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n res = 0\n n = len(nums)\n \n for i in range(n):\n sub = []\n# print(i)\n diff = 0\n for j in range(i, n):\n if sub == []:\n sub = [nums[j]]\n continue\n ii = bisect.bisect_left(sub, nums[j])\n if ii == 0 and sub[0] - nums[j] > 1:\n diff += 1\n elif ii == len(sub) and nums[j] - sub[-1] > 1:\n diff += 1\n elif 0 < ii < len(sub) and nums[j] - sub[ii - 1] > 1 and sub[ii] - nums[j] > 1:\n diff += 1\n elif 0 < ii < len(sub) and nums[j] - sub[ii - 1] <= 1 and sub[ii] - nums[j] <= 1 and \\\n sub[ii]- sub[ii - 1] == 2:\n \n diff -= 1\n bisect.insort(sub, nums[j])\n res += diff\n# print(j, res)\n return res\n ","runtime":"555"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n added = set([nums[i]])\n sorted_subarray = [nums[i]]\n count = 0\n # print(sorted_subarray)\n for j in range(i+1, n):\n # skip this number if it's already in the sorted subarray\n if nums[j] in added:\n ans += count\n # print(f\"Continued, Count: {count}, Answer: {ans}\")\n continue\n \n added.add(nums[j])\n # binary search to find the correct position\n l, r = 0, len(sorted_subarray)-1\n # Add it to the very end if no intermediate answer found\n correct_idx = len(sorted_subarray)\n while l <= r:\n mid = (l + r) // 2\n if l == r and nums[j] < sorted_subarray[mid]:\n correct_idx = mid\n break\n if nums[j] < sorted_subarray[mid]:\n r = mid\n else:\n l = mid + 1\n # print(len(sorted_subarray), correct_idx)\n sorted_subarray.insert(correct_idx, nums[j])\n # print(j, correct_idx, sorted_subarray)\n\n # update the `ans`\n if correct_idx == 0:\n count += int(sorted_subarray[0] + 1 < sorted_subarray[1])\n elif correct_idx == len(sorted_subarray)-1:\n count += int(sorted_subarray[-1] - 1 > sorted_subarray[-2])\n else:\n idx = correct_idx\n if sorted_subarray[idx-1] + 1 < sorted_subarray[idx] \\\n and sorted_subarray[idx] + 1 < sorted_subarray[idx+1]:\n count += 1\n elif sorted_subarray[idx-1] + 1 == sorted_subarray[idx] \\\n and sorted_subarray[idx] + 1 == sorted_subarray[idx+1]:\n count -= 1\n ans += count\n # print(f\"Count: {count}, Answer: {ans}\")\n return ans","runtime":"599"},{"code":"class Solution:\r\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\r\n ans = 0\r\n for lf in range(len(nums)):\r\n win = []\r\n cnt = 0\r\n for rh in range(lf, len(nums)):\r\n index = bisect_left(win, nums[rh])\r\n # on the left\r\n if len(win) > 0 and index == 0:\r\n cnt += 1 if win[0] - nums[rh] > 1 else 0\r\n # on the right\r\n elif len(win) > 0 and index == len(win):\r\n cnt += 1 if nums[rh] - win[-1] > 1 else 0\r\n # in between\r\n elif len(win) > 1:\r\n t1 = 1 if nums[rh] - win[index-1] > 1 else 0\r\n t2 = 1 if win[index] - nums[rh] > 1 else 0\r\n if t1 + t2 == 2:\r\n cnt += 1\r\n elif t1 + t2 == 1:\r\n cnt = cnt\r\n else:\r\n if win[index] - win[index-1] > 1:\r\n cnt -= 1\r\n else:\r\n cnt = cnt\r\n insort_left(win, nums[rh])\r\n ans += cnt\r\n # print(f\"{lf} : {rh} : {cnt}\")\r\n return ans\r\n # in between","runtime":"644"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n status = [\n [0, 0, 1],\n [0, -1, 0],\n [1, 0, 1]\n ]\n\n for i in range(n):\n sl = SortedList()\n temp = 0\n\n for j in range(i, n):\n if nums[j] in sl:\n res += temp\n continue\n idx = sl.bisect_left(nums[j])\n \n left_status = right_status = 0\n\n if 0 <= idx - 1 < len(sl):\n if nums[j] - sl[idx - 1] > 1:\n left_status = 2\n else:\n left_status = 1\n \n if idx < len(sl):\n if sl[idx] - nums[j] > 1:\n right_status = 2\n else:\n right_status = 1\n \n temp += status[left_status][right_status]\n\n res += temp\n sl.add(nums[j])\n\n return res","runtime":"688"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n): \n cnt = 0 \n sl = SortedList()\n for j in range(i, n): \n if nums[j] not in sl: \n k = sl.bisect_left(nums[j])\n if k and k < len(sl) and sl[k-1]+1 < sl[k]: cnt -= 1\n if k and sl[k-1]+1 < nums[j]: cnt += 1\n if k < len(sl) and nums[j]+1 < sl[k]: cnt += 1\n sl.add(nums[j])\n ans += cnt \n return ans ","runtime":"733"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n \n result = 0\n for st in range(len(nums)):\n sl = SortedList([nums[st]])\n currsumimb = 0\n for end in range(st+1, len(nums)):\n num = nums[end]\n j = sl.bisect_left(num)\n if j == 0:\n if sl[0] - num > 1:\n currsumimb += 1\n elif j == len(sl):\n if num - sl[-1] > 1:\n currsumimb += 1\n else:\n nxt = sl[j]\n prv = sl[j-1]\n if nxt - prv > 1:\n currsumimb -= 1\n if nxt - num > 1:\n currsumimb += 1\n if num - prv > 1:\n currsumimb += 1\n sl.add(num)\n result += currsumimb\n \n return result","runtime":"777"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n-1):\n sl = SortedList()\n sl.add(nums[i])\n inBalance = 0\n for j in range(i+1, n):\n idx = sl.bisect_left(nums[j])\n if idx < len(sl) and sl[idx] == nums[j]:\n ans += inBalance\n sl.add(nums[j])\n continue\n pre = sl[idx-1] if idx > 0 else 0\n post = sl[idx] if idx < len(sl) else 0\n if post and post-nums[j] > 1:\n inBalance += 1\n if pre and nums[j]-pre > 1:\n inBalance += 1\n if pre and post and post - pre > 1:\n inBalance -= 1\n ans += inBalance\n sl.add(nums[j])\n return ans","runtime":"822"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n for i in range(n):\n sl = SortedList() \n sl.add(nums[i])\n tmpres = 0 \n for j in range(i+1, n):\n idx = sl.bisect_right(nums[j])\n if idx:\n if idx == len(sl):\n if nums[j] - sl[-1] > 1:\n tmpres += 1\n else:\n if sl[idx] - sl[idx-1] > 1:\n if nums[j] - sl[idx-1] > 1 and sl[idx] - nums[j] > 1:\n tmpres += 1\n elif nums[j] - sl[idx-1] <= 1 and sl[idx] - nums[j] <= 1:\n tmpres -= 1\n else:\n if sl[0] - nums[j] > 1:\n tmpres += 1\n res += tmpres\n sl.add(nums[j])\n return res","runtime":"866"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n ans = 0\n sz = len(nums)\n for i in range(sz):\n sl = SortedList()\n curr = 0\n for j in range(i, sz):\n \n if not sl: \n sl.add(nums[i])\n continue\n n = len(sl)\n idx = sl.bisect_left(nums[j])\n if idx == n:\n curr += 1 if nums[j] - sl[-1] > 1 else 0\n sl.add(nums[j])\n elif idx == 0:\n curr += 1 if sl[0] - nums[j] > 1 else 0\n sl.add(nums[j])\n else:\n a = sl[idx - 1]\n b = sl[idx]\n if b - a <= 1:\n sl.add(nums[j])\n ans += curr\n continue\n curr -= 1\n fuck = [a, nums[j] ,b]\n for i in range(len(fuck) - 1):\n if fuck[i + 1] - fuck[i] > 1:\n curr += 1\n sl.add(nums[j])\n ans += curr\n return ans","runtime":"911"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n res = 0\n \n for i in range(len(nums)):\n sl = SortedList()\n sl.add(nums[i])\n \n score = 0\n for j in range(i+1, len(nums)):\n pos = sl.bisect_right(nums[j])\n minn, maxx = sl[0], sl[-1]\n \n if pos >= len(sl):\n # the new number is the largest\n if nums[j] - maxx > 1:\n score += 1\n \n elif pos == 0:\n # the new number is the smallest\n if minn - nums[j] > 1:\n score += 1\n \n else:\n \n # look at both elements on the left and on the right\n left, right = sl[pos-1], sl[pos]\n \n # previous gap destroyed\n if right - left > 1:\n score -= 1\n \n # newly formed gaps\n if right - nums[j] > 1:\n score += 1\n \n if nums[j] - left > 1:\n score += 1\n \n sl.add(nums[j])\n res += score\n \n return res\n \n \n \n \n ","runtime":"955"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n res = 0\n n = len(nums)\n\n for i in range(n):\n curr = 0\n sl = SortedList([nums[i]])\n\n for j in range(i + 1, n):\n k = sl.bisect_left(nums[j])\n\n if 0 < k < len(sl):\n lgap = nums[j] - sl[k - 1]\n rgap = sl[k] - nums[j]\n if lgap == rgap == 1:\n curr -= 1\n elif lgap > 1 and rgap > 1:\n curr += 1\n elif k == 0:\n curr += ((sl[0] - nums[j]) > 1)\n else:\n curr += ((nums[j] - sl[-1]) > 1)\n res += curr\n sl.add(nums[j])\n return res\n \n ","runtime":"999"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n #print(i)\n for j in range(i,n):\n v = nums[j]\n m = len(sl)\n pos = sl.bisect_left(v)\n if(pos == 0):\n #add start\n if(m==0):\n pass\n else:\n if(v+1<sl[0]):\n cnt +=1\n elif(pos == m):\n #add end\n if(sl[m-1]+1<v):\n cnt +=1\n else:\n pass\n else:\n #add to middle\n if(v == sl[pos]):\n pass\n elif(sl[pos]-sl[pos-1]==1):\n pass\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\n #break the original one\n cnt -=1\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\n #no change\n pass\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\n #no change\n pass\n else:\n cnt +=1\n \n\n #print((j,pos,cnt))\n sl.add(v)\n ans += cnt\n return ans","runtime":"1044"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n #print(i)\n for j in range(i,n):\n v = nums[j]\n m = len(sl)\n pos = sl.bisect_left(v)\n if(pos == 0):\n #add start\n if(m==0):\n pass\n else:\n if(v+1<sl[0]):\n cnt +=1\n elif(pos == m):\n #add end\n if(sl[m-1]+1<v):\n cnt +=1\n else:\n pass\n else:\n #add to middle\n if(v == sl[pos]):\n pass\n elif(sl[pos]-sl[pos-1]==1):\n pass\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\n #break the original one\n cnt -=1\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\n #no change\n pass\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\n #no change\n pass\n else:\n cnt +=1\n \n sl.add(v)\n ans += cnt\n return ans","runtime":"1088"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n #print(i)\n for j in range(i,n):\n v = nums[j]\n m = len(sl)\n pos = sl.bisect_left(v)\n if(pos == 0):\n #add start\n if(m==0):\n pass\n else:\n if(v+1<sl[0]):\n cnt +=1\n elif(pos == m):\n #add end\n if(sl[m-1]+1<v):\n cnt +=1\n else:\n pass\n else:\n #add to middle\n if(v == sl[pos]):\n pass\n elif(sl[pos]-sl[pos-1]==1):\n pass\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\n #break the original one\n cnt -=1\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\n #no change\n pass\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\n #no change\n pass\n else:\n cnt +=1\n \n sl.add(v)\n ans += cnt\n return ans","runtime":"1133"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n res = 0\n \n for p in range(len(nums)):\n elems = SortedList()\n elems.add(nums[p])\n cnt = 0\n for q in range(p+1, len(nums)):\n pos = elems.bisect_left(nums[q])\n if pos >= len(elems): # largest number in the subarray\n if nums[q] - elems[-1] > 1:\n cnt += 1\n elif pos == 0: # smallest number in the subarray\n if elems[0] - nums[q] > 1:\n cnt += 1\n else:\n if elems[pos] - elems[pos-1] > 1:\n cnt -= 1\n if nums[q] - elems[pos-1] > 1:\n cnt += 1\n if elems[pos] - nums[q] > 1:\n cnt += 1\n elems.add(nums[q])\n \n res += cnt\n #print(p, q, cnt, res)\n \n return res\n ","runtime":"1177"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans","runtime":"1222"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n count = 0\n contr = defaultdict(int)\n\n for j in range(i, n):\n cur = nums[j]\n if sl:\n pos = sl.bisect_left((nums[j], j))\n if pos > 0:\n ele, idx = sl[pos-1]\n prevContr = contr[idx] # change pos to index in nums\n \n if cur > ele + 1:\n if prevContr == 0:\n count += 1\n contr[idx] = 1\n # contr[j] = int(prevContr == 0)\n else:\n if prevContr == 1:\n contr[idx] = 0\n count -= 1\n # contr[idx] = int(prevContr == 1)\n\n if 0 <= pos < len(sl):\n ele, idx = sl[pos]\n nextContr = contr[idx]\n \n if cur + 1 < ele:\n count += 1\n contr[j] = 1\n else:\n # count -= 1\n contr[j] = 0\n\n ans += count\n sl.add((nums[j], j))\n\n return ans","runtime":"1266"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans","runtime":"1311"},{"code":"from sortedcontainers import SortedList\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n cnt = 0\n sl = SortedList()\n sl.add(nums[i])\n for j in range(i + 1, n):\n k = sl.bisect_left(nums[j])\n if k < len(sl) and sl[k] - nums[j] > 1: cnt += 1\n if k > 0 and nums[j] - sl[k - 1] > 1: cnt += 1\n if 0 < k < len(sl) and sl[k] - sl[k - 1] > 1: cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans","runtime":"1355"},{"code":"# Daily\n\nfrom sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans\n","runtime":"1400"},{"code":"import sortedcontainers\n\nclass Solution:\n def sumImbalanceNumbers(self, N: List[int]) -> int:\n n = len(N)\n T = 0\n for i in range(n):\n L = sortedcontainers.SortedList()\n S = 0\n for a in N[i:]:\n j = L.bisect(a)\n if 0<j<len(L):\n S -= (L[j]-L[j-1]>1)\n if j<len(L):\n S += (L[j]-a>1)\n if 0<j:\n S += (a-L[j-1]>1)\n T+=S\n L.add(a)\n return T","runtime":"1444"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans","runtime":"1489"},{"code":"# Daily\n\nfrom sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans\n","runtime":"1533"}],"string":"[\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, A: List[int]) -> int:\\n n = len(A)\\n left = [-1] * n\\n last = [-1] * (n + 2)\\n for i in range(n):\\n left[i] = last[A[i] + 1]\\n last[A[i]] = i\\n\\n right = [n] * n\\n last = [n] * (n + 2)\\n for i in range(n - 1, -1, -1):\\n right[i] = min(last[A[i]], last[A[i] + 1])\\n last[A[i]] = i\\n\\n ans = 0\\n for i in range(n):\\n ans += (i - left[i]) * (right[i] - i)\\n return ans - n * (n + 1) // 2\\n\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n right = [0] * n \\n idx = [n] * (n + 1)\\n for i in range(n - 1, -1, -1):\\n x = nums[i]\\n right[i] = min(idx[x], idx[x - 1])\\n idx[x] = i\\n\\n ans = 0\\n idx = [-1] * (n + 1)\\n for i, (x, r) in enumerate(zip(nums, right)):\\n ans += (i - idx[x - 1]) * (r - i) \\n idx[x] = i\\n return ans - n * (n + 1) // 2\\n\\n\",\n \"runtime\": \"66\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ret = 0\\n \\n for i in range(n):\\n prev_invalid = -1\\n prev_larger_than_one = -1\\n for j in range(i - 1, -1, -1):\\n if nums[j] == nums[i] + 1:\\n prev_invalid = j\\n break\\n if nums[j] > nums[i] + 1 and prev_larger_than_one == -1:\\n prev_larger_than_one = j\\n\\n after_invalid = n\\n after_larger_than_one = n\\n for j in range(i + 1, n):\\n if nums[j] == nums[i] + 1 or nums[j] == nums[i]:\\n after_invalid = j\\n break\\n if nums[j] > nums[i] + 1 and after_larger_than_one == n:\\n after_larger_than_one = j\\n\\n a = i - prev_invalid\\n b = after_invalid - i\\n c = i - max(prev_invalid, prev_larger_than_one)\\n d = min(after_invalid, after_larger_than_one) - i\\n\\n ret += max(0, a * b - c * d)\\n \\n return ret\",\n \"runtime\": \"110\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n res, n = 0, len(nums)\\n for i, x in enumerate(nums):\\n aux = [False] * (n + 2)\\n aux[x] = True\\n cnt = 0\\n for j in range(i + 1, n):\\n x = nums[j]\\n if not aux[x]:\\n cnt += 1 - aux[x - 1] - aux[x + 1]\\n aux[x] = True\\n res += cnt\\n return res\\n \",\n \"runtime\": \"110\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n ans, n = 0, len(nums)\\n for i, x in enumerate(nums):\\n vis = [False] * (n + 2)\\n vis[x] = True\\n cnt = 0\\n for j in range(i + 1, n):\\n x = nums[j]\\n if not vis[x]:\\n cnt += 1 - vis[x - 1] - vis[x + 1]\\n vis[x] = True\\n ans += cnt\\n return ans\\n \",\n \"runtime\": \"155\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n ans, n = 0, len(nums)\\n for i, x in enumerate(nums):\\n vis = [False] * (n + 2)\\n vis[x] = True\\n cnt = 0\\n for j in range(i + 1, n):\\n x = nums[j]\\n if not vis[x]:\\n cnt += 1 - vis[x - 1] - vis[x + 1]\\n vis[x] = True\\n ans += cnt\\n return ans\",\n \"runtime\": \"199\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n\\n n, ans = len(nums), 0\\n\\n for i, num1 in enumerate(nums):\\n\\n s, cnt = {num1}, 0\\n\\n for num2 in nums[i+1:]:\\n\\n if num2 not in s:\\n s.add(num2)\\n cnt+= 1 - (num2-1 in s) - (num2+1 in s)\\n\\n ans+= cnt\\n \\n return ans\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n ans, n = 0, len(nums)\\n for i, x in enumerate(nums):\\n vis = [False] * (n + 2)\\n vis[x] = True\\n cnt = 0\\n for j in range(i + 1, n):\\n x = nums[j]\\n if not vis[x]:\\n cnt += 1 - vis[x - 1] - vis[x + 1]\\n vis[x] = True\\n ans += cnt\\n return ans\\n\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n for i in range(n-1):\\n s = set([nums[i]])\\n cur = 0\\n for j in range(i+1,n):\\n if not (nums[j] in s):\\n cur += (1 - (nums[j]+1 in s) - (nums[j]-1 in s))\\n s.add(nums[j])\\n res += cur\\n return res\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n - imbalance number\\n - index of sorted(arr) when sarr[i + 1] - sarr[i] > 1\\n - imbalance when non-consecutive\\n - subarrays of length 1 have an imbalance number of 0\\n - O(n ^ 2)\\n - go through each subarray\\n - maintain a ordered set of the numbers\\n - imbalance is the number of breaks in the set\\n - i.e. 1 _ 3 is a break\\n \\\"\\\"\\\"\\n n = len(nums)\\n res = 0\\n for i in range(n):\\n subset = set()\\n nonconsecutive = 0\\n for j in range(i, n):\\n if nums[j] in subset:\\n res += nonconsecutive - 1\\n continue\\n subset.add(nums[j])\\n if nums[j] - 1 in subset:\\n nonconsecutive -= 1\\n if nums[j] + 1 not in subset:\\n nonconsecutive += 1\\n res += nonconsecutive - 1\\n return res\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n for i in range(n):\\n s = set()\\n cur = -1\\n for j in range(i,n):\\n if nums[j] not in s:\\n d = 1\\n if nums[j] - 1 in s:\\n d -= 1\\n if nums[j] + 1 in s:\\n d -= 1\\n cur += d\\n s.add(nums[j])\\n res += cur\\n return res\",\n \"runtime\": \"333\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n for i in range(n):\\n prefix = set()\\n prefix.add(nums[i])\\n cur_min = nums[i]\\n cur_max = nums[i]\\n cur_imba = 0\\n for j in range(i + 1, n):\\n v = nums[j]\\n if v in prefix:\\n pass\\n elif v > cur_max:\\n cur_max = v\\n if v - 1 not in prefix:\\n cur_imba += 1\\n\\n elif v < cur_min:\\n cur_min = v\\n if v + 1 not in prefix:\\n cur_imba += 1\\n else:\\n cur_imba += 1\\n if v + 1 in prefix:\\n cur_imba -= 1\\n if v - 1 in prefix:\\n cur_imba -= 1\\n \\n res += cur_imba\\n prefix.add(v)\\n \\n return res\",\n \"runtime\": \"333\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, A: List[int]) -> int:\\n n = len(A)\\n res = 0\\n for i in range(n):\\n s = set()\\n cur = -1\\n for j in range(i, n):\\n cur += 0 if A[j] in s else 1 - (A[j] + 1 in s) - (A[j] - 1 in s)\\n s.add(A[j])\\n res += cur\\n return res\",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n imbalance = 0\\n \\n for i,start in enumerate(nums):\\n d = {}\\n d[start] = 1\\n c = 0\\n \\n for j in range(i+1, len(nums)):\\n n = nums[j]\\n if n in d:\\n pass\\n else:\\n if n+1 in d and n-1 in d:\\n c -= 1\\n elif n+1 not in d and n-1 not in d:\\n c += 1\\n d[n] = 1\\n imbalance += c\\n \\n return imbalance \",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n imbalance = 0\\n currSet = set()\\n for j in range(i, n):\\n if nums[j] not in currSet and nums[j] - 1 in currSet and nums[j] + 1 in currSet:\\n imbalance -= 1\\n if j - i > 0 and nums[j] not in currSet and nums[j] - 1 not in currSet and nums[j] + 1 not in currSet:\\n imbalance += 1\\n currSet.add(nums[j])\\n ans += imbalance\\n \\n return ans\\n\",\n \"runtime\": \"421\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n=len(nums); res=0\\n for i in range(n):\\n j=i; imbalance=0; _set=set()\\n while j<n:\\n if nums[j] not in _set and nums[j]-1 in _set and nums[j]+1 in _set:\\n imbalance-=1\\n if j-i>0 and nums[j] not in _set and nums[j]-1 not in _set and nums[j]+1 not in _set:\\n imbalance+=1\\n _set.add(nums[j])\\n res+=imbalance\\n j+=1\\n return res\",\n \"runtime\": \"421\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n from sortedcontainers import SortedList\\n ret = 0\\n for i in range(len(nums)):\\n cur = 0\\n ma = - inf\\n seen = set()\\n for j in range(i, len(nums)):\\n if nums[j] not in seen:\\n if nums[j] + 1 not in seen and nums[j] < ma:\\n cur += 1\\n if seen and nums[j] > ma and nums[j] - 1 not in seen:\\n cur += 1\\n if nums[j] < ma and nums[j] - 1 in seen:\\n cur -= 1\\n seen.add(nums[j])\\n ma = max(ma, nums[j])\\n ret += cur\\n # print(i, j, seen, ma, cur, ret)\\n return ret\\n\",\n \"runtime\": \"466\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n total = 0\\n N = len(nums)\\n\\n for s in range(N):\\n count = [0] * 1002\\n maxVal = nums[s]\\n minVal = nums[s]\\n imbalance = 0\\n count[nums[s]] = 1\\n for e in range(s + 1, N):\\n x = nums[e]\\n if x > maxVal:\\n if count[x - 1] == 0:\\n imbalance += 1\\n elif x < minVal:\\n if count[x + 1] == 0:\\n imbalance += 1\\n else:\\n if count[x] == 0:\\n imbalance -= 1\\n if count[x + 1] > 0:\\n imbalance += 0\\n else:\\n imbalance += 1\\n\\n if count[x - 1] > 0:\\n imbalance += 0\\n else:\\n imbalance += 1\\n\\n total += imbalance\\n count[x] += 1\\n minVal = min(minVal, x)\\n maxVal = max(maxVal, x) \\n\\n\\n # 1 10 20 40 70 300\\n\\n return total\",\n \"runtime\": \"510\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n res = 0\\n n = len(nums)\\n \\n for i in range(n):\\n sub = []\\n# print(i)\\n diff = 0\\n for j in range(i, n):\\n if sub == []:\\n sub = [nums[j]]\\n continue\\n ii = bisect.bisect_left(sub, nums[j])\\n if ii == 0 and sub[0] - nums[j] > 1:\\n diff += 1\\n elif ii == len(sub) and nums[j] - sub[-1] > 1:\\n diff += 1\\n elif 0 < ii < len(sub) and nums[j] - sub[ii - 1] > 1 and sub[ii] - nums[j] > 1:\\n diff += 1\\n elif 0 < ii < len(sub) and nums[j] - sub[ii - 1] <= 1 and sub[ii] - nums[j] <= 1 and \\\\\\n sub[ii]- sub[ii - 1] == 2:\\n \\n diff -= 1\\n bisect.insort(sub, nums[j])\\n res += diff\\n# print(j, res)\\n return res\\n \",\n \"runtime\": \"555\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n added = set([nums[i]])\\n sorted_subarray = [nums[i]]\\n count = 0\\n # print(sorted_subarray)\\n for j in range(i+1, n):\\n # skip this number if it's already in the sorted subarray\\n if nums[j] in added:\\n ans += count\\n # print(f\\\"Continued, Count: {count}, Answer: {ans}\\\")\\n continue\\n \\n added.add(nums[j])\\n # binary search to find the correct position\\n l, r = 0, len(sorted_subarray)-1\\n # Add it to the very end if no intermediate answer found\\n correct_idx = len(sorted_subarray)\\n while l <= r:\\n mid = (l + r) // 2\\n if l == r and nums[j] < sorted_subarray[mid]:\\n correct_idx = mid\\n break\\n if nums[j] < sorted_subarray[mid]:\\n r = mid\\n else:\\n l = mid + 1\\n # print(len(sorted_subarray), correct_idx)\\n sorted_subarray.insert(correct_idx, nums[j])\\n # print(j, correct_idx, sorted_subarray)\\n\\n # update the `ans`\\n if correct_idx == 0:\\n count += int(sorted_subarray[0] + 1 < sorted_subarray[1])\\n elif correct_idx == len(sorted_subarray)-1:\\n count += int(sorted_subarray[-1] - 1 > sorted_subarray[-2])\\n else:\\n idx = correct_idx\\n if sorted_subarray[idx-1] + 1 < sorted_subarray[idx] \\\\\\n and sorted_subarray[idx] + 1 < sorted_subarray[idx+1]:\\n count += 1\\n elif sorted_subarray[idx-1] + 1 == sorted_subarray[idx] \\\\\\n and sorted_subarray[idx] + 1 == sorted_subarray[idx+1]:\\n count -= 1\\n ans += count\\n # print(f\\\"Count: {count}, Answer: {ans}\\\")\\n return ans\",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"class Solution:\\r\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\r\\n ans = 0\\r\\n for lf in range(len(nums)):\\r\\n win = []\\r\\n cnt = 0\\r\\n for rh in range(lf, len(nums)):\\r\\n index = bisect_left(win, nums[rh])\\r\\n # on the left\\r\\n if len(win) > 0 and index == 0:\\r\\n cnt += 1 if win[0] - nums[rh] > 1 else 0\\r\\n # on the right\\r\\n elif len(win) > 0 and index == len(win):\\r\\n cnt += 1 if nums[rh] - win[-1] > 1 else 0\\r\\n # in between\\r\\n elif len(win) > 1:\\r\\n t1 = 1 if nums[rh] - win[index-1] > 1 else 0\\r\\n t2 = 1 if win[index] - nums[rh] > 1 else 0\\r\\n if t1 + t2 == 2:\\r\\n cnt += 1\\r\\n elif t1 + t2 == 1:\\r\\n cnt = cnt\\r\\n else:\\r\\n if win[index] - win[index-1] > 1:\\r\\n cnt -= 1\\r\\n else:\\r\\n cnt = cnt\\r\\n insort_left(win, nums[rh])\\r\\n ans += cnt\\r\\n # print(f\\\"{lf} : {rh} : {cnt}\\\")\\r\\n return ans\\r\\n # in between\",\n \"runtime\": \"644\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n status = [\\n [0, 0, 1],\\n [0, -1, 0],\\n [1, 0, 1]\\n ]\\n\\n for i in range(n):\\n sl = SortedList()\\n temp = 0\\n\\n for j in range(i, n):\\n if nums[j] in sl:\\n res += temp\\n continue\\n idx = sl.bisect_left(nums[j])\\n \\n left_status = right_status = 0\\n\\n if 0 <= idx - 1 < len(sl):\\n if nums[j] - sl[idx - 1] > 1:\\n left_status = 2\\n else:\\n left_status = 1\\n \\n if idx < len(sl):\\n if sl[idx] - nums[j] > 1:\\n right_status = 2\\n else:\\n right_status = 1\\n \\n temp += status[left_status][right_status]\\n\\n res += temp\\n sl.add(nums[j])\\n\\n return res\",\n \"runtime\": \"688\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n): \\n cnt = 0 \\n sl = SortedList()\\n for j in range(i, n): \\n if nums[j] not in sl: \\n k = sl.bisect_left(nums[j])\\n if k and k < len(sl) and sl[k-1]+1 < sl[k]: cnt -= 1\\n if k and sl[k-1]+1 < nums[j]: cnt += 1\\n if k < len(sl) and nums[j]+1 < sl[k]: cnt += 1\\n sl.add(nums[j])\\n ans += cnt \\n return ans \",\n \"runtime\": \"733\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n \\n result = 0\\n for st in range(len(nums)):\\n sl = SortedList([nums[st]])\\n currsumimb = 0\\n for end in range(st+1, len(nums)):\\n num = nums[end]\\n j = sl.bisect_left(num)\\n if j == 0:\\n if sl[0] - num > 1:\\n currsumimb += 1\\n elif j == len(sl):\\n if num - sl[-1] > 1:\\n currsumimb += 1\\n else:\\n nxt = sl[j]\\n prv = sl[j-1]\\n if nxt - prv > 1:\\n currsumimb -= 1\\n if nxt - num > 1:\\n currsumimb += 1\\n if num - prv > 1:\\n currsumimb += 1\\n sl.add(num)\\n result += currsumimb\\n \\n return result\",\n \"runtime\": \"777\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n-1):\\n sl = SortedList()\\n sl.add(nums[i])\\n inBalance = 0\\n for j in range(i+1, n):\\n idx = sl.bisect_left(nums[j])\\n if idx < len(sl) and sl[idx] == nums[j]:\\n ans += inBalance\\n sl.add(nums[j])\\n continue\\n pre = sl[idx-1] if idx > 0 else 0\\n post = sl[idx] if idx < len(sl) else 0\\n if post and post-nums[j] > 1:\\n inBalance += 1\\n if pre and nums[j]-pre > 1:\\n inBalance += 1\\n if pre and post and post - pre > 1:\\n inBalance -= 1\\n ans += inBalance\\n sl.add(nums[j])\\n return ans\",\n \"runtime\": \"822\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n for i in range(n):\\n sl = SortedList() \\n sl.add(nums[i])\\n tmpres = 0 \\n for j in range(i+1, n):\\n idx = sl.bisect_right(nums[j])\\n if idx:\\n if idx == len(sl):\\n if nums[j] - sl[-1] > 1:\\n tmpres += 1\\n else:\\n if sl[idx] - sl[idx-1] > 1:\\n if nums[j] - sl[idx-1] > 1 and sl[idx] - nums[j] > 1:\\n tmpres += 1\\n elif nums[j] - sl[idx-1] <= 1 and sl[idx] - nums[j] <= 1:\\n tmpres -= 1\\n else:\\n if sl[0] - nums[j] > 1:\\n tmpres += 1\\n res += tmpres\\n sl.add(nums[j])\\n return res\",\n \"runtime\": \"866\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n ans = 0\\n sz = len(nums)\\n for i in range(sz):\\n sl = SortedList()\\n curr = 0\\n for j in range(i, sz):\\n \\n if not sl: \\n sl.add(nums[i])\\n continue\\n n = len(sl)\\n idx = sl.bisect_left(nums[j])\\n if idx == n:\\n curr += 1 if nums[j] - sl[-1] > 1 else 0\\n sl.add(nums[j])\\n elif idx == 0:\\n curr += 1 if sl[0] - nums[j] > 1 else 0\\n sl.add(nums[j])\\n else:\\n a = sl[idx - 1]\\n b = sl[idx]\\n if b - a <= 1:\\n sl.add(nums[j])\\n ans += curr\\n continue\\n curr -= 1\\n fuck = [a, nums[j] ,b]\\n for i in range(len(fuck) - 1):\\n if fuck[i + 1] - fuck[i] > 1:\\n curr += 1\\n sl.add(nums[j])\\n ans += curr\\n return ans\",\n \"runtime\": \"911\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n res = 0\\n \\n for i in range(len(nums)):\\n sl = SortedList()\\n sl.add(nums[i])\\n \\n score = 0\\n for j in range(i+1, len(nums)):\\n pos = sl.bisect_right(nums[j])\\n minn, maxx = sl[0], sl[-1]\\n \\n if pos >= len(sl):\\n # the new number is the largest\\n if nums[j] - maxx > 1:\\n score += 1\\n \\n elif pos == 0:\\n # the new number is the smallest\\n if minn - nums[j] > 1:\\n score += 1\\n \\n else:\\n \\n # look at both elements on the left and on the right\\n left, right = sl[pos-1], sl[pos]\\n \\n # previous gap destroyed\\n if right - left > 1:\\n score -= 1\\n \\n # newly formed gaps\\n if right - nums[j] > 1:\\n score += 1\\n \\n if nums[j] - left > 1:\\n score += 1\\n \\n sl.add(nums[j])\\n res += score\\n \\n return res\\n \\n \\n \\n \\n \",\n \"runtime\": \"955\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n res = 0\\n n = len(nums)\\n\\n for i in range(n):\\n curr = 0\\n sl = SortedList([nums[i]])\\n\\n for j in range(i + 1, n):\\n k = sl.bisect_left(nums[j])\\n\\n if 0 < k < len(sl):\\n lgap = nums[j] - sl[k - 1]\\n rgap = sl[k] - nums[j]\\n if lgap == rgap == 1:\\n curr -= 1\\n elif lgap > 1 and rgap > 1:\\n curr += 1\\n elif k == 0:\\n curr += ((sl[0] - nums[j]) > 1)\\n else:\\n curr += ((nums[j] - sl[-1]) > 1)\\n res += curr\\n sl.add(nums[j])\\n return res\\n \\n \",\n \"runtime\": \"999\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n #print(i)\\n for j in range(i,n):\\n v = nums[j]\\n m = len(sl)\\n pos = sl.bisect_left(v)\\n if(pos == 0):\\n #add start\\n if(m==0):\\n pass\\n else:\\n if(v+1<sl[0]):\\n cnt +=1\\n elif(pos == m):\\n #add end\\n if(sl[m-1]+1<v):\\n cnt +=1\\n else:\\n pass\\n else:\\n #add to middle\\n if(v == sl[pos]):\\n pass\\n elif(sl[pos]-sl[pos-1]==1):\\n pass\\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\\n #break the original one\\n cnt -=1\\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\\n #no change\\n pass\\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\\n #no change\\n pass\\n else:\\n cnt +=1\\n \\n\\n #print((j,pos,cnt))\\n sl.add(v)\\n ans += cnt\\n return ans\",\n \"runtime\": \"1044\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n #print(i)\\n for j in range(i,n):\\n v = nums[j]\\n m = len(sl)\\n pos = sl.bisect_left(v)\\n if(pos == 0):\\n #add start\\n if(m==0):\\n pass\\n else:\\n if(v+1<sl[0]):\\n cnt +=1\\n elif(pos == m):\\n #add end\\n if(sl[m-1]+1<v):\\n cnt +=1\\n else:\\n pass\\n else:\\n #add to middle\\n if(v == sl[pos]):\\n pass\\n elif(sl[pos]-sl[pos-1]==1):\\n pass\\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\\n #break the original one\\n cnt -=1\\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\\n #no change\\n pass\\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\\n #no change\\n pass\\n else:\\n cnt +=1\\n \\n sl.add(v)\\n ans += cnt\\n return ans\",\n \"runtime\": \"1088\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n #print(i)\\n for j in range(i,n):\\n v = nums[j]\\n m = len(sl)\\n pos = sl.bisect_left(v)\\n if(pos == 0):\\n #add start\\n if(m==0):\\n pass\\n else:\\n if(v+1<sl[0]):\\n cnt +=1\\n elif(pos == m):\\n #add end\\n if(sl[m-1]+1<v):\\n cnt +=1\\n else:\\n pass\\n else:\\n #add to middle\\n if(v == sl[pos]):\\n pass\\n elif(sl[pos]-sl[pos-1]==1):\\n pass\\n elif(sl[pos-1]+1 == v and v+1 == sl[pos]):\\n #break the original one\\n cnt -=1\\n elif(sl[pos-1]+1 == v and v+1 < sl[pos]):\\n #no change\\n pass\\n elif(sl[pos-1]+1 < v and v+1 == sl[pos]):\\n #no change\\n pass\\n else:\\n cnt +=1\\n \\n sl.add(v)\\n ans += cnt\\n return ans\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n res = 0\\n \\n for p in range(len(nums)):\\n elems = SortedList()\\n elems.add(nums[p])\\n cnt = 0\\n for q in range(p+1, len(nums)):\\n pos = elems.bisect_left(nums[q])\\n if pos >= len(elems): # largest number in the subarray\\n if nums[q] - elems[-1] > 1:\\n cnt += 1\\n elif pos == 0: # smallest number in the subarray\\n if elems[0] - nums[q] > 1:\\n cnt += 1\\n else:\\n if elems[pos] - elems[pos-1] > 1:\\n cnt -= 1\\n if nums[q] - elems[pos-1] > 1:\\n cnt += 1\\n if elems[pos] - nums[q] > 1:\\n cnt += 1\\n elems.add(nums[q])\\n \\n res += cnt\\n #print(p, q, cnt, res)\\n \\n return res\\n \",\n \"runtime\": \"1177\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\",\n \"runtime\": \"1222\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n count = 0\\n contr = defaultdict(int)\\n\\n for j in range(i, n):\\n cur = nums[j]\\n if sl:\\n pos = sl.bisect_left((nums[j], j))\\n if pos > 0:\\n ele, idx = sl[pos-1]\\n prevContr = contr[idx] # change pos to index in nums\\n \\n if cur > ele + 1:\\n if prevContr == 0:\\n count += 1\\n contr[idx] = 1\\n # contr[j] = int(prevContr == 0)\\n else:\\n if prevContr == 1:\\n contr[idx] = 0\\n count -= 1\\n # contr[idx] = int(prevContr == 1)\\n\\n if 0 <= pos < len(sl):\\n ele, idx = sl[pos]\\n nextContr = contr[idx]\\n \\n if cur + 1 < ele:\\n count += 1\\n contr[j] = 1\\n else:\\n # count -= 1\\n contr[j] = 0\\n\\n ans += count\\n sl.add((nums[j], j))\\n\\n return ans\",\n \"runtime\": \"1266\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\",\n \"runtime\": \"1311\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n cnt = 0\\n sl = SortedList()\\n sl.add(nums[i])\\n for j in range(i + 1, n):\\n k = sl.bisect_left(nums[j])\\n if k < len(sl) and sl[k] - nums[j] > 1: cnt += 1\\n if k > 0 and nums[j] - sl[k - 1] > 1: cnt += 1\\n if 0 < k < len(sl) and sl[k] - sl[k - 1] > 1: cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\",\n \"runtime\": \"1355\"\n },\n {\n \"code\": \"# Daily\\n\\nfrom sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\\n\",\n \"runtime\": \"1400\"\n },\n {\n \"code\": \"import sortedcontainers\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, N: List[int]) -> int:\\n n = len(N)\\n T = 0\\n for i in range(n):\\n L = sortedcontainers.SortedList()\\n S = 0\\n for a in N[i:]:\\n j = L.bisect(a)\\n if 0<j<len(L):\\n S -= (L[j]-L[j-1]>1)\\n if j<len(L):\\n S += (L[j]-a>1)\\n if 0<j:\\n S += (a-L[j-1]>1)\\n T+=S\\n L.add(a)\\n return T\",\n \"runtime\": \"1444\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\",\n \"runtime\": \"1489\"\n },\n {\n \"code\": \"# Daily\\n\\nfrom sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\\n\",\n \"runtime\": \"1533\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":41,"string":"41"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n for i in range(n):\n s = set()\n cur = -1\n for j in range(i, n):\n cur += 0 if nums[j] in s else 1 - (nums[j] + 1 in s) - (nums[j] - 1 in s)\n s.add(nums[j])\n res += cur\n return res","memory":"16500"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums):\n n = len(nums)\n total_sum = 0\n for i in range(n):\n seen = [False] * (n + 2) \n connected_components = 0\n for j in range(i, n):\n num = nums[j]\n if not seen[num]:\n adj_seen = 0\n if num - 1 >= 1 and seen[num - 1]:\n adj_seen += 1\n if num + 1 <= n and seen[num + 1]:\n adj_seen += 1\n delta_cc = 1 - adj_seen\n connected_components += delta_cc\n seen[num] = True\n imbalance = connected_components - 1\n total_sum += imbalance\n return total_sum","memory":"16600"},{"code":"class Solution:\n # def sumImbalanceNumbers(self, A: List[int]) -> int:\n # n = len(A)\n # left = [-1] * n\n # last = [-1] * (n + 2)\n # for i in range(n):\n # left[i] = last[A[i] + 1]\n # last[A[i]] = i\n # right = [n] * n\n # last = [n] * (n + 2)\n # for i in range(n - 1, -1, -1):\n # right[i] = min(last[A[i]], last[A[i] + 1])\n # last[A[i]] = i\n # ans = 0\n # for i in range(n):\n # ans += (i - left[i]) * (right[i] - i)\n # return ans - n * (n + 1) // 2\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n r = 0\n for i in range(n):\n s = set()\n temp = 0\n for j in range(i, n):\n if nums[j] not in s:\n s.add(nums[j])\n temp += 1 - (nums[j] + 1 in s) - (nums[j] - 1 in s)\n r += temp-1\n return r","memory":"16700"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n ans = 0\n for i in range(len(nums)):\n m = set([nums[i]])\n ok = True\n c = 0\n for j in reversed(range(i)):\n n = nums[j]\n if ok:\n if n in m or n - 1 in m or n + 1 in m:\n pass\n else:\n ok = False\n ans += 1\n c = 1\n # print(\"(1)\", j, i, nums[j:i+1])\n else:\n if n in m:\n ans += c\n elif n - 1 in m and n + 1 in m:\n c -= 1 \n ans += c\n #print(\"(3)\", j, i, nums[j:i+1], c)\n if c == 0:\n ok = True\n else:\n if n not in m and n - 1 not in m and n + 1 not in m:\n c += 1\n #print(\"(2)\", j, i, nums[j:i+1], c)\n ans += c\n m.add(n)\n return ans","memory":"16700"},{"code":"from sortedcontainers import SortedList\n\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n):\n sl = SortedList()\n cnt = 0\n for j in range(i, n):\n k = sl.bisect_left(nums[j])\n h = k - 1\n if h >= 0 and nums[j] - sl[h] > 1:\n cnt += 1\n if k < len(sl) and sl[k] - nums[j] > 1:\n cnt += 1\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\n cnt -= 1\n sl.add(nums[j])\n ans += cnt\n return ans","memory":"17000"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n for i in range(n): \n cnt = 0 \n sl = SortedList()\n for j in range(i, n): \n if nums[j] not in sl: \n k = sl.bisect_left(nums[j])\n if k and k < len(sl) and sl[k-1]+1 < sl[k]: cnt -= 1\n if k and sl[k-1]+1 < nums[j]: cnt += 1\n if k < len(sl) and nums[j]+1 < sl[k]: cnt += 1\n sl.add(nums[j])\n ans += cnt \n return ans ","memory":"17100"},{"code":"class Solution:\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\n from sortedcontainers import SortedList\n ret = 0\n for i in range(len(nums)):\n sl = SortedList()\n cur = 0\n for j in range(i, len(nums)):\n ind = sl.bisect_left(nums[j])\n first = ind == len(sl) or sl[ind] != nums[j]\n sl.add(nums[j])\n ind = sl.bisect_left(nums[j])\n if first and ind + 1 == len(sl) and ind > 0 and sl[ind - 1] + 1 < nums[j]:\n # unmax prev\n cur += 1\n if first and ind + 1 < len(sl) and nums[j] + 1 < sl[ind + 1]:\n # add nums[j]\n cur += 1\n if first and ind > 0 and ind + 1 < len(sl) and sl[ind - 1] + 1 == nums[j]:\n cur -= 1\n ret += cur\n # print(i, j, sl, cur, ret)\n return ret\n","memory":"17200"}],"string":"[\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n for i in range(n):\\n s = set()\\n cur = -1\\n for j in range(i, n):\\n cur += 0 if nums[j] in s else 1 - (nums[j] + 1 in s) - (nums[j] - 1 in s)\\n s.add(nums[j])\\n res += cur\\n return res\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums):\\n n = len(nums)\\n total_sum = 0\\n for i in range(n):\\n seen = [False] * (n + 2) \\n connected_components = 0\\n for j in range(i, n):\\n num = nums[j]\\n if not seen[num]:\\n adj_seen = 0\\n if num - 1 >= 1 and seen[num - 1]:\\n adj_seen += 1\\n if num + 1 <= n and seen[num + 1]:\\n adj_seen += 1\\n delta_cc = 1 - adj_seen\\n connected_components += delta_cc\\n seen[num] = True\\n imbalance = connected_components - 1\\n total_sum += imbalance\\n return total_sum\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n # def sumImbalanceNumbers(self, A: List[int]) -> int:\\n # n = len(A)\\n # left = [-1] * n\\n # last = [-1] * (n + 2)\\n # for i in range(n):\\n # left[i] = last[A[i] + 1]\\n # last[A[i]] = i\\n # right = [n] * n\\n # last = [n] * (n + 2)\\n # for i in range(n - 1, -1, -1):\\n # right[i] = min(last[A[i]], last[A[i] + 1])\\n # last[A[i]] = i\\n # ans = 0\\n # for i in range(n):\\n # ans += (i - left[i]) * (right[i] - i)\\n # return ans - n * (n + 1) // 2\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n r = 0\\n for i in range(n):\\n s = set()\\n temp = 0\\n for j in range(i, n):\\n if nums[j] not in s:\\n s.add(nums[j])\\n temp += 1 - (nums[j] + 1 in s) - (nums[j] - 1 in s)\\n r += temp-1\\n return r\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n ans = 0\\n for i in range(len(nums)):\\n m = set([nums[i]])\\n ok = True\\n c = 0\\n for j in reversed(range(i)):\\n n = nums[j]\\n if ok:\\n if n in m or n - 1 in m or n + 1 in m:\\n pass\\n else:\\n ok = False\\n ans += 1\\n c = 1\\n # print(\\\"(1)\\\", j, i, nums[j:i+1])\\n else:\\n if n in m:\\n ans += c\\n elif n - 1 in m and n + 1 in m:\\n c -= 1 \\n ans += c\\n #print(\\\"(3)\\\", j, i, nums[j:i+1], c)\\n if c == 0:\\n ok = True\\n else:\\n if n not in m and n - 1 not in m and n + 1 not in m:\\n c += 1\\n #print(\\\"(2)\\\", j, i, nums[j:i+1], c)\\n ans += c\\n m.add(n)\\n return ans\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n):\\n sl = SortedList()\\n cnt = 0\\n for j in range(i, n):\\n k = sl.bisect_left(nums[j])\\n h = k - 1\\n if h >= 0 and nums[j] - sl[h] > 1:\\n cnt += 1\\n if k < len(sl) and sl[k] - nums[j] > 1:\\n cnt += 1\\n if h >= 0 and k < len(sl) and sl[k] - sl[h] > 1:\\n cnt -= 1\\n sl.add(nums[j])\\n ans += cnt\\n return ans\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n for i in range(n): \\n cnt = 0 \\n sl = SortedList()\\n for j in range(i, n): \\n if nums[j] not in sl: \\n k = sl.bisect_left(nums[j])\\n if k and k < len(sl) and sl[k-1]+1 < sl[k]: cnt -= 1\\n if k and sl[k-1]+1 < nums[j]: cnt += 1\\n if k < len(sl) and nums[j]+1 < sl[k]: cnt += 1\\n sl.add(nums[j])\\n ans += cnt \\n return ans \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def sumImbalanceNumbers(self, nums: List[int]) -> int:\\n from sortedcontainers import SortedList\\n ret = 0\\n for i in range(len(nums)):\\n sl = SortedList()\\n cur = 0\\n for j in range(i, len(nums)):\\n ind = sl.bisect_left(nums[j])\\n first = ind == len(sl) or sl[ind] != nums[j]\\n sl.add(nums[j])\\n ind = sl.bisect_left(nums[j])\\n if first and ind + 1 == len(sl) and ind > 0 and sl[ind - 1] + 1 < nums[j]:\\n # unmax prev\\n cur += 1\\n if first and ind + 1 < len(sl) and nums[j] + 1 < sl[ind + 1]:\\n # add nums[j]\\n cur += 1\\n if first and ind > 0 and ind + 1 < len(sl) and sl[ind - 1] + 1 == nums[j]:\\n cur -= 1\\n ret += cur\\n # print(i, j, sl, cur, ret)\\n return ret\\n\",\n \"memory\": \"17200\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":7,"string":"7"}}},{"rowIdx":2453,"cells":{"question_id":{"kind":"number","value":2588,"string":"2,588"},"name":{"kind":"string","value":"maximum-number-of-points-from-grid-queries"},"content":{"kind":"string","value":"<p>You are given an <code>m x n</code> integer matrix <code>grid</code> and an array <code>queries</code> of size <code>k</code>.</p>\n\n<p>Find an array <code>answer</code> of size <code>k</code> such that for each integer <code>queries[i]</code> you start in the <strong>top left</strong> cell of the matrix and repeat the following process:</p>\n\n<ul>\n\t<li>If <code>queries[i]</code> is <strong>strictly</strong> greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any <strong>adjacent</strong> cell in all <code>4</code> directions: up, down, left, and right.</li>\n\t<li>Otherwise, you do not get any points, and you end this process.</li>\n</ul>\n\n<p>After the process, <code>answer[i]</code> is the <strong>maximum</strong> number of points you can get. <strong>Note</strong> that for each query you are allowed to visit the same cell <strong>multiple</strong> times.</p>\n\n<p>Return <em>the resulting array</em> <code>answer</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2022/10/19/yetgriddrawio.png\" style=\"width: 571px; height: 151px;\" />\n<pre>\n<strong>Input:</strong> grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]\n<strong>Output:</strong> [5,8,1]\n<strong>Explanation:</strong> The diagrams above show which cells we visit to get points for each query.</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2022/10/20/yetgriddrawio-2.png\" />\n<pre>\n<strong>Input:</strong> grid = [[5,2,1],[1,1,2]], queries = [3]\n<strong>Output:</strong> [0]\n<strong>Explanation:</strong> We can not get any points because the value of the top left cell is already greater than or equal to 3.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>m == grid.length</code></li>\n\t<li><code>n == grid[i].length</code></li>\n\t<li><code>2 <= m, n <= 1000</code></li>\n\t<li><code>4 <= m * n <= 10<sup>5</sup></code></li>\n\t<li><code>k == queries.length</code></li>\n\t<li><code>1 <= k <= 10<sup>4</sup></code></li>\n\t<li><code>1 <= grid[i][j], queries[i] <= 10<sup>6</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":37.995223111043714,"string":"37.995223"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","two-pointers","breadth-first-search","union-find","sorting","heap-priority-queue","matrix"],"string":"[\n \"array\",\n \"two-pointers\",\n \"breadth-first-search\",\n \"union-find\",\n \"sorting\",\n \"heap-priority-queue\",\n \"matrix\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"637\", 2.0724], [\"663\", 0.5181], [\"689\", 0.5181], [\"715\", 1.0363], [\"741\", 1.0363], [\"767\", 0.5181], [\"793\", 10.880600000000001], [\"819\", 5.699399999999999], [\"845\", 4.6631], [\"871\", 1.5543], [\"897\", 2.0724], [\"923\", 4.1449], [\"949\", 6.735400000000002], [\"975\", 9.326200000000002], [\"1001\", 4.6631], [\"1027\", 5.6993], [\"1053\", 6.217300000000002], [\"1079\", 6.735799999999999], [\"1105\", 2.5906], [\"1131\", 2.5905], [\"1157\", 1.5543], [\"1183\", 0.5181], [\"1209\", 1.0362], [\"1235\", 0.5181], [\"1261\", 1.0362], [\"1287\", 1.0362], [\"1313\", 0.5181], [\"1340\", 0.5181], [\"1366\", 1.0362], [\"1392\", 0.5181], [\"1418\", 0.5181], [\"1444\", 0.5181], [\"1470\", 0.5181], [\"1496\", 0.5181], [\"1522\", 0.5181], [\"1548\", 0.5181], [\"1574\", 0.5181], [\"1600\", 0.5181], [\"1626\", 0.5181], [\"1652\", 0.5181], [\"1678\", 0.5181], [\"1704\", 0.5181], [\"1730\", 0.5181], [\"1756\", 0.5181]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"28600\", 1.5544], [\"28700\", 1.0363], [\"28900\", 0.5181], [\"29500\", 2.5907], [\"29600\", 2.5907], [\"29700\", 1.0363], [\"29800\", 4.6632], [\"29900\", 1.5544], [\"30100\", 1.0363], [\"30200\", 0.5181], [\"30300\", 0.5181], [\"31800\", 1.0363], [\"32000\", 0.5181], [\"32100\", 0.5181], [\"32200\", 0.5181], [\"32500\", 0.5181], [\"32600\", 2.0725], [\"32700\", 1.0363], [\"33000\", 1.0363], [\"33100\", 3.1088], [\"33200\", 3.1088], [\"33300\", 0.5181], [\"33400\", 0.5181], [\"33800\", 0.5181], [\"35000\", 0.5181], [\"35700\", 0.5181], [\"35800\", 0.5181], [\"37300\", 1.5544], [\"37400\", 0.5181], [\"39900\", 0.5181], [\"40500\", 0.5181], [\"40700\", 0.5181], [\"40900\", 1.0363], [\"41000\", 0.5181], [\"41200\", 0.5181], [\"41300\", 0.5181], [\"41500\", 0.5181], [\"41600\", 0.5181], [\"41700\", 0.5181], [\"42400\", 1.0363], [\"42500\", 2.5907], [\"42600\", 5.6995], [\"42700\", 1.5544], [\"42800\", 3.1088], [\"42900\", 2.5907], [\"43100\", 1.5544], [\"43300\", 0.5181], [\"43400\", 1.0363], [\"43500\", 1.0363], [\"43600\", 1.5544], [\"43700\", 7.772], [\"43800\", 15.544], [\"43900\", 2.5907], [\"44200\", 0.5181], [\"44300\", 0.5181], [\"44400\", 1.0363], [\"44500\", 0.5181], [\"44700\", 1.0363], [\"44800\", 1.0363]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n q = len(queries)\n\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\n answers = [0] * q\n prev_query = 0\n points = 0\n fringe = [(grid[0][0], 0, 0)]\n heapq.heapify(fringe)\n\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\n\n for i in sorted_indices:\n query = queries[i]\n # print(query, '----------------')\n # print(fringe)\n\n if query == prev_query:\n answers[i] = points\n continue\n\n stack = deque()\n while fringe and fringe[0][0] < query:\n (val, r, c) = heapq.heappop(fringe)\n stack.append((r, c))\n points += 1\n grid[r][c] = 0\n\n while stack:\n (r, c) = stack.pop()\n # print(r, c)\n for (x, y) in dirs:\n rr = r + x\n cc = c + y\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\n if grid[rr][cc] < query:\n stack.append((rr, cc))\n points += 1\n else:\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\n grid[rr][cc] = 0\n\n answers[i] = points\n prev_query = query\n\n return answers","runtime":"637"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries2: List[int]) -> List[int]:\n queries = sorted(set(queries2))\n res = {}\n rows, cols = len(grid), len(grid[0])\n q = [(grid[0][0], 0, 0)]\n prevCount = 0\n\n for num in queries:\n count = prevCount\n\n while q:\n val, r, c = q[0]\n if val >= num: break\n else:\n heappop(q)\n grid[r][c] = None\n count += 1\n \n for i, j in [(r+1, c), (r, c+1), (r-1, c), (r, c-1)]:\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\n heappush(q, (grid[i][j], i, j))\n grid[i][j] = None\n \n res[num] = prevCount = count\n ans = [res[num] for num in queries2]\n return ans\n\n def maxPoints2(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\n def calculate(i, j, maximum, visited):\n if visited[i][j] == 1: return 0\n visited[i][j] = 1\n if grid[i-1][j-1] >= maximum: return 0\n\n return 1 + calculate(i, j-1, maximum, visited) + calculate(i, j+1, maximum, visited) + calculate(i-1, j, maximum, visited) + calculate(i+1, j, maximum, visited)\n\n result = []\n for maximum in queries: \n visited = [[0 for i in range(len(grid[0])+2)] for j in range(len(grid)+2)]\n \n for i in range(len(visited[0])):\n visited[0][i] = 1\n visited[len(visited)-1][i] = 1\n \n for j in range(len(visited)):\n visited[j][0] = 1\n visited[j][len(visited[0])-1] = 1\n\n result.append(calculate(1, 1, maximum, visited))\n return result\n","runtime":"689"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n qs = sorted(set(queries))\n res = dict()\n rows, cols = len(grid), len(grid[0])\n q = [(grid[0][0], 0, 0)]\n prevCount = 0\n\n for num in qs:\n count = prevCount\n while q:\n val, r, c = q[0]\n\n if val >= num:\n break\n else:\n heappop(q)\n grid[r][c] = None\n count += 1\n\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\n heappush(q, (grid[i][j], i, j))\n grid[i][j] = None\n \n res[num] = prevCount = count\n\n out = [res[num] for num in queries]\n return out","runtime":"715"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n num_queries = len(queries)\n \n # Sort queries and keep track of their original indices\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\n \n # Prepare the answer array\n answer = [0] * num_queries\n \n # Directions for moving up, down, left, and right\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Priority queue for BFS\n pq = []\n # Visited matrix\n visited = [[False] * n for _ in range(m)]\n \n # Start from the top-left corner\n heappush(pq, (grid[0][0], 0, 0))\n visited[0][0] = True\n current_points = 0\n \n # Process the queries in sorted order\n for query_value, original_index in sorted_queries:\n # Expand the BFS frontier for the current query_value\n while pq and pq[0][0] < query_value:\n value, x, y = heappop(pq)\n current_points += 1\n\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heappush(pq, (grid[nx][ny], nx, ny))\n \n # Store the result for this query\n answer[original_index] = current_points\n \n return answer","runtime":"741"},{"code":"import heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n n, m = len(grid[0]), len(grid)\n k = len(queries)\n\n ordered_queries = sorted((q, i) for i, q in enumerate(queries))\n answer = [0] * k\n \n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n\n heap = []\n heapq.heappush(heap, (grid[0][0], 0, 0))\n\n directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]\n\n point = 0\n\n for q, i in ordered_queries:\n while heap and heap[0][0] < q:\n val, x, y = heapq.heappop(heap)\n point += 1\n\n for dx, dy in directions:\n xn = dx + x\n ym = dy + y\n\n if 0 <= xn < n and 0 <= ym < m and not visited[ym][xn]:\n visited[ym][xn] = True\n heapq.heappush(heap, (grid[ym][xn], xn, ym))\n \n answer[i] = point\n \n return answer\n","runtime":"767"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n num_queries = len(queries)\n result = [0] * num_queries\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\n\n # Directions for moving: right, down, left, up\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Min-heap to process grid cells in order of their values\n min_heap = [(grid[0][0], 0, 0)] # (value, x-coordinate, y-coordinate)\n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n\n current_points = 0\n cell_values = []\n\n # Process each query\n for value, idx in indexed_queries:\n # Explore the grid and collect valid cells whose values are below the current query value\n while min_heap and min_heap[0][0] < value:\n cell_value, x, y = heappop(min_heap)\n \n if cell_value < value:\n current_points += 1\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n heappush(min_heap, (grid[nx][ny], nx, ny))\n visited[nx][ny] = True\n else:\n break\n \n result[idx] = current_points\n \n return result\n\n# Example use-cases\nsol = Solution()\nprint(sol.maxPoints([[1,2,3],[2,5,7],[3,5,1]], [5,6,2])) # Output: [5,8,1]\nprint(sol.maxPoints([[5,2,1],[1,1,2]], [3])) # Output: [0]","runtime":"793"},{"code":"class Solution:\n def maxPoints(self, grid, qs: List[int]) -> List[int]:\n queries = sorted(set(qs))\n res = {}\n rows, cols = len(grid), len(grid[0])\n q = [(grid[0][0], 0, 0)] # heap\n prevCount = 0\n\n for num in queries:\n count = prevCount\n\n while q:\n val, r, c = q[0]\n\n if val >= num: break # pop only when the condition satisfy else break\n else:\n heappop(q)\n grid[r][c] = None\n count += 1\n\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\n heappush(q, (grid[i][j], i, j))\n grid[i][j] = None\n\n res[num] = prevCount = count\n\n ans = [res[num] for num in qs]\n return ans","runtime":"793"},{"code":"\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n M = len(grid)\n N = len(grid[0])\n \n visited = [[0 for i in range(N)] for j in range(M)]\n queries_copy = queries.copy()\n queries_copy.sort()\n q = []\n cnt = 0\n rel_dict ={}\n q.append((grid[0][0],0,0))\n for num in queries_copy:\n new_q = []\n \n while(q):\n val, x, y = q[0]\n if val >= num:\n break\n else:\n heappop(q)\n neigbors = [(x+1,y), (x-1,y),(x,y+1), (x,y-1)]\n visited[x][y] = 1\n cnt += 1\n for (a,b) in neigbors:\n if 0<=a <M and 0 <=b<N and visited[a][b] == 0:\n heappush(q, (grid[a][b],a,b))\n visited[a][b] = 1\n \n\n rel_dict[num] = cnt\n ans = []\n for num in queries:\n ans.append(rel_dict[num])\n \n return ans\n\n ","runtime":"819"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n moves = [[1,0], [0, 1], [-1,0], [0,-1]]\n rows, cols = len(grid), len(grid[0])\n qs = sorted(set(queries))\n heap = [(grid[0][0], 0, 0)]\n prev = 0 \n res = {}\n\n for num in qs:\n count = prev \n while heap:\n val, r, c = heap[0]\n if val>=num:\n break\n else:\n heappop(heap)\n grid[r][c] = None\n count += 1\n for move in moves:\n i, j = r + move[0], c + move[1]\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] != None:\n heappush(heap, (grid[i][j], i, j))\n grid[i][j] = None\n res[num] = prev = count\n ans = []\n for num in queries:\n ans.append(res[num])\n return ans\n \n\n\n","runtime":"819"},{"code":"class Solution:\n def maxPoints(self, a: List[List[int]], queries: List[int]) -> List[int]:\n queries = [[val,idx] for idx,val in enumerate(queries)]\n ans = [0]*len(queries)\n queries.sort()\n h = [(a[0][0],0,0)]; a[0][0] = -1\n n,m = len(a),len(a[0])\n count = 0\n for qval,idx in queries:\n while h and h[0][0]<qval:\n val,i,j = heappop(h)\n count+=1\n for p,q in [[1,0],[-1,0],[0,1],[0,-1]]:\n x,y = i+p,j+q\n if 0<=x<n and 0<=y<m and a[x][y]!=-1:\n heappush(h,(a[x][y],x,y))\n a[x][y] = -1\n ans[idx] = count\n return ans\n ","runtime":"845"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n qs = sorted((v, i) for i, v in enumerate(queries))\n ans = [0] * len(qs)\n q = [(grid[0][0], 0, 0)]\n cnt = 0\n vis = [[False] * n for _ in range(m)]\n vis[0][0] = True\n for v, k in qs:\n while q and q[0][0] < v:\n _, i, j = heappop(q)\n cnt += 1\n for a, b in pairwise((-1, 0, 1, 0, -1)):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n and not vis[x][y]:\n heappush(q, (grid[x][y], x, y))\n vis[x][y] = True\n ans[k] = cnt\n return ans","runtime":"845"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n pq = [(grid[0][0], 0, 0)]\n point = []\n prev = -inf\n pre_sc = 0\n m=len(grid)\n n = len(grid[0])\n res = []\n grid[0][0] =0\n while pq:\n v, x, y = heappop(pq)\n if prev != v:\n point.append((prev, pre_sc))\n pre_sc += 1\n prev = v\n for a, b in [0, -1], [0, 1], [1, 0], [-1, 0]:\n xa = x+a\n yb = y+b\n if 0 <= xa < m and 0 <= yb < n and grid[xa][yb]:\n vv = max(v, grid[xa][yb])\n heappush(pq, (vv, xa, yb))\n grid[xa][yb] = 0\n point.append((prev, pre_sc))\n\n for query in queries:\n sci = bisect_left(point, query, key = lambda x: x[0]) - 1\n res.append(point[sci][1])\n return res","runtime":"871"},{"code":"from heapq import heapify, heappush, heappop\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n rows = len(grid)\n cols = len(grid[0])\n newqueries= sorted([(queries[j], j) for j in range(len(queries))])\n\n minheap = [[grid[0][0], 0, 0]]\n heapify(minheap)\n\n visited = [[0 for i in range(cols)]for j in range(rows)]\n visited[0][0] = 1\n \n count = 0\n ans = [0] * len(queries)\n for limit,index in newqueries:\n while(minheap and minheap[0][0]<limit):\n val, i, j = heappop(minheap)\n count+=1\n for a,b in [(0,1),(0,-1),(1,0),(-1,0)]:\n newi = i+a\n newj = j+b\n if(0<=newi<rows and 0<=newj<cols and visited[newi][newj]==0):\n heappush(minheap, [grid[newi][newj], newi, newj])\n visited[newi][newj] = 1\n ans[index] = count\n return ans\n \n \n\n\n","runtime":"871"},{"code":"import heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n ROWS, COLS = len(grid), len(grid[0])\n query_to_res = {}\n new_queries = sorted(queries)\n res = []\n points = 0\n min_heap = []\n visit = set()\n\n heapq.heappush(min_heap, (grid[0][0], 0, 0))\n visit.add((0, 0))\n\n for query in new_queries:\n while min_heap and query > min_heap[0][0]:\n _, i, j = heapq.heappop(min_heap)\n points += 1\n\n directions = [(i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)]\n\n for new_i, new_j in directions:\n if 0 <= new_i < ROWS and 0 <= new_j < COLS and (new_i, new_j) not in visit:\n visit.add((new_i, new_j))\n heapq.heappush(min_heap, (grid[new_i][new_j], new_i, new_j))\n\n query_to_res[query] = points\n \n for this_query in queries:\n res.append(query_to_res[this_query])\n \n return res\n\n\n \n\n\n\n \n \n\n\n\n \n\n ","runtime":"897"},{"code":"from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass IndexedQuery:\n queryIndex: int\n query: int\n\n def __iter__(self):\n yield self.queryIndex\n yield self.query\n\n\nclass Solution:\n def maxPoints(self, grid: list[list[int]], queries: list[int]) -> list[int]:\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n ans = [0] * len(queries)\n minHeap = [(grid[0][0], 0, 0)] # (grid[i][j], i, j)\n seen = {(0, 0)}\n accumulate = 0\n\n for queryIndex, query in sorted([IndexedQuery(i, query)\n for i, query in enumerate(queries)],\n key=lambda x: x.query):\n while minHeap:\n val, i, j = heapq.heappop(minHeap)\n if val >= query:\n # The smallest neighbor is still larger than `query`, so no need to\n # keep exploring. Re-push (i, j, grid[i][j]) back to the `minHeap`.\n heapq.heappush(minHeap, (val, i, j))\n break\n accumulate += 1\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n heapq.heappush(minHeap, (grid[x][y], x, y))\n seen.add((x, y))\n ans[queryIndex] = accumulate\n\n return ans","runtime":"897"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n numRows, numCols = len(grid), len(grid[0])\n queriesSorted, hashMap = sorted(queries), {}\n heap, visited = [(grid[0][0], 0, 0)], set()\n visited.add((0, 0))\n for query in queriesSorted:\n while heap:\n val, row, col = heap[0]\n if val >= query:\n break\n heappop(heap)\n for newRow, newCol in (row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1):\n if newRow < 0 or newRow >= numRows or newCol < 0 or newCol >= numCols: \n continue\n if (newRow, newCol) in visited: \n continue\n heappush(heap, (grid[newRow][newCol], newRow, newCol))\n visited.add((newRow, newCol))\n hashMap[query] = len(visited) - len(heap)\n return [hashMap[query] for query in queries]","runtime":"923"},{"code":"from typing import List\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n # Create a list of tuples (value, x, y) for each position in the grid\n cells = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\n # Sort the cells by their values\n cells.sort()\n \n # Prepare result list for each query\n result = [0] * len(queries)\n # Pair queries with their original indices and sort them\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\n \n # Direction vectors for moving up, down, left, right\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n \n # Track visited cells\n visited = [[False] * n for _ in range(m)]\n # Priority queue for BFS\n pq = []\n # Start from the top-left corner\n heapq.heappush(pq, (grid[0][0], 0, 0))\n visited[0][0] = True\n \n # Keep track of points we can gather\n points = 0\n # Process each query\n for q, original_index in queries_with_indices:\n # Process all cells with value less than the current query\n while pq and pq[0][0] < q:\n value, x, y = heapq.heappop(pq)\n points += 1\n # Explore neighbors\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\n # Assign the result for this query\n result[original_index] = points\n \n return result","runtime":"923"},{"code":"\nimport heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sq = sorted(queries)\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n\n numRows, numCols = len(grid), len(grid[0])\n\n\n priorityQ = [(grid[0][0], 0, 0)]\n seenCord = set()\n seenCord.add((0,0))\n count = 0\n qScore = {}\n\n # time complexity : O(max(q + q*log(q), m*n*log(m*n) + q*log(q) ))\n # space complexity : O(max(q, m + n))\n\n\n for q in sq:\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\n count += 1\n currVal, currRow, currCol = heapq.heappop(priorityQ)\n \n for d in directions:\n\n newRow = currRow + d[0]\n newCol = currCol + d[1]\n\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\n\n if (newRow, newCol) not in seenCord:\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\n seenCord.add((newRow, newCol))\n\n qScore[q] = count\n \n return [qScore[q] for q in queries]\n\n\n","runtime":"949"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n \n min_heap = [(grid[0][0], 0, 0)]\n visited = set()\n visited.add((0,0))\n \n threshold_order = []\n threshold = -1\n \n while min_heap:\n val, r, c = heapq.heappop(min_heap)\n threshold = max(threshold, val)\n threshold_order.append(threshold)\n \n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\n continue\n visited.add((x, y))\n heapq.heappush(min_heap, (grid[x][y], x, y))\n \n res = []\n for q in queries:\n res.append(bisect.bisect_left(threshold_order, q))\n \n return res","runtime":"949"},{"code":"\nimport heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sq = sorted(queries)\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n\n numRows, numCols = len(grid), len(grid[0])\n\n\n priorityQ = [(grid[0][0], 0, 0)]\n seenCord = set()\n seenCord.add((0,0))\n count = 0\n qScore = {}\n\n # time complexity : O(max(q + q*log(q), m*n*log(m*n) + q*log(q) ))\n # space complexity : O(max(q, m + n))\n\n\n for q in sq:\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\n count += 1\n currVal, currRow, currCol = heapq.heappop(priorityQ)\n \n for d in directions:\n\n newRow = currRow + d[0]\n newCol = currCol + d[1]\n\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\n\n if (newRow, newCol) not in seenCord:\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\n seenCord.add((newRow, newCol))\n\n qScore[q] = count\n \n return [qScore[q] for q in queries]\n\n\n","runtime":"975"},{"code":"import heapq as h\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\n q = []\n\n m = len(grid)\n n = len(grid[0])\n\n best = defaultdict(int)\n\n best[(0, 0)] = grid[0][0]\n\n h.heappush(q, (grid[0][0], 0, 0))\n\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\n\n while q and len(best) < m * n:\n (val, x, y) = h.heappop(q)\n\n for [i, j] in moves:\n xi = x + i\n yj = y + j\n \n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\n nVal = max(val, grid[xi][yj])\n best[(xi, yj)] = nVal\n h.heappush(q, (nVal, xi, yj))\n\n counts = defaultdict(int)\n\n for key in best:\n counts[best[key]] += 1\n \n counts = [[x, counts[x]] for x in counts]\n\n counts.sort()\n\n for i in range(1, len(counts)):\n counts[i][1] += counts[i-1][1]\n \n ret = []\n for query in queries:\n query -= 1\n l = 0\n r = len(counts) - 1\n ans = -1\n\n while l <= r:\n mid = (l + r) // 2\n\n if counts[mid][0] <= query:\n ans = mid\n l = mid + 1\n else:\n r = mid - 1\n if ans == -1:\n ret.append(0)\n else:\n ret.append(counts[ans][1])\n \n return ret","runtime":"975"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n \n min_heap = [(grid[0][0], 0, 0)]\n visited = set()\n visited.add((0,0))\n \n threshold_order = []\n threshold = -1\n \n while min_heap:\n val, r, c = heapq.heappop(min_heap)\n threshold = max(threshold, val)\n threshold_order.append(threshold)\n \n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\n continue\n visited.add((x, y))\n heapq.heappush(min_heap, (grid[x][y], x, y))\n \n res = []\n for q in queries:\n res.append(bisect.bisect_left(threshold_order, q))\n \n return res","runtime":"1001"},{"code":"import heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n def dfs(q, r=0, c=0):\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n count = 1\n for dr, dc in dirs:\n nr, nc = r+dr, c+dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\n continue\n if (nr, nc) in edges_set:\n continue\n if q <= grid[nr][nc]:\n heapq.heappush(edges, (grid[nr][nc], nr, nc))\n edges_set.add((nr, nc))\n continue\n visited.add((nr, nc))\n count += dfs(q, nr, nc)\n\n return count\n \n result = [0] * len(queries)\n pos = [(q, i) for i, q in enumerate(queries)]\n pos.sort()\n visited = set()\n edges = [(grid[0][0], 0, 0)]\n edges_set = set() # to avoid additional node being added to edges(heap)\n edges_set.add((0, 0))\n points = 0\n for q, i in pos:\n for _ in range(len(edges)):\n val, r, c = edges[0]\n if q > val and (r, c) not in visited:\n heapq.heappop(edges)\n edges_set.remove((r, c))\n visited.add((r, c))\n points += dfs(q, r, c)\n else:\n break\n result[i] = points\n \n return result","runtime":"1001"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n ret = [0 for _ in range(len(queries))]\n prev = 0\n for q in sorted(list(set(queries))):\n pos = bisect.bisect_left(order, q,lo=prev)\n for idx in mapping[q]:\n ret[idx]=pos\n prev = pos\n return ret\n\n","runtime":"1027"},{"code":"# BFS + PriorityQueue\n\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n rows, cols = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n\n pq = []\n heapq.heappush(pq, (grid[0][0], 0, 0))\n\n visited = set([(0, 0)])\n\n points = 0 # Start with 1 point because we can visit the start cell\n queries = sorted((q,idx) for idx,q in enumerate(queries))\n i = 0\n count = 0\n ans = [0]*len(queries)\n\n for i in range(len(queries)):\n query_value = queries[i][0]\n while pq and pq[0][0] < query_value:\n\n _,x,y = heapq.heappop(pq)\n count += 1\n points += 1\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < rows and 0 <= ny < cols and (nx, ny) not in visited:\n visited.add((nx, ny))\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\n ans[queries[i][1]] = count\n return ans\n \n \n\n\n \n\n\n\n\n","runtime":"1027"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\t\t#It is a simple questions based on the concept of graph\n\t\t#As we all know we can represent a matrix/grid into a graph\n\t\t#Then we can use the heap(min Heap) to get a perfect path.\n\t\t#Then we are using maxYet(means max till that index).\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n # print(order)\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n res = []\n # for each q, do BS to find the index of the first element larger or equal to q\n for i, q in enumerate(queries):\n l, r = 0, len(order) - 1\n while l <= r:\n mid = (l + r) // 2\n if order[mid] >= q:\n r = mid - 1\n else:\n l = mid + 1\n res.append(l)\n # print(order)\n return res","runtime":"1053"},{"code":"import heapq as h\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\n q = []\n\n m = len(grid)\n n = len(grid[0])\n\n best = defaultdict(int)\n\n best[(0, 0)] = grid[0][0]\n\n h.heappush(q, (grid[0][0], 0, 0))\n\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\n\n while q and len(best) < m * n:\n (val, x, y) = h.heappop(q)\n\n for [i, j] in moves:\n xi = x + i\n yj = y + j\n \n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\n nVal = max(val, grid[xi][yj])\n best[(xi, yj)] = nVal\n h.heappush(q, (nVal, xi, yj))\n \n print(best)\n\n counts = defaultdict(int)\n\n for key in best:\n counts[best[key]] += 1\n \n counts = [[x, counts[x]] for x in counts]\n\n counts.sort()\n\n for i in range(1, len(counts)):\n counts[i][1] += counts[i-1][1]\n \n ret = []\n print(counts)\n for query in queries:\n query -= 1\n l = 0\n r = len(counts) - 1\n ans = -1\n\n while l <= r:\n mid = (l + r) // 2\n\n if counts[mid][0] <= query:\n ans = mid\n l = mid + 1\n else:\n r = mid - 1\n if ans == -1:\n ret.append(0)\n else:\n ret.append(counts[ans][1])\n \n return ret","runtime":"1053"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n res = []\n\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n i = 0\n ret = [0 for _ in range(len(queries))]\n for q in sorted(list(set(queries))):\n while i < len(order) and q > order[i]:\n i+=1\n i = i-1\n for idx in mapping[q]:\n ret[idx] = i+1 \n i = max(0,i)\n return ret\n\n","runtime":"1079"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n \n min_heap = [(grid[0][0], 0, 0)]\n visited = set()\n visited.add((0,0))\n \n threshold_order = []\n threshold = -1\n \n while min_heap:\n val, r, c = heapq.heappop(min_heap)\n threshold = max(threshold, val)\n threshold_order.append(threshold)\n \n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\n continue\n visited.add((x, y))\n heapq.heappush(min_heap, (grid[x][y], x, y))\n \n res = []\n \n for q in queries:\n res.append(bisect.bisect_left(threshold_order, q))\n \n return res\n \n \n \n\n \n\n","runtime":"1079"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # Some setup\n dirs = [(0,1),(1,0),(-1,0),(0,-1)]\n nrows = len(grid)\n ncols = len(grid[0])\n\t\t\n # Sort queries. Keep track of the original index.\n q_and_i = [[queries[i], i] for i in range(len(queries))]\n q_and_i.sort() # Sort based on the value of the query\n\t\n # Prepare for BFS. Start with top-left cell.\n answer = [0 for _ in range(len(queries))]\n heap = [[grid[0][0], 0, 0]]\n seen = {(0,0)} # Cells we have seen (but not necessarily visited)\n n_visited = 0\n\t\t\n # BFS. Go through queries from smallest to largest.\n for q, i in q_and_i:\n\t\t # Only visit a cell if it is less than the current query\n while heap and heap[0][0] < q:\n n_visited += 1\n _, r, c = heapq.heappop(heap)\n\t\t\t\t# Check all neighboring cells\n for h, v in dirs:\n r2, c2 = r + v, c + h\n\t\t\t\t\t# Check that coordinates are valid\n if r2 >= 0 and r2 < nrows and c2 >= 0 and c2 < ncols:\n\t\t\t\t\t # Check that the cell has never been in the heap\n if (r2, c2) not in seen:\n\t\t\t\t\t\t # Add cell to our options\n seen.add((r2, c2))\n heapq.heappush(heap, [grid[r2][c2], r2, c2])\n\t\t\t# Update the answer for the current query\n answer[i] = n_visited\n #\n return answer","runtime":"1105"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n\n root = [elem for elem in range(m*n)]\n size = [1] * (m * n)\n\n def find(x):\n if root[x] == x:\n return x\n root[x] = find(root[x])\n return root[x]\n\n def union(x, y):\n root_x = find(x)\n root_y = find(y)\n\n if size[root_x] < size[root_y]:\n root_x, root_y = root_y, root_x\n\n if root_x != root_y:\n root[root_y] = root_x\n size[root_x] += size[root_y]\n\n # if rank[root_x] > rank[root_y]:\n # root[root_y] = root_x\n # size[root_x] += size[root_y] \n # elif rank[root_x] < rank[root_y]:\n # root[root_x] = root_y\n # size[root_y] += size[root_x]\n # else:\n # root[root_y] = root_x\n # rank[root_x] += 1\n # size[root_x] += size[root_y]\n\n def is_connected(x, y):\n return find(x) == find(y)\n \n def get_size(x):\n return size[find(x)]\n\n flatten_grid = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\n flatten_grid.sort()\n \n sorted_queries = [(query, index) for index, query in enumerate(queries)]\n sorted_queries.sort()\n\n answers = [0] * len(queries)\n directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n\n curr_index = 0\n for query, query_index in sorted_queries:\n while curr_index < (m*n) and flatten_grid[curr_index][0] < query:\n _, x, y = flatten_grid[curr_index]\n for dx, dy in directions:\n new_x = x + dx\n new_y = y + dy\n\n if not (0 <= new_x < m) or not (0 <= new_y < n):\n continue\n \n if grid[new_x][new_y] < query:\n union(x * n + y, new_x * n + new_y)\n curr_index += 1\n\n if grid[0][0] < query:\n answers[query_index] = get_size(find(0))\n\n return answers","runtime":"1105"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # sort the queries, to make the from smaller value to bigger value\n # this way we can eliminate some of the recomputation\n # because if smaller value pass, that means the bigger values will pass\n\n # we can keep the same set of visited coordinates? \n # and increase the count for the subsequence queries\n\n # let's say for ex1, we sort the 5 6 2 to 2 5 6\n # we run the 2 first\n # we mark the first cell to be cleared, so count is 1\n # and for 5, we start with count = 1\n # then do bfs , get 5 cells\n # and for 6, we start with count of 5, and spread out\n\n # for the bfs, if the value is >= than the value, we add it back to the queue? \n # because there might be other cells behind it that < than the current value\n\n # how do we mark them as already check?\n # we can add them to a heap, with value, r, c\n # that should help with dealing with the value, or bigger cell\n # so we can start other queries\n\n result = [0 for _ in range(len(queries))]\n\n check = [(i, val) for i, val in enumerate(queries)]\n check.sort(key = lambda x: x[1])\n\n # check = [index, val that we will check]\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n heap = [] # heap = (value, r, c)\n heapq.heappush(heap, (grid[0][0], 0, 0))\n heapq.heappush(heap, (10 ** 6 + 1, -1, -1))\n visited.add((0, 0))\n\n # we start checking from the first value in the check array\n checkIndex = 0\n curCount = 0\n\n \n while heap:\n val, r, c = heapq.heappop(heap)\n # check if the current val is already out of range for our query val\n # move till we find a new value that within range\n while checkIndex < len(check) and val >= check[checkIndex][1]:\n \n result[check[checkIndex][0]] = curCount\n checkIndex += 1\n \n # see if we reach the end of queries but there are still coordinates, we should still break\n if checkIndex == len(check):\n break\n \n # now we have a new query val that within range\n # increase count, and add the neighbors to the heap\n curCount += 1\n\n # go through the neighbors, check if within range and not visited\n # add to the heap\n for dr, dc in [[1, 0], [0, 1], [-1, 0], [0, -1]]:\n if 0 <= r + dr < rows and 0 <= c + dc < cols and (r + dr, c + dc) not in visited:\n heapq.heappush(heap, (grid[r+dr][c+dc], r + dr, c + dc))\n visited.add((r + dr, c + dc))\n\n # print(curCount, checkIndex)\n\n # # we still have 1 last case, where if we reach the end with the extremely big value, that covers every value\n # if checkIndex < len(check) and curCount and result[check[checkIndex][0]] == 0:\n # result[check[checkIndex][0]] = curCount\n\n\n return result\n","runtime":"1131"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n res = []\n for q in queries:\n res.append(bisect.bisect_left(order, q))\n return res\n\n","runtime":"1131"},{"code":"from collections import deque, defaultdict\nfrom bisect import bisect_left\nfrom heapq import heappush as hpush, heappop as hpop, heapify\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n\n def move(x, y):\n return 0 <= x < len(grid) and 0 <= y < len(grid[0])\n \n scores, find = [], []\n\n seen = set([(0,0)])\n q = [(grid[0][0], (0, 0))]\n heapify(q)\n \n curr_max = grid[0][0]\n s = 0\n\n while q:\n score, (x , y) = hpop(q)\n if score > curr_max:\n scores.append(s)\n find.append(curr_max)\n curr_max = score\n s += 1\n for dx, dy in dirs:\n newPos = (x + dx, y + dy)\n if move(*newPos) and newPos not in seen:\n seen.add(newPos)\n hpush(q, (grid[newPos[0]][newPos[1]], newPos))\n\n scores.append(s)\n find.append(curr_max)\n\n res = []\n for q in queries:\n if q <= find[0]:\n res.append(0)\n elif q > find[-1]:\n res.append(scores[-1])\n else:\n idx = bisect_left(find, q)\n res.append(scores[idx - 1])\n return res","runtime":"1157"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n n, m = len(grid), len(grid[0])\n\n directions = [(0,1),(1,0), (-1,0), (0,-1)]\n\n def isValid(row, col):\n return 0 <= row < n and 0 <= col < m and (row,col) not in self.visited\n \n heap = [(grid[0][0], 0, 0)]\n self.visited = set()\n self.visited.add((0,0))\n\n thresholdOrder = []\n threshold = -1\n \n while heap:\n val, row, col = heapq.heappop(heap)\n \n threshold = max(threshold, val)\n thresholdOrder.append(threshold)\n\n for dx, dy in directions:\n newX = row + dx\n newY = col + dy\n if not isValid(newX,newY):\n continue\n self.visited.add((newX,newY))\n heapq.heappush(heap, (grid[newX][newY], newX, newY))\n\n res = []\n\n for query in queries:\n res.append(bisect.bisect_left(thresholdOrder, query))\n\n return res\n","runtime":"1157"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\n results = [0] * len(queries)\n queries = sorted([(q, i) for i, q in enumerate(queries)])\n visited = set()\n heap = [(grid[0][0], 0, 0)]\n \n for q, original_index in queries:\n while heap and heap[0][0] < q:\n value, x, y = heappop(heap)\n if (x, y) not in visited:\n visited.add((x, y))\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heappush(heap, (grid[nx][ny], nx, ny))\n results[original_index] = len(visited)\n \n return results\n ","runtime":"1183"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n mn = m * n\n\n # 并查集模板\n fa = list(range(mn))\n size = [1] * mn\n def find(x: int) -> int:\n if fa[x] != x:\n fa[x] = find(fa[x])\n return fa[x]\n def merge(from_: int, to: int) -> None:\n from_ = find(from_)\n to = find(to)\n if from_ != to:\n fa[from_] = to\n size[to] += size[from_]\n\n # 矩阵元素从小到大排序，方便离线\n a = sorted((x, i, j) for i, row in enumerate(grid) for j, x in enumerate(row))\n\n ans, j = [0] * len(queries), 0\n # 查询的下标按照查询值从小到大排序，方便离线\n for i, q in sorted(enumerate(queries), key=lambda p: p[1]):\n while j < mn and a[j][0] < q:\n _, x, y = a[j]\n # 枚举周围四个格子，值小于 q 才可以合并\n for x2, y2 in (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1):\n if 0 <= x2 < m and 0 <= y2 < n and grid[x2][y2] < q:\n merge(x * n + y, x2 * n + y2) # 把坐标压缩成一维的编号\n j += 1\n if grid[0][0] < q:\n ans[i] = size[find(0)] # 左上角的连通块的大小\n return ans","runtime":"1209"},{"code":"import heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n queries = [(q, i) for i, q in enumerate(queries)]\n s_queries = sorted(queries, key = lambda x: x[0])\n ret = [0] * len(queries)\n visited = set()\n h = [(grid[0][0], 0,0)]\n offsets = [(0,1), (0, -1), (-1, 0), (1, 0)]\n m = len(grid)\n n = len(grid[0])\n count = 0\n for q, i in s_queries:\n while h and h[0][0] < q:\n _, r, c = heappop(h)\n if (r, c) in visited:\n continue\n visited.add((r,c))\n count += 1\n for o in offsets:\n newr, newc = r + o[0], c + o[1]\n if newr >= 0 and newr < m and newc >= 0 and newc < n and (newr, newc) not in visited:\n heappush(h, (grid[newr][newc], newr, newc))\n ret[i] = count\n return ret","runtime":"1209"},{"code":"from heapq import heappush as hpush, heappop as hpop\ndelta = [(0,1), (0,-1), (1,0), (-1,0)]\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n n,m = len(grid), len(grid[0])\n mx = max(queries)\n count = [0] * (mx+1)\n curr = grid[0][0] + 1\n\n h = [(grid[0][0],0,0)]\n grid[0][0] = '#'\n while curr <= mx and h:\n if curr <= h[0][0]:\n curr += 1\n if curr <= mx:\n count[curr] = count[curr-1]\n continue \n u,ux,uy = hpop(h)\n count[curr] += 1\n for dx,dy in delta:\n vx,vy = ux+dx,uy+dy\n if -1 < vx < n and -1 < vy < m and grid[vx][vy] != '#':\n hpush(h,(grid[vx][vy],vx,vy))\n grid[vx][vy] = '#'\n\n while curr < mx:\n count[curr + 1] = count[curr]\n curr += 1\n # print(count)\n return [count[k] for k in queries ]\n \n\n \n\n\n\n\n\n\n","runtime":"1235"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n query_list = sorted(enumerate(queries), key = lambda x: x[1])\n res = [0] * len(queries)\n\n ROWS = len(grid)\n COLS = len(grid[0])\n q = [(grid[0][0], 0, 0)]\n count = 0\n visited = set()\n for query in query_list:\n while q and q[0][0] < query[1]:\n _, r, c = heapq.heappop(q)\n if (r, c) in visited:\n continue\n visited.add((r, c))\n count += 1\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\n if (nr, nc) not in visited and 0 <= nr < ROWS and 0 <= nc < COLS:\n heapq.heappush(q, (grid[nr][nc], nr, nc))\n res[query[0]] = count\n return res","runtime":"1261"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n R, C = len(grid), len(grid[0])\n dxns=[(1,0),(-1,0),(0,1),(0,-1)]\n heap = [(grid[0][0], 0, 0)]\n vis = [[False] * C for _ in range(R)]\n cur = -1\n arr = []\n\n def valid(r, c):\n return 0 <= r < R and 0 <= c < C and not vis[r][c]\n sz = 0\n\n while heap:\n val, r, c = heapq.heappop(heap)\n if vis[r][c]: continue\n vis[r][c] = True\n if val > cur:\n arr.append((cur, sz))\n cur = val\n sz += 1\n for dr, dc in dxns:\n if valid(r + dr, c + dc):\n heapq.heappush(heap, (grid[r + dr][c + dc], r + dr, c + dc))\n arr.append((cur, sz))\n ans = []\n for q in queries:\n i = bisect_left(arr, (q, -1)) - 1\n ans.append(arr[i][1])\n return ans","runtime":"1261"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n query_list = sorted(enumerate(queries), key = lambda x: x[1])\n res = [0] * len(queries)\n\n ROWS = len(grid)\n COLS = len(grid[0])\n q = [(grid[0][0], 0, 0)]\n count = 0\n visited = set()\n for query in query_list:\n if q:\n k = query[1]\n while q and q[0][0] < k:\n _, r, c = heapq.heappop(q)\n if (r, c) in visited:\n continue\n visited.add((r, c))\n count += 1\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\n if (nr, nc) not in visited and 0 <= nr < ROWS and 0 <= nc < COLS:\n heapq.heappush(q, (grid[nr][nc], nr, nc))\n res[query[0]] = count\n return res","runtime":"1287"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n\n visited = {(i,j):False for i in range(m) for j in range(n)}\n sorted_queries = sorted(queries)\n border = [(grid[0][0], 0, 0)]\n score = defaultdict(int)\n current_score = 0\n\n for query in sorted_queries:\n\n while border:\n g,i,j = border[0]\n\n if visited[(i,j)]:\n heapq.heappop(border)\n\n elif g >= query:\n break\n \n else:\n heapq.heappop(border)\n \n current_score += 1\n visited[(i,j)] = True\n \n # add neighbour if neighbour wasn't visited\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\n\n score[query] = current_score\n \n return [score[query] for query in queries]\n","runtime":"1287"},{"code":"class Solution:\n from typing import List\n import heapq\n\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n queries = sorted([(q, i) for i, q in enumerate(queries)])\n answer = [0] * len(queries)\n visited = set()\n heap = [(grid[0][0], 0, 0)]\n count = 0\n\n for q, i in queries:\n while heap and heap[0][0] < q:\n val, x, y = heapq.heappop(heap)\n if (x, y) not in visited:\n visited.add((x, y))\n count += 1\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\n answer[i] = count\n\n return answer","runtime":"1313"},{"code":"class Solution:\n from typing import List\n import heapq\n\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n queries = sorted([(q, i) for i, q in enumerate(queries)])\n answer = [0] * len(queries)\n visited = set()\n heap = [(grid[0][0], 0, 0)]\n points = 0\n for q, i in queries:\n while heap and heap[0][0] < q:\n val, x, y = heapq.heappop(heap)\n if (x, y) not in visited:\n visited.add((x, y))\n points += 1\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\n answer[i] = points\n return answer","runtime":"1340"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n\n visited = {(i,j):False for i in range(m) for j in range(n)}\n sorted_queries = sorted(queries)\n border = [(grid[0][0], 0, 0)]\n score = defaultdict(int)\n current_score = 0\n\n for query in sorted_queries:\n\n while border:\n g,i,j = border[0]\n\n if visited[(i,j)]:\n heapq.heappop(border)\n\n elif g >= query:\n break\n \n else:\n heapq.heappop(border)\n \n current_score += 1\n visited[(i,j)] = True\n \n # add neighbour if neighbour wasn't visited\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\n\n score[query] = current_score\n \n return [score[query] for query in queries]\n","runtime":"1366"},{"code":"import collections\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n index_query = [(i, query) for i, query in enumerate(queries)]\n\n index_query.sort(key = lambda x : x[1])\n boundary = [ (grid[0][0], (0,0)) ] # (val, (x,y))\n heapq.heapify(boundary)\n index_point = [] # [idx, point]\n explored = set() # (x, y)\n\n for idx, query in index_query:\n if len(index_point) == 0:\n index_point.append( [idx, 0] )\n else:\n index_point.append( [idx, index_point[-1][1]] )\n \n while len(boundary) > 0 and query > boundary[0][0]:\n if boundary[0][1] in explored:\n heapq.heappop(boundary)\n continue\n\n index_point[-1][1] += 1\n explored.add( boundary[0][1] )\n x, y = boundary[0][1]\n heapq.heappop(boundary)\n\n if x + 1 < len(grid) and (x+1, y) not in explored:\n heapq.heappush(boundary, (grid[x+1][y], (x+1, y)))\n \n if y + 1 < len(grid[0]) and (x, y+1) not in explored:\n heapq.heappush(boundary, (grid[x][y+1], (x, y+1)))\n \n if x - 1 >= 0 and (x-1, y) not in explored:\n heapq.heappush(boundary, (grid[x-1][y], (x-1, y)))\n \n if y - 1 >= 0 and (x, y-1) not in explored:\n heapq.heappush(boundary, (grid[x][y-1], (x, y-1)))\n \n index_point.sort(key= lambda x : x[0])\n\n return [x[1] for x in index_point]\n ","runtime":"1366"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n\n visited = {(i,j):False for i in range(m) for j in range(n)}\n sorted_queries = sorted(queries)\n border = [(grid[0][0], 0, 0)]\n score = defaultdict(int)\n current_score = 0\n\n for query in sorted_queries:\n\n while border:\n g,i,j = border[0]\n\n if visited[(i,j)]:\n heapq.heappop(border)\n\n elif g >= query:\n break\n \n else:\n heapq.heappop(border)\n \n current_score += 1\n visited[(i,j)] = True\n \n # add neighbour if neighbour wasn't visited\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\n\n score[query] = current_score\n \n return [score[query] for query in queries]\n","runtime":"1392"},{"code":"import heapq\nfrom collections import defaultdict\nfrom bisect import bisect_left\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n dirr=[(0,1),(1,0),(0,-1),(-1,0)]\n\n row=len(grid)\n col=len(grid[0])\n visited=set()\n stc=[]\n stc.append((grid[0][0],0,0))\n heapq.heapify(stc)\n visited.add((0,0))\n result=defaultdict(int)\n count=0\n while stc:\n start=stc[0][0]\n result[start]=count\n while stc and stc[0][0]<=start:\n K=heapq.heappop(stc)\n val=K[0]\n r=K[1]\n c=K[2]\n for d in dirr:\n if r+d[0] in range(row) and c+d[1] in range(col) and (r+d[0],c+d[1]) not in visited:\n visited.add((r+d[0],c+d[1]))\n heapq.heappush(stc,(grid[r+d[0]][c+d[1]],r+d[0],c+d[1]))\n count+=1\n ans=[]\n KEY=list(result.keys())\n KEY.sort()\n lk=len(KEY)\n for i in queries:\n K=bisect_left(KEY,i)\n if K<lk:\n ans.append(result[KEY[K]])\n else:\n ans.append(row*col)\n return ans","runtime":"1418"},{"code":"from collections import deque\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\n \n completed = set()\n heap = [(grid[0][0], 0, 0)]\n heapq.heapify(heap)\n\n answer = [0] * len(queries)\n for ind in range(len(sorted_queries)):\n query = sorted_queries[ind][0]\n index = sorted_queries[ind][1]\n sol = 0\n\n while heap:\n val, x, y = heap[0]\n if query <= val:\n break\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\n # continue\n\n heapq.heappop(heap)\n\n if (x,y) in completed:\n continue\n sol += 1\n completed.add((x,y))\n\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\n\n\n if ind-1>=0:\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\n else: answer[index]= sol\n\n return answer","runtime":"1444"},{"code":"from collections import deque\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\n \n completed = set()\n heap = [(grid[0][0], 0, 0)]\n heapq.heapify(heap)\n\n answer = [0] * len(queries)\n for ind in range(len(sorted_queries)):\n query = sorted_queries[ind][0]\n index = sorted_queries[ind][1]\n sol = 0\n\n while heap:\n val, x, y = heap[0]\n if query <= val:\n break\n\n if (x,y) in completed:\n heapq.heappop(heap)\n continue\n\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\n # continue\n\n heapq.heappop(heap)\n sol += 1\n completed.add((x,y))\n\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\n\n\n if ind-1>=0:\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\n else: answer[index]= sol\n\n return answer","runtime":"1470"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n\n query_index_list = sorted(\n [(q, i) for i, q in enumerate(queries)],\n reverse=True,\n )\n # print(f\"query_index_list= {query_index_list}\")\n num_points_and_index_list = []\n\n visited_set = set()\n h = [(grid[0][0], 0, 0)]\n while query_index_list and h:\n height, i, j = heapq.heappop(h)\n\n if (i, j) in visited_set:\n continue\n elif height >= query_index_list[-1][0]:\n _, index = query_index_list.pop()\n num_points_and_index_list.append((len(visited_set), index))\n heapq.heappush(h, (height, i, j))\n continue\n\n visited_set.add((i, j))\n\n for i_, j_ in [\n [i + 1, j],\n [i - 1, j],\n [i, j + 1],\n [i, j - 1],\n ]:\n if i_ < 0 or i_ > m - 1 or j_ < 0 or j_ > n - 1:\n continue\n\n heapq.heappush(h, (grid[i_][j_], i_, j_))\n \n ans = [-1] * len(queries)\n for num_points, index in num_points_and_index_list:\n ans[index] = num_points\n\n # print(f\"query_index_list= {query_index_list}\")\n while query_index_list:\n _, i = query_index_list.pop()\n ans[i] = len(visited_set)\n \n return ans","runtime":"1496"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n threshold = [[0 for j in range(n)] for i in range(m)]\n heap = []\n heapq.heappush(heap, [grid[0][0], 0, 0])\n while heap:\n while heap and threshold[heap[0][1]][heap[0][2]] > 0:\n heapq.heappop(heap)\n if heap:\n cost, x, y = heapq.heappop(heap)\n threshold[x][y] = cost\n for nx, ny in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:\n if 0 <= nx < m and 0 <= ny < n:\n heapq.heappush(heap, [max(grid[nx][ny], cost), nx, ny])\n elements = []\n for i in range(m):\n for j in range(n):\n elements.append(threshold[i][j])\n elements.sort()\n \n result = []\n for query in queries:\n result.append(bisect.bisect_left(elements, query))\n return result","runtime":"1522"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n count = [0] * (10**6 + 1)\n rows, cols = len(grid), len(grid[0])\n pq = []\n vis = [[0] * cols for i in range(rows)]\n vis[0][0] = 1\n heappush(pq, (grid[0][0], 0, 0))\n dir_arr = [0, 1, 0, -1, 0]\n while pq:\n cur_cost, cur_x, cur_y = heappop(pq)\n count[cur_cost] += 1\n for i in range(4):\n new_x = cur_x + dir_arr[i]\n new_y = cur_y + dir_arr[i + 1]\n if 0 <= new_x < rows and 0 <= new_y < cols and vis[new_x][new_y] == 0:\n vis[new_x][new_y] = 1\n heappush(pq, (max(cur_cost, grid[new_x][new_y]), new_x, new_y))\n\n for i in range(1, len(count)):\n count[i] += count[i - 1]\n\n ans = []\n for i in queries:\n ans.append(count[i - 1])\n\n return ans\n","runtime":"1548"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n g = defaultdict(int)\n visited = []\n visited.append((grid[0][0], 0,0))\n vis = set()\n m = 0\n while visited:\n tv, tl, tr = heappop(visited)\n if (tl,tr) in vis:\n continue\n vis.add((tl, tr))\n m = max(tv, m)\n print(tv, tl, tr, m)\n \n g[m]+=1\n for x,y in [[-1, 0], [1, 0], [0, 1], [0, -1]]:\n a = tl+x\n b = tr +y\n if a >=0 and a < len(grid) and b >=0 and b < len(grid[0]):\n if (a,b) not in vis:\n heappush(visited, (grid[a][b], a, b))\n print(g)\n res = []\n gsort = [[k,v] for k,v in g.items()]\n gsort.sort()\n for i in range(1, len(gsort)):\n gsort[i][1] += gsort[i-1][1]\n print(gsort)\n for q in queries:\n dex = bisect_left(gsort, [q-1, float('inf')])-1\n if q <= gsort[dex][0]:\n res.append(0)\n continue\n res.append(gsort[dex][1])\n return res","runtime":"1574"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n g = defaultdict(int)\n visited = []\n visited.append((grid[0][0], 0,0))\n vis = set()\n m = 0\n while visited:\n tv, tl, tr = heappop(visited)\n if (tl,tr) in vis:\n continue\n vis.add((tl, tr))\n m = max(tv, m)\n print(tv, tl, tr, m)\n \n g[m]+=1\n for x,y in [[-1, 0], [1, 0], [0, 1], [0, -1]]:\n a = tl+x\n b = tr +y\n if a >=0 and a < len(grid) and b >=0 and b < len(grid[0]):\n if (a,b) not in vis:\n heappush(visited, (grid[a][b], a, b))\n print(g)\n res = []\n gsort = [[k,v] for k,v in g.items()]\n gsort.sort()\n for i in range(1, len(gsort)):\n gsort[i][1] += gsort[i-1][1]\n print(gsort)\n for q in queries:\n dex = bisect_left(gsort, [q-1, float('inf')])-1\n if q <= gsort[dex][0]:\n res.append(0)\n continue\n res.append(gsort[dex][1])\n return res\n \n \n \n ","runtime":"1600"},{"code":"from collections import deque\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\n \n completed = set()\n heap = [(grid[0][0], 0, 0)]\n heapq.heapify(heap)\n\n answer = [0] * len(queries)\n for ind in range(len(sorted_queries)):\n query = sorted_queries[ind][0]\n index = sorted_queries[ind][1]\n sol = 0\n\n while heap:\n val, x, y = heap[0]\n print(val)\n if query <= val:\n break\n\n if (x,y) in completed:\n heapq.heappop(heap)\n continue\n\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\n # continue\n\n heapq.heappop(heap)\n sol += 1\n completed.add((x,y))\n\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\n\n\n if ind-1>=0:\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\n else: answer[index]= sol\n\n return answer","runtime":"1626"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n q = [[grid[0][0], 0, 0]]\n heapq.heapify(q)\n\n seen = set()\n\n grid_sort = []\n\n while q:\n [num, i, j] = heapq.heappop(q)\n if (i,j) in seen:\n continue\n seen.add((i,j))\n grid_sort.append(num)\n if i+1<m:\n heapq.heappush(q, [grid[i+1][j], i+1, j])\n if j+1<n:\n heapq.heappush(q, [grid[i][j+1], i, j+1])\n if i-1>=0:\n heapq.heappush(q, [grid[i-1][j], i-1, j])\n if j-1>=0:\n heapq.heappush(q, [grid[i][j-1], i, j-1])\n # print(len(grid_sort), m*n)\n max_num = -1\n for i in range(len(grid_sort)):\n max_num = max(max_num, grid_sort[i])\n grid_sort[i] = max_num\n # print(grid_sort)\n ans = []\n for query in queries:\n left, right = 0, len(grid_sort)-1\n while left<=right:\n mid = (left+right)//2\n if grid_sort[mid]>=query:\n right = mid-1\n else:\n left = mid+1\n ans.append(left)\n return ans\n\n \n","runtime":"1652"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries: \n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n if num_queries == total_num_queries:\n break\n query_i += 1\n return answer","runtime":"1678"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # # OPTIMIZED: sort values in increasing order\n # # maps num -> index in queries before sort\n # original_indices = {}\n # total_num_queries = len(queries)\n # for i in range(total_num_queries):\n # if queries[i] not in original_indices:\n # original_indices[queries[i]] = []\n # original_indices[queries[i]].append(i)\n # queries.sort()\n # answer = [0] * total_num_queries\n # n, m = len(grid), len(grid[0])\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # # function checking if i, j is a valid coordinate in grid\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n # first_i, first_coord = 0, (0, 0)\n # queue, adjacent_coords, queued = [first_coord], [], set()\n # queued.add(first_coord)\n # count, num_queries = 0, 0\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n # first_i += 1\n # for query_i in range(first_i, total_num_queries):\n # # while queue is not empty\n # while queue:\n # # pop and add to count\n # coord = queue.pop(0)\n # count += 1\n # # for each dir in directions:\n # for dir in directions:\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # # if is a valid coordinate and not queued yet:\n # if is_valid_coord(next_coord) and next_coord not in queued:\n # # if it is less than current num:\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # # append to queue\n # queue.append(next_coord)\n # # add to queued\n # queued.add(next_coord)\n # else:\n # adjacent_coords.append(next_coord)\n # queued.add(next_coord)\n # for answer_i in original_indices[queries[query_i]]:\n # answer[answer_i] = count\n # num_queries += 1\n # if query_i + 1 < total_num_queries:\n # next_adjacent_coords = []\n # for coord in adjacent_coords:\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n # queue.append(coord)\n # else:\n # next_adjacent_coords.append(coord)\n # adjacent_coords = next_adjacent_coords\n # if num_queries == total_num_queries:\n # break\n # return answer\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries:\n # for query_i in range(first_i, total_num_queries):\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop()\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if num_queries == total_num_queries:\n break\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n query_i += 1\n return answer\n ","runtime":"1704"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # # OPTIMIZED: sort values in increasing order\n # # maps num -> index in queries before sort\n # original_indices = {}\n # total_num_queries = len(queries)\n # for i in range(total_num_queries):\n # if queries[i] not in original_indices:\n # original_indices[queries[i]] = []\n # original_indices[queries[i]].append(i)\n # queries.sort()\n # answer = [0] * total_num_queries\n # n, m = len(grid), len(grid[0])\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # # function checking if i, j is a valid coordinate in grid\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n # first_i, first_coord = 0, (0, 0)\n # queue, adjacent_coords, queued = [first_coord], [], set()\n # queued.add(first_coord)\n # count, num_queries = 0, 0\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n # first_i += 1\n # for query_i in range(first_i, total_num_queries):\n # # while queue is not empty\n # while queue:\n # # pop and add to count\n # coord = queue.pop(0)\n # count += 1\n # # for each dir in directions:\n # for dir in directions:\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # # if is a valid coordinate and not queued yet:\n # if is_valid_coord(next_coord) and next_coord not in queued:\n # # if it is less than current num:\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # # append to queue\n # queue.append(next_coord)\n # # add to queued\n # queued.add(next_coord)\n # else:\n # adjacent_coords.append(next_coord)\n # queued.add(next_coord)\n # for answer_i in original_indices[queries[query_i]]:\n # answer[answer_i] = count\n # num_queries += 1\n # if query_i + 1 < total_num_queries:\n # next_adjacent_coords = []\n # for coord in adjacent_coords:\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n # queue.append(coord)\n # else:\n # next_adjacent_coords.append(coord)\n # adjacent_coords = next_adjacent_coords\n # if num_queries == total_num_queries:\n # break\n # return answer\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries:\n # for query_i in range(first_i, total_num_queries):\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if num_queries == total_num_queries:\n break\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n query_i += 1\n return answer\n ","runtime":"1730"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n q = len(queries)\\n\\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\\n answers = [0] * q\\n prev_query = 0\\n points = 0\\n fringe = [(grid[0][0], 0, 0)]\\n heapq.heapify(fringe)\\n\\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\\n\\n for i in sorted_indices:\\n query = queries[i]\\n # print(query, '----------------')\\n # print(fringe)\\n\\n if query == prev_query:\\n answers[i] = points\\n continue\\n\\n stack = deque()\\n while fringe and fringe[0][0] < query:\\n (val, r, c) = heapq.heappop(fringe)\\n stack.append((r, c))\\n points += 1\\n grid[r][c] = 0\\n\\n while stack:\\n (r, c) = stack.pop()\\n # print(r, c)\\n for (x, y) in dirs:\\n rr = r + x\\n cc = c + y\\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\\n if grid[rr][cc] < query:\\n stack.append((rr, cc))\\n points += 1\\n else:\\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\\n grid[rr][cc] = 0\\n\\n answers[i] = points\\n prev_query = query\\n\\n return answers\",\n \"runtime\": \"637\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries2: List[int]) -> List[int]:\\n queries = sorted(set(queries2))\\n res = {}\\n rows, cols = len(grid), len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n prevCount = 0\\n\\n for num in queries:\\n count = prevCount\\n\\n while q:\\n val, r, c = q[0]\\n if val >= num: break\\n else:\\n heappop(q)\\n grid[r][c] = None\\n count += 1\\n \\n for i, j in [(r+1, c), (r, c+1), (r-1, c), (r, c-1)]:\\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\\n heappush(q, (grid[i][j], i, j))\\n grid[i][j] = None\\n \\n res[num] = prevCount = count\\n ans = [res[num] for num in queries2]\\n return ans\\n\\n def maxPoints2(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\n def calculate(i, j, maximum, visited):\\n if visited[i][j] == 1: return 0\\n visited[i][j] = 1\\n if grid[i-1][j-1] >= maximum: return 0\\n\\n return 1 + calculate(i, j-1, maximum, visited) + calculate(i, j+1, maximum, visited) + calculate(i-1, j, maximum, visited) + calculate(i+1, j, maximum, visited)\\n\\n result = []\\n for maximum in queries: \\n visited = [[0 for i in range(len(grid[0])+2)] for j in range(len(grid)+2)]\\n \\n for i in range(len(visited[0])):\\n visited[0][i] = 1\\n visited[len(visited)-1][i] = 1\\n \\n for j in range(len(visited)):\\n visited[j][0] = 1\\n visited[j][len(visited[0])-1] = 1\\n\\n result.append(calculate(1, 1, maximum, visited))\\n return result\\n\",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n qs = sorted(set(queries))\\n res = dict()\\n rows, cols = len(grid), len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n prevCount = 0\\n\\n for num in qs:\\n count = prevCount\\n while q:\\n val, r, c = q[0]\\n\\n if val >= num:\\n break\\n else:\\n heappop(q)\\n grid[r][c] = None\\n count += 1\\n\\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\\n heappush(q, (grid[i][j], i, j))\\n grid[i][j] = None\\n \\n res[num] = prevCount = count\\n\\n out = [res[num] for num in queries]\\n return out\",\n \"runtime\": \"715\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n num_queries = len(queries)\\n \\n # Sort queries and keep track of their original indices\\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Prepare the answer array\\n answer = [0] * num_queries\\n \\n # Directions for moving up, down, left, and right\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Priority queue for BFS\\n pq = []\\n # Visited matrix\\n visited = [[False] * n for _ in range(m)]\\n \\n # Start from the top-left corner\\n heappush(pq, (grid[0][0], 0, 0))\\n visited[0][0] = True\\n current_points = 0\\n \\n # Process the queries in sorted order\\n for query_value, original_index in sorted_queries:\\n # Expand the BFS frontier for the current query_value\\n while pq and pq[0][0] < query_value:\\n value, x, y = heappop(pq)\\n current_points += 1\\n\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heappush(pq, (grid[nx][ny], nx, ny))\\n \\n # Store the result for this query\\n answer[original_index] = current_points\\n \\n return answer\",\n \"runtime\": \"741\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n n, m = len(grid[0]), len(grid)\\n k = len(queries)\\n\\n ordered_queries = sorted((q, i) for i, q in enumerate(queries))\\n answer = [0] * k\\n \\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n\\n heap = []\\n heapq.heappush(heap, (grid[0][0], 0, 0))\\n\\n directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]\\n\\n point = 0\\n\\n for q, i in ordered_queries:\\n while heap and heap[0][0] < q:\\n val, x, y = heapq.heappop(heap)\\n point += 1\\n\\n for dx, dy in directions:\\n xn = dx + x\\n ym = dy + y\\n\\n if 0 <= xn < n and 0 <= ym < m and not visited[ym][xn]:\\n visited[ym][xn] = True\\n heapq.heappush(heap, (grid[ym][xn], xn, ym))\\n \\n answer[i] = point\\n \\n return answer\\n\",\n \"runtime\": \"767\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n num_queries = len(queries)\\n result = [0] * num_queries\\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\\n\\n # Directions for moving: right, down, left, up\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Min-heap to process grid cells in order of their values\\n min_heap = [(grid[0][0], 0, 0)] # (value, x-coordinate, y-coordinate)\\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n\\n current_points = 0\\n cell_values = []\\n\\n # Process each query\\n for value, idx in indexed_queries:\\n # Explore the grid and collect valid cells whose values are below the current query value\\n while min_heap and min_heap[0][0] < value:\\n cell_value, x, y = heappop(min_heap)\\n \\n if cell_value < value:\\n current_points += 1\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n heappush(min_heap, (grid[nx][ny], nx, ny))\\n visited[nx][ny] = True\\n else:\\n break\\n \\n result[idx] = current_points\\n \\n return result\\n\\n# Example use-cases\\nsol = Solution()\\nprint(sol.maxPoints([[1,2,3],[2,5,7],[3,5,1]], [5,6,2])) # Output: [5,8,1]\\nprint(sol.maxPoints([[5,2,1],[1,1,2]], [3])) # Output: [0]\",\n \"runtime\": \"793\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid, qs: List[int]) -> List[int]:\\n queries = sorted(set(qs))\\n res = {}\\n rows, cols = len(grid), len(grid[0])\\n q = [(grid[0][0], 0, 0)] # heap\\n prevCount = 0\\n\\n for num in queries:\\n count = prevCount\\n\\n while q:\\n val, r, c = q[0]\\n\\n if val >= num: break # pop only when the condition satisfy else break\\n else:\\n heappop(q)\\n grid[r][c] = None\\n count += 1\\n\\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\\n heappush(q, (grid[i][j], i, j))\\n grid[i][j] = None\\n\\n res[num] = prevCount = count\\n\\n ans = [res[num] for num in qs]\\n return ans\",\n \"runtime\": \"793\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n M = len(grid)\\n N = len(grid[0])\\n \\n visited = [[0 for i in range(N)] for j in range(M)]\\n queries_copy = queries.copy()\\n queries_copy.sort()\\n q = []\\n cnt = 0\\n rel_dict ={}\\n q.append((grid[0][0],0,0))\\n for num in queries_copy:\\n new_q = []\\n \\n while(q):\\n val, x, y = q[0]\\n if val >= num:\\n break\\n else:\\n heappop(q)\\n neigbors = [(x+1,y), (x-1,y),(x,y+1), (x,y-1)]\\n visited[x][y] = 1\\n cnt += 1\\n for (a,b) in neigbors:\\n if 0<=a <M and 0 <=b<N and visited[a][b] == 0:\\n heappush(q, (grid[a][b],a,b))\\n visited[a][b] = 1\\n \\n\\n rel_dict[num] = cnt\\n ans = []\\n for num in queries:\\n ans.append(rel_dict[num])\\n \\n return ans\\n\\n \",\n \"runtime\": \"819\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n moves = [[1,0], [0, 1], [-1,0], [0,-1]]\\n rows, cols = len(grid), len(grid[0])\\n qs = sorted(set(queries))\\n heap = [(grid[0][0], 0, 0)]\\n prev = 0 \\n res = {}\\n\\n for num in qs:\\n count = prev \\n while heap:\\n val, r, c = heap[0]\\n if val>=num:\\n break\\n else:\\n heappop(heap)\\n grid[r][c] = None\\n count += 1\\n for move in moves:\\n i, j = r + move[0], c + move[1]\\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] != None:\\n heappush(heap, (grid[i][j], i, j))\\n grid[i][j] = None\\n res[num] = prev = count\\n ans = []\\n for num in queries:\\n ans.append(res[num])\\n return ans\\n \\n\\n\\n\",\n \"runtime\": \"819\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, a: List[List[int]], queries: List[int]) -> List[int]:\\n queries = [[val,idx] for idx,val in enumerate(queries)]\\n ans = [0]*len(queries)\\n queries.sort()\\n h = [(a[0][0],0,0)]; a[0][0] = -1\\n n,m = len(a),len(a[0])\\n count = 0\\n for qval,idx in queries:\\n while h and h[0][0]<qval:\\n val,i,j = heappop(h)\\n count+=1\\n for p,q in [[1,0],[-1,0],[0,1],[0,-1]]:\\n x,y = i+p,j+q\\n if 0<=x<n and 0<=y<m and a[x][y]!=-1:\\n heappush(h,(a[x][y],x,y))\\n a[x][y] = -1\\n ans[idx] = count\\n return ans\\n \",\n \"runtime\": \"845\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n qs = sorted((v, i) for i, v in enumerate(queries))\\n ans = [0] * len(qs)\\n q = [(grid[0][0], 0, 0)]\\n cnt = 0\\n vis = [[False] * n for _ in range(m)]\\n vis[0][0] = True\\n for v, k in qs:\\n while q and q[0][0] < v:\\n _, i, j = heappop(q)\\n cnt += 1\\n for a, b in pairwise((-1, 0, 1, 0, -1)):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n and not vis[x][y]:\\n heappush(q, (grid[x][y], x, y))\\n vis[x][y] = True\\n ans[k] = cnt\\n return ans\",\n \"runtime\": \"845\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n pq = [(grid[0][0], 0, 0)]\\n point = []\\n prev = -inf\\n pre_sc = 0\\n m=len(grid)\\n n = len(grid[0])\\n res = []\\n grid[0][0] =0\\n while pq:\\n v, x, y = heappop(pq)\\n if prev != v:\\n point.append((prev, pre_sc))\\n pre_sc += 1\\n prev = v\\n for a, b in [0, -1], [0, 1], [1, 0], [-1, 0]:\\n xa = x+a\\n yb = y+b\\n if 0 <= xa < m and 0 <= yb < n and grid[xa][yb]:\\n vv = max(v, grid[xa][yb])\\n heappush(pq, (vv, xa, yb))\\n grid[xa][yb] = 0\\n point.append((prev, pre_sc))\\n\\n for query in queries:\\n sci = bisect_left(point, query, key = lambda x: x[0]) - 1\\n res.append(point[sci][1])\\n return res\",\n \"runtime\": \"871\"\n },\n {\n \"code\": \"from heapq import heapify, heappush, heappop\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n rows = len(grid)\\n cols = len(grid[0])\\n newqueries= sorted([(queries[j], j) for j in range(len(queries))])\\n\\n minheap = [[grid[0][0], 0, 0]]\\n heapify(minheap)\\n\\n visited = [[0 for i in range(cols)]for j in range(rows)]\\n visited[0][0] = 1\\n \\n count = 0\\n ans = [0] * len(queries)\\n for limit,index in newqueries:\\n while(minheap and minheap[0][0]<limit):\\n val, i, j = heappop(minheap)\\n count+=1\\n for a,b in [(0,1),(0,-1),(1,0),(-1,0)]:\\n newi = i+a\\n newj = j+b\\n if(0<=newi<rows and 0<=newj<cols and visited[newi][newj]==0):\\n heappush(minheap, [grid[newi][newj], newi, newj])\\n visited[newi][newj] = 1\\n ans[index] = count\\n return ans\\n \\n \\n\\n\\n\",\n \"runtime\": \"871\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n ROWS, COLS = len(grid), len(grid[0])\\n query_to_res = {}\\n new_queries = sorted(queries)\\n res = []\\n points = 0\\n min_heap = []\\n visit = set()\\n\\n heapq.heappush(min_heap, (grid[0][0], 0, 0))\\n visit.add((0, 0))\\n\\n for query in new_queries:\\n while min_heap and query > min_heap[0][0]:\\n _, i, j = heapq.heappop(min_heap)\\n points += 1\\n\\n directions = [(i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)]\\n\\n for new_i, new_j in directions:\\n if 0 <= new_i < ROWS and 0 <= new_j < COLS and (new_i, new_j) not in visit:\\n visit.add((new_i, new_j))\\n heapq.heappush(min_heap, (grid[new_i][new_j], new_i, new_j))\\n\\n query_to_res[query] = points\\n \\n for this_query in queries:\\n res.append(query_to_res[this_query])\\n \\n return res\\n\\n\\n \\n\\n\\n\\n \\n \\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"897\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\n\\n\\n@dataclass(frozen=True)\\nclass IndexedQuery:\\n queryIndex: int\\n query: int\\n\\n def __iter__(self):\\n yield self.queryIndex\\n yield self.query\\n\\n\\nclass Solution:\\n def maxPoints(self, grid: list[list[int]], queries: list[int]) -> list[int]:\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n ans = [0] * len(queries)\\n minHeap = [(grid[0][0], 0, 0)] # (grid[i][j], i, j)\\n seen = {(0, 0)}\\n accumulate = 0\\n\\n for queryIndex, query in sorted([IndexedQuery(i, query)\\n for i, query in enumerate(queries)],\\n key=lambda x: x.query):\\n while minHeap:\\n val, i, j = heapq.heappop(minHeap)\\n if val >= query:\\n # The smallest neighbor is still larger than `query`, so no need to\\n # keep exploring. Re-push (i, j, grid[i][j]) back to the `minHeap`.\\n heapq.heappush(minHeap, (val, i, j))\\n break\\n accumulate += 1\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n heapq.heappush(minHeap, (grid[x][y], x, y))\\n seen.add((x, y))\\n ans[queryIndex] = accumulate\\n\\n return ans\",\n \"runtime\": \"897\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n numRows, numCols = len(grid), len(grid[0])\\n queriesSorted, hashMap = sorted(queries), {}\\n heap, visited = [(grid[0][0], 0, 0)], set()\\n visited.add((0, 0))\\n for query in queriesSorted:\\n while heap:\\n val, row, col = heap[0]\\n if val >= query:\\n break\\n heappop(heap)\\n for newRow, newCol in (row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1):\\n if newRow < 0 or newRow >= numRows or newCol < 0 or newCol >= numCols: \\n continue\\n if (newRow, newCol) in visited: \\n continue\\n heappush(heap, (grid[newRow][newCol], newRow, newCol))\\n visited.add((newRow, newCol))\\n hashMap[query] = len(visited) - len(heap)\\n return [hashMap[query] for query in queries]\",\n \"runtime\": \"923\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n # Create a list of tuples (value, x, y) for each position in the grid\\n cells = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\\n # Sort the cells by their values\\n cells.sort()\\n \\n # Prepare result list for each query\\n result = [0] * len(queries)\\n # Pair queries with their original indices and sort them\\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Direction vectors for moving up, down, left, right\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n \\n # Track visited cells\\n visited = [[False] * n for _ in range(m)]\\n # Priority queue for BFS\\n pq = []\\n # Start from the top-left corner\\n heapq.heappush(pq, (grid[0][0], 0, 0))\\n visited[0][0] = True\\n \\n # Keep track of points we can gather\\n points = 0\\n # Process each query\\n for q, original_index in queries_with_indices:\\n # Process all cells with value less than the current query\\n while pq and pq[0][0] < q:\\n value, x, y = heapq.heappop(pq)\\n points += 1\\n # Explore neighbors\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\\n # Assign the result for this query\\n result[original_index] = points\\n \\n return result\",\n \"runtime\": \"923\"\n },\n {\n \"code\": \"\\nimport heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sq = sorted(queries)\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n\\n numRows, numCols = len(grid), len(grid[0])\\n\\n\\n priorityQ = [(grid[0][0], 0, 0)]\\n seenCord = set()\\n seenCord.add((0,0))\\n count = 0\\n qScore = {}\\n\\n # time complexity : O(max(q + q*log(q), m*n*log(m*n) + q*log(q) ))\\n # space complexity : O(max(q, m + n))\\n\\n\\n for q in sq:\\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\\n count += 1\\n currVal, currRow, currCol = heapq.heappop(priorityQ)\\n \\n for d in directions:\\n\\n newRow = currRow + d[0]\\n newCol = currCol + d[1]\\n\\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\\n\\n if (newRow, newCol) not in seenCord:\\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\\n seenCord.add((newRow, newCol))\\n\\n qScore[q] = count\\n \\n return [qScore[q] for q in queries]\\n\\n\\n\",\n \"runtime\": \"949\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n \\n min_heap = [(grid[0][0], 0, 0)]\\n visited = set()\\n visited.add((0,0))\\n \\n threshold_order = []\\n threshold = -1\\n \\n while min_heap:\\n val, r, c = heapq.heappop(min_heap)\\n threshold = max(threshold, val)\\n threshold_order.append(threshold)\\n \\n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\\n continue\\n visited.add((x, y))\\n heapq.heappush(min_heap, (grid[x][y], x, y))\\n \\n res = []\\n for q in queries:\\n res.append(bisect.bisect_left(threshold_order, q))\\n \\n return res\",\n \"runtime\": \"949\"\n },\n {\n \"code\": \"\\nimport heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sq = sorted(queries)\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n\\n numRows, numCols = len(grid), len(grid[0])\\n\\n\\n priorityQ = [(grid[0][0], 0, 0)]\\n seenCord = set()\\n seenCord.add((0,0))\\n count = 0\\n qScore = {}\\n\\n # time complexity : O(max(q + q*log(q), m*n*log(m*n) + q*log(q) ))\\n # space complexity : O(max(q, m + n))\\n\\n\\n for q in sq:\\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\\n count += 1\\n currVal, currRow, currCol = heapq.heappop(priorityQ)\\n \\n for d in directions:\\n\\n newRow = currRow + d[0]\\n newCol = currCol + d[1]\\n\\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\\n\\n if (newRow, newCol) not in seenCord:\\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\\n seenCord.add((newRow, newCol))\\n\\n qScore[q] = count\\n \\n return [qScore[q] for q in queries]\\n\\n\\n\",\n \"runtime\": \"975\"\n },\n {\n \"code\": \"import heapq as h\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\n q = []\\n\\n m = len(grid)\\n n = len(grid[0])\\n\\n best = defaultdict(int)\\n\\n best[(0, 0)] = grid[0][0]\\n\\n h.heappush(q, (grid[0][0], 0, 0))\\n\\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\\n\\n while q and len(best) < m * n:\\n (val, x, y) = h.heappop(q)\\n\\n for [i, j] in moves:\\n xi = x + i\\n yj = y + j\\n \\n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\\n nVal = max(val, grid[xi][yj])\\n best[(xi, yj)] = nVal\\n h.heappush(q, (nVal, xi, yj))\\n\\n counts = defaultdict(int)\\n\\n for key in best:\\n counts[best[key]] += 1\\n \\n counts = [[x, counts[x]] for x in counts]\\n\\n counts.sort()\\n\\n for i in range(1, len(counts)):\\n counts[i][1] += counts[i-1][1]\\n \\n ret = []\\n for query in queries:\\n query -= 1\\n l = 0\\n r = len(counts) - 1\\n ans = -1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n\\n if counts[mid][0] <= query:\\n ans = mid\\n l = mid + 1\\n else:\\n r = mid - 1\\n if ans == -1:\\n ret.append(0)\\n else:\\n ret.append(counts[ans][1])\\n \\n return ret\",\n \"runtime\": \"975\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n \\n min_heap = [(grid[0][0], 0, 0)]\\n visited = set()\\n visited.add((0,0))\\n \\n threshold_order = []\\n threshold = -1\\n \\n while min_heap:\\n val, r, c = heapq.heappop(min_heap)\\n threshold = max(threshold, val)\\n threshold_order.append(threshold)\\n \\n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\\n continue\\n visited.add((x, y))\\n heapq.heappush(min_heap, (grid[x][y], x, y))\\n \\n res = []\\n for q in queries:\\n res.append(bisect.bisect_left(threshold_order, q))\\n \\n return res\",\n \"runtime\": \"1001\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n def dfs(q, r=0, c=0):\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n count = 1\\n for dr, dc in dirs:\\n nr, nc = r+dr, c+dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\\n continue\\n if (nr, nc) in edges_set:\\n continue\\n if q <= grid[nr][nc]:\\n heapq.heappush(edges, (grid[nr][nc], nr, nc))\\n edges_set.add((nr, nc))\\n continue\\n visited.add((nr, nc))\\n count += dfs(q, nr, nc)\\n\\n return count\\n \\n result = [0] * len(queries)\\n pos = [(q, i) for i, q in enumerate(queries)]\\n pos.sort()\\n visited = set()\\n edges = [(grid[0][0], 0, 0)]\\n edges_set = set() # to avoid additional node being added to edges(heap)\\n edges_set.add((0, 0))\\n points = 0\\n for q, i in pos:\\n for _ in range(len(edges)):\\n val, r, c = edges[0]\\n if q > val and (r, c) not in visited:\\n heapq.heappop(edges)\\n edges_set.remove((r, c))\\n visited.add((r, c))\\n points += dfs(q, r, c)\\n else:\\n break\\n result[i] = points\\n \\n return result\",\n \"runtime\": \"1001\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n ret = [0 for _ in range(len(queries))]\\n prev = 0\\n for q in sorted(list(set(queries))):\\n pos = bisect.bisect_left(order, q,lo=prev)\\n for idx in mapping[q]:\\n ret[idx]=pos\\n prev = pos\\n return ret\\n\\n\",\n \"runtime\": \"1027\"\n },\n {\n \"code\": \"# BFS + PriorityQueue\\n\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n rows, cols = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n\\n pq = []\\n heapq.heappush(pq, (grid[0][0], 0, 0))\\n\\n visited = set([(0, 0)])\\n\\n points = 0 # Start with 1 point because we can visit the start cell\\n queries = sorted((q,idx) for idx,q in enumerate(queries))\\n i = 0\\n count = 0\\n ans = [0]*len(queries)\\n\\n for i in range(len(queries)):\\n query_value = queries[i][0]\\n while pq and pq[0][0] < query_value:\\n\\n _,x,y = heapq.heappop(pq)\\n count += 1\\n points += 1\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < rows and 0 <= ny < cols and (nx, ny) not in visited:\\n visited.add((nx, ny))\\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\\n ans[queries[i][1]] = count\\n return ans\\n \\n \\n\\n\\n \\n\\n\\n\\n\\n\",\n \"runtime\": \"1027\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\t\\t#It is a simple questions based on the concept of graph\\n\\t\\t#As we all know we can represent a matrix/grid into a graph\\n\\t\\t#Then we can use the heap(min Heap) to get a perfect path.\\n\\t\\t#Then we are using maxYet(means max till that index).\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n # print(order)\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n res = []\\n # for each q, do BS to find the index of the first element larger or equal to q\\n for i, q in enumerate(queries):\\n l, r = 0, len(order) - 1\\n while l <= r:\\n mid = (l + r) // 2\\n if order[mid] >= q:\\n r = mid - 1\\n else:\\n l = mid + 1\\n res.append(l)\\n # print(order)\\n return res\",\n \"runtime\": \"1053\"\n },\n {\n \"code\": \"import heapq as h\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\n q = []\\n\\n m = len(grid)\\n n = len(grid[0])\\n\\n best = defaultdict(int)\\n\\n best[(0, 0)] = grid[0][0]\\n\\n h.heappush(q, (grid[0][0], 0, 0))\\n\\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\\n\\n while q and len(best) < m * n:\\n (val, x, y) = h.heappop(q)\\n\\n for [i, j] in moves:\\n xi = x + i\\n yj = y + j\\n \\n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\\n nVal = max(val, grid[xi][yj])\\n best[(xi, yj)] = nVal\\n h.heappush(q, (nVal, xi, yj))\\n \\n print(best)\\n\\n counts = defaultdict(int)\\n\\n for key in best:\\n counts[best[key]] += 1\\n \\n counts = [[x, counts[x]] for x in counts]\\n\\n counts.sort()\\n\\n for i in range(1, len(counts)):\\n counts[i][1] += counts[i-1][1]\\n \\n ret = []\\n print(counts)\\n for query in queries:\\n query -= 1\\n l = 0\\n r = len(counts) - 1\\n ans = -1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n\\n if counts[mid][0] <= query:\\n ans = mid\\n l = mid + 1\\n else:\\n r = mid - 1\\n if ans == -1:\\n ret.append(0)\\n else:\\n ret.append(counts[ans][1])\\n \\n return ret\",\n \"runtime\": \"1053\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n res = []\\n\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n i = 0\\n ret = [0 for _ in range(len(queries))]\\n for q in sorted(list(set(queries))):\\n while i < len(order) and q > order[i]:\\n i+=1\\n i = i-1\\n for idx in mapping[q]:\\n ret[idx] = i+1 \\n i = max(0,i)\\n return ret\\n\\n\",\n \"runtime\": \"1079\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n \\n min_heap = [(grid[0][0], 0, 0)]\\n visited = set()\\n visited.add((0,0))\\n \\n threshold_order = []\\n threshold = -1\\n \\n while min_heap:\\n val, r, c = heapq.heappop(min_heap)\\n threshold = max(threshold, val)\\n threshold_order.append(threshold)\\n \\n for x,y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if x < 0 or x >= m or y < 0 or y>=n or (x, y) in visited:\\n continue\\n visited.add((x, y))\\n heapq.heappush(min_heap, (grid[x][y], x, y))\\n \\n res = []\\n \\n for q in queries:\\n res.append(bisect.bisect_left(threshold_order, q))\\n \\n return res\\n \\n \\n \\n\\n \\n\\n\",\n \"runtime\": \"1079\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # Some setup\\n dirs = [(0,1),(1,0),(-1,0),(0,-1)]\\n nrows = len(grid)\\n ncols = len(grid[0])\\n\\t\\t\\n # Sort queries. Keep track of the original index.\\n q_and_i = [[queries[i], i] for i in range(len(queries))]\\n q_and_i.sort() # Sort based on the value of the query\\n\\t\\n # Prepare for BFS. Start with top-left cell.\\n answer = [0 for _ in range(len(queries))]\\n heap = [[grid[0][0], 0, 0]]\\n seen = {(0,0)} # Cells we have seen (but not necessarily visited)\\n n_visited = 0\\n\\t\\t\\n # BFS. Go through queries from smallest to largest.\\n for q, i in q_and_i:\\n\\t\\t # Only visit a cell if it is less than the current query\\n while heap and heap[0][0] < q:\\n n_visited += 1\\n _, r, c = heapq.heappop(heap)\\n\\t\\t\\t\\t# Check all neighboring cells\\n for h, v in dirs:\\n r2, c2 = r + v, c + h\\n\\t\\t\\t\\t\\t# Check that coordinates are valid\\n if r2 >= 0 and r2 < nrows and c2 >= 0 and c2 < ncols:\\n\\t\\t\\t\\t\\t # Check that the cell has never been in the heap\\n if (r2, c2) not in seen:\\n\\t\\t\\t\\t\\t\\t # Add cell to our options\\n seen.add((r2, c2))\\n heapq.heappush(heap, [grid[r2][c2], r2, c2])\\n\\t\\t\\t# Update the answer for the current query\\n answer[i] = n_visited\\n #\\n return answer\",\n \"runtime\": \"1105\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n\\n root = [elem for elem in range(m*n)]\\n size = [1] * (m * n)\\n\\n def find(x):\\n if root[x] == x:\\n return x\\n root[x] = find(root[x])\\n return root[x]\\n\\n def union(x, y):\\n root_x = find(x)\\n root_y = find(y)\\n\\n if size[root_x] < size[root_y]:\\n root_x, root_y = root_y, root_x\\n\\n if root_x != root_y:\\n root[root_y] = root_x\\n size[root_x] += size[root_y]\\n\\n # if rank[root_x] > rank[root_y]:\\n # root[root_y] = root_x\\n # size[root_x] += size[root_y] \\n # elif rank[root_x] < rank[root_y]:\\n # root[root_x] = root_y\\n # size[root_y] += size[root_x]\\n # else:\\n # root[root_y] = root_x\\n # rank[root_x] += 1\\n # size[root_x] += size[root_y]\\n\\n def is_connected(x, y):\\n return find(x) == find(y)\\n \\n def get_size(x):\\n return size[find(x)]\\n\\n flatten_grid = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\\n flatten_grid.sort()\\n \\n sorted_queries = [(query, index) for index, query in enumerate(queries)]\\n sorted_queries.sort()\\n\\n answers = [0] * len(queries)\\n directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]\\n\\n curr_index = 0\\n for query, query_index in sorted_queries:\\n while curr_index < (m*n) and flatten_grid[curr_index][0] < query:\\n _, x, y = flatten_grid[curr_index]\\n for dx, dy in directions:\\n new_x = x + dx\\n new_y = y + dy\\n\\n if not (0 <= new_x < m) or not (0 <= new_y < n):\\n continue\\n \\n if grid[new_x][new_y] < query:\\n union(x * n + y, new_x * n + new_y)\\n curr_index += 1\\n\\n if grid[0][0] < query:\\n answers[query_index] = get_size(find(0))\\n\\n return answers\",\n \"runtime\": \"1105\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # sort the queries, to make the from smaller value to bigger value\\n # this way we can eliminate some of the recomputation\\n # because if smaller value pass, that means the bigger values will pass\\n\\n # we can keep the same set of visited coordinates? \\n # and increase the count for the subsequence queries\\n\\n # let's say for ex1, we sort the 5 6 2 to 2 5 6\\n # we run the 2 first\\n # we mark the first cell to be cleared, so count is 1\\n # and for 5, we start with count = 1\\n # then do bfs , get 5 cells\\n # and for 6, we start with count of 5, and spread out\\n\\n # for the bfs, if the value is >= than the value, we add it back to the queue? \\n # because there might be other cells behind it that < than the current value\\n\\n # how do we mark them as already check?\\n # we can add them to a heap, with value, r, c\\n # that should help with dealing with the value, or bigger cell\\n # so we can start other queries\\n\\n result = [0 for _ in range(len(queries))]\\n\\n check = [(i, val) for i, val in enumerate(queries)]\\n check.sort(key = lambda x: x[1])\\n\\n # check = [index, val that we will check]\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n heap = [] # heap = (value, r, c)\\n heapq.heappush(heap, (grid[0][0], 0, 0))\\n heapq.heappush(heap, (10 ** 6 + 1, -1, -1))\\n visited.add((0, 0))\\n\\n # we start checking from the first value in the check array\\n checkIndex = 0\\n curCount = 0\\n\\n \\n while heap:\\n val, r, c = heapq.heappop(heap)\\n # check if the current val is already out of range for our query val\\n # move till we find a new value that within range\\n while checkIndex < len(check) and val >= check[checkIndex][1]:\\n \\n result[check[checkIndex][0]] = curCount\\n checkIndex += 1\\n \\n # see if we reach the end of queries but there are still coordinates, we should still break\\n if checkIndex == len(check):\\n break\\n \\n # now we have a new query val that within range\\n # increase count, and add the neighbors to the heap\\n curCount += 1\\n\\n # go through the neighbors, check if within range and not visited\\n # add to the heap\\n for dr, dc in [[1, 0], [0, 1], [-1, 0], [0, -1]]:\\n if 0 <= r + dr < rows and 0 <= c + dc < cols and (r + dr, c + dc) not in visited:\\n heapq.heappush(heap, (grid[r+dr][c+dc], r + dr, c + dc))\\n visited.add((r + dr, c + dc))\\n\\n # print(curCount, checkIndex)\\n\\n # # we still have 1 last case, where if we reach the end with the extremely big value, that covers every value\\n # if checkIndex < len(check) and curCount and result[check[checkIndex][0]] == 0:\\n # result[check[checkIndex][0]] = curCount\\n\\n\\n return result\\n\",\n \"runtime\": \"1131\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n res = []\\n for q in queries:\\n res.append(bisect.bisect_left(order, q))\\n return res\\n\\n\",\n \"runtime\": \"1131\"\n },\n {\n \"code\": \"from collections import deque, defaultdict\\nfrom bisect import bisect_left\\nfrom heapq import heappush as hpush, heappop as hpop, heapify\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n\\n def move(x, y):\\n return 0 <= x < len(grid) and 0 <= y < len(grid[0])\\n \\n scores, find = [], []\\n\\n seen = set([(0,0)])\\n q = [(grid[0][0], (0, 0))]\\n heapify(q)\\n \\n curr_max = grid[0][0]\\n s = 0\\n\\n while q:\\n score, (x , y) = hpop(q)\\n if score > curr_max:\\n scores.append(s)\\n find.append(curr_max)\\n curr_max = score\\n s += 1\\n for dx, dy in dirs:\\n newPos = (x + dx, y + dy)\\n if move(*newPos) and newPos not in seen:\\n seen.add(newPos)\\n hpush(q, (grid[newPos[0]][newPos[1]], newPos))\\n\\n scores.append(s)\\n find.append(curr_max)\\n\\n res = []\\n for q in queries:\\n if q <= find[0]:\\n res.append(0)\\n elif q > find[-1]:\\n res.append(scores[-1])\\n else:\\n idx = bisect_left(find, q)\\n res.append(scores[idx - 1])\\n return res\",\n \"runtime\": \"1157\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n n, m = len(grid), len(grid[0])\\n\\n directions = [(0,1),(1,0), (-1,0), (0,-1)]\\n\\n def isValid(row, col):\\n return 0 <= row < n and 0 <= col < m and (row,col) not in self.visited\\n \\n heap = [(grid[0][0], 0, 0)]\\n self.visited = set()\\n self.visited.add((0,0))\\n\\n thresholdOrder = []\\n threshold = -1\\n \\n while heap:\\n val, row, col = heapq.heappop(heap)\\n \\n threshold = max(threshold, val)\\n thresholdOrder.append(threshold)\\n\\n for dx, dy in directions:\\n newX = row + dx\\n newY = col + dy\\n if not isValid(newX,newY):\\n continue\\n self.visited.add((newX,newY))\\n heapq.heappush(heap, (grid[newX][newY], newX, newY))\\n\\n res = []\\n\\n for query in queries:\\n res.append(bisect.bisect_left(thresholdOrder, query))\\n\\n return res\\n\",\n \"runtime\": \"1157\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\\n results = [0] * len(queries)\\n queries = sorted([(q, i) for i, q in enumerate(queries)])\\n visited = set()\\n heap = [(grid[0][0], 0, 0)]\\n \\n for q, original_index in queries:\\n while heap and heap[0][0] < q:\\n value, x, y = heappop(heap)\\n if (x, y) not in visited:\\n visited.add((x, y))\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heappush(heap, (grid[nx][ny], nx, ny))\\n results[original_index] = len(visited)\\n \\n return results\\n \",\n \"runtime\": \"1183\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n mn = m * n\\n\\n # 并查集模板\\n fa = list(range(mn))\\n size = [1] * mn\\n def find(x: int) -> int:\\n if fa[x] != x:\\n fa[x] = find(fa[x])\\n return fa[x]\\n def merge(from_: int, to: int) -> None:\\n from_ = find(from_)\\n to = find(to)\\n if from_ != to:\\n fa[from_] = to\\n size[to] += size[from_]\\n\\n # 矩阵元素从小到大排序，方便离线\\n a = sorted((x, i, j) for i, row in enumerate(grid) for j, x in enumerate(row))\\n\\n ans, j = [0] * len(queries), 0\\n # 查询的下标按照查询值从小到大排序，方便离线\\n for i, q in sorted(enumerate(queries), key=lambda p: p[1]):\\n while j < mn and a[j][0] < q:\\n _, x, y = a[j]\\n # 枚举周围四个格子，值小于 q 才可以合并\\n for x2, y2 in (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1):\\n if 0 <= x2 < m and 0 <= y2 < n and grid[x2][y2] < q:\\n merge(x * n + y, x2 * n + y2) # 把坐标压缩成一维的编号\\n j += 1\\n if grid[0][0] < q:\\n ans[i] = size[find(0)] # 左上角的连通块的大小\\n return ans\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n queries = [(q, i) for i, q in enumerate(queries)]\\n s_queries = sorted(queries, key = lambda x: x[0])\\n ret = [0] * len(queries)\\n visited = set()\\n h = [(grid[0][0], 0,0)]\\n offsets = [(0,1), (0, -1), (-1, 0), (1, 0)]\\n m = len(grid)\\n n = len(grid[0])\\n count = 0\\n for q, i in s_queries:\\n while h and h[0][0] < q:\\n _, r, c = heappop(h)\\n if (r, c) in visited:\\n continue\\n visited.add((r,c))\\n count += 1\\n for o in offsets:\\n newr, newc = r + o[0], c + o[1]\\n if newr >= 0 and newr < m and newc >= 0 and newc < n and (newr, newc) not in visited:\\n heappush(h, (grid[newr][newc], newr, newc))\\n ret[i] = count\\n return ret\",\n \"runtime\": \"1209\"\n },\n {\n \"code\": \"from heapq import heappush as hpush, heappop as hpop\\ndelta = [(0,1), (0,-1), (1,0), (-1,0)]\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n n,m = len(grid), len(grid[0])\\n mx = max(queries)\\n count = [0] * (mx+1)\\n curr = grid[0][0] + 1\\n\\n h = [(grid[0][0],0,0)]\\n grid[0][0] = '#'\\n while curr <= mx and h:\\n if curr <= h[0][0]:\\n curr += 1\\n if curr <= mx:\\n count[curr] = count[curr-1]\\n continue \\n u,ux,uy = hpop(h)\\n count[curr] += 1\\n for dx,dy in delta:\\n vx,vy = ux+dx,uy+dy\\n if -1 < vx < n and -1 < vy < m and grid[vx][vy] != '#':\\n hpush(h,(grid[vx][vy],vx,vy))\\n grid[vx][vy] = '#'\\n\\n while curr < mx:\\n count[curr + 1] = count[curr]\\n curr += 1\\n # print(count)\\n return [count[k] for k in queries ]\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"1235\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n query_list = sorted(enumerate(queries), key = lambda x: x[1])\\n res = [0] * len(queries)\\n\\n ROWS = len(grid)\\n COLS = len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n count = 0\\n visited = set()\\n for query in query_list:\\n while q and q[0][0] < query[1]:\\n _, r, c = heapq.heappop(q)\\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n count += 1\\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\\n if (nr, nc) not in visited and 0 <= nr < ROWS and 0 <= nc < COLS:\\n heapq.heappush(q, (grid[nr][nc], nr, nc))\\n res[query[0]] = count\\n return res\",\n \"runtime\": \"1261\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n R, C = len(grid), len(grid[0])\\n dxns=[(1,0),(-1,0),(0,1),(0,-1)]\\n heap = [(grid[0][0], 0, 0)]\\n vis = [[False] * C for _ in range(R)]\\n cur = -1\\n arr = []\\n\\n def valid(r, c):\\n return 0 <= r < R and 0 <= c < C and not vis[r][c]\\n sz = 0\\n\\n while heap:\\n val, r, c = heapq.heappop(heap)\\n if vis[r][c]: continue\\n vis[r][c] = True\\n if val > cur:\\n arr.append((cur, sz))\\n cur = val\\n sz += 1\\n for dr, dc in dxns:\\n if valid(r + dr, c + dc):\\n heapq.heappush(heap, (grid[r + dr][c + dc], r + dr, c + dc))\\n arr.append((cur, sz))\\n ans = []\\n for q in queries:\\n i = bisect_left(arr, (q, -1)) - 1\\n ans.append(arr[i][1])\\n return ans\",\n \"runtime\": \"1261\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n query_list = sorted(enumerate(queries), key = lambda x: x[1])\\n res = [0] * len(queries)\\n\\n ROWS = len(grid)\\n COLS = len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n count = 0\\n visited = set()\\n for query in query_list:\\n if q:\\n k = query[1]\\n while q and q[0][0] < k:\\n _, r, c = heapq.heappop(q)\\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n count += 1\\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\\n if (nr, nc) not in visited and 0 <= nr < ROWS and 0 <= nc < COLS:\\n heapq.heappush(q, (grid[nr][nc], nr, nc))\\n res[query[0]] = count\\n return res\",\n \"runtime\": \"1287\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n\\n visited = {(i,j):False for i in range(m) for j in range(n)}\\n sorted_queries = sorted(queries)\\n border = [(grid[0][0], 0, 0)]\\n score = defaultdict(int)\\n current_score = 0\\n\\n for query in sorted_queries:\\n\\n while border:\\n g,i,j = border[0]\\n\\n if visited[(i,j)]:\\n heapq.heappop(border)\\n\\n elif g >= query:\\n break\\n \\n else:\\n heapq.heappop(border)\\n \\n current_score += 1\\n visited[(i,j)] = True\\n \\n # add neighbour if neighbour wasn't visited\\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\\n\\n score[query] = current_score\\n \\n return [score[query] for query in queries]\\n\",\n \"runtime\": \"1287\"\n },\n {\n \"code\": \"class Solution:\\n from typing import List\\n import heapq\\n\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n queries = sorted([(q, i) for i, q in enumerate(queries)])\\n answer = [0] * len(queries)\\n visited = set()\\n heap = [(grid[0][0], 0, 0)]\\n count = 0\\n\\n for q, i in queries:\\n while heap and heap[0][0] < q:\\n val, x, y = heapq.heappop(heap)\\n if (x, y) not in visited:\\n visited.add((x, y))\\n count += 1\\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\\n answer[i] = count\\n\\n return answer\",\n \"runtime\": \"1313\"\n },\n {\n \"code\": \"class Solution:\\n from typing import List\\n import heapq\\n\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n queries = sorted([(q, i) for i, q in enumerate(queries)])\\n answer = [0] * len(queries)\\n visited = set()\\n heap = [(grid[0][0], 0, 0)]\\n points = 0\\n for q, i in queries:\\n while heap and heap[0][0] < q:\\n val, x, y = heapq.heappop(heap)\\n if (x, y) not in visited:\\n visited.add((x, y))\\n points += 1\\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\\n answer[i] = points\\n return answer\",\n \"runtime\": \"1340\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n\\n visited = {(i,j):False for i in range(m) for j in range(n)}\\n sorted_queries = sorted(queries)\\n border = [(grid[0][0], 0, 0)]\\n score = defaultdict(int)\\n current_score = 0\\n\\n for query in sorted_queries:\\n\\n while border:\\n g,i,j = border[0]\\n\\n if visited[(i,j)]:\\n heapq.heappop(border)\\n\\n elif g >= query:\\n break\\n \\n else:\\n heapq.heappop(border)\\n \\n current_score += 1\\n visited[(i,j)] = True\\n \\n # add neighbour if neighbour wasn't visited\\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\\n\\n score[query] = current_score\\n \\n return [score[query] for query in queries]\\n\",\n \"runtime\": \"1366\"\n },\n {\n \"code\": \"import collections\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n index_query = [(i, query) for i, query in enumerate(queries)]\\n\\n index_query.sort(key = lambda x : x[1])\\n boundary = [ (grid[0][0], (0,0)) ] # (val, (x,y))\\n heapq.heapify(boundary)\\n index_point = [] # [idx, point]\\n explored = set() # (x, y)\\n\\n for idx, query in index_query:\\n if len(index_point) == 0:\\n index_point.append( [idx, 0] )\\n else:\\n index_point.append( [idx, index_point[-1][1]] )\\n \\n while len(boundary) > 0 and query > boundary[0][0]:\\n if boundary[0][1] in explored:\\n heapq.heappop(boundary)\\n continue\\n\\n index_point[-1][1] += 1\\n explored.add( boundary[0][1] )\\n x, y = boundary[0][1]\\n heapq.heappop(boundary)\\n\\n if x + 1 < len(grid) and (x+1, y) not in explored:\\n heapq.heappush(boundary, (grid[x+1][y], (x+1, y)))\\n \\n if y + 1 < len(grid[0]) and (x, y+1) not in explored:\\n heapq.heappush(boundary, (grid[x][y+1], (x, y+1)))\\n \\n if x - 1 >= 0 and (x-1, y) not in explored:\\n heapq.heappush(boundary, (grid[x-1][y], (x-1, y)))\\n \\n if y - 1 >= 0 and (x, y-1) not in explored:\\n heapq.heappush(boundary, (grid[x][y-1], (x, y-1)))\\n \\n index_point.sort(key= lambda x : x[0])\\n\\n return [x[1] for x in index_point]\\n \",\n \"runtime\": \"1366\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n\\n visited = {(i,j):False for i in range(m) for j in range(n)}\\n sorted_queries = sorted(queries)\\n border = [(grid[0][0], 0, 0)]\\n score = defaultdict(int)\\n current_score = 0\\n\\n for query in sorted_queries:\\n\\n while border:\\n g,i,j = border[0]\\n\\n if visited[(i,j)]:\\n heapq.heappop(border)\\n\\n elif g >= query:\\n break\\n \\n else:\\n heapq.heappop(border)\\n \\n current_score += 1\\n visited[(i,j)] = True\\n \\n # add neighbour if neighbour wasn't visited\\n for neigh_i, neigh_j in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\\n if 0 <= neigh_i < m and 0 <= neigh_j < n and not visited[(neigh_i, neigh_j)]:\\n heapq.heappush(border, (grid[neigh_i][neigh_j], neigh_i, neigh_j))\\n\\n score[query] = current_score\\n \\n return [score[query] for query in queries]\\n\",\n \"runtime\": \"1392\"\n },\n {\n \"code\": \"import heapq\\nfrom collections import defaultdict\\nfrom bisect import bisect_left\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n dirr=[(0,1),(1,0),(0,-1),(-1,0)]\\n\\n row=len(grid)\\n col=len(grid[0])\\n visited=set()\\n stc=[]\\n stc.append((grid[0][0],0,0))\\n heapq.heapify(stc)\\n visited.add((0,0))\\n result=defaultdict(int)\\n count=0\\n while stc:\\n start=stc[0][0]\\n result[start]=count\\n while stc and stc[0][0]<=start:\\n K=heapq.heappop(stc)\\n val=K[0]\\n r=K[1]\\n c=K[2]\\n for d in dirr:\\n if r+d[0] in range(row) and c+d[1] in range(col) and (r+d[0],c+d[1]) not in visited:\\n visited.add((r+d[0],c+d[1]))\\n heapq.heappush(stc,(grid[r+d[0]][c+d[1]],r+d[0],c+d[1]))\\n count+=1\\n ans=[]\\n KEY=list(result.keys())\\n KEY.sort()\\n lk=len(KEY)\\n for i in queries:\\n K=bisect_left(KEY,i)\\n if K<lk:\\n ans.append(result[KEY[K]])\\n else:\\n ans.append(row*col)\\n return ans\",\n \"runtime\": \"1418\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\\n \\n completed = set()\\n heap = [(grid[0][0], 0, 0)]\\n heapq.heapify(heap)\\n\\n answer = [0] * len(queries)\\n for ind in range(len(sorted_queries)):\\n query = sorted_queries[ind][0]\\n index = sorted_queries[ind][1]\\n sol = 0\\n\\n while heap:\\n val, x, y = heap[0]\\n if query <= val:\\n break\\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\\n # continue\\n\\n heapq.heappop(heap)\\n\\n if (x,y) in completed:\\n continue\\n sol += 1\\n completed.add((x,y))\\n\\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\\n\\n\\n if ind-1>=0:\\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\\n else: answer[index]= sol\\n\\n return answer\",\n \"runtime\": \"1444\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\\n \\n completed = set()\\n heap = [(grid[0][0], 0, 0)]\\n heapq.heapify(heap)\\n\\n answer = [0] * len(queries)\\n for ind in range(len(sorted_queries)):\\n query = sorted_queries[ind][0]\\n index = sorted_queries[ind][1]\\n sol = 0\\n\\n while heap:\\n val, x, y = heap[0]\\n if query <= val:\\n break\\n\\n if (x,y) in completed:\\n heapq.heappop(heap)\\n continue\\n\\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\\n # continue\\n\\n heapq.heappop(heap)\\n sol += 1\\n completed.add((x,y))\\n\\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\\n\\n\\n if ind-1>=0:\\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\\n else: answer[index]= sol\\n\\n return answer\",\n \"runtime\": \"1470\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n\\n query_index_list = sorted(\\n [(q, i) for i, q in enumerate(queries)],\\n reverse=True,\\n )\\n # print(f\\\"query_index_list= {query_index_list}\\\")\\n num_points_and_index_list = []\\n\\n visited_set = set()\\n h = [(grid[0][0], 0, 0)]\\n while query_index_list and h:\\n height, i, j = heapq.heappop(h)\\n\\n if (i, j) in visited_set:\\n continue\\n elif height >= query_index_list[-1][0]:\\n _, index = query_index_list.pop()\\n num_points_and_index_list.append((len(visited_set), index))\\n heapq.heappush(h, (height, i, j))\\n continue\\n\\n visited_set.add((i, j))\\n\\n for i_, j_ in [\\n [i + 1, j],\\n [i - 1, j],\\n [i, j + 1],\\n [i, j - 1],\\n ]:\\n if i_ < 0 or i_ > m - 1 or j_ < 0 or j_ > n - 1:\\n continue\\n\\n heapq.heappush(h, (grid[i_][j_], i_, j_))\\n \\n ans = [-1] * len(queries)\\n for num_points, index in num_points_and_index_list:\\n ans[index] = num_points\\n\\n # print(f\\\"query_index_list= {query_index_list}\\\")\\n while query_index_list:\\n _, i = query_index_list.pop()\\n ans[i] = len(visited_set)\\n \\n return ans\",\n \"runtime\": \"1496\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n threshold = [[0 for j in range(n)] for i in range(m)]\\n heap = []\\n heapq.heappush(heap, [grid[0][0], 0, 0])\\n while heap:\\n while heap and threshold[heap[0][1]][heap[0][2]] > 0:\\n heapq.heappop(heap)\\n if heap:\\n cost, x, y = heapq.heappop(heap)\\n threshold[x][y] = cost\\n for nx, ny in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:\\n if 0 <= nx < m and 0 <= ny < n:\\n heapq.heappush(heap, [max(grid[nx][ny], cost), nx, ny])\\n elements = []\\n for i in range(m):\\n for j in range(n):\\n elements.append(threshold[i][j])\\n elements.sort()\\n \\n result = []\\n for query in queries:\\n result.append(bisect.bisect_left(elements, query))\\n return result\",\n \"runtime\": \"1522\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n count = [0] * (10**6 + 1)\\n rows, cols = len(grid), len(grid[0])\\n pq = []\\n vis = [[0] * cols for i in range(rows)]\\n vis[0][0] = 1\\n heappush(pq, (grid[0][0], 0, 0))\\n dir_arr = [0, 1, 0, -1, 0]\\n while pq:\\n cur_cost, cur_x, cur_y = heappop(pq)\\n count[cur_cost] += 1\\n for i in range(4):\\n new_x = cur_x + dir_arr[i]\\n new_y = cur_y + dir_arr[i + 1]\\n if 0 <= new_x < rows and 0 <= new_y < cols and vis[new_x][new_y] == 0:\\n vis[new_x][new_y] = 1\\n heappush(pq, (max(cur_cost, grid[new_x][new_y]), new_x, new_y))\\n\\n for i in range(1, len(count)):\\n count[i] += count[i - 1]\\n\\n ans = []\\n for i in queries:\\n ans.append(count[i - 1])\\n\\n return ans\\n\",\n \"runtime\": \"1548\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n g = defaultdict(int)\\n visited = []\\n visited.append((grid[0][0], 0,0))\\n vis = set()\\n m = 0\\n while visited:\\n tv, tl, tr = heappop(visited)\\n if (tl,tr) in vis:\\n continue\\n vis.add((tl, tr))\\n m = max(tv, m)\\n print(tv, tl, tr, m)\\n \\n g[m]+=1\\n for x,y in [[-1, 0], [1, 0], [0, 1], [0, -1]]:\\n a = tl+x\\n b = tr +y\\n if a >=0 and a < len(grid) and b >=0 and b < len(grid[0]):\\n if (a,b) not in vis:\\n heappush(visited, (grid[a][b], a, b))\\n print(g)\\n res = []\\n gsort = [[k,v] for k,v in g.items()]\\n gsort.sort()\\n for i in range(1, len(gsort)):\\n gsort[i][1] += gsort[i-1][1]\\n print(gsort)\\n for q in queries:\\n dex = bisect_left(gsort, [q-1, float('inf')])-1\\n if q <= gsort[dex][0]:\\n res.append(0)\\n continue\\n res.append(gsort[dex][1])\\n return res\",\n \"runtime\": \"1574\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n g = defaultdict(int)\\n visited = []\\n visited.append((grid[0][0], 0,0))\\n vis = set()\\n m = 0\\n while visited:\\n tv, tl, tr = heappop(visited)\\n if (tl,tr) in vis:\\n continue\\n vis.add((tl, tr))\\n m = max(tv, m)\\n print(tv, tl, tr, m)\\n \\n g[m]+=1\\n for x,y in [[-1, 0], [1, 0], [0, 1], [0, -1]]:\\n a = tl+x\\n b = tr +y\\n if a >=0 and a < len(grid) and b >=0 and b < len(grid[0]):\\n if (a,b) not in vis:\\n heappush(visited, (grid[a][b], a, b))\\n print(g)\\n res = []\\n gsort = [[k,v] for k,v in g.items()]\\n gsort.sort()\\n for i in range(1, len(gsort)):\\n gsort[i][1] += gsort[i-1][1]\\n print(gsort)\\n for q in queries:\\n dex = bisect_left(gsort, [q-1, float('inf')])-1\\n if q <= gsort[dex][0]:\\n res.append(0)\\n continue\\n res.append(gsort[dex][1])\\n return res\\n \\n \\n \\n \",\n \"runtime\": \"1600\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\\n \\n completed = set()\\n heap = [(grid[0][0], 0, 0)]\\n heapq.heapify(heap)\\n\\n answer = [0] * len(queries)\\n for ind in range(len(sorted_queries)):\\n query = sorted_queries[ind][0]\\n index = sorted_queries[ind][1]\\n sol = 0\\n\\n while heap:\\n val, x, y = heap[0]\\n print(val)\\n if query <= val:\\n break\\n\\n if (x,y) in completed:\\n heapq.heappop(heap)\\n continue\\n\\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\\n # continue\\n\\n heapq.heappop(heap)\\n sol += 1\\n completed.add((x,y))\\n\\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\\n\\n\\n if ind-1>=0:\\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\\n else: answer[index]= sol\\n\\n return answer\",\n \"runtime\": \"1626\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n q = [[grid[0][0], 0, 0]]\\n heapq.heapify(q)\\n\\n seen = set()\\n\\n grid_sort = []\\n\\n while q:\\n [num, i, j] = heapq.heappop(q)\\n if (i,j) in seen:\\n continue\\n seen.add((i,j))\\n grid_sort.append(num)\\n if i+1<m:\\n heapq.heappush(q, [grid[i+1][j], i+1, j])\\n if j+1<n:\\n heapq.heappush(q, [grid[i][j+1], i, j+1])\\n if i-1>=0:\\n heapq.heappush(q, [grid[i-1][j], i-1, j])\\n if j-1>=0:\\n heapq.heappush(q, [grid[i][j-1], i, j-1])\\n # print(len(grid_sort), m*n)\\n max_num = -1\\n for i in range(len(grid_sort)):\\n max_num = max(max_num, grid_sort[i])\\n grid_sort[i] = max_num\\n # print(grid_sort)\\n ans = []\\n for query in queries:\\n left, right = 0, len(grid_sort)-1\\n while left<=right:\\n mid = (left+right)//2\\n if grid_sort[mid]>=query:\\n right = mid-1\\n else:\\n left = mid+1\\n ans.append(left)\\n return ans\\n\\n \\n\",\n \"runtime\": \"1652\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries: \\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n if num_queries == total_num_queries:\\n break\\n query_i += 1\\n return answer\",\n \"runtime\": \"1678\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # # OPTIMIZED: sort values in increasing order\\n # # maps num -> index in queries before sort\\n # original_indices = {}\\n # total_num_queries = len(queries)\\n # for i in range(total_num_queries):\\n # if queries[i] not in original_indices:\\n # original_indices[queries[i]] = []\\n # original_indices[queries[i]].append(i)\\n # queries.sort()\\n # answer = [0] * total_num_queries\\n # n, m = len(grid), len(grid[0])\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # # function checking if i, j is a valid coordinate in grid\\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n # first_i, first_coord = 0, (0, 0)\\n # queue, adjacent_coords, queued = [first_coord], [], set()\\n # queued.add(first_coord)\\n # count, num_queries = 0, 0\\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n # first_i += 1\\n # for query_i in range(first_i, total_num_queries):\\n # # while queue is not empty\\n # while queue:\\n # # pop and add to count\\n # coord = queue.pop(0)\\n # count += 1\\n # # for each dir in directions:\\n # for dir in directions:\\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # # if is a valid coordinate and not queued yet:\\n # if is_valid_coord(next_coord) and next_coord not in queued:\\n # # if it is less than current num:\\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # # append to queue\\n # queue.append(next_coord)\\n # # add to queued\\n # queued.add(next_coord)\\n # else:\\n # adjacent_coords.append(next_coord)\\n # queued.add(next_coord)\\n # for answer_i in original_indices[queries[query_i]]:\\n # answer[answer_i] = count\\n # num_queries += 1\\n # if query_i + 1 < total_num_queries:\\n # next_adjacent_coords = []\\n # for coord in adjacent_coords:\\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n # queue.append(coord)\\n # else:\\n # next_adjacent_coords.append(coord)\\n # adjacent_coords = next_adjacent_coords\\n # if num_queries == total_num_queries:\\n # break\\n # return answer\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries:\\n # for query_i in range(first_i, total_num_queries):\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop()\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if num_queries == total_num_queries:\\n break\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n query_i += 1\\n return answer\\n \",\n \"runtime\": \"1704\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # # OPTIMIZED: sort values in increasing order\\n # # maps num -> index in queries before sort\\n # original_indices = {}\\n # total_num_queries = len(queries)\\n # for i in range(total_num_queries):\\n # if queries[i] not in original_indices:\\n # original_indices[queries[i]] = []\\n # original_indices[queries[i]].append(i)\\n # queries.sort()\\n # answer = [0] * total_num_queries\\n # n, m = len(grid), len(grid[0])\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # # function checking if i, j is a valid coordinate in grid\\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n # first_i, first_coord = 0, (0, 0)\\n # queue, adjacent_coords, queued = [first_coord], [], set()\\n # queued.add(first_coord)\\n # count, num_queries = 0, 0\\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n # first_i += 1\\n # for query_i in range(first_i, total_num_queries):\\n # # while queue is not empty\\n # while queue:\\n # # pop and add to count\\n # coord = queue.pop(0)\\n # count += 1\\n # # for each dir in directions:\\n # for dir in directions:\\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # # if is a valid coordinate and not queued yet:\\n # if is_valid_coord(next_coord) and next_coord not in queued:\\n # # if it is less than current num:\\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # # append to queue\\n # queue.append(next_coord)\\n # # add to queued\\n # queued.add(next_coord)\\n # else:\\n # adjacent_coords.append(next_coord)\\n # queued.add(next_coord)\\n # for answer_i in original_indices[queries[query_i]]:\\n # answer[answer_i] = count\\n # num_queries += 1\\n # if query_i + 1 < total_num_queries:\\n # next_adjacent_coords = []\\n # for coord in adjacent_coords:\\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n # queue.append(coord)\\n # else:\\n # next_adjacent_coords.append(coord)\\n # adjacent_coords = next_adjacent_coords\\n # if num_queries == total_num_queries:\\n # break\\n # return answer\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries:\\n # for query_i in range(first_i, total_num_queries):\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if num_queries == total_num_queries:\\n break\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n query_i += 1\\n return answer\\n \",\n \"runtime\": \"1730\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":61,"string":"61"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n rows, cols = len(grid), len(grid[0])\n sorted_q = [(b, a) for a, b in enumerate(queries) if grid[0][0] < b]\n sorted_q.sort()\n pq = []\n heappush(pq, (grid[0][0], 0, 0))\n grid[0][0] = -1\n dir_arr = [0, 1, 0, -1, 0]\n cnt = 0\n ans = [0] * len(queries)\n for q, index in sorted_q:\n while pq:\n cur_cost, cur_x, cur_y = pq[0]\n if cur_cost >= q:\n break\n cnt += 1\n heappop(pq)\n for i in range(4):\n new_x = cur_x + dir_arr[i]\n new_y = cur_y + dir_arr[i + 1]\n if (\n 0 <= new_x < rows\n and 0 <= new_y < cols\n and grid[new_x][new_y] != -1\n ):\n heappush(pq, (max(cur_cost, grid[new_x][new_y]), new_x, new_y))\n grid[new_x][new_y] = -1\n\n ans[index] = cnt\n return ans\n","memory":"28900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n s_queries = sorted(set(queries))\n ans = {}\n from heapq import heappush, heappop\n prevCount = 0\n\n q = [(grid[0][0], 0, 0)]\n\n for query in s_queries:\n curCount = prevCount\n while q:\n val, r, c = q[0]\n if val >= query:\n break\n \n heappop(q)\n grid[r][c] = None\n curCount += 1\n\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\n if 0 <=nr<m and 0<=nc<n and grid[nr][nc] is not None:\n heappush(q, (grid[nr][nc], nr, nc))\n grid[nr][nc] = None\n \n ans[query] = curCount\n prevCount = curCount\n \n res = [ans[query] for query in queries]\n\n return res\n \n\n\n\n\n ","memory":"29500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n q = len(queries)\n\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\n answers = [0] * q\n prev_query = 0\n points = 0\n fringe = [(grid[0][0], 0, 0)]\n grid[0][0] = 0\n heapq.heapify(fringe)\n\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\n\n for i in sorted_indices:\n query = queries[i]\n\n if query == prev_query:\n answers[i] = points\n continue\n\n stack = deque()\n while fringe and fringe[0][0] < query:\n (val, r, c) = heapq.heappop(fringe)\n stack.append((r, c))\n points += 1\n\n while stack:\n (r, c) = stack.pop()\n for (x, y) in dirs:\n rr = r + x\n cc = c + y\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\n if grid[rr][cc] < query:\n stack.append((rr, cc))\n points += 1\n else:\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\n grid[rr][cc] = 0\n\n answers[i] = points\n prev_query = query\n\n return answers","memory":"29600"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n q = len(queries)\n\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\n answers = [0] * q\n prev_query = 0\n points = 0\n fringe = [(grid[0][0], 0, 0)]\n heapq.heapify(fringe)\n\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\n\n for i in sorted_indices:\n query = queries[i]\n # print(query, '----------------')\n # print(fringe)\n\n if query == prev_query:\n answers[i] = points\n continue\n\n stack = deque()\n while fringe and fringe[0][0] < query:\n (val, r, c) = heapq.heappop(fringe)\n stack.append((r, c))\n points += 1\n grid[r][c] = 0\n\n while stack:\n (r, c) = stack.pop()\n # print(r, c)\n for (x, y) in dirs:\n rr = r + x\n cc = c + y\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\n if grid[rr][cc] < query:\n stack.append((rr, cc))\n points += 1\n else:\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\n grid[rr][cc] = 0\n\n answers[i] = points\n prev_query = query\n\n return answers","memory":"29700"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n qs = sorted(set(queries))\n res = dict()\n rows, cols = len(grid), len(grid[0])\n q = [(grid[0][0], 0, 0)]\n prevCount = 0\n\n for num in qs:\n count = prevCount\n while q:\n val, r, c = q[0]\n\n if val >= num:\n break\n else:\n heappop(q)\n grid[r][c] = None\n count += 1\n\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\n heappush(q, (grid[i][j], i, j))\n grid[i][j] = None\n \n res[num] = prevCount = count\n\n out = [res[num] for num in queries]\n return out","memory":"29800"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n queriesOg=queries\n queries = sorted(set(queries))\n res = {}\n rows, cols = len(grid), len(grid[0])\n q = [(grid[0][0], 0, 0)]\n prevCount = 0\n\n for num in queries:\n count = prevCount\n\n while q:\n val, r, c = q[0]\n\n if val >= num: break\n else:\n heappop(q)\n grid[r][c] = None\n count += 1\n\n for i,j in [(r+1,c), (r-1,c), (r,c+1), (r,c-1)]:\n if 0<=i <rows and 0<=j <cols and grid[i][j] is not None:\n heappush(q, (grid[i][j], i, j))\n grid[i][j] = None\n res[num] = prevCount = count\n ans = [res[num] for num in queriesOg]\n return ans\n","memory":"29900"},{"code":"class Solution:\n def maxPoints(self, a: List[List[int]], queries: List[int]) -> List[int]:\n queries = [[val,idx] for idx,val in enumerate(queries)]\n ans = [0]*len(queries)\n queries.sort()\n h = [(a[0][0],0,0)]; a[0][0] = -1\n n,m = len(a),len(a[0])\n count = 0\n for qval,idx in queries:\n while h and h[0][0]<qval:\n val,i,j = heappop(h)\n count+=1\n for p,q in [[1,0],[-1,0],[0,1],[0,-1]]:\n x,y = i+p,j+q\n if 0<=x<n and 0<=y<m and a[x][y]!=-1:\n heappush(h,(a[x][y],x,y))\n a[x][y] = -1\n ans[idx] = count\n return ans\n ","memory":"30100"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n R = len(grid)\n C = len(grid[0])\n \n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n res = [0] * len(queries)\n\n \n queries = [(num, i) for i, num in enumerate(queries)]\n queries.sort()\n q = [(grid[0][0], 0, 0)]\n count = 0\n for query, original_index in queries:\n while q:\n val, r, c = q[0]\n if val >= query:\n break\n\n count += 1\n heapq.heappop(q)\n grid[r][c] = None\n \n for dr, dc in dirs:\n new_r = r + dr\n new_c = c + dc\n \n if 0 <= new_r < R and 0 <= new_c < C and grid[new_r][new_c] is not None:\n heapq.heappush(q, (grid[new_r][new_c], new_r, new_c))\n grid[new_r][new_c] = None\n \n res[original_index] = count\n \n return res\n ","memory":"30200"},{"code":"class Solution:\n def maxPoints(self, matrix: List[List[int]], queries: List[int]) -> List[int]:\n arr = []\n m = len(matrix)\n n = len(matrix[0])\n length = len(queries)\n for i in range (length):\n arr.append((queries[i], i))\n X = [-1, 0, 1, 0]\n Y = [0, -1, 0, 1]\n arr.sort()\n h = [(matrix[0][0], 0, 0)]\n matrix[0][0] = -1\n count = 0\n res = [0 for i in range (length)]\n for i in range (length):\n cur_query, index = arr[i]\n if not h or h[0][0] >= cur_query:\n res[index] = count \n else:\n while h:\n if h[0][0] >= cur_query:\n break\n cur_height, curX, curY = heapq.heappop(h)\n count += 1\n for i in range (4):\n neighborX = curX + X[i]\n neighborY = curY + Y[i]\n if 0 <= neighborX < m and 0 <= neighborY < n and matrix[neighborX][neighborY] != -1: \n heapq.heappush(h, (matrix[neighborX][neighborY], neighborX, neighborY))\n matrix[neighborX][neighborY] = -1\n res[index] = count\n \n return res","memory":"30300"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n h,w = len(grid), len(grid[0])\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n print(len(queries),len(set(queries)),len(mapping.keys()))\n ret = [0 for _ in range(len(queries))]\n sorted_query = sorted(list(set(queries)))\n deq = collections.deque([(0,0)])\n seen = [[0 for _ in range(w)] for _ in range(h)]\n seen[0][0] = 1\n p1 = 0\n deqnext = collections.deque()\n counter = 0\n while deq or deqnext:\n smallest = math.inf\n while deq:\n x,y = deq.popleft()\n num = grid[x][y]\n if num >= sorted_query[p1]:\n deqnext.append((x,y))\n smallest = min(smallest,num)\n else:\n counter+=1\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n seen[dx+x][dy+y] = 1 \n deq.append((dx+x,dy+y))\n # print(p1,sorted_query[p1] , smallest)\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n for idx in mapping[sorted_query[p1]]:\n ret[idx]+=counter \n p1+=1\n deq.extend(deqnext)\n deqnext = collections.deque()\n # print(ret)\n # print(deq,deqnext) \n if p1 >= len(sorted_query):\n break\n\n return ret\n\n","memory":"31800"},{"code":"from heapq import heapify, heappush, heappop\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n rows = len(grid)\n cols = len(grid[0])\n newqueries= sorted([(queries[j], j) for j in range(len(queries))])\n\n minheap = [[grid[0][0], 0, 0]]\n heapify(minheap)\n\n visited = [[0 for i in range(cols)]for j in range(rows)]\n visited[0][0] = 1\n \n count = 0\n ans = [0] * len(queries)\n for limit,index in newqueries:\n while(minheap and minheap[0][0]<limit):\n val, i, j = heappop(minheap)\n count+=1\n for a,b in [(0,1),(0,-1),(1,0),(-1,0)]:\n newi = i+a\n newj = j+b\n if(0<=newi<rows and 0<=newj<cols and visited[newi][newj]==0):\n heappush(minheap, [grid[newi][newj], newi, newj])\n visited[newi][newj] = 1\n ans[index] = count\n return ans\n \n \n\n\n","memory":"32000"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n h,w = len(grid), len(grid[0])\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n ret = [0 for _ in range(len(queries))]\n sorted_query = sorted(list(set(queries)))\n deq = collections.deque([(0,0)])\n seen = [[0 for _ in range(w)] for _ in range(h)]\n seen[0][0] = 1\n p1 = 0\n deqnext = collections.deque()\n counter = 0\n while deq or deqnext:\n smallest = math.inf\n while deq:\n x,y = deq.popleft()\n num = grid[x][y]\n if num >= sorted_query[p1]:\n deqnext.append((x,y))\n smallest = min(smallest,num)\n else:\n counter+=1\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n seen[dx+x][dy+y] = 1 \n deq.append((dx+x,dy+y))\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n for idx in mapping[sorted_query[p1]]:\n ret[idx]+=counter \n p1+=1\n deq.extend(deqnext)\n deqnext = collections.deque()\n if p1 >= len(sorted_query):\n break\n\n return ret\n\n","memory":"32100"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n h,w = len(grid), len(grid[0])\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n ret = [0 for _ in range(len(queries))]\n sorted_query = sorted(list(set(queries)))\n deq = collections.deque([(0,0)])\n seen = [[0 for _ in range(w)] for _ in range(h)]\n seen[0][0] = 1\n p1 = 0\n deqnext = collections.deque()\n counter = 0\n while deq or deqnext:\n smallest = math.inf\n while deq:\n x,y = deq.popleft()\n num = grid[x][y]\n if num >= sorted_query[p1]:\n deqnext.append((x,y))\n smallest = min(smallest,num)\n else:\n counter+=1\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n seen[dx+x][dy+y] = 1 \n deq.append((dx+x,dy+y))\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n for idx in mapping[sorted_query[p1]]:\n ret[idx]+=counter \n p1+=1\n deq.extend(deqnext)\n deqnext = collections.deque()\n if p1 >= len(sorted_query):\n break\n\n return ret\n\n","memory":"32200"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n q = len(queries)\n\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\n answers = [0] * q\n prev_query = 0\n points = 0\n prev_fringe = [(0,0)]\n\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\n\n for i in sorted_indices:\n query = queries[i]\n # print(query, '----------------')\n\n if query == prev_query:\n answers[i] = points\n continue\n\n stack = deque()\n fringe = []\n for (r, c) in prev_fringe:\n if grid[r][c] < query:\n stack.append((r, c))\n else:\n fringe.append((r, c))\n\n while stack:\n (r, c) = stack.pop()\n if grid[r][c] == 0:\n continue\n points += 1\n grid[r][c] = 0\n # print(r, c)\n for (x, y) in dirs:\n rr = r + x\n cc = c + y\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\n if grid[rr][cc] < query:\n stack.append((rr, cc))\n else:\n fringe.append((rr, cc))\n\n answers[i] = points\n prev_fringe = fringe\n prev_query = query\n\n return answers","memory":"32500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n seen = [[0 for _ in range(n)] for _ in range(m)]\n sorted_queries = sorted(queries)\n dic = dict()\n count = 0\n p1 = 0\n seen[0][0] = 1\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n count+=1\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and seen[x][y] == 0:\n seen[x][y] = 1\n heapq.heappush(heap, (grid[x][y], x, y))\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n dic[sorted_queries[p1]] = count-1\n p1+=1\n if p1 >= len(sorted_queries):\n break\n return [dic[q] if q in dic else count for q in queries]\n\n","memory":"32600"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n seen = [[0 for _ in range(n)] for _ in range(m)]\n sorted_queries = sorted(queries)\n dic = dict()\n count = 0\n p1 = 0\n seen[0][0] = 1\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n count+=1\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and seen[x][y] == 0:\n seen[x][y] = 1\n heapq.heappush(heap, (grid[x][y], x, y))\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n dic[sorted_queries[p1]] = count-1\n p1+=1\n if p1 >= len(sorted_queries):\n break\n return [dic[q] if q in dic else count for q in queries]\n\n","memory":"32600"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Priority queue for Dijkstra-like approach\n min_heap = [(grid[0][0], 0, 0)]\n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n \n # Preprocess the grid to find the order of visiting cells\n cell_values = []\n while min_heap:\n value, x, y = heappop(min_heap)\n cell_values.append(value)\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heappush(min_heap, (grid[nx][ny], nx, ny))\n \n # Sort queries and prepare the result array\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\n result = [0] * len(queries)\n \n # Process each query\n cell_index = 0\n points = 0\n for query, original_index in queries_with_indices:\n # Count cells with values less than the current query\n while cell_index < len(cell_values) and cell_values[cell_index] < query:\n points += 1\n cell_index += 1\n result[original_index] = points\n \n return result","memory":"32700"},{"code":"class Solution:\n from typing import List\n import heapq\n\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n visited = [[False]*n for _ in range(m)]\n heap = [(grid[0][0], 0, 0)]\n visited[0][0] = True\n res = [0]*len(queries)\n queries_sorted = sorted([(q, i) for i, q in enumerate(queries)])\n points = 0\n for q, i in queries_sorted:\n while heap and heap[0][0] < q:\n _, x, y = heapq.heappop(heap)\n points += 1\n for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n nx, ny = x+dx, y+dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\n res[i] = points\n return res","memory":"33000"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \"\"\"\n bfs\n \"\"\"\n k = len(queries)\n res = [0] * k\n\n queries = sorted([[i, num] for i, num in enumerate(queries)], key=lambda x: x[1])\n \n # current index in queries.\n curr = 0\n # monotonically increasing count.\n count = 0\n \n h = [[grid[0][0], 0, 0]]\n \n m, n = len(grid), len(grid[0])\n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n\n while h:\n height, r, c = heapq.heappop(h)\n while curr < k and queries[curr][1] <= height:\n res[queries[curr][0]] = count\n curr += 1\n if curr == k:\n return res\n \n count += 1\n for x, y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if 0 <= x < m and 0 <= y < n and not visited[x][y]:\n heapq.heappush(h, (grid[x][y], x, y))\n visited[x][y] = True\n \n while curr < k:\n res[queries[curr][0]] = count\n curr += 1\n \n return res","memory":"33100"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Sort queries with their original indices\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\n answer = [0] * len(queries)\n \n # Priority queue for cells to explore\n pq = []\n heappush(pq, (grid[0][0], 0, 0))\n \n # Visited matrix\n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n \n # Points counter\n points = 0\n \n for query_value, query_index in sorted_queries:\n # Process the queue until we can no longer visit new cells\n while pq and pq[0][0] < query_value:\n value, x, y = heappop(pq)\n points += 1\n \n # Explore neighbors\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heappush(pq, (grid[nx][ny], nx, ny))\n \n # Store the result for this query\n answer[query_index] = points\n \n return answer","memory":"33200"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n num_queries = len(queries)\n \n # Sort queries and keep track of their original indices\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\n \n # Prepare the answer array\n answer = [0] * num_queries\n \n # Directions for moving up, down, left, and right\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Priority queue for BFS\n pq = []\n # Visited matrix\n visited = [[False] * n for _ in range(m)]\n \n # Start from the top-left corner\n heappush(pq, (grid[0][0], 0, 0))\n visited[0][0] = True\n current_points = 0\n \n # Process the queries in sorted order\n for query_value, original_index in sorted_queries:\n # Expand the BFS frontier for the current query_value\n while pq and pq[0][0] < query_value:\n value, x, y = heappop(pq)\n current_points += 1\n\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heappush(pq, (grid[nx][ny], nx, ny))\n \n # Store the result for this query\n answer[original_index] = current_points\n \n return answer","memory":"33200"},{"code":"from typing import List\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n num_queries = len(queries)\n \n # Sort queries with their original indices\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\n \n # Result array\n result = [0] * num_queries\n \n # Directions for moving up, down, left, right\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Min-heap priority queue\n pq = [(grid[0][0], 0, 0)]\n visited = [[False] * n for _ in range(m)]\n visited[0][0] = True\n current_points = 0\n \n # Process each query\n for query_value, query_index in indexed_queries:\n while pq and pq[0][0] < query_value:\n cell_value, x, y = heapq.heappop(pq)\n current_points += 1 # Gain a point because query_value > cell_value\n \n # Explore neighbors\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\n \n result[query_index] = current_points\n \n return result","memory":"33300"},{"code":"\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n nq = len(queries)\n n = len(grid)\n if not n:\n return [0 for _ in range(nq)]\n\n m = len(grid[0])\n if not m:\n return [0 for _ in range(nq)]\n\n qi = list(sorted([(v, i) for i, v in enumerate(queries)]))\n\n visited = [[False for _ in range(m)] for _ in range(n)]\n added = [[False for _ in range(m)] for _ in range(n)]\n q = [(grid[0][0], 0, 0)]\n added[0][0] = True\n ans = [0 for _ in range(nq)]\n value = 0\n qv = {}\n\n heapq.heapify(q)\n for v, i in qi:\n if v in qv:\n ans[i] = qv[v]\n continue\n\n # nq = []\n # inq = {w for w in q}\n while q:\n # x, y = q.pop()\n # xyv, x, y = heapq.heappop(q)\n xyv, x, y = q[0]\n if visited[x][y]:\n continue\n if xyv < v:\n value += 1\n # visited.add((x, y))\n heapq.heappop(q)\n visited[x][y] = True\n for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:\n if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny] and not added[nx][ny]:\n # q.append((nx, ny))\n heapq.heappush(q, (grid[nx][ny], nx, ny))\n added[nx][ny] = True\n else:\n break\n\n ans[i] = value\n qv[v] = value\n\n return ans","memory":"33400"},{"code":"\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n nq = len(queries)\n n = len(grid)\n if not n:\n return [0 for _ in range(nq)]\n\n m = len(grid[0])\n if not m:\n return [0 for _ in range(nq)]\n\n qi = list(sorted([(v, i) for i, v in enumerate(queries)]))\n\n visited = [[False for _ in range(m)] for _ in range(n)]\n added = [[False for _ in range(m)] for _ in range(n)]\n q = [(0, 0)]\n added[0][0] = True\n ans = [0 for _ in range(nq)]\n value = 0\n qv = {}\n for v, i in qi:\n if v in qv:\n ans[i] = qv[v]\n continue\n\n nq = []\n # inq = {w for w in q}\n while q:\n x, y = q.pop()\n if visited[x][y]:\n continue\n if grid[x][y] < v:\n value += 1\n # visited.add((x, y))\n visited[x][y] = True\n for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:\n if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny] and not added[nx][ny]:\n q.append((nx, ny))\n added[nx][ny] = True\n else:\n nq.append((x, y))\n q = list(set(nq))\n\n ans[i] = value\n qv[v] = value\n\n return ans","memory":"33800"},{"code":"from typing import List\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n # Create a list of tuples (value, x, y) for each position in the grid\n cells = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\n # Sort the cells by their values\n cells.sort()\n \n # Prepare result list for each query\n result = [0] * len(queries)\n # Pair queries with their original indices and sort them\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\n \n # Direction vectors for moving up, down, left, right\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n \n # Track visited cells\n visited = [[False] * n for _ in range(m)]\n # Priority queue for BFS\n pq = []\n # Start from the top-left corner\n heapq.heappush(pq, (grid[0][0], 0, 0))\n visited[0][0] = True\n \n # Keep track of points we can gather\n points = 0\n # Process each query\n for q, original_index in queries_with_indices:\n # Process all cells with value less than the current query\n while pq and pq[0][0] < q:\n value, x, y = heapq.heappop(pq)\n points += 1\n # Explore neighbors\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n visited[nx][ny] = True\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\n # Assign the result for this query\n result[original_index] = points\n \n return result","memory":"35000"},{"code":"from typing import List\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n cell_values = sorted([(grid[i][j], i, j) for i in range(m) for j in range(n)])\n query_values = sorted([(q, i) for i, q in enumerate(queries)])\n ans = [0] * len(queries)\n visited = [[False] * n for _ in range(m)]\n pq = [(grid[0][0], 0, 0)]\n visited[0][0] = True\n points = 0\n\n for q, q_index in query_values:\n while pq and pq[0][0] < q:\n _, i, j = heapq.heappop(pq)\n points += 1\n for di, dj in dirs:\n ni, nj = i + di, j + dj\n if 0 <= ni < m and 0 <= nj < n and not visited[ni][nj]:\n heapq.heappush(pq, (grid[ni][nj], ni, nj))\n visited[ni][nj] = True\n ans[q_index] = points\n\n return ans","memory":"35700"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n R, C = len(grid), len(grid[0])\n dxns=[(1,0),(-1,0),(0,1),(0,-1)]\n heap = [(grid[0][0], 0, 0)]\n vis = [[False] * C for _ in range(R)]\n cur = -1\n arr = []\n\n def valid(r, c):\n return 0 <= r < R and 0 <= c < C and not vis[r][c]\n sz = 0\n\n while heap:\n val, r, c = heapq.heappop(heap)\n if vis[r][c]: continue\n vis[r][c] = True\n if val > cur:\n arr.append((cur, sz))\n cur = val\n sz += 1\n for dr, dc in dxns:\n if valid(r + dr, c + dc):\n heapq.heappush(heap, (grid[r + dr][c + dc], r + dr, c + dc))\n arr.append((cur, sz))\n ans = []\n for q in queries:\n i = bisect_left(arr, (q, -1)) - 1\n ans.append(arr[i][1])\n return ans","memory":"35800"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n # Directions: up, down, left, right\n dirs = [(-1,0),(1,0),(0,-1),(0,1)]\n \n # Flatten and sort the cells\n cells = []\n for i in range(m):\n for j in range(n):\n cells.append((grid[i][j], i, j))\n cells.sort()\n \n # Sort queries with their indices\n sorted_queries = sorted([(q, idx) for idx, q in enumerate(queries)])\n \n # Initialize Union-Find\n parent = [i for i in range(m*n)]\n size = [1]*(m*n)\n \n def find(u):\n while parent[u] != u:\n parent[u] = parent[parent[u]]\n u = parent[u]\n return u\n \n def union(u, v):\n pu, pv = find(u), find(v)\n if pu == pv:\n return\n if size[pu] < size[pv]:\n parent[pu] = pv\n size[pv] += size[pu]\n else:\n parent[pv] = pu\n size[pu] += size[pv]\n \n # Activate grid cells\n active = [[False]*n for _ in range(m)]\n \n answer = [0]*len(queries)\n cell_ptr = 0\n total_cells = len(cells)\n \n for q, idx in sorted_queries:\n # Activate all cells with value < q\n while cell_ptr < total_cells and cells[cell_ptr][0] < q:\n val, x, y = cells[cell_ptr]\n active[x][y] = True\n current = x*n + y\n # Union with active neighbors\n for dx, dy in dirs:\n nx, ny = x + dx, y + dy\n if 0<=nx<m and 0<=ny<n and active[nx][ny]:\n neighbor = nx*n + ny\n union(current, neighbor)\n cell_ptr +=1\n # Check if (0,0) is active\n if active[0][0]:\n root = find(0)\n answer[idx] = size[root]\n else:\n answer[idx] =0\n return answer","memory":"37300"},{"code":"import heapq\nfrom typing import List\n\nclass UnionFind:\n def __init__(self, n):\n self.parent = list(range(n))\n self.size = [1] * n\n\n def find(self, x):\n if self.parent[x] != x:\n self.parent[x] = self.find(self.parent[x])\n return self.parent[x]\n\n def union(self, x, y):\n px, py = self.find(x), self.find(y)\n if px == py:\n return\n if self.size[px] < self.size[py]:\n px, py = py, px\n self.parent[py] = px\n self.size[px] += self.size[py]\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Flatten the grid and sort it\n cells = [(val, i, j) for i, row in enumerate(grid) for j, val in enumerate(row)]\n cells.sort()\n \n # Sort queries with their indices\n queries_with_index = sorted((q, i) for i, q in enumerate(queries))\n \n uf = UnionFind(m * n)\n answer = [0] * len(queries)\n cell_index = 0\n \n for query, query_index in queries_with_index:\n while cell_index < len(cells) and cells[cell_index][0] < query:\n _, i, j = cells[cell_index]\n for di, dj in directions:\n ni, nj = i + di, j + dj\n if 0 <= ni < m and 0 <= nj < n and grid[ni][nj] < query:\n uf.union(i * n + j, ni * n + nj)\n cell_index += 1\n \n if grid[0][0] < query:\n answer[query_index] = uf.size[uf.find(0)]\n \n return answer","memory":"37400"},{"code":"from heapq import heappush as hpush, heappop as hpop\ndelta = [(0,1), (0,-1), (1,0), (-1,0)]\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n n,m = len(grid), len(grid[0])\n mx = max(queries)\n count = [0] * (mx+1)\n curr = grid[0][0] + 1\n\n h = [(grid[0][0],0,0)]\n grid[0][0] = '#'\n while curr <= mx and h:\n if curr <= h[0][0]:\n curr += 1\n if curr <= mx:\n count[curr] = count[curr-1]\n continue \n u,ux,uy = hpop(h)\n count[curr] += 1\n for dx,dy in delta:\n vx,vy = ux+dx,uy+dy\n if -1 < vx < n and -1 < vy < m and grid[vx][vy] != '#':\n hpush(h,(grid[vx][vy],vx,vy))\n grid[vx][vy] = '#'\n\n while curr < mx:\n count[curr + 1] = count[curr]\n curr += 1\n # print(count)\n return [count[k] for k in queries ]\n \n\n \n\n\n\n\n\n\n","memory":"39900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n mn = m * n\n\n # 并查集模板\n fa = list(range(mn))\n size = [1] * mn\n def find(x: int) -> int:\n if fa[x] != x:\n fa[x] = find(fa[x])\n return fa[x]\n def merge(from_: int, to: int) -> None:\n from_ = find(from_)\n to = find(to)\n if from_ != to:\n fa[from_] = to\n size[to] += size[from_]\n\n # 矩阵元素从小到大排序，方便离线\n a = sorted((x, i, j) for i, row in enumerate(grid) for j, x in enumerate(row))\n\n ans, j = [0] * len(queries), 0\n # 查询的下标按照查询值从小到大排序，方便离线\n for i, q in sorted(enumerate(queries), key=lambda p: p[1]):\n while j < mn and a[j][0] < q:\n _, x, y = a[j]\n # 枚举周围四个格子，值小于 q 才可以合并\n for x2, y2 in (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1):\n if 0 <= x2 < m and 0 <= y2 < n and grid[x2][y2] < q:\n merge(x * n + y, x2 * n + y2) # 把坐标压缩成一维的编号\n j += 1\n if grid[0][0] < q:\n ans[i] = size[find(0)] # 左上角的连通块的大小\n return ans","memory":"40500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n\n root = [elem for elem in range(m*n)]\n size = [1] * (m * n)\n\n def find(x):\n if root[x] == x:\n return x\n root[x] = find(root[x])\n return root[x]\n\n def union(x, y):\n root_x = find(x)\n root_y = find(y)\n\n if size[root_x] < size[root_y]:\n root_x, root_y = root_y, root_x\n\n if root_x != root_y:\n root[root_y] = root_x\n size[root_x] += size[root_y]\n\n # if rank[root_x] > rank[root_y]:\n # root[root_y] = root_x\n # size[root_x] += size[root_y] \n # elif rank[root_x] < rank[root_y]:\n # root[root_x] = root_y\n # size[root_y] += size[root_x]\n # else:\n # root[root_y] = root_x\n # rank[root_x] += 1\n # size[root_x] += size[root_y]\n\n def is_connected(x, y):\n return find(x) == find(y)\n \n def get_size(x):\n return size[find(x)]\n\n flatten_grid = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\n flatten_grid.sort()\n \n sorted_queries = [(query, index) for index, query in enumerate(queries)]\n sorted_queries.sort()\n\n answers = [0] * len(queries)\n directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n\n curr_index = 0\n for query, query_index in sorted_queries:\n while curr_index < (m*n) and flatten_grid[curr_index][0] < query:\n _, x, y = flatten_grid[curr_index]\n for dx, dy in directions:\n new_x = x + dx\n new_y = y + dy\n\n if not (0 <= new_x < m) or not (0 <= new_y < n):\n continue\n \n if grid[new_x][new_y] < query:\n union(x * n + y, new_x * n + new_y)\n curr_index += 1\n\n if grid[0][0] < query:\n answers[query_index] = get_size(find(0))\n\n return answers","memory":"40700"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # # OPTIMIZED: sort values in increasing order\n # # maps num -> index in queries before sort\n # original_indices = {}\n # total_num_queries = len(queries)\n # for i in range(total_num_queries):\n # if queries[i] not in original_indices:\n # original_indices[queries[i]] = []\n # original_indices[queries[i]].append(i)\n # queries.sort()\n # answer = [0] * total_num_queries\n # n, m = len(grid), len(grid[0])\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # # function checking if i, j is a valid coordinate in grid\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n # first_i, first_coord = 0, (0, 0)\n # queue, adjacent_coords, queued = [first_coord], [], set()\n # queued.add(first_coord)\n # count, num_queries = 0, 0\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n # first_i += 1\n # for query_i in range(first_i, total_num_queries):\n # # while queue is not empty\n # while queue:\n # # pop and add to count\n # coord = queue.pop(0)\n # count += 1\n # # for each dir in directions:\n # for dir in directions:\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # # if is a valid coordinate and not queued yet:\n # if is_valid_coord(next_coord) and next_coord not in queued:\n # # if it is less than current num:\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # # append to queue\n # queue.append(next_coord)\n # # add to queued\n # queued.add(next_coord)\n # else:\n # adjacent_coords.append(next_coord)\n # queued.add(next_coord)\n # for answer_i in original_indices[queries[query_i]]:\n # answer[answer_i] = count\n # num_queries += 1\n # if query_i + 1 < total_num_queries:\n # next_adjacent_coords = []\n # for coord in adjacent_coords:\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n # queue.append(coord)\n # else:\n # next_adjacent_coords.append(coord)\n # adjacent_coords = next_adjacent_coords\n # if num_queries == total_num_queries:\n # break\n # return answer\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries:\n # for query_i in range(first_i, total_num_queries):\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop()\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if num_queries == total_num_queries:\n break\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n query_i += 1\n return answer\n ","memory":"40900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries: \n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n if num_queries == total_num_queries:\n break\n query_i += 1\n return answer","memory":"40900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # # OPTIMIZED: sort values in increasing order\n # # maps num -> index in queries before sort\n # original_indices = {}\n # total_num_queries = len(queries)\n # for i in range(total_num_queries):\n # if queries[i] not in original_indices:\n # original_indices[queries[i]] = []\n # original_indices[queries[i]].append(i)\n # queries.sort()\n # answer = [0] * total_num_queries\n # n, m = len(grid), len(grid[0])\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # # function checking if i, j is a valid coordinate in grid\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n # first_i, first_coord = 0, (0, 0)\n # queue, adjacent_coords, queued = [first_coord], [], set()\n # queued.add(first_coord)\n # count, num_queries = 0, 0\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n # first_i += 1\n # for query_i in range(first_i, total_num_queries):\n # # while queue is not empty\n # while queue:\n # # pop and add to count\n # coord = queue.pop(0)\n # count += 1\n # # for each dir in directions:\n # for dir in directions:\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # # if is a valid coordinate and not queued yet:\n # if is_valid_coord(next_coord) and next_coord not in queued:\n # # if it is less than current num:\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # # append to queue\n # queue.append(next_coord)\n # # add to queued\n # queued.add(next_coord)\n # else:\n # adjacent_coords.append(next_coord)\n # queued.add(next_coord)\n # for answer_i in original_indices[queries[query_i]]:\n # answer[answer_i] = count\n # num_queries += 1\n # if query_i + 1 < total_num_queries:\n # next_adjacent_coords = []\n # for coord in adjacent_coords:\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n # queue.append(coord)\n # else:\n # next_adjacent_coords.append(coord)\n # adjacent_coords = next_adjacent_coords\n # if num_queries == total_num_queries:\n # break\n # return answer\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n query_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\n query_i += 1\n while query_i < total_num_queries:\n # for query_i in range(first_i, total_num_queries):\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if num_queries == total_num_queries:\n break\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n query_i += 1\n return answer\n ","memory":"41000"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # function checking if i, j is a valid coordinate in grid\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n first_i, first_coord = 0, (0, 0)\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n count, num_queries = 0, 0\n while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n first_i += 1\n for query_i in range(first_i, total_num_queries):\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n if num_queries == total_num_queries:\n break\n return answer\n ","memory":"41200"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # original_indices = {queries[i]: i for i in range(len(queries))}\n # queries.sort()\n # answer = [0] * len(queries)\n # query_i, count, n, m, num_visited, starting_x, starting_y = 0, 0, len(grid), len(grid[0]), 0, 0, 0\n # queue, visited, directions = [], set(), [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # starting_set = False\n # is_valid_coord = lambda i, j: 0 <= i < n and 0 <= j < m and (i, j) not in visited\n # # in visited, store: i * len(grid[0]) + j. or just (i, j)\n # while query_i < len(queries):\n # query_num = queries[query_i]\n # print(\"query_num: \", query_num)\n # queue.append((starting_x, starting_y))\n # starting_set = False\n # while queue and num_visited < n*m:\n # x, y = queue.pop(0)\n # if (x, y) not in visited and grid[x][y] < query_num:\n # visited.add((x, y))\n # count += 1\n # num_visited += 1\n # for dx, dy in directions:\n # next_x, next_y = x + dx, y + dy\n # if is_valid_coord(next_x, next_y):\n # queue.append((x, y))\n # elif not grid[x][y] < query_num and not starting_set:\n # starting_x, starting_y = x, y\n # starting_set = True\n # answer[original_indices[query_num]] = count\n # query_i += 1\n # return answer\n # answer[i]: num blocks for queries[i]\n\n # BRUTE FORCE\n # answer = []\n # n, m = len(grid), len(grid[0])\n # is_valid_coord = lambda i, j: 0 <= i < n and 0 <= j < m\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # for num in queries:\n # queue, processed, count = [], set(), 0\n # if grid[0][0] < num:\n # queue.append((0, 0))\n # processed.add((0, 0))\n # while queue:\n # x, y = queue.pop(0)\n # count += 1\n # for dx, dy in directions:\n # new_x, new_y = x + dx, y + dy\n # if is_valid_coord(new_x, new_y) and grid[new_x][new_y] < num and (new_x, new_y) not in processed:\n # processed.add((new_x, new_y))\n # queue.append((new_x, new_y))\n # answer.append(count)\n # return answer\n\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n # COULD QUERIES HAVE MULTIPLE OF THE SAME NUMBER? assume not for now... adjust later\n # original_indices = {queries[i]: i for i in range(len(queries))}\n # queries.sort()\n # answer = [0] * len(queries)\n # n, m = len(grid), len(grid[0])\n # # function checking if i, j is a valid coordinate in grid\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n # first_i, first_coord = 0, (0, 0)\n # # queue (i, j) only if grid[i][j] < current num. add (i, j) to processed too.\n # # queue in new_queue only if grid[i][j] < next num. add (i, j) to processed too.\n # queue, adjacent_coords, queued = [first_coord], [], set()\n # queued.add(first_coord)\n # # print(\"processed: \", processed)\n # # for row in grid:\n # # print(row)\n # # print(\"\\n\\n\")\n # count = 1\n # counted = [[0] * m for _ in range(n)]\n # while first_i < len(queries) and grid[0][0] >= queries[first_i]:\n # first_i += 1\n # for query_i in range(first_i, len(queries)):\n # # while queue is not empty\n # while queue:\n # # pop and add to count\n # coord = queue.pop(0)\n # # if it is less than this query number:\n # # if grid[coord[0]][coord[1]] < queries[query_i]:\n # # count += 1\n # # else:\n # # adjacent_coords.append(coord)\n # # if coord not in queued:\n # count += 1\n # counted[coord[0]][coord[1]] = 1\n # # for each dir in directions:\n # for dir in directions:\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # # if is a valid coordinate and not processed yet:\n # if is_valid_coord(next_coord) and next_coord not in queued:\n # # if it is less than current num:\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # # append to queue\n # queue.append(next_coord)\n # # add to processed\n # queued.add(next_coord)\n \n # # # if it is less than next num:\n # elif query_i + 1 < len(queries) and grid[next_coord[0]][next_coord[1]] < queries[query_i + 1]:\n # # append to adjacent_coords\n # adjacent_coords.append(next_coord)\n # # add to processed\n # queued.add(next_coord)\n\n # # otherwise, add it to adjacent_coords:\n # # else:\n\n # # print(\"queue after processing coordinates \", coord, \" is: \", queue)\n # # print(\"next queue after processing coordinates \", coord, \" is: \", adjacent_coords)\n # # -- post-processing --\n # print(\"processed number: \", queries[query_i])\n # print(\"queue after processing full number: \", queue)\n # print(\"adjacent_coords after processing full number: \", adjacent_coords)\n # print(\"count after processing full number: \", count)\n # print(\"processed after processing full number: \", queued)\n # # add count to answer in the correct index: answer[original_indicies[queries[query_i]]] = count\n # count -= 1\n # answer[original_indices[queries[query_i]]] = count\n # # set queue = adjacent_coords and adjacent_coords = queue\n # queue, adjacent_coords = adjacent_coords, queue\n # queue.append((0, 0))\n # # print(\"\\n\\n\")\n # # print(\"counted for num: \", queries[query_i])\n # # for row in counted:\n # # print(row)\n # # print(\"\\n\\n\")\n # # raw_counted = [[0] * m for _ in range(n)]\n # # for i in range(n):\n # # for j in range(m):\n # # if grid[i][j] < queries[query_i]:\n # # raw_counted[i][j] = 1\n # # print(\"RAW counted for num: \", queries[query_i])\n # # for row in raw_counted:\n # # print(row)\n # # print(\"\\n\\n\")\n # return answer\n # OPTIMIZED: sort values in increasing order\n # maps num -> index in queries before sort\n # COULD QUERIES HAVE MULTIPLE OF THE SAME NUMBER? assume not for now... adjust later\n original_indices = {}\n total_num_queries = len(queries)\n for i in range(total_num_queries):\n if queries[i] not in original_indices:\n original_indices[queries[i]] = []\n original_indices[queries[i]].append(i)\n queries.sort()\n answer = [0] * total_num_queries\n n, m = len(grid), len(grid[0])\n # function checking if i, j is a valid coordinate in grid\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\n first_i, first_coord = 0, (0, 0)\n # queue (i, j) only if grid[i][j] < current num. add (i, j) to queued too.\n # queue in new_queue only if grid[i][j] < next num. add (i, j) to queued too.\n queue, adjacent_coords, queued = [first_coord], [], set()\n queued.add(first_coord)\n # print(\"queued: \", queued)\n count, num_queries = 0, 0\n while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\n first_i += 1\n for query_i in range(first_i, total_num_queries):\n # if query_i - 1 > 0 and queries[query_i - 1] == queries[query_i]:\n # continue\n # while queue is not empty\n while queue:\n # pop and add to count\n coord = queue.pop(0)\n count += 1\n # for each dir in directions:\n for dir in directions:\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\n # if is a valid coordinate and not queued yet:\n if is_valid_coord(next_coord) and next_coord not in queued:\n # if it is less than current num:\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\n # append to queue\n queue.append(next_coord)\n # add to queued\n queued.add(next_coord)\n # if it is less than next num:\n # elif query_i + 1 < total_num_queries and grid[next_coord[0]][next_coord[1]] < queries[query_i + 1]:\n # # append to adjacent_coords\n # adjacent_coords.append(next_coord)\n # # add to queued\n # queued.add(next_coord)\n else:\n adjacent_coords.append(next_coord)\n queued.add(next_coord)\n # print(\"queue after processing coordinates \", coord, \" is: \", queue)\n # print(\"next queue after processing coordinates \", coord, \" is: \", adjacent_coords)\n # -- post-processing --\n # print(\"processed number: \", queries[query_i])\n # print(\"queue after processing full number: \", queue)\n # print(\"adjacent_coords after processing full number: \", adjacent_coords)\n # add count to answer in the correct index: answer[original_indicies[queries[query_i]]] = count\n for answer_i in original_indices[queries[query_i]]:\n answer[answer_i] = count\n num_queries += 1\n # query_i += 1\n # query_i -= 1\n # answer[original_indices[queries[query_i]]] = count\n # set queue = adjacent_coords and adjacent_coords = queue\n if query_i + 1 < total_num_queries:\n next_adjacent_coords = []\n for coord in adjacent_coords:\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\n queue.append(coord)\n # queued.add(coord)\n else:\n next_adjacent_coords.append(coord)\n adjacent_coords = next_adjacent_coords\n if num_queries == total_num_queries:\n break\n # queue, adjacent_coords = adjacent_coords, queue\n # print(\"new queue, adjacent_coords: \", queue, adjacent_coords)\n # print(\"NEW QUEUED: \", queued)\n # print(\"\\n\\n\")\n return answer\n ","memory":"41300"},{"code":"from typing import List, Tuple\nfrom heapq import heappush, heappop\n\ndef maxPoints(grid: List[List[int]], queries: List[int]) -> List[int]:\n def sort_queries_with_indices(queries: List[int]) -> List[Tuple[int, int]]:\n return sorted(enumerate(queries), key=lambda x: x[1])\n \n def initialize_bfs(grid: List[List[int]]) -> Tuple[List[Tuple[int, int, int]], set]:\n m, n = len(grid), len(grid[0])\n min_heap = []\n visited = set()\n \n # Start from the top-left cell (0, 0)\n heappush(min_heap, (grid[0][0], 0, 0))\n visited.add((0, 0))\n \n return min_heap, visited\n \n m, n = len(grid), len(grid[0])\n sorted_queries = sort_queries_with_indices(queries)\n min_heap, visited = initialize_bfs(grid)\n answer = [0] * len(queries)\n points = 0\n \n # Directions for moving in the grid (up, down, left, right)\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n \n for original_index, query in sorted_queries:\n while min_heap and min_heap[0][0] < query:\n value, x, y = heappop(min_heap)\n points += 1\n \n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heappush(min_heap, (grid[nx][ny], nx, ny))\n visited.add((nx, ny))\n \n answer[original_index] = points\n \n return answer\n\n# Example usage:\ngrid = [[1, 2, 3], [2, 5, 7], [3, 5, 1]]\nqueries = [5, 6, 2]\nprint(maxPoints(grid, queries)) # Output: [5, 8, 1]\n\n\n\nclass Solution:\n def maxPoints(self, *args, **kwargs):\n return maxPoints(*args, **kwargs)\n\n","memory":"41500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n ques = list(set(queries))\n ques.sort()\n values = defaultdict(int)\n n, m, k = len(grid), len(grid[0]), len(ques)\n def is_valid(r, c):\n return 0 <= r < n and 0 <= c < m and grid[r][c] != -1 and (r, c) not in visited\n dires = [(1,0), (0,1),(-1, 0), (0, -1)]\n ind = 0\n heap = [(grid[0][0], 0 ,0)]\n visited= set()\n while heap:\n \n while ind < k and ques[ind] <= heap[0][0]:\n # print('here')\n ind += 1\n if ind >= k:\n break\n # print(ind, heap)\n val, r, c = heappop(heap)\n values[ques[ind]] += 1\n grid[r][c] = -1\n visited.add((r, c))\n for dr, dc in dires:\n nr, nc = r + dr, c + dc\n if is_valid(nr, nc):\n heappush(heap, (grid[nr][nc], nr, nc))\n visited.add((nr, nc))\n\n for i in range(1,k):\n values[ques[i]] += values[ques[i-1]]\n \n result = []\n for q in queries:\n result.append(values[q])\n return result \n\n print(values) \n","memory":"41600"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n ques = list(set(queries))\n ques.sort()\n values = defaultdict(int)\n n, m, k = len(grid), len(grid[0]), len(ques)\n def is_valid(r, c):\n return 0 <= r < n and 0 <= c < m and grid[r][c] != -1 and (r, c) not in visited\n dires = [(1,0), (0,1),(-1, 0), (0, -1)]\n ind = 0\n heap = [(grid[0][0], 0 ,0)]\n visited= set()\n while heap:\n \n while ind < k and ques[ind] <= heap[0][0]:\n # print('here')\n ind += 1\n if ind >= k:\n break\n # print(ind, heap)\n val, r, c = heappop(heap)\n values[ques[ind]] += 1\n grid[r][c] = -1\n visited.add((r, c))\n for dr, dc in dires:\n nr, nc = r + dr, c + dc\n if is_valid(nr, nc):\n heappush(heap, (grid[nr][nc], nr, nc))\n visited.add((nr, nc))\n\n for i in range(1,k):\n values[ques[i]] += values[ques[i-1]]\n \n result = []\n for q in queries:\n result.append(values[q])\n return result \n\n print(values) \n","memory":"41700"},{"code":"import heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n \n # Sort queries with their original indices\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\n \n # Initialize the result array\n answer = [0] * len(queries)\n \n # Priority queue to store cells to visit\n pq = [(grid[0][0], 0, 0)]\n \n # Set to store visited cells\n visited = set()\n visited.add((0, 0))\n \n # Current points\n points = 0\n \n # Process each query in sorted order\n for q, original_index in sorted_queries:\n # Explore cells until the priority queue is empty or the top cell value is greater than the query\n while pq and pq[0][0] < q:\n val, x, y = heapq.heappop(pq)\n points += 1\n \n # Explore adjacent cells\n for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\n visited.add((nx, ny))\n \n # Update the answer for the current query\n answer[original_index] = points\n \n return answer\n\n# Example usage:\nsolution = Solution()\ngrid = [[1,2,3],[2,5,7],[3,5,1]]\nqueries = [5,6,2]\nprint(solution.maxPoints(grid, queries)) # Output: [5, 8, 1]","memory":"42400"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sol = [0] * len(queries)\n count = 0\n r,c = len(grid), len(grid[0])\n heap = []\n heapq.heappush(heap, (grid[0][0], 0, 0))\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\n visited = {(0,0)}\n\n for q, index in sorted(indexed_queries):\n while heap and (heap[0][0] < q):\n curr, i, j = heapq.heappop(heap)\n count += 1\n \n\n for ni, nj in (i, j+1), (i, j-1), (i+1, j), (i-1, j):\n if (0<= ni < r) and (0 <=nj < c) and ((ni,nj) not in visited):\n heapq.heappush(heap, (grid[ni][nj], ni, nj))\n visited.add((ni, nj))\n \n \n sol[index] = count\n\n return sol\n\n\n\n","memory":"42500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sol = [0] * len(queries)\n count = 0\n r,c = len(grid), len(grid[0])\n heap = []\n heapq.heappush(heap, (grid[0][0], 0, 0))\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\n visited = {(0,0)}\n\n for q, index in sorted(indexed_queries):\n while heap and (heap[0][0] < q):\n curr, i, j = heapq.heappop(heap)\n count += 1\n \n\n for ni, nj in (i, j+1), (i, j-1), (i+1, j), (i-1, j):\n if (0<= ni < r) and (0 <=nj < c) and ((ni,nj) not in visited):\n heapq.heappush(heap, (grid[ni][nj], ni, nj))\n visited.add((ni, nj))\n \n \n sol[index] = count\n\n return sol\n\n # TC = O( n log n + q log q)\n # SC = O(n)\n\n","memory":"42500"},{"code":"import heapq\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Sort queries with their original indices\n sorted_queries = sorted(enumerate(queries), key=lambda x: x[1])\n \n answer = [0] * len(queries)\n heap = [(grid[0][0], 0, 0)] # (value, row, col)\n visited = set([(0, 0)])\n total_visited = 0\n \n for idx, query in sorted_queries:\n while heap and heap[0][0] < query:\n _, r, c = heapq.heappop(heap)\n total_visited += 1\n \n for dr, dc in directions:\n nr, nc = r + dr, c + dc\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\n visited.add((nr, nc))\n heapq.heappush(heap, (grid[nr][nc], nr, nc))\n \n answer[idx] = total_visited\n \n return answer","memory":"42600"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n ret = [0 for _ in range(len(queries))]\n prev = 0\n for q in sorted(list(set(queries))):\n pos = bisect.bisect_left(order, q,lo=prev)\n for idx in mapping[q]:\n ret[idx]=pos\n prev = pos\n return ret\n\n","memory":"42700"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n\n mapping = dict()\n for idx,num in enumerate(queries):\n if num not in mapping:\n mapping[num] = [idx]\n else:\n mapping[num].append(idx)\n ret = [0 for _ in range(len(queries))]\n prev = 0\n for q in sorted(list(set(queries))):\n pos = bisect.bisect_left(order, q,lo=prev)\n for idx in mapping[q]:\n ret[idx]=pos\n prev = pos\n return ret\n\n","memory":"42700"},{"code":"from dataclasses import dataclass\n\n\n@dataclass(frozen=True)\nclass IndexedQuery:\n queryIndex: int\n query: int\n\n def __iter__(self):\n yield self.queryIndex\n yield self.query\n\n\nclass Solution:\n def maxPoints(self, grid: list[list[int]], queries: list[int]) -> list[int]:\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n ans = [0] * len(queries)\n minHeap = [(grid[0][0], 0, 0)] # (grid[i][j], i, j)\n seen = {(0, 0)}\n accumulate = 0\n\n for queryIndex, query in sorted([IndexedQuery(i, query)\n for i, query in enumerate(queries)],\n key=lambda x: x.query):\n while minHeap:\n val, i, j = heapq.heappop(minHeap)\n if val >= query:\n # The smallest neighbor is still larger than `query`, so no need to\n # keep exploring. Re-push (i, j, grid[i][j]) back to the `minHeap`.\n heapq.heappush(minHeap, (val, i, j))\n break\n accumulate += 1\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n heapq.heappush(minHeap, (grid[x][y], x, y))\n seen.add((x, y))\n ans[queryIndex] = accumulate\n\n return ans","memory":"42800"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n # Priority queue to explore cells in increasing order of their values\n pq = []\n heappush(pq, (grid[0][0], 0, 0))\n \n # Visited set to keep track of visited cells\n visited = set()\n visited.add((0, 0))\n \n # Precompute the maximum points for each query\n max_points = [0] * len(queries)\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\n \n # Current number of points\n points = 0\n \n # Process each query in sorted order\n for query, idx in sorted_queries:\n # Explore the grid while the top of the heap is less than the current query\n while pq and pq[0][0] < query:\n value, x, y = heappop(pq)\n points += 1 # We can collect a point for this cell\n \n # Explore neighbors\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n visited.add((nx, ny))\n heappush(pq, (grid[nx][ny], nx, ny))\n \n # Store the result for this query\n max_points[idx] = points\n \n return max_points","memory":"42900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # sort the queries, to make the from smaller value to bigger value\n # this way we can eliminate some of the recomputation\n # because if smaller value pass, that means the bigger values will pass\n\n # we can keep the same set of visited coordinates? \n # and increase the count for the subsequence queries\n\n # let's say for ex1, we sort the 5 6 2 to 2 5 6\n # we run the 2 first\n # we mark the first cell to be cleared, so count is 1\n # and for 5, we start with count = 1\n # then do bfs , get 5 cells\n # and for 6, we start with count of 5, and spread out\n\n # for the bfs, if the value is >= than the value, we add it back to the queue? \n # because there might be other cells behind it that < than the current value\n\n # how do we mark them as already check?\n # we can add them to a heap, with value, r, c\n # that should help with dealing with the value, or bigger cell\n # so we can start other queries\n\n result = [0 for _ in range(len(queries))]\n\n check = [(i, val) for i, val in enumerate(queries)]\n check.sort(key = lambda x: x[1])\n\n # check = [index, val that we will check]\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n heap = [] # heap = (value, r, c)\n heapq.heappush(heap, (grid[0][0], 0, 0))\n heapq.heappush(heap, (10 ** 6 + 1, -1, -1))\n visited.add((0, 0))\n\n # we start checking from the first value in the check array\n checkIndex = 0\n curCount = 0\n\n \n while heap:\n val, r, c = heapq.heappop(heap)\n # check if the current val is already out of range for our query val\n # move till we find a new value that within range\n while checkIndex < len(check) and val >= check[checkIndex][1]:\n \n result[check[checkIndex][0]] = curCount\n checkIndex += 1\n \n # see if we reach the end of queries but there are still coordinates, we should still break\n if checkIndex == len(check):\n break\n \n # now we have a new query val that within range\n # increase count, and add the neighbors to the heap\n curCount += 1\n\n # go through the neighbors, check if within range and not visited\n # add to the heap\n for dr, dc in [[1, 0], [0, 1], [-1, 0], [0, -1]]:\n if 0 <= r + dr < rows and 0 <= c + dc < cols and (r + dr, c + dc) not in visited:\n heapq.heappush(heap, (grid[r+dr][c+dc], r + dr, c + dc))\n visited.add((r + dr, c + dc))\n\n # print(curCount, checkIndex)\n\n # # we still have 1 last case, where if we reach the end with the extremely big value, that covers every value\n # if checkIndex < len(check) and curCount and result[check[checkIndex][0]] == 0:\n # result[check[checkIndex][0]] = curCount\n\n\n return result\n","memory":"42900"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n dirs = [(0,1),(1,0),(-1,0),(0,-1)]\n nrows = len(grid)\n ncols = len(grid[0])\n \n q_and_i = [[queries[i], i] for i in range(len(queries))]\n q_and_i.sort()\n \n answer = [0 for _ in range(len(queries))]\n heap = [[grid[0][0], 0, 0]]\n seen = {(0,0)}\n n_visited = 0\n \n for q, i in q_and_i:\n while heap and heap[0][0] < q:\n n_visited += 1\n _, r, c = heapq.heappop(heap)\n for h, v in dirs:\n r2, c2 = r + v, c + h\n if r2 >= 0 and r2 < nrows and c2 >= 0 and c2 < ncols:\n if (r2, c2) not in seen:\n seen.add((r2, c2))\n heapq.heappush(heap, [grid[r2][c2], r2, c2])\n answer[i] = n_visited\n return answer","memory":"43100"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n # Dont Forget this Technique of making the sorted kind of arr\n # and then answering the queries ( VERY Nice Approach )\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0,0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x,y))\n heapq.heappush(heap, (grid[x][y], x, y))\n\n # This is the main part of the code logic in this approach\n # Here even the samller elements which are not unlocked\n # will unlock but not add at the prev stage rather maximizing \n # When it needs to be unlocked and counted\n\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n # Excellent IDEA\n\n res = []\n for q in queries:\n res.append(bisect.bisect_left(order, q))\n return res\n\n \"\"\" # Another Approach From Coding Mohan \"\"\"\n\n q = len(queries)\n rows = len(grid)\n cols = len(grid[0])\n \n # Store queries and their original index\n queries_and_ind = [(queries[j], j) for j in range(q)]\n queries_and_ind.sort()\n \n result = [0] * q\n visited = [[False] * cols for _ in range(rows)]\n total_visited = 0\n \n # Use a SortedList to mimic the sorted set behavior in C++\n nodes = SortedList([(grid[0][0], 0, 0)])\n visited[0][0] = True\n \n for mx_val, ind in queries_and_ind:\n # While we have nodes and their value is less than the current query value\n while nodes and nodes[0][0] < mx_val:\n val, row, col = nodes.pop(0)\n total_visited += 1\n \n # Define the neighbors for traversal\n neighbors = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n for dr, dc in neighbors:\n r, c = row + dr, col + dc\n \n if 0 <= r < rows and 0 <= c < cols and not visited[r][c]:\n visited[r][c] = True\n nodes.add((grid[r][c], r, c))\n \n # Store the total number of visited cells for this query\n result[ind] = total_visited\n \n return result","memory":"43300"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\n results = [0] * len(queries)\n queries = sorted([(q, i) for i, q in enumerate(queries)])\n visited = set()\n heap = [(grid[0][0], 0, 0)]\n \n for q, original_index in queries:\n while heap and heap[0][0] < q:\n value, x, y = heappop(heap)\n if (x, y) not in visited:\n visited.add((x, y))\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\n heappush(heap, (grid[nx][ny], nx, ny))\n results[original_index] = len(visited)\n \n return results\n ","memory":"43400"},{"code":"\nimport heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sq = sorted(queries)\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n\n numRows = len(grid)\n numCols = len(grid[0])\n\n priorityQ = [(grid[0][0], 0, 0)]\n seenCord = set()\n seenCord.add((0,0))\n count = 0\n qScore = {}\n for q in sq:\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\n count += 1\n currVal, currRow, currCol = heapq.heappop(priorityQ)\n \n for d in directions:\n\n newRow = currRow + d[0]\n newCol = currCol + d[1]\n\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\n\n if (newRow, newCol) not in seenCord:\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\n seenCord.add((newRow, newCol))\n\n qScore[q] = count\n \n return [qScore[q] for q in queries]\n\n\n","memory":"43500"},{"code":"\nimport heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sq = sorted(queries)\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n\n numRows = len(grid)\n numCols = len(grid[0])\n\n priorityQ = [(grid[0][0], 0, 0)]\n seenCord = set()\n seenCord.add((0,0))\n count = 0\n qScore = {}\n for q in sq:\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\n count += 1\n currVal, currRow, currCol = heapq.heappop(priorityQ)\n \n for d in directions:\n\n newRow = currRow + d[0]\n newCol = currCol + d[1]\n\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\n\n if (newRow, newCol) not in seenCord:\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\n seenCord.add((newRow, newCol))\n\n qScore[q] = count\n \n return [qScore[q] for q in queries]\n\n\n","memory":"43500"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n # h,w = len(grid), len(grid[0])\n # mapping = dict()\n # for idx,num in enumerate(queries):\n # if num not in mapping:\n # mapping[num] = [idx]\n # else:\n # mapping[num].append(idx)\n # ret = [0 for _ in range(len(queries))]\n # sorted_query = sorted(list(set(queries)))\n # deq = collections.deque([(0,0)])\n # seen = [[0 for _ in range(w)] for _ in range(h)]\n # seen[0][0] = 1\n # p1 = 0\n # deqnext = collections.deque()\n # counter = 0\n # while deq or deqnext:\n # smallest = math.inf\n # while deq:\n # x,y = deq.popleft()\n # num = grid[x][y]\n # if num >= sorted_query[p1]:\n # deqnext.append((x,y))\n # smallest = min(smallest,num)\n # else:\n # counter+=1\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\n # seen[dx+x][dy+y] = 1 \n # deq.append((dx+x,dy+y))\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\n # for idx in mapping[sorted_query[p1]]:\n # ret[idx]+=counter \n # p1+=1\n # deq.extend(deqnext)\n # deqnext = collections.deque()\n # if p1 >= len(sorted_query):\n # break\n\n # return ret\n\n\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n sorted_queries = sorted(queries)\n dic = dict()\n count = 0\n p1 = 0\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n count+=1\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heapq.heappush(heap, (grid[x][y], x, y))\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\n dic[sorted_queries[p1]] = count-1\n p1+=1\n if p1 >= len(sorted_queries):\n break\n return [dic[q] if q in dic else count for q in queries]\n\n","memory":"43600"},{"code":"class Solution:\n\tdef maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\t\t#It is a simple questions based on the concept of graph\n\t\t#As we all know we can represent a matrix/grid into a graph\n\t\t#Then we can use the heap(min Heap) to get a perfect path.\n\t\t#Then we are using maxYet(means max till that index).\n\t\tm = len(grid)\n\t\tn = len(grid[0])\n\t\theap = [(grid[0][0], 0, 0)]\n\t\tv = {(0, 0)}\n\t\torder = []\n\t\twhile len(heap) > 0:\n\t\t\tcurr, i, j = heapq.heappop(heap)\n\t\t\torder.append(curr)\n\t\t\tfor x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n\t\t\t\tif 0 <= x < m and 0 <= y < n and (x, y) not in v:\n\t\t\t\t\tv.add((x, y))\n\t\t\t\t\theapq.heappush(heap, (grid[x][y], x, y))\n\t\tmaxYet = -1\n\t\tfor i in range(len(order)):\n\t\t\tmaxYet = max(maxYet, order[i])\n\t\t\torder[i] = maxYet\n\t\tres = []\n\t\tfor q in queries:\n\t\t\tres.append(bisect.bisect_left(order, q))\n\t\treturn res","memory":"43700"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0, 0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x, y))\n heappush(heap, (grid[x][y], x, y))\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n res = []\n for q in queries:\n res.append(bisect_left(order, q))\n return res\n","memory":"43800"},{"code":"class Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n \n m = len(grid)\n n = len(grid[0])\n heap = [(grid[0][0], 0, 0)]\n v = {(0,0)}\n order = []\n while len(heap) > 0:\n curr, i, j = heapq.heappop(heap)\n order.append(curr)\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\n v.add((x,y))\n heapq.heappush(heap, (grid[x][y], x, y))\n\n # This is the main part of the code logic in this approach\n # Here even the samller elements which are not unlocked\n # will unlock but not add at the prev stage rather maximizing \n # When it needs to be unlocked and counted\n\n maxYet = -1\n for i in range(len(order)):\n maxYet = max(maxYet, order[i])\n order[i] = maxYet\n # Excellent IDEA\n\n res = []\n for q in queries:\n res.append(bisect.bisect_left(order, q))\n return res","memory":"43900"},{"code":"import heapq\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n queries = [(q, i) for i, q in enumerate(queries)]\n s_queries = sorted(queries, key = lambda x: x[0])\n ret = [0] * len(queries)\n visited = set()\n h = [(grid[0][0], 0,0)]\n offsets = [(0,1), (0, -1), (-1, 0), (1, 0)]\n m = len(grid)\n n = len(grid[0])\n count = 0\n for q, i in s_queries:\n while h and h[0][0] < q:\n _, r, c = heappop(h)\n if (r, c) in visited:\n continue\n visited.add((r,c))\n count += 1\n for o in offsets:\n newr, newc = r + o[0], c + o[1]\n if newr >= 0 and newr < m and newc >= 0 and newc < n and (newr, newc) not in visited:\n heappush(h, (grid[newr][newc], newr, newc))\n ret[i] = count\n return ret","memory":"44200"},{"code":"from collections import deque\nimport heapq\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\n \n completed = set()\n heap = [(grid[0][0], 0, 0)]\n heapq.heapify(heap)\n\n answer = [0] * len(queries)\n for ind in range(len(sorted_queries)):\n query = sorted_queries[ind][0]\n index = sorted_queries[ind][1]\n sol = 0\n\n while heap:\n val, x, y = heap[0]\n if query <= val:\n break\n\n if (x,y) in completed:\n heapq.heappop(heap)\n continue\n\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\n # continue\n\n heapq.heappop(heap)\n sol += 1\n completed.add((x,y))\n\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\n\n\n if ind-1>=0:\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\n else: answer[index]= sol\n\n return answer","memory":"44300"},{"code":"import heapq as h\n\nclass Solution:\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\n\n q = []\n\n m = len(grid)\n n = len(grid[0])\n\n best = defaultdict(int)\n\n best[(0, 0)] = grid[0][0]\n\n h.heappush(q, (grid[0][0], 0, 0))\n\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\n\n while q and len(best) < m * n:\n (val, x, y) = h.heappop(q)\n\n for [i, j] in moves:\n xi = x + i\n yj = y + j\n \n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\n nVal = max(val, grid[xi][yj])\n best[(xi, yj)] = nVal\n h.heappush(q, (nVal, xi, yj))\n \n print(best)\n\n counts = defaultdict(int)\n\n for key in best:\n counts[best[key]] += 1\n \n counts = [[x, counts[x]] for x in counts]\n\n counts.sort()\n\n for i in range(1, len(counts)):\n counts[i][1] += counts[i-1][1]\n \n ret = []\n print(counts)\n for query in queries:\n query -= 1\n l = 0\n r = len(counts) - 1\n ans = -1\n\n while l <= r:\n mid = (l + r) // 2\n\n if counts[mid][0] <= query:\n ans = mid\n l = mid + 1\n else:\n r = mid - 1\n if ans == -1:\n ret.append(0)\n else:\n ret.append(counts[ans][1])\n \n return ret","memory":"44800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n rows, cols = len(grid), len(grid[0])\\n sorted_q = [(b, a) for a, b in enumerate(queries) if grid[0][0] < b]\\n sorted_q.sort()\\n pq = []\\n heappush(pq, (grid[0][0], 0, 0))\\n grid[0][0] = -1\\n dir_arr = [0, 1, 0, -1, 0]\\n cnt = 0\\n ans = [0] * len(queries)\\n for q, index in sorted_q:\\n while pq:\\n cur_cost, cur_x, cur_y = pq[0]\\n if cur_cost >= q:\\n break\\n cnt += 1\\n heappop(pq)\\n for i in range(4):\\n new_x = cur_x + dir_arr[i]\\n new_y = cur_y + dir_arr[i + 1]\\n if (\\n 0 <= new_x < rows\\n and 0 <= new_y < cols\\n and grid[new_x][new_y] != -1\\n ):\\n heappush(pq, (max(cur_cost, grid[new_x][new_y]), new_x, new_y))\\n grid[new_x][new_y] = -1\\n\\n ans[index] = cnt\\n return ans\\n\",\n \"memory\": \"28900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n s_queries = sorted(set(queries))\\n ans = {}\\n from heapq import heappush, heappop\\n prevCount = 0\\n\\n q = [(grid[0][0], 0, 0)]\\n\\n for query in s_queries:\\n curCount = prevCount\\n while q:\\n val, r, c = q[0]\\n if val >= query:\\n break\\n \\n heappop(q)\\n grid[r][c] = None\\n curCount += 1\\n\\n for nr, nc in [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)]:\\n if 0 <=nr<m and 0<=nc<n and grid[nr][nc] is not None:\\n heappush(q, (grid[nr][nc], nr, nc))\\n grid[nr][nc] = None\\n \\n ans[query] = curCount\\n prevCount = curCount\\n \\n res = [ans[query] for query in queries]\\n\\n return res\\n \\n\\n\\n\\n\\n \",\n \"memory\": \"29500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n q = len(queries)\\n\\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\\n answers = [0] * q\\n prev_query = 0\\n points = 0\\n fringe = [(grid[0][0], 0, 0)]\\n grid[0][0] = 0\\n heapq.heapify(fringe)\\n\\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\\n\\n for i in sorted_indices:\\n query = queries[i]\\n\\n if query == prev_query:\\n answers[i] = points\\n continue\\n\\n stack = deque()\\n while fringe and fringe[0][0] < query:\\n (val, r, c) = heapq.heappop(fringe)\\n stack.append((r, c))\\n points += 1\\n\\n while stack:\\n (r, c) = stack.pop()\\n for (x, y) in dirs:\\n rr = r + x\\n cc = c + y\\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\\n if grid[rr][cc] < query:\\n stack.append((rr, cc))\\n points += 1\\n else:\\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\\n grid[rr][cc] = 0\\n\\n answers[i] = points\\n prev_query = query\\n\\n return answers\",\n \"memory\": \"29600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n q = len(queries)\\n\\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\\n answers = [0] * q\\n prev_query = 0\\n points = 0\\n fringe = [(grid[0][0], 0, 0)]\\n heapq.heapify(fringe)\\n\\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\\n\\n for i in sorted_indices:\\n query = queries[i]\\n # print(query, '----------------')\\n # print(fringe)\\n\\n if query == prev_query:\\n answers[i] = points\\n continue\\n\\n stack = deque()\\n while fringe and fringe[0][0] < query:\\n (val, r, c) = heapq.heappop(fringe)\\n stack.append((r, c))\\n points += 1\\n grid[r][c] = 0\\n\\n while stack:\\n (r, c) = stack.pop()\\n # print(r, c)\\n for (x, y) in dirs:\\n rr = r + x\\n cc = c + y\\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\\n if grid[rr][cc] < query:\\n stack.append((rr, cc))\\n points += 1\\n else:\\n heapq.heappush(fringe, (grid[rr][cc], rr, cc))\\n grid[rr][cc] = 0\\n\\n answers[i] = points\\n prev_query = query\\n\\n return answers\",\n \"memory\": \"29700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n qs = sorted(set(queries))\\n res = dict()\\n rows, cols = len(grid), len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n prevCount = 0\\n\\n for num in qs:\\n count = prevCount\\n while q:\\n val, r, c = q[0]\\n\\n if val >= num:\\n break\\n else:\\n heappop(q)\\n grid[r][c] = None\\n count += 1\\n\\n for i, j in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:\\n if 0 <= i < rows and 0 <= j < cols and grid[i][j] is not None:\\n heappush(q, (grid[i][j], i, j))\\n grid[i][j] = None\\n \\n res[num] = prevCount = count\\n\\n out = [res[num] for num in queries]\\n return out\",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n queriesOg=queries\\n queries = sorted(set(queries))\\n res = {}\\n rows, cols = len(grid), len(grid[0])\\n q = [(grid[0][0], 0, 0)]\\n prevCount = 0\\n\\n for num in queries:\\n count = prevCount\\n\\n while q:\\n val, r, c = q[0]\\n\\n if val >= num: break\\n else:\\n heappop(q)\\n grid[r][c] = None\\n count += 1\\n\\n for i,j in [(r+1,c), (r-1,c), (r,c+1), (r,c-1)]:\\n if 0<=i <rows and 0<=j <cols and grid[i][j] is not None:\\n heappush(q, (grid[i][j], i, j))\\n grid[i][j] = None\\n res[num] = prevCount = count\\n ans = [res[num] for num in queriesOg]\\n return ans\\n\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, a: List[List[int]], queries: List[int]) -> List[int]:\\n queries = [[val,idx] for idx,val in enumerate(queries)]\\n ans = [0]*len(queries)\\n queries.sort()\\n h = [(a[0][0],0,0)]; a[0][0] = -1\\n n,m = len(a),len(a[0])\\n count = 0\\n for qval,idx in queries:\\n while h and h[0][0]<qval:\\n val,i,j = heappop(h)\\n count+=1\\n for p,q in [[1,0],[-1,0],[0,1],[0,-1]]:\\n x,y = i+p,j+q\\n if 0<=x<n and 0<=y<m and a[x][y]!=-1:\\n heappush(h,(a[x][y],x,y))\\n a[x][y] = -1\\n ans[idx] = count\\n return ans\\n \",\n \"memory\": \"30100\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n R = len(grid)\\n C = len(grid[0])\\n \\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n res = [0] * len(queries)\\n\\n \\n queries = [(num, i) for i, num in enumerate(queries)]\\n queries.sort()\\n q = [(grid[0][0], 0, 0)]\\n count = 0\\n for query, original_index in queries:\\n while q:\\n val, r, c = q[0]\\n if val >= query:\\n break\\n\\n count += 1\\n heapq.heappop(q)\\n grid[r][c] = None\\n \\n for dr, dc in dirs:\\n new_r = r + dr\\n new_c = c + dc\\n \\n if 0 <= new_r < R and 0 <= new_c < C and grid[new_r][new_c] is not None:\\n heapq.heappush(q, (grid[new_r][new_c], new_r, new_c))\\n grid[new_r][new_c] = None\\n \\n res[original_index] = count\\n \\n return res\\n \",\n \"memory\": \"30200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, matrix: List[List[int]], queries: List[int]) -> List[int]:\\n arr = []\\n m = len(matrix)\\n n = len(matrix[0])\\n length = len(queries)\\n for i in range (length):\\n arr.append((queries[i], i))\\n X = [-1, 0, 1, 0]\\n Y = [0, -1, 0, 1]\\n arr.sort()\\n h = [(matrix[0][0], 0, 0)]\\n matrix[0][0] = -1\\n count = 0\\n res = [0 for i in range (length)]\\n for i in range (length):\\n cur_query, index = arr[i]\\n if not h or h[0][0] >= cur_query:\\n res[index] = count \\n else:\\n while h:\\n if h[0][0] >= cur_query:\\n break\\n cur_height, curX, curY = heapq.heappop(h)\\n count += 1\\n for i in range (4):\\n neighborX = curX + X[i]\\n neighborY = curY + Y[i]\\n if 0 <= neighborX < m and 0 <= neighborY < n and matrix[neighborX][neighborY] != -1: \\n heapq.heappush(h, (matrix[neighborX][neighborY], neighborX, neighborY))\\n matrix[neighborX][neighborY] = -1\\n res[index] = count\\n \\n return res\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n h,w = len(grid), len(grid[0])\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n print(len(queries),len(set(queries)),len(mapping.keys()))\\n ret = [0 for _ in range(len(queries))]\\n sorted_query = sorted(list(set(queries)))\\n deq = collections.deque([(0,0)])\\n seen = [[0 for _ in range(w)] for _ in range(h)]\\n seen[0][0] = 1\\n p1 = 0\\n deqnext = collections.deque()\\n counter = 0\\n while deq or deqnext:\\n smallest = math.inf\\n while deq:\\n x,y = deq.popleft()\\n num = grid[x][y]\\n if num >= sorted_query[p1]:\\n deqnext.append((x,y))\\n smallest = min(smallest,num)\\n else:\\n counter+=1\\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n seen[dx+x][dy+y] = 1 \\n deq.append((dx+x,dy+y))\\n # print(p1,sorted_query[p1] , smallest)\\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n for idx in mapping[sorted_query[p1]]:\\n ret[idx]+=counter \\n p1+=1\\n deq.extend(deqnext)\\n deqnext = collections.deque()\\n # print(ret)\\n # print(deq,deqnext) \\n if p1 >= len(sorted_query):\\n break\\n\\n return ret\\n\\n\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"from heapq import heapify, heappush, heappop\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n rows = len(grid)\\n cols = len(grid[0])\\n newqueries= sorted([(queries[j], j) for j in range(len(queries))])\\n\\n minheap = [[grid[0][0], 0, 0]]\\n heapify(minheap)\\n\\n visited = [[0 for i in range(cols)]for j in range(rows)]\\n visited[0][0] = 1\\n \\n count = 0\\n ans = [0] * len(queries)\\n for limit,index in newqueries:\\n while(minheap and minheap[0][0]<limit):\\n val, i, j = heappop(minheap)\\n count+=1\\n for a,b in [(0,1),(0,-1),(1,0),(-1,0)]:\\n newi = i+a\\n newj = j+b\\n if(0<=newi<rows and 0<=newj<cols and visited[newi][newj]==0):\\n heappush(minheap, [grid[newi][newj], newi, newj])\\n visited[newi][newj] = 1\\n ans[index] = count\\n return ans\\n \\n \\n\\n\\n\",\n \"memory\": \"32000\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n h,w = len(grid), len(grid[0])\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n ret = [0 for _ in range(len(queries))]\\n sorted_query = sorted(list(set(queries)))\\n deq = collections.deque([(0,0)])\\n seen = [[0 for _ in range(w)] for _ in range(h)]\\n seen[0][0] = 1\\n p1 = 0\\n deqnext = collections.deque()\\n counter = 0\\n while deq or deqnext:\\n smallest = math.inf\\n while deq:\\n x,y = deq.popleft()\\n num = grid[x][y]\\n if num >= sorted_query[p1]:\\n deqnext.append((x,y))\\n smallest = min(smallest,num)\\n else:\\n counter+=1\\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n seen[dx+x][dy+y] = 1 \\n deq.append((dx+x,dy+y))\\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n for idx in mapping[sorted_query[p1]]:\\n ret[idx]+=counter \\n p1+=1\\n deq.extend(deqnext)\\n deqnext = collections.deque()\\n if p1 >= len(sorted_query):\\n break\\n\\n return ret\\n\\n\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n h,w = len(grid), len(grid[0])\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n ret = [0 for _ in range(len(queries))]\\n sorted_query = sorted(list(set(queries)))\\n deq = collections.deque([(0,0)])\\n seen = [[0 for _ in range(w)] for _ in range(h)]\\n seen[0][0] = 1\\n p1 = 0\\n deqnext = collections.deque()\\n counter = 0\\n while deq or deqnext:\\n smallest = math.inf\\n while deq:\\n x,y = deq.popleft()\\n num = grid[x][y]\\n if num >= sorted_query[p1]:\\n deqnext.append((x,y))\\n smallest = min(smallest,num)\\n else:\\n counter+=1\\n for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n seen[dx+x][dy+y] = 1 \\n deq.append((dx+x,dy+y))\\n while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n for idx in mapping[sorted_query[p1]]:\\n ret[idx]+=counter \\n p1+=1\\n deq.extend(deqnext)\\n deqnext = collections.deque()\\n if p1 >= len(sorted_query):\\n break\\n\\n return ret\\n\\n\",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n q = len(queries)\\n\\n sorted_indices = sorted(range(q), key=lambda k: queries[k])\\n answers = [0] * q\\n prev_query = 0\\n points = 0\\n prev_fringe = [(0,0)]\\n\\n dirs = [[0,1], [0,-1], [1,0], [-1,0]]\\n\\n for i in sorted_indices:\\n query = queries[i]\\n # print(query, '----------------')\\n\\n if query == prev_query:\\n answers[i] = points\\n continue\\n\\n stack = deque()\\n fringe = []\\n for (r, c) in prev_fringe:\\n if grid[r][c] < query:\\n stack.append((r, c))\\n else:\\n fringe.append((r, c))\\n\\n while stack:\\n (r, c) = stack.pop()\\n if grid[r][c] == 0:\\n continue\\n points += 1\\n grid[r][c] = 0\\n # print(r, c)\\n for (x, y) in dirs:\\n rr = r + x\\n cc = c + y\\n if 0 <= rr and rr < m and 0 <= cc and cc < n and grid[rr][cc]:\\n if grid[rr][cc] < query:\\n stack.append((rr, cc))\\n else:\\n fringe.append((rr, cc))\\n\\n answers[i] = points\\n prev_fringe = fringe\\n prev_query = query\\n\\n return answers\",\n \"memory\": \"32500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n seen = [[0 for _ in range(n)] for _ in range(m)]\\n sorted_queries = sorted(queries)\\n dic = dict()\\n count = 0\\n p1 = 0\\n seen[0][0] = 1\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n count+=1\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and seen[x][y] == 0:\\n seen[x][y] = 1\\n heapq.heappush(heap, (grid[x][y], x, y))\\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n dic[sorted_queries[p1]] = count-1\\n p1+=1\\n if p1 >= len(sorted_queries):\\n break\\n return [dic[q] if q in dic else count for q in queries]\\n\\n\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n seen = [[0 for _ in range(n)] for _ in range(m)]\\n sorted_queries = sorted(queries)\\n dic = dict()\\n count = 0\\n p1 = 0\\n seen[0][0] = 1\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n count+=1\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and seen[x][y] == 0:\\n seen[x][y] = 1\\n heapq.heappush(heap, (grid[x][y], x, y))\\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n dic[sorted_queries[p1]] = count-1\\n p1+=1\\n if p1 >= len(sorted_queries):\\n break\\n return [dic[q] if q in dic else count for q in queries]\\n\\n\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Priority queue for Dijkstra-like approach\\n min_heap = [(grid[0][0], 0, 0)]\\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n \\n # Preprocess the grid to find the order of visiting cells\\n cell_values = []\\n while min_heap:\\n value, x, y = heappop(min_heap)\\n cell_values.append(value)\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heappush(min_heap, (grid[nx][ny], nx, ny))\\n \\n # Sort queries and prepare the result array\\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\\n result = [0] * len(queries)\\n \\n # Process each query\\n cell_index = 0\\n points = 0\\n for query, original_index in queries_with_indices:\\n # Count cells with values less than the current query\\n while cell_index < len(cell_values) and cell_values[cell_index] < query:\\n points += 1\\n cell_index += 1\\n result[original_index] = points\\n \\n return result\",\n \"memory\": \"32700\"\n },\n {\n \"code\": \"class Solution:\\n from typing import List\\n import heapq\\n\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n visited = [[False]*n for _ in range(m)]\\n heap = [(grid[0][0], 0, 0)]\\n visited[0][0] = True\\n res = [0]*len(queries)\\n queries_sorted = sorted([(q, i) for i, q in enumerate(queries)])\\n points = 0\\n for q, i in queries_sorted:\\n while heap and heap[0][0] < q:\\n _, x, y = heapq.heappop(heap)\\n points += 1\\n for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n nx, ny = x+dx, y+dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heapq.heappush(heap, (grid[nx][ny], nx, ny))\\n res[i] = points\\n return res\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\\"\\\"\\\"\\n bfs\\n \\\"\\\"\\\"\\n k = len(queries)\\n res = [0] * k\\n\\n queries = sorted([[i, num] for i, num in enumerate(queries)], key=lambda x: x[1])\\n \\n # current index in queries.\\n curr = 0\\n # monotonically increasing count.\\n count = 0\\n \\n h = [[grid[0][0], 0, 0]]\\n \\n m, n = len(grid), len(grid[0])\\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n\\n while h:\\n height, r, c = heapq.heappop(h)\\n while curr < k and queries[curr][1] <= height:\\n res[queries[curr][0]] = count\\n curr += 1\\n if curr == k:\\n return res\\n \\n count += 1\\n for x, y in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if 0 <= x < m and 0 <= y < n and not visited[x][y]:\\n heapq.heappush(h, (grid[x][y], x, y))\\n visited[x][y] = True\\n \\n while curr < k:\\n res[queries[curr][0]] = count\\n curr += 1\\n \\n return res\",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Sort queries with their original indices\\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\\n answer = [0] * len(queries)\\n \\n # Priority queue for cells to explore\\n pq = []\\n heappush(pq, (grid[0][0], 0, 0))\\n \\n # Visited matrix\\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n \\n # Points counter\\n points = 0\\n \\n for query_value, query_index in sorted_queries:\\n # Process the queue until we can no longer visit new cells\\n while pq and pq[0][0] < query_value:\\n value, x, y = heappop(pq)\\n points += 1\\n \\n # Explore neighbors\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heappush(pq, (grid[nx][ny], nx, ny))\\n \\n # Store the result for this query\\n answer[query_index] = points\\n \\n return answer\",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n num_queries = len(queries)\\n \\n # Sort queries and keep track of their original indices\\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Prepare the answer array\\n answer = [0] * num_queries\\n \\n # Directions for moving up, down, left, and right\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Priority queue for BFS\\n pq = []\\n # Visited matrix\\n visited = [[False] * n for _ in range(m)]\\n \\n # Start from the top-left corner\\n heappush(pq, (grid[0][0], 0, 0))\\n visited[0][0] = True\\n current_points = 0\\n \\n # Process the queries in sorted order\\n for query_value, original_index in sorted_queries:\\n # Expand the BFS frontier for the current query_value\\n while pq and pq[0][0] < query_value:\\n value, x, y = heappop(pq)\\n current_points += 1\\n\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heappush(pq, (grid[nx][ny], nx, ny))\\n \\n # Store the result for this query\\n answer[original_index] = current_points\\n \\n return answer\",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n num_queries = len(queries)\\n \\n # Sort queries with their original indices\\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Result array\\n result = [0] * num_queries\\n \\n # Directions for moving up, down, left, right\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Min-heap priority queue\\n pq = [(grid[0][0], 0, 0)]\\n visited = [[False] * n for _ in range(m)]\\n visited[0][0] = True\\n current_points = 0\\n \\n # Process each query\\n for query_value, query_index in indexed_queries:\\n while pq and pq[0][0] < query_value:\\n cell_value, x, y = heapq.heappop(pq)\\n current_points += 1 # Gain a point because query_value > cell_value\\n \\n # Explore neighbors\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\\n \\n result[query_index] = current_points\\n \\n return result\",\n \"memory\": \"33300\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n nq = len(queries)\\n n = len(grid)\\n if not n:\\n return [0 for _ in range(nq)]\\n\\n m = len(grid[0])\\n if not m:\\n return [0 for _ in range(nq)]\\n\\n qi = list(sorted([(v, i) for i, v in enumerate(queries)]))\\n\\n visited = [[False for _ in range(m)] for _ in range(n)]\\n added = [[False for _ in range(m)] for _ in range(n)]\\n q = [(grid[0][0], 0, 0)]\\n added[0][0] = True\\n ans = [0 for _ in range(nq)]\\n value = 0\\n qv = {}\\n\\n heapq.heapify(q)\\n for v, i in qi:\\n if v in qv:\\n ans[i] = qv[v]\\n continue\\n\\n # nq = []\\n # inq = {w for w in q}\\n while q:\\n # x, y = q.pop()\\n # xyv, x, y = heapq.heappop(q)\\n xyv, x, y = q[0]\\n if visited[x][y]:\\n continue\\n if xyv < v:\\n value += 1\\n # visited.add((x, y))\\n heapq.heappop(q)\\n visited[x][y] = True\\n for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:\\n if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny] and not added[nx][ny]:\\n # q.append((nx, ny))\\n heapq.heappush(q, (grid[nx][ny], nx, ny))\\n added[nx][ny] = True\\n else:\\n break\\n\\n ans[i] = value\\n qv[v] = value\\n\\n return ans\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n nq = len(queries)\\n n = len(grid)\\n if not n:\\n return [0 for _ in range(nq)]\\n\\n m = len(grid[0])\\n if not m:\\n return [0 for _ in range(nq)]\\n\\n qi = list(sorted([(v, i) for i, v in enumerate(queries)]))\\n\\n visited = [[False for _ in range(m)] for _ in range(n)]\\n added = [[False for _ in range(m)] for _ in range(n)]\\n q = [(0, 0)]\\n added[0][0] = True\\n ans = [0 for _ in range(nq)]\\n value = 0\\n qv = {}\\n for v, i in qi:\\n if v in qv:\\n ans[i] = qv[v]\\n continue\\n\\n nq = []\\n # inq = {w for w in q}\\n while q:\\n x, y = q.pop()\\n if visited[x][y]:\\n continue\\n if grid[x][y] < v:\\n value += 1\\n # visited.add((x, y))\\n visited[x][y] = True\\n for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:\\n if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny] and not added[nx][ny]:\\n q.append((nx, ny))\\n added[nx][ny] = True\\n else:\\n nq.append((x, y))\\n q = list(set(nq))\\n\\n ans[i] = value\\n qv[v] = value\\n\\n return ans\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n # Create a list of tuples (value, x, y) for each position in the grid\\n cells = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\\n # Sort the cells by their values\\n cells.sort()\\n \\n # Prepare result list for each query\\n result = [0] * len(queries)\\n # Pair queries with their original indices and sort them\\n queries_with_indices = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Direction vectors for moving up, down, left, right\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n \\n # Track visited cells\\n visited = [[False] * n for _ in range(m)]\\n # Priority queue for BFS\\n pq = []\\n # Start from the top-left corner\\n heapq.heappush(pq, (grid[0][0], 0, 0))\\n visited[0][0] = True\\n \\n # Keep track of points we can gather\\n points = 0\\n # Process each query\\n for q, original_index in queries_with_indices:\\n # Process all cells with value less than the current query\\n while pq and pq[0][0] < q:\\n value, x, y = heapq.heappop(pq)\\n points += 1\\n # Explore neighbors\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n visited[nx][ny] = True\\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\\n # Assign the result for this query\\n result[original_index] = points\\n \\n return result\",\n \"memory\": \"35000\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n cell_values = sorted([(grid[i][j], i, j) for i in range(m) for j in range(n)])\\n query_values = sorted([(q, i) for i, q in enumerate(queries)])\\n ans = [0] * len(queries)\\n visited = [[False] * n for _ in range(m)]\\n pq = [(grid[0][0], 0, 0)]\\n visited[0][0] = True\\n points = 0\\n\\n for q, q_index in query_values:\\n while pq and pq[0][0] < q:\\n _, i, j = heapq.heappop(pq)\\n points += 1\\n for di, dj in dirs:\\n ni, nj = i + di, j + dj\\n if 0 <= ni < m and 0 <= nj < n and not visited[ni][nj]:\\n heapq.heappush(pq, (grid[ni][nj], ni, nj))\\n visited[ni][nj] = True\\n ans[q_index] = points\\n\\n return ans\",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n R, C = len(grid), len(grid[0])\\n dxns=[(1,0),(-1,0),(0,1),(0,-1)]\\n heap = [(grid[0][0], 0, 0)]\\n vis = [[False] * C for _ in range(R)]\\n cur = -1\\n arr = []\\n\\n def valid(r, c):\\n return 0 <= r < R and 0 <= c < C and not vis[r][c]\\n sz = 0\\n\\n while heap:\\n val, r, c = heapq.heappop(heap)\\n if vis[r][c]: continue\\n vis[r][c] = True\\n if val > cur:\\n arr.append((cur, sz))\\n cur = val\\n sz += 1\\n for dr, dc in dxns:\\n if valid(r + dr, c + dc):\\n heapq.heappush(heap, (grid[r + dr][c + dc], r + dr, c + dc))\\n arr.append((cur, sz))\\n ans = []\\n for q in queries:\\n i = bisect_left(arr, (q, -1)) - 1\\n ans.append(arr[i][1])\\n return ans\",\n \"memory\": \"35800\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n # Directions: up, down, left, right\\n dirs = [(-1,0),(1,0),(0,-1),(0,1)]\\n \\n # Flatten and sort the cells\\n cells = []\\n for i in range(m):\\n for j in range(n):\\n cells.append((grid[i][j], i, j))\\n cells.sort()\\n \\n # Sort queries with their indices\\n sorted_queries = sorted([(q, idx) for idx, q in enumerate(queries)])\\n \\n # Initialize Union-Find\\n parent = [i for i in range(m*n)]\\n size = [1]*(m*n)\\n \\n def find(u):\\n while parent[u] != u:\\n parent[u] = parent[parent[u]]\\n u = parent[u]\\n return u\\n \\n def union(u, v):\\n pu, pv = find(u), find(v)\\n if pu == pv:\\n return\\n if size[pu] < size[pv]:\\n parent[pu] = pv\\n size[pv] += size[pu]\\n else:\\n parent[pv] = pu\\n size[pu] += size[pv]\\n \\n # Activate grid cells\\n active = [[False]*n for _ in range(m)]\\n \\n answer = [0]*len(queries)\\n cell_ptr = 0\\n total_cells = len(cells)\\n \\n for q, idx in sorted_queries:\\n # Activate all cells with value < q\\n while cell_ptr < total_cells and cells[cell_ptr][0] < q:\\n val, x, y = cells[cell_ptr]\\n active[x][y] = True\\n current = x*n + y\\n # Union with active neighbors\\n for dx, dy in dirs:\\n nx, ny = x + dx, y + dy\\n if 0<=nx<m and 0<=ny<n and active[nx][ny]:\\n neighbor = nx*n + ny\\n union(current, neighbor)\\n cell_ptr +=1\\n # Check if (0,0) is active\\n if active[0][0]:\\n root = find(0)\\n answer[idx] = size[root]\\n else:\\n answer[idx] =0\\n return answer\",\n \"memory\": \"37300\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass UnionFind:\\n def __init__(self, n):\\n self.parent = list(range(n))\\n self.size = [1] * n\\n\\n def find(self, x):\\n if self.parent[x] != x:\\n self.parent[x] = self.find(self.parent[x])\\n return self.parent[x]\\n\\n def union(self, x, y):\\n px, py = self.find(x), self.find(y)\\n if px == py:\\n return\\n if self.size[px] < self.size[py]:\\n px, py = py, px\\n self.parent[py] = px\\n self.size[px] += self.size[py]\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Flatten the grid and sort it\\n cells = [(val, i, j) for i, row in enumerate(grid) for j, val in enumerate(row)]\\n cells.sort()\\n \\n # Sort queries with their indices\\n queries_with_index = sorted((q, i) for i, q in enumerate(queries))\\n \\n uf = UnionFind(m * n)\\n answer = [0] * len(queries)\\n cell_index = 0\\n \\n for query, query_index in queries_with_index:\\n while cell_index < len(cells) and cells[cell_index][0] < query:\\n _, i, j = cells[cell_index]\\n for di, dj in directions:\\n ni, nj = i + di, j + dj\\n if 0 <= ni < m and 0 <= nj < n and grid[ni][nj] < query:\\n uf.union(i * n + j, ni * n + nj)\\n cell_index += 1\\n \\n if grid[0][0] < query:\\n answer[query_index] = uf.size[uf.find(0)]\\n \\n return answer\",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"from heapq import heappush as hpush, heappop as hpop\\ndelta = [(0,1), (0,-1), (1,0), (-1,0)]\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n n,m = len(grid), len(grid[0])\\n mx = max(queries)\\n count = [0] * (mx+1)\\n curr = grid[0][0] + 1\\n\\n h = [(grid[0][0],0,0)]\\n grid[0][0] = '#'\\n while curr <= mx and h:\\n if curr <= h[0][0]:\\n curr += 1\\n if curr <= mx:\\n count[curr] = count[curr-1]\\n continue \\n u,ux,uy = hpop(h)\\n count[curr] += 1\\n for dx,dy in delta:\\n vx,vy = ux+dx,uy+dy\\n if -1 < vx < n and -1 < vy < m and grid[vx][vy] != '#':\\n hpush(h,(grid[vx][vy],vx,vy))\\n grid[vx][vy] = '#'\\n\\n while curr < mx:\\n count[curr + 1] = count[curr]\\n curr += 1\\n # print(count)\\n return [count[k] for k in queries ]\\n \\n\\n \\n\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"39900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n mn = m * n\\n\\n # 并查集模板\\n fa = list(range(mn))\\n size = [1] * mn\\n def find(x: int) -> int:\\n if fa[x] != x:\\n fa[x] = find(fa[x])\\n return fa[x]\\n def merge(from_: int, to: int) -> None:\\n from_ = find(from_)\\n to = find(to)\\n if from_ != to:\\n fa[from_] = to\\n size[to] += size[from_]\\n\\n # 矩阵元素从小到大排序，方便离线\\n a = sorted((x, i, j) for i, row in enumerate(grid) for j, x in enumerate(row))\\n\\n ans, j = [0] * len(queries), 0\\n # 查询的下标按照查询值从小到大排序，方便离线\\n for i, q in sorted(enumerate(queries), key=lambda p: p[1]):\\n while j < mn and a[j][0] < q:\\n _, x, y = a[j]\\n # 枚举周围四个格子，值小于 q 才可以合并\\n for x2, y2 in (x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1):\\n if 0 <= x2 < m and 0 <= y2 < n and grid[x2][y2] < q:\\n merge(x * n + y, x2 * n + y2) # 把坐标压缩成一维的编号\\n j += 1\\n if grid[0][0] < q:\\n ans[i] = size[find(0)] # 左上角的连通块的大小\\n return ans\",\n \"memory\": \"40500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n\\n root = [elem for elem in range(m*n)]\\n size = [1] * (m * n)\\n\\n def find(x):\\n if root[x] == x:\\n return x\\n root[x] = find(root[x])\\n return root[x]\\n\\n def union(x, y):\\n root_x = find(x)\\n root_y = find(y)\\n\\n if size[root_x] < size[root_y]:\\n root_x, root_y = root_y, root_x\\n\\n if root_x != root_y:\\n root[root_y] = root_x\\n size[root_x] += size[root_y]\\n\\n # if rank[root_x] > rank[root_y]:\\n # root[root_y] = root_x\\n # size[root_x] += size[root_y] \\n # elif rank[root_x] < rank[root_y]:\\n # root[root_x] = root_y\\n # size[root_y] += size[root_x]\\n # else:\\n # root[root_y] = root_x\\n # rank[root_x] += 1\\n # size[root_x] += size[root_y]\\n\\n def is_connected(x, y):\\n return find(x) == find(y)\\n \\n def get_size(x):\\n return size[find(x)]\\n\\n flatten_grid = [(grid[i][j], i, j) for i in range(m) for j in range(n)]\\n flatten_grid.sort()\\n \\n sorted_queries = [(query, index) for index, query in enumerate(queries)]\\n sorted_queries.sort()\\n\\n answers = [0] * len(queries)\\n directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]\\n\\n curr_index = 0\\n for query, query_index in sorted_queries:\\n while curr_index < (m*n) and flatten_grid[curr_index][0] < query:\\n _, x, y = flatten_grid[curr_index]\\n for dx, dy in directions:\\n new_x = x + dx\\n new_y = y + dy\\n\\n if not (0 <= new_x < m) or not (0 <= new_y < n):\\n continue\\n \\n if grid[new_x][new_y] < query:\\n union(x * n + y, new_x * n + new_y)\\n curr_index += 1\\n\\n if grid[0][0] < query:\\n answers[query_index] = get_size(find(0))\\n\\n return answers\",\n \"memory\": \"40700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # # OPTIMIZED: sort values in increasing order\\n # # maps num -> index in queries before sort\\n # original_indices = {}\\n # total_num_queries = len(queries)\\n # for i in range(total_num_queries):\\n # if queries[i] not in original_indices:\\n # original_indices[queries[i]] = []\\n # original_indices[queries[i]].append(i)\\n # queries.sort()\\n # answer = [0] * total_num_queries\\n # n, m = len(grid), len(grid[0])\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # # function checking if i, j is a valid coordinate in grid\\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n # first_i, first_coord = 0, (0, 0)\\n # queue, adjacent_coords, queued = [first_coord], [], set()\\n # queued.add(first_coord)\\n # count, num_queries = 0, 0\\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n # first_i += 1\\n # for query_i in range(first_i, total_num_queries):\\n # # while queue is not empty\\n # while queue:\\n # # pop and add to count\\n # coord = queue.pop(0)\\n # count += 1\\n # # for each dir in directions:\\n # for dir in directions:\\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # # if is a valid coordinate and not queued yet:\\n # if is_valid_coord(next_coord) and next_coord not in queued:\\n # # if it is less than current num:\\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # # append to queue\\n # queue.append(next_coord)\\n # # add to queued\\n # queued.add(next_coord)\\n # else:\\n # adjacent_coords.append(next_coord)\\n # queued.add(next_coord)\\n # for answer_i in original_indices[queries[query_i]]:\\n # answer[answer_i] = count\\n # num_queries += 1\\n # if query_i + 1 < total_num_queries:\\n # next_adjacent_coords = []\\n # for coord in adjacent_coords:\\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n # queue.append(coord)\\n # else:\\n # next_adjacent_coords.append(coord)\\n # adjacent_coords = next_adjacent_coords\\n # if num_queries == total_num_queries:\\n # break\\n # return answer\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries:\\n # for query_i in range(first_i, total_num_queries):\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop()\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if num_queries == total_num_queries:\\n break\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n query_i += 1\\n return answer\\n \",\n \"memory\": \"40900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries: \\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n if num_queries == total_num_queries:\\n break\\n query_i += 1\\n return answer\",\n \"memory\": \"40900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # # OPTIMIZED: sort values in increasing order\\n # # maps num -> index in queries before sort\\n # original_indices = {}\\n # total_num_queries = len(queries)\\n # for i in range(total_num_queries):\\n # if queries[i] not in original_indices:\\n # original_indices[queries[i]] = []\\n # original_indices[queries[i]].append(i)\\n # queries.sort()\\n # answer = [0] * total_num_queries\\n # n, m = len(grid), len(grid[0])\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # # function checking if i, j is a valid coordinate in grid\\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n # first_i, first_coord = 0, (0, 0)\\n # queue, adjacent_coords, queued = [first_coord], [], set()\\n # queued.add(first_coord)\\n # count, num_queries = 0, 0\\n # while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n # first_i += 1\\n # for query_i in range(first_i, total_num_queries):\\n # # while queue is not empty\\n # while queue:\\n # # pop and add to count\\n # coord = queue.pop(0)\\n # count += 1\\n # # for each dir in directions:\\n # for dir in directions:\\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # # if is a valid coordinate and not queued yet:\\n # if is_valid_coord(next_coord) and next_coord not in queued:\\n # # if it is less than current num:\\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # # append to queue\\n # queue.append(next_coord)\\n # # add to queued\\n # queued.add(next_coord)\\n # else:\\n # adjacent_coords.append(next_coord)\\n # queued.add(next_coord)\\n # for answer_i in original_indices[queries[query_i]]:\\n # answer[answer_i] = count\\n # num_queries += 1\\n # if query_i + 1 < total_num_queries:\\n # next_adjacent_coords = []\\n # for coord in adjacent_coords:\\n # if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n # queue.append(coord)\\n # else:\\n # next_adjacent_coords.append(coord)\\n # adjacent_coords = next_adjacent_coords\\n # if num_queries == total_num_queries:\\n # break\\n # return answer\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n query_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while query_i < total_num_queries and grid[0][0] >= queries[query_i]:\\n query_i += 1\\n while query_i < total_num_queries:\\n # for query_i in range(first_i, total_num_queries):\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if num_queries == total_num_queries:\\n break\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n query_i += 1\\n return answer\\n \",\n \"memory\": \"41000\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # function checking if i, j is a valid coordinate in grid\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n first_i, first_coord = 0, (0, 0)\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n count, num_queries = 0, 0\\n while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n first_i += 1\\n for query_i in range(first_i, total_num_queries):\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n if num_queries == total_num_queries:\\n break\\n return answer\\n \",\n \"memory\": \"41200\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # original_indices = {queries[i]: i for i in range(len(queries))}\\n # queries.sort()\\n # answer = [0] * len(queries)\\n # query_i, count, n, m, num_visited, starting_x, starting_y = 0, 0, len(grid), len(grid[0]), 0, 0, 0\\n # queue, visited, directions = [], set(), [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # starting_set = False\\n # is_valid_coord = lambda i, j: 0 <= i < n and 0 <= j < m and (i, j) not in visited\\n # # in visited, store: i * len(grid[0]) + j. or just (i, j)\\n # while query_i < len(queries):\\n # query_num = queries[query_i]\\n # print(\\\"query_num: \\\", query_num)\\n # queue.append((starting_x, starting_y))\\n # starting_set = False\\n # while queue and num_visited < n*m:\\n # x, y = queue.pop(0)\\n # if (x, y) not in visited and grid[x][y] < query_num:\\n # visited.add((x, y))\\n # count += 1\\n # num_visited += 1\\n # for dx, dy in directions:\\n # next_x, next_y = x + dx, y + dy\\n # if is_valid_coord(next_x, next_y):\\n # queue.append((x, y))\\n # elif not grid[x][y] < query_num and not starting_set:\\n # starting_x, starting_y = x, y\\n # starting_set = True\\n # answer[original_indices[query_num]] = count\\n # query_i += 1\\n # return answer\\n # answer[i]: num blocks for queries[i]\\n\\n # BRUTE FORCE\\n # answer = []\\n # n, m = len(grid), len(grid[0])\\n # is_valid_coord = lambda i, j: 0 <= i < n and 0 <= j < m\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # for num in queries:\\n # queue, processed, count = [], set(), 0\\n # if grid[0][0] < num:\\n # queue.append((0, 0))\\n # processed.add((0, 0))\\n # while queue:\\n # x, y = queue.pop(0)\\n # count += 1\\n # for dx, dy in directions:\\n # new_x, new_y = x + dx, y + dy\\n # if is_valid_coord(new_x, new_y) and grid[new_x][new_y] < num and (new_x, new_y) not in processed:\\n # processed.add((new_x, new_y))\\n # queue.append((new_x, new_y))\\n # answer.append(count)\\n # return answer\\n\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n # COULD QUERIES HAVE MULTIPLE OF THE SAME NUMBER? assume not for now... adjust later\\n # original_indices = {queries[i]: i for i in range(len(queries))}\\n # queries.sort()\\n # answer = [0] * len(queries)\\n # n, m = len(grid), len(grid[0])\\n # # function checking if i, j is a valid coordinate in grid\\n # directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n # is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n # first_i, first_coord = 0, (0, 0)\\n # # queue (i, j) only if grid[i][j] < current num. add (i, j) to processed too.\\n # # queue in new_queue only if grid[i][j] < next num. add (i, j) to processed too.\\n # queue, adjacent_coords, queued = [first_coord], [], set()\\n # queued.add(first_coord)\\n # # print(\\\"processed: \\\", processed)\\n # # for row in grid:\\n # # print(row)\\n # # print(\\\"\\\\n\\\\n\\\")\\n # count = 1\\n # counted = [[0] * m for _ in range(n)]\\n # while first_i < len(queries) and grid[0][0] >= queries[first_i]:\\n # first_i += 1\\n # for query_i in range(first_i, len(queries)):\\n # # while queue is not empty\\n # while queue:\\n # # pop and add to count\\n # coord = queue.pop(0)\\n # # if it is less than this query number:\\n # # if grid[coord[0]][coord[1]] < queries[query_i]:\\n # # count += 1\\n # # else:\\n # # adjacent_coords.append(coord)\\n # # if coord not in queued:\\n # count += 1\\n # counted[coord[0]][coord[1]] = 1\\n # # for each dir in directions:\\n # for dir in directions:\\n # next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # # if is a valid coordinate and not processed yet:\\n # if is_valid_coord(next_coord) and next_coord not in queued:\\n # # if it is less than current num:\\n # if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # # append to queue\\n # queue.append(next_coord)\\n # # add to processed\\n # queued.add(next_coord)\\n \\n # # # if it is less than next num:\\n # elif query_i + 1 < len(queries) and grid[next_coord[0]][next_coord[1]] < queries[query_i + 1]:\\n # # append to adjacent_coords\\n # adjacent_coords.append(next_coord)\\n # # add to processed\\n # queued.add(next_coord)\\n\\n # # otherwise, add it to adjacent_coords:\\n # # else:\\n\\n # # print(\\\"queue after processing coordinates \\\", coord, \\\" is: \\\", queue)\\n # # print(\\\"next queue after processing coordinates \\\", coord, \\\" is: \\\", adjacent_coords)\\n # # -- post-processing --\\n # print(\\\"processed number: \\\", queries[query_i])\\n # print(\\\"queue after processing full number: \\\", queue)\\n # print(\\\"adjacent_coords after processing full number: \\\", adjacent_coords)\\n # print(\\\"count after processing full number: \\\", count)\\n # print(\\\"processed after processing full number: \\\", queued)\\n # # add count to answer in the correct index: answer[original_indicies[queries[query_i]]] = count\\n # count -= 1\\n # answer[original_indices[queries[query_i]]] = count\\n # # set queue = adjacent_coords and adjacent_coords = queue\\n # queue, adjacent_coords = adjacent_coords, queue\\n # queue.append((0, 0))\\n # # print(\\\"\\\\n\\\\n\\\")\\n # # print(\\\"counted for num: \\\", queries[query_i])\\n # # for row in counted:\\n # # print(row)\\n # # print(\\\"\\\\n\\\\n\\\")\\n # # raw_counted = [[0] * m for _ in range(n)]\\n # # for i in range(n):\\n # # for j in range(m):\\n # # if grid[i][j] < queries[query_i]:\\n # # raw_counted[i][j] = 1\\n # # print(\\\"RAW counted for num: \\\", queries[query_i])\\n # # for row in raw_counted:\\n # # print(row)\\n # # print(\\\"\\\\n\\\\n\\\")\\n # return answer\\n # OPTIMIZED: sort values in increasing order\\n # maps num -> index in queries before sort\\n # COULD QUERIES HAVE MULTIPLE OF THE SAME NUMBER? assume not for now... adjust later\\n original_indices = {}\\n total_num_queries = len(queries)\\n for i in range(total_num_queries):\\n if queries[i] not in original_indices:\\n original_indices[queries[i]] = []\\n original_indices[queries[i]].append(i)\\n queries.sort()\\n answer = [0] * total_num_queries\\n n, m = len(grid), len(grid[0])\\n # function checking if i, j is a valid coordinate in grid\\n directions = [(-1, 0), (1, 0), (0, 1), (0, -1)]\\n is_valid_coord = lambda coord: 0 <= coord[0] < n and 0 <= coord[1] < m\\n first_i, first_coord = 0, (0, 0)\\n # queue (i, j) only if grid[i][j] < current num. add (i, j) to queued too.\\n # queue in new_queue only if grid[i][j] < next num. add (i, j) to queued too.\\n queue, adjacent_coords, queued = [first_coord], [], set()\\n queued.add(first_coord)\\n # print(\\\"queued: \\\", queued)\\n count, num_queries = 0, 0\\n while first_i < total_num_queries and grid[0][0] >= queries[first_i]:\\n first_i += 1\\n for query_i in range(first_i, total_num_queries):\\n # if query_i - 1 > 0 and queries[query_i - 1] == queries[query_i]:\\n # continue\\n # while queue is not empty\\n while queue:\\n # pop and add to count\\n coord = queue.pop(0)\\n count += 1\\n # for each dir in directions:\\n for dir in directions:\\n next_coord = (coord[0] + dir[0], coord[1] + dir[1])\\n # if is a valid coordinate and not queued yet:\\n if is_valid_coord(next_coord) and next_coord not in queued:\\n # if it is less than current num:\\n if grid[next_coord[0]][next_coord[1]] < queries[query_i]:\\n # append to queue\\n queue.append(next_coord)\\n # add to queued\\n queued.add(next_coord)\\n # if it is less than next num:\\n # elif query_i + 1 < total_num_queries and grid[next_coord[0]][next_coord[1]] < queries[query_i + 1]:\\n # # append to adjacent_coords\\n # adjacent_coords.append(next_coord)\\n # # add to queued\\n # queued.add(next_coord)\\n else:\\n adjacent_coords.append(next_coord)\\n queued.add(next_coord)\\n # print(\\\"queue after processing coordinates \\\", coord, \\\" is: \\\", queue)\\n # print(\\\"next queue after processing coordinates \\\", coord, \\\" is: \\\", adjacent_coords)\\n # -- post-processing --\\n # print(\\\"processed number: \\\", queries[query_i])\\n # print(\\\"queue after processing full number: \\\", queue)\\n # print(\\\"adjacent_coords after processing full number: \\\", adjacent_coords)\\n # add count to answer in the correct index: answer[original_indicies[queries[query_i]]] = count\\n for answer_i in original_indices[queries[query_i]]:\\n answer[answer_i] = count\\n num_queries += 1\\n # query_i += 1\\n # query_i -= 1\\n # answer[original_indices[queries[query_i]]] = count\\n # set queue = adjacent_coords and adjacent_coords = queue\\n if query_i + 1 < total_num_queries:\\n next_adjacent_coords = []\\n for coord in adjacent_coords:\\n if grid[coord[0]][coord[1]] < queries[query_i + 1]:\\n queue.append(coord)\\n # queued.add(coord)\\n else:\\n next_adjacent_coords.append(coord)\\n adjacent_coords = next_adjacent_coords\\n if num_queries == total_num_queries:\\n break\\n # queue, adjacent_coords = adjacent_coords, queue\\n # print(\\\"new queue, adjacent_coords: \\\", queue, adjacent_coords)\\n # print(\\\"NEW QUEUED: \\\", queued)\\n # print(\\\"\\\\n\\\\n\\\")\\n return answer\\n \",\n \"memory\": \"41300\"\n },\n {\n \"code\": \"from typing import List, Tuple\\nfrom heapq import heappush, heappop\\n\\ndef maxPoints(grid: List[List[int]], queries: List[int]) -> List[int]:\\n def sort_queries_with_indices(queries: List[int]) -> List[Tuple[int, int]]:\\n return sorted(enumerate(queries), key=lambda x: x[1])\\n \\n def initialize_bfs(grid: List[List[int]]) -> Tuple[List[Tuple[int, int, int]], set]:\\n m, n = len(grid), len(grid[0])\\n min_heap = []\\n visited = set()\\n \\n # Start from the top-left cell (0, 0)\\n heappush(min_heap, (grid[0][0], 0, 0))\\n visited.add((0, 0))\\n \\n return min_heap, visited\\n \\n m, n = len(grid), len(grid[0])\\n sorted_queries = sort_queries_with_indices(queries)\\n min_heap, visited = initialize_bfs(grid)\\n answer = [0] * len(queries)\\n points = 0\\n \\n # Directions for moving in the grid (up, down, left, right)\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n \\n for original_index, query in sorted_queries:\\n while min_heap and min_heap[0][0] < query:\\n value, x, y = heappop(min_heap)\\n points += 1\\n \\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heappush(min_heap, (grid[nx][ny], nx, ny))\\n visited.add((nx, ny))\\n \\n answer[original_index] = points\\n \\n return answer\\n\\n# Example usage:\\ngrid = [[1, 2, 3], [2, 5, 7], [3, 5, 1]]\\nqueries = [5, 6, 2]\\nprint(maxPoints(grid, queries)) # Output: [5, 8, 1]\\n\\n\\n\\nclass Solution:\\n def maxPoints(self, *args, **kwargs):\\n return maxPoints(*args, **kwargs)\\n\\n\",\n \"memory\": \"41500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n ques = list(set(queries))\\n ques.sort()\\n values = defaultdict(int)\\n n, m, k = len(grid), len(grid[0]), len(ques)\\n def is_valid(r, c):\\n return 0 <= r < n and 0 <= c < m and grid[r][c] != -1 and (r, c) not in visited\\n dires = [(1,0), (0,1),(-1, 0), (0, -1)]\\n ind = 0\\n heap = [(grid[0][0], 0 ,0)]\\n visited= set()\\n while heap:\\n \\n while ind < k and ques[ind] <= heap[0][0]:\\n # print('here')\\n ind += 1\\n if ind >= k:\\n break\\n # print(ind, heap)\\n val, r, c = heappop(heap)\\n values[ques[ind]] += 1\\n grid[r][c] = -1\\n visited.add((r, c))\\n for dr, dc in dires:\\n nr, nc = r + dr, c + dc\\n if is_valid(nr, nc):\\n heappush(heap, (grid[nr][nc], nr, nc))\\n visited.add((nr, nc))\\n\\n for i in range(1,k):\\n values[ques[i]] += values[ques[i-1]]\\n \\n result = []\\n for q in queries:\\n result.append(values[q])\\n return result \\n\\n print(values) \\n\",\n \"memory\": \"41600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n ques = list(set(queries))\\n ques.sort()\\n values = defaultdict(int)\\n n, m, k = len(grid), len(grid[0]), len(ques)\\n def is_valid(r, c):\\n return 0 <= r < n and 0 <= c < m and grid[r][c] != -1 and (r, c) not in visited\\n dires = [(1,0), (0,1),(-1, 0), (0, -1)]\\n ind = 0\\n heap = [(grid[0][0], 0 ,0)]\\n visited= set()\\n while heap:\\n \\n while ind < k and ques[ind] <= heap[0][0]:\\n # print('here')\\n ind += 1\\n if ind >= k:\\n break\\n # print(ind, heap)\\n val, r, c = heappop(heap)\\n values[ques[ind]] += 1\\n grid[r][c] = -1\\n visited.add((r, c))\\n for dr, dc in dires:\\n nr, nc = r + dr, c + dc\\n if is_valid(nr, nc):\\n heappush(heap, (grid[nr][nc], nr, nc))\\n visited.add((nr, nc))\\n\\n for i in range(1,k):\\n values[ques[i]] += values[ques[i-1]]\\n \\n result = []\\n for q in queries:\\n result.append(values[q])\\n return result \\n\\n print(values) \\n\",\n \"memory\": \"41700\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n \\n # Sort queries with their original indices\\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Initialize the result array\\n answer = [0] * len(queries)\\n \\n # Priority queue to store cells to visit\\n pq = [(grid[0][0], 0, 0)]\\n \\n # Set to store visited cells\\n visited = set()\\n visited.add((0, 0))\\n \\n # Current points\\n points = 0\\n \\n # Process each query in sorted order\\n for q, original_index in sorted_queries:\\n # Explore cells until the priority queue is empty or the top cell value is greater than the query\\n while pq and pq[0][0] < q:\\n val, x, y = heapq.heappop(pq)\\n points += 1\\n \\n # Explore adjacent cells\\n for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heapq.heappush(pq, (grid[nx][ny], nx, ny))\\n visited.add((nx, ny))\\n \\n # Update the answer for the current query\\n answer[original_index] = points\\n \\n return answer\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[1,2,3],[2,5,7],[3,5,1]]\\nqueries = [5,6,2]\\nprint(solution.maxPoints(grid, queries)) # Output: [5, 8, 1]\",\n \"memory\": \"42400\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sol = [0] * len(queries)\\n count = 0\\n r,c = len(grid), len(grid[0])\\n heap = []\\n heapq.heappush(heap, (grid[0][0], 0, 0))\\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\\n visited = {(0,0)}\\n\\n for q, index in sorted(indexed_queries):\\n while heap and (heap[0][0] < q):\\n curr, i, j = heapq.heappop(heap)\\n count += 1\\n \\n\\n for ni, nj in (i, j+1), (i, j-1), (i+1, j), (i-1, j):\\n if (0<= ni < r) and (0 <=nj < c) and ((ni,nj) not in visited):\\n heapq.heappush(heap, (grid[ni][nj], ni, nj))\\n visited.add((ni, nj))\\n \\n \\n sol[index] = count\\n\\n return sol\\n\\n\\n\\n\",\n \"memory\": \"42500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sol = [0] * len(queries)\\n count = 0\\n r,c = len(grid), len(grid[0])\\n heap = []\\n heapq.heappush(heap, (grid[0][0], 0, 0))\\n indexed_queries = sorted((q, i) for i, q in enumerate(queries))\\n visited = {(0,0)}\\n\\n for q, index in sorted(indexed_queries):\\n while heap and (heap[0][0] < q):\\n curr, i, j = heapq.heappop(heap)\\n count += 1\\n \\n\\n for ni, nj in (i, j+1), (i, j-1), (i+1, j), (i-1, j):\\n if (0<= ni < r) and (0 <=nj < c) and ((ni,nj) not in visited):\\n heapq.heappush(heap, (grid[ni][nj], ni, nj))\\n visited.add((ni, nj))\\n \\n \\n sol[index] = count\\n\\n return sol\\n\\n # TC = O( n log n + q log q)\\n # SC = O(n)\\n\\n\",\n \"memory\": \"42500\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Sort queries with their original indices\\n sorted_queries = sorted(enumerate(queries), key=lambda x: x[1])\\n \\n answer = [0] * len(queries)\\n heap = [(grid[0][0], 0, 0)] # (value, row, col)\\n visited = set([(0, 0)])\\n total_visited = 0\\n \\n for idx, query in sorted_queries:\\n while heap and heap[0][0] < query:\\n _, r, c = heapq.heappop(heap)\\n total_visited += 1\\n \\n for dr, dc in directions:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\\n visited.add((nr, nc))\\n heapq.heappush(heap, (grid[nr][nc], nr, nc))\\n \\n answer[idx] = total_visited\\n \\n return answer\",\n \"memory\": \"42600\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n ret = [0 for _ in range(len(queries))]\\n prev = 0\\n for q in sorted(list(set(queries))):\\n pos = bisect.bisect_left(order, q,lo=prev)\\n for idx in mapping[q]:\\n ret[idx]=pos\\n prev = pos\\n return ret\\n\\n\",\n \"memory\": \"42700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n\\n mapping = dict()\\n for idx,num in enumerate(queries):\\n if num not in mapping:\\n mapping[num] = [idx]\\n else:\\n mapping[num].append(idx)\\n ret = [0 for _ in range(len(queries))]\\n prev = 0\\n for q in sorted(list(set(queries))):\\n pos = bisect.bisect_left(order, q,lo=prev)\\n for idx in mapping[q]:\\n ret[idx]=pos\\n prev = pos\\n return ret\\n\\n\",\n \"memory\": \"42700\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\n\\n\\n@dataclass(frozen=True)\\nclass IndexedQuery:\\n queryIndex: int\\n query: int\\n\\n def __iter__(self):\\n yield self.queryIndex\\n yield self.query\\n\\n\\nclass Solution:\\n def maxPoints(self, grid: list[list[int]], queries: list[int]) -> list[int]:\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n ans = [0] * len(queries)\\n minHeap = [(grid[0][0], 0, 0)] # (grid[i][j], i, j)\\n seen = {(0, 0)}\\n accumulate = 0\\n\\n for queryIndex, query in sorted([IndexedQuery(i, query)\\n for i, query in enumerate(queries)],\\n key=lambda x: x.query):\\n while minHeap:\\n val, i, j = heapq.heappop(minHeap)\\n if val >= query:\\n # The smallest neighbor is still larger than `query`, so no need to\\n # keep exploring. Re-push (i, j, grid[i][j]) back to the `minHeap`.\\n heapq.heappush(minHeap, (val, i, j))\\n break\\n accumulate += 1\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n heapq.heappush(minHeap, (grid[x][y], x, y))\\n seen.add((x, y))\\n ans[queryIndex] = accumulate\\n\\n return ans\",\n \"memory\": \"42800\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n # Priority queue to explore cells in increasing order of their values\\n pq = []\\n heappush(pq, (grid[0][0], 0, 0))\\n \\n # Visited set to keep track of visited cells\\n visited = set()\\n visited.add((0, 0))\\n \\n # Precompute the maximum points for each query\\n max_points = [0] * len(queries)\\n sorted_queries = sorted((q, i) for i, q in enumerate(queries))\\n \\n # Current number of points\\n points = 0\\n \\n # Process each query in sorted order\\n for query, idx in sorted_queries:\\n # Explore the grid while the top of the heap is less than the current query\\n while pq and pq[0][0] < query:\\n value, x, y = heappop(pq)\\n points += 1 # We can collect a point for this cell\\n \\n # Explore neighbors\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n visited.add((nx, ny))\\n heappush(pq, (grid[nx][ny], nx, ny))\\n \\n # Store the result for this query\\n max_points[idx] = points\\n \\n return max_points\",\n \"memory\": \"42900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # sort the queries, to make the from smaller value to bigger value\\n # this way we can eliminate some of the recomputation\\n # because if smaller value pass, that means the bigger values will pass\\n\\n # we can keep the same set of visited coordinates? \\n # and increase the count for the subsequence queries\\n\\n # let's say for ex1, we sort the 5 6 2 to 2 5 6\\n # we run the 2 first\\n # we mark the first cell to be cleared, so count is 1\\n # and for 5, we start with count = 1\\n # then do bfs , get 5 cells\\n # and for 6, we start with count of 5, and spread out\\n\\n # for the bfs, if the value is >= than the value, we add it back to the queue? \\n # because there might be other cells behind it that < than the current value\\n\\n # how do we mark them as already check?\\n # we can add them to a heap, with value, r, c\\n # that should help with dealing with the value, or bigger cell\\n # so we can start other queries\\n\\n result = [0 for _ in range(len(queries))]\\n\\n check = [(i, val) for i, val in enumerate(queries)]\\n check.sort(key = lambda x: x[1])\\n\\n # check = [index, val that we will check]\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n heap = [] # heap = (value, r, c)\\n heapq.heappush(heap, (grid[0][0], 0, 0))\\n heapq.heappush(heap, (10 ** 6 + 1, -1, -1))\\n visited.add((0, 0))\\n\\n # we start checking from the first value in the check array\\n checkIndex = 0\\n curCount = 0\\n\\n \\n while heap:\\n val, r, c = heapq.heappop(heap)\\n # check if the current val is already out of range for our query val\\n # move till we find a new value that within range\\n while checkIndex < len(check) and val >= check[checkIndex][1]:\\n \\n result[check[checkIndex][0]] = curCount\\n checkIndex += 1\\n \\n # see if we reach the end of queries but there are still coordinates, we should still break\\n if checkIndex == len(check):\\n break\\n \\n # now we have a new query val that within range\\n # increase count, and add the neighbors to the heap\\n curCount += 1\\n\\n # go through the neighbors, check if within range and not visited\\n # add to the heap\\n for dr, dc in [[1, 0], [0, 1], [-1, 0], [0, -1]]:\\n if 0 <= r + dr < rows and 0 <= c + dc < cols and (r + dr, c + dc) not in visited:\\n heapq.heappush(heap, (grid[r+dr][c+dc], r + dr, c + dc))\\n visited.add((r + dr, c + dc))\\n\\n # print(curCount, checkIndex)\\n\\n # # we still have 1 last case, where if we reach the end with the extremely big value, that covers every value\\n # if checkIndex < len(check) and curCount and result[check[checkIndex][0]] == 0:\\n # result[check[checkIndex][0]] = curCount\\n\\n\\n return result\\n\",\n \"memory\": \"42900\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n dirs = [(0,1),(1,0),(-1,0),(0,-1)]\\n nrows = len(grid)\\n ncols = len(grid[0])\\n \\n q_and_i = [[queries[i], i] for i in range(len(queries))]\\n q_and_i.sort()\\n \\n answer = [0 for _ in range(len(queries))]\\n heap = [[grid[0][0], 0, 0]]\\n seen = {(0,0)}\\n n_visited = 0\\n \\n for q, i in q_and_i:\\n while heap and heap[0][0] < q:\\n n_visited += 1\\n _, r, c = heapq.heappop(heap)\\n for h, v in dirs:\\n r2, c2 = r + v, c + h\\n if r2 >= 0 and r2 < nrows and c2 >= 0 and c2 < ncols:\\n if (r2, c2) not in seen:\\n seen.add((r2, c2))\\n heapq.heappush(heap, [grid[r2][c2], r2, c2])\\n answer[i] = n_visited\\n return answer\",\n \"memory\": \"43100\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n # Dont Forget this Technique of making the sorted kind of arr\\n # and then answering the queries ( VERY Nice Approach )\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0,0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x,y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n\\n # This is the main part of the code logic in this approach\\n # Here even the samller elements which are not unlocked\\n # will unlock but not add at the prev stage rather maximizing \\n # When it needs to be unlocked and counted\\n\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n # Excellent IDEA\\n\\n res = []\\n for q in queries:\\n res.append(bisect.bisect_left(order, q))\\n return res\\n\\n \\\"\\\"\\\" # Another Approach From Coding Mohan \\\"\\\"\\\"\\n\\n q = len(queries)\\n rows = len(grid)\\n cols = len(grid[0])\\n \\n # Store queries and their original index\\n queries_and_ind = [(queries[j], j) for j in range(q)]\\n queries_and_ind.sort()\\n \\n result = [0] * q\\n visited = [[False] * cols for _ in range(rows)]\\n total_visited = 0\\n \\n # Use a SortedList to mimic the sorted set behavior in C++\\n nodes = SortedList([(grid[0][0], 0, 0)])\\n visited[0][0] = True\\n \\n for mx_val, ind in queries_and_ind:\\n # While we have nodes and their value is less than the current query value\\n while nodes and nodes[0][0] < mx_val:\\n val, row, col = nodes.pop(0)\\n total_visited += 1\\n \\n # Define the neighbors for traversal\\n neighbors = [(1, 0), (0, 1), (-1, 0), (0, -1)]\\n for dr, dc in neighbors:\\n r, c = row + dr, col + dc\\n \\n if 0 <= r < rows and 0 <= c < cols and not visited[r][c]:\\n visited[r][c] = True\\n nodes.add((grid[r][c], r, c))\\n \\n # Store the total number of visited cells for this query\\n result[ind] = total_visited\\n \\n return result\",\n \"memory\": \"43300\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\\n results = [0] * len(queries)\\n queries = sorted([(q, i) for i, q in enumerate(queries)])\\n visited = set()\\n heap = [(grid[0][0], 0, 0)]\\n \\n for q, original_index in queries:\\n while heap and heap[0][0] < q:\\n value, x, y = heappop(heap)\\n if (x, y) not in visited:\\n visited.add((x, y))\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited:\\n heappush(heap, (grid[nx][ny], nx, ny))\\n results[original_index] = len(visited)\\n \\n return results\\n \",\n \"memory\": \"43400\"\n },\n {\n \"code\": \"\\nimport heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sq = sorted(queries)\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n\\n numRows = len(grid)\\n numCols = len(grid[0])\\n\\n priorityQ = [(grid[0][0], 0, 0)]\\n seenCord = set()\\n seenCord.add((0,0))\\n count = 0\\n qScore = {}\\n for q in sq:\\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\\n count += 1\\n currVal, currRow, currCol = heapq.heappop(priorityQ)\\n \\n for d in directions:\\n\\n newRow = currRow + d[0]\\n newCol = currCol + d[1]\\n\\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\\n\\n if (newRow, newCol) not in seenCord:\\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\\n seenCord.add((newRow, newCol))\\n\\n qScore[q] = count\\n \\n return [qScore[q] for q in queries]\\n\\n\\n\",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"\\nimport heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sq = sorted(queries)\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n\\n numRows = len(grid)\\n numCols = len(grid[0])\\n\\n priorityQ = [(grid[0][0], 0, 0)]\\n seenCord = set()\\n seenCord.add((0,0))\\n count = 0\\n qScore = {}\\n for q in sq:\\n while(len(priorityQ) > 0 and priorityQ[0][0] < q):\\n count += 1\\n currVal, currRow, currCol = heapq.heappop(priorityQ)\\n \\n for d in directions:\\n\\n newRow = currRow + d[0]\\n newCol = currCol + d[1]\\n\\n if newRow >= 0 and newRow < numRows and newCol >= 0 and newCol < numCols:\\n\\n if (newRow, newCol) not in seenCord:\\n heapq.heappush(priorityQ, (grid[newRow][newCol], newRow, newCol))\\n seenCord.add((newRow, newCol))\\n\\n qScore[q] = count\\n \\n return [qScore[q] for q in queries]\\n\\n\\n\",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n # h,w = len(grid), len(grid[0])\\n # mapping = dict()\\n # for idx,num in enumerate(queries):\\n # if num not in mapping:\\n # mapping[num] = [idx]\\n # else:\\n # mapping[num].append(idx)\\n # ret = [0 for _ in range(len(queries))]\\n # sorted_query = sorted(list(set(queries)))\\n # deq = collections.deque([(0,0)])\\n # seen = [[0 for _ in range(w)] for _ in range(h)]\\n # seen[0][0] = 1\\n # p1 = 0\\n # deqnext = collections.deque()\\n # counter = 0\\n # while deq or deqnext:\\n # smallest = math.inf\\n # while deq:\\n # x,y = deq.popleft()\\n # num = grid[x][y]\\n # if num >= sorted_query[p1]:\\n # deqnext.append((x,y))\\n # smallest = min(smallest,num)\\n # else:\\n # counter+=1\\n # for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n # if 0 <= dx+x < h and 0 <= dy+y < w and seen[dx+x][dy+y] == 0:\\n # seen[dx+x][dy+y] = 1 \\n # deq.append((dx+x,dy+y))\\n # while p1 < len(sorted_query) and sorted_query[p1] <= smallest :\\n # for idx in mapping[sorted_query[p1]]:\\n # ret[idx]+=counter \\n # p1+=1\\n # deq.extend(deqnext)\\n # deqnext = collections.deque()\\n # if p1 >= len(sorted_query):\\n # break\\n\\n # return ret\\n\\n\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n sorted_queries = sorted(queries)\\n dic = dict()\\n count = 0\\n p1 = 0\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n count+=1\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n if p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n while p1 < len(sorted_queries) and sorted_queries[p1] <= curr:\\n dic[sorted_queries[p1]] = count-1\\n p1+=1\\n if p1 >= len(sorted_queries):\\n break\\n return [dic[q] if q in dic else count for q in queries]\\n\\n\",\n \"memory\": \"43600\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\t\\t#It is a simple questions based on the concept of graph\\n\\t\\t#As we all know we can represent a matrix/grid into a graph\\n\\t\\t#Then we can use the heap(min Heap) to get a perfect path.\\n\\t\\t#Then we are using maxYet(means max till that index).\\n\\t\\tm = len(grid)\\n\\t\\tn = len(grid[0])\\n\\t\\theap = [(grid[0][0], 0, 0)]\\n\\t\\tv = {(0, 0)}\\n\\t\\torder = []\\n\\t\\twhile len(heap) > 0:\\n\\t\\t\\tcurr, i, j = heapq.heappop(heap)\\n\\t\\t\\torder.append(curr)\\n\\t\\t\\tfor x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n\\t\\t\\t\\tif 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n\\t\\t\\t\\t\\tv.add((x, y))\\n\\t\\t\\t\\t\\theapq.heappush(heap, (grid[x][y], x, y))\\n\\t\\tmaxYet = -1\\n\\t\\tfor i in range(len(order)):\\n\\t\\t\\tmaxYet = max(maxYet, order[i])\\n\\t\\t\\torder[i] = maxYet\\n\\t\\tres = []\\n\\t\\tfor q in queries:\\n\\t\\t\\tres.append(bisect.bisect_left(order, q))\\n\\t\\treturn res\",\n \"memory\": \"43700\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0, 0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x, y))\\n heappush(heap, (grid[x][y], x, y))\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n res = []\\n for q in queries:\\n res.append(bisect_left(order, q))\\n return res\\n\",\n \"memory\": \"43800\"\n },\n {\n \"code\": \"class Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n \\n m = len(grid)\\n n = len(grid[0])\\n heap = [(grid[0][0], 0, 0)]\\n v = {(0,0)}\\n order = []\\n while len(heap) > 0:\\n curr, i, j = heapq.heappop(heap)\\n order.append(curr)\\n for x, y in [(i - 1, j), (i, j - 1), (i + 1, j), (i, j + 1)]:\\n if 0 <= x < m and 0 <= y < n and (x, y) not in v:\\n v.add((x,y))\\n heapq.heappush(heap, (grid[x][y], x, y))\\n\\n # This is the main part of the code logic in this approach\\n # Here even the samller elements which are not unlocked\\n # will unlock but not add at the prev stage rather maximizing \\n # When it needs to be unlocked and counted\\n\\n maxYet = -1\\n for i in range(len(order)):\\n maxYet = max(maxYet, order[i])\\n order[i] = maxYet\\n # Excellent IDEA\\n\\n res = []\\n for q in queries:\\n res.append(bisect.bisect_left(order, q))\\n return res\",\n \"memory\": \"43900\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n queries = [(q, i) for i, q in enumerate(queries)]\\n s_queries = sorted(queries, key = lambda x: x[0])\\n ret = [0] * len(queries)\\n visited = set()\\n h = [(grid[0][0], 0,0)]\\n offsets = [(0,1), (0, -1), (-1, 0), (1, 0)]\\n m = len(grid)\\n n = len(grid[0])\\n count = 0\\n for q, i in s_queries:\\n while h and h[0][0] < q:\\n _, r, c = heappop(h)\\n if (r, c) in visited:\\n continue\\n visited.add((r,c))\\n count += 1\\n for o in offsets:\\n newr, newc = r + o[0], c + o[1]\\n if newr >= 0 and newr < m and newc >= 0 and newc < n and (newr, newc) not in visited:\\n heappush(h, (grid[newr][newc], newr, newc))\\n ret[i] = count\\n return ret\",\n \"memory\": \"44200\"\n },\n {\n \"code\": \"from collections import deque\\nimport heapq\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n sorted_queries = sorted(zip(queries,range(len(queries))), key=lambda x: x[0])\\n \\n completed = set()\\n heap = [(grid[0][0], 0, 0)]\\n heapq.heapify(heap)\\n\\n answer = [0] * len(queries)\\n for ind in range(len(sorted_queries)):\\n query = sorted_queries[ind][0]\\n index = sorted_queries[ind][1]\\n sol = 0\\n\\n while heap:\\n val, x, y = heap[0]\\n if query <= val:\\n break\\n\\n if (x,y) in completed:\\n heapq.heappop(heap)\\n continue\\n\\n # in_bounds = item[0] >= 0 and item[0] < len(grid) and item[1] >= 0 and item[1] < len(grid[0])\\n # if item in completed or not in_bounds or query <= grid[item[0]][item[1]]:\\n # continue\\n\\n heapq.heappop(heap)\\n sol += 1\\n completed.add((x,y))\\n\\n if y-1 >= 0: heapq.heappush(heap, (grid[x][y-1], x, y-1))\\n if x-1 >= 0: heapq.heappush(heap, (grid[x-1][y], x-1, y))\\n if y+1 < len(grid[0]): heapq.heappush(heap, (grid[x][y+1], x, y+1))\\n if x+1 < len(grid): heapq.heappush(heap, (grid[x+1][y], x+1, y))\\n\\n\\n if ind-1>=0:\\n answer[index] = sol + answer[sorted_queries[ind-1][1]]\\n else: answer[index]= sol\\n\\n return answer\",\n \"memory\": \"44300\"\n },\n {\n \"code\": \"import heapq as h\\n\\nclass Solution:\\n def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:\\n\\n q = []\\n\\n m = len(grid)\\n n = len(grid[0])\\n\\n best = defaultdict(int)\\n\\n best[(0, 0)] = grid[0][0]\\n\\n h.heappush(q, (grid[0][0], 0, 0))\\n\\n moves = [[-1, 0], [0, -1], [1, 0], [0, 1]]\\n\\n while q and len(best) < m * n:\\n (val, x, y) = h.heappop(q)\\n\\n for [i, j] in moves:\\n xi = x + i\\n yj = y + j\\n \\n if 0 <= xi < m and 0 <= yj < n and (xi, yj) not in best:\\n nVal = max(val, grid[xi][yj])\\n best[(xi, yj)] = nVal\\n h.heappush(q, (nVal, xi, yj))\\n \\n print(best)\\n\\n counts = defaultdict(int)\\n\\n for key in best:\\n counts[best[key]] += 1\\n \\n counts = [[x, counts[x]] for x in counts]\\n\\n counts.sort()\\n\\n for i in range(1, len(counts)):\\n counts[i][1] += counts[i-1][1]\\n \\n ret = []\\n print(counts)\\n for query in queries:\\n query -= 1\\n l = 0\\n r = len(counts) - 1\\n ans = -1\\n\\n while l <= r:\\n mid = (l + r) // 2\\n\\n if counts[mid][0] <= query:\\n ans = mid\\n l = mid + 1\\n else:\\n r = mid - 1\\n if ans == -1:\\n ret.append(0)\\n else:\\n ret.append(counts[ans][1])\\n \\n return ret\",\n \"memory\": \"44800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":61,"string":"61"}}},{"rowIdx":2454,"cells":{"question_id":{"kind":"number","value":2711,"string":"2,711"},"name":{"kind":"string","value":"minimum-time-to-visit-a-cell-in-a-grid"},"content":{"kind":"string","value":"<p>You are given a <code>m x n</code> matrix <code>grid</code> consisting of <b>non-negative</b> integers where <code>grid[row][col]</code> represents the <strong>minimum</strong> time required to be able to visit the cell <code>(row, col)</code>, which means you can visit the cell <code>(row, col)</code> only when the time you visit it is greater than or equal to <code>grid[row][col]</code>.</p>\n\n<p>You are standing in the <strong>top-left</strong> cell of the matrix in the <code>0<sup>th</sup></code> second, and you must move to <strong>any</strong> adjacent cell in the four directions: up, down, left, and right. Each move you make takes 1 second.</p>\n\n<p>Return <em>the <strong>minimum</strong> time required in which you can visit the bottom-right cell of the matrix</em>. If you cannot visit the bottom-right cell, then return <code>-1</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png\" /></p>\n\n<pre>\n<strong>Input:</strong> grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\n<strong>Output:</strong> 7\n<strong>Explanation:</strong> One of the paths that we can take is the following:\n- at t = 0, we are on the cell (0,0).\n- at t = 1, we move to the cell (0,1). It is possible because grid[0][1] <= 1.\n- at t = 2, we move to the cell (1,1). It is possible because grid[1][1] <= 2.\n- at t = 3, we move to the cell (1,2). It is possible because grid[1][2] <= 3.\n- at t = 4, we move to the cell (1,1). It is possible because grid[1][1] <= 4.\n- at t = 5, we move to the cell (1,2). It is possible because grid[1][2] <= 5.\n- at t = 6, we move to the cell (1,3). It is possible because grid[1][3] <= 6.\n- at t = 7, we move to the cell (2,3). It is possible because grid[2][3] <= 7.\nThe final time is 7. It can be shown that it is the minimum time possible.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png\" style=\"width: 151px; height: 151px;\" /></p>\n\n<pre>\n<strong>Input:</strong> grid = [[0,2,4],[3,2,1],[1,0,4]]\n<strong>Output:</strong> -1\n<strong>Explanation:</strong> There is no path from the top left to the bottom-right cell.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>m == grid.length</code></li>\n\t<li><code>n == grid[i].length</code></li>\n\t<li><code>2 <= m, n <= 1000</code></li>\n\t<li><code>4 <= m * n <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= grid[i][j] <= 10<sup>5</sup></code></li>\n\t<li><code>grid[0][0] == 0</code></li>\n</ul>\n\n<p> </p>\n<style type=\"text/css\">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; \n}\n.spoiler {overflow:hidden;}\n.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}\n.spoilerbutton[value=\"Show Message\"] + .spoiler > div {margin-top:-500%;}\n.spoilerbutton[value=\"Hide Message\"] + .spoiler {padding:5px;}\n</style>\n"},"acRate":{"kind":"number","value":35.75801328328039,"string":"35.758013"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","breadth-first-search","graph","heap-priority-queue","matrix","shortest-path"],"string":"[\n \"array\",\n \"breadth-first-search\",\n \"graph\",\n \"heap-priority-queue\",\n \"matrix\",\n \"shortest-path\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1324\", 1.8867], [\"1342\", 0.6289], [\"1361\", 0.6289], [\"1380\", 0.6289], [\"1398\", 0.6289], [\"1417\", 0.6289], [\"1435\", 1.2579], [\"1454\", 0.6289], [\"1473\", 1.2578], [\"1491\", 0.6289], [\"1510\", 1.2578], [\"1529\", 3.7736], [\"1547\", 2.5158], [\"1566\", 1.8867], [\"1584\", 2.5156], [\"1603\", 1.8867], [\"1622\", 0.6289], [\"1640\", 1.2579], [\"1659\", 0.6289], [\"1677\", 0.6289], [\"1696\", 1.8867], [\"1715\", 2.5156], [\"1733\", 2.5156], [\"1752\", 0.6289], [\"1771\", 0.6289], [\"1789\", 0.6289], [\"1808\", 0.6289], [\"1826\", 1.2578], [\"1845\", 1.8867], [\"1864\", 2.5157], [\"1882\", 1.8867], [\"1901\", 1.8867], [\"1919\", 4.4024], [\"1938\", 1.8867], [\"1957\", 4.4025], [\"1975\", 1.8867], [\"1994\", 1.8867], [\"2012\", 5.031299999999999], [\"2031\", 2.5156], [\"2050\", 3.7733999999999996], [\"2068\", 1.8868], [\"2087\", 1.2578], [\"2106\", 1.2578], [\"2124\", 0.6289], [\"2143\", 0.6289], [\"2161\", 3.1447000000000003], [\"2180\", 0.6289], [\"2199\", 0.6289], [\"2217\", 1.8867], [\"2236\", 1.2578], [\"2254\", 0.6289], [\"2273\", 0.6289], [\"2292\", 0.6289], [\"2310\", 0.6289], [\"2329\", 1.8867], [\"2347\", 1.2578], [\"2366\", 0.6289], [\"2385\", 0.6289], [\"2403\", 0.6289], [\"2422\", 0.6289], [\"2441\", 0.6289], [\"2459\", 0.6289], [\"2478\", 0.6289], [\"2496\", 0.6289], [\"2515\", 0.6289]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"29200\", 0.6289], [\"31000\", 0.6289], [\"31500\", 0.6289], [\"31600\", 0.6289], [\"31700\", 1.2579], [\"31800\", 1.8868], [\"31900\", 1.8868], [\"32000\", 1.2579], [\"32200\", 1.2579], [\"32299\", 0.6289], [\"32400\", 0.6289], [\"32800\", 0.6289], [\"33100\", 0.6289], [\"33800\", 0.6289], [\"33900\", 0.6289], [\"34000\", 4.4025], [\"34100\", 1.8868], [\"34200\", 0.6289], [\"36400\", 0.6289], [\"36700\", 0.6289], [\"37000\", 0.6289], [\"37400\", 0.6289], [\"38700\", 0.6289], [\"39900\", 0.6289], [\"40100\", 0.6289], [\"40200\", 0.6289], [\"40300\", 0.6289], [\"40600\", 1.2579], [\"40700\", 1.2579], [\"40800\", 0.6289], [\"40900\", 2.5157], [\"41000\", 1.8868], [\"41200\", 0.6289], [\"41400\", 1.8868], [\"41500\", 3.1447], [\"41600\", 3.7736], [\"41700\", 8.1761], [\"41800\", 4.4025], [\"41900\", 2.5157], [\"42000\", 1.2579], [\"42100\", 1.8868], [\"42400\", 0.6289], [\"42900\", 0.6289], [\"43100\", 0.6289], [\"43400\", 1.2579], [\"43500\", 0.6289], [\"43600\", 5.0314], [\"43700\", 3.7736], [\"43800\", 2.5157], [\"43900\", 1.8868], [\"45100\", 1.8868], [\"45300\", 0.6289], [\"45400\", 0.6289], [\"45500\", 1.8868], [\"45700\", 0.6289], [\"45800\", 0.6289], [\"46000\", 0.6289], [\"46100\", 1.2579], [\"46500\", 0.6289], [\"46600\", 0.6289], [\"46700\", 0.6289], [\"47300\", 0.6289], [\"49200\", 0.6289], [\"49300\", 0.6289], [\"50200\", 0.6289], [\"51700\", 0.6289], [\"54900\", 0.6289], [\"55300\", 0.6289], [\"56400\", 1.2579], [\"61000\", 0.6289]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n q = [(0, 0, 0)]\n while True:\n t, r, c = heappop(q)\n t += 1\n for i, j in ((r-1,c), (r+1,c), (r, c-1), (r, c+1)):\n if i<0 or i>=m or j<0 or j>=n or grid[i][j] == -1: continue\n when = max(t, grid[i][j] + (1 if (t+grid[i][j])%2 else 0 ) )\n if i == m-1 and j == n-1: return when\n heappush(q, (when, i, j))\n grid[i][j] = -1","runtime":"1324"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if not grid or not grid[0] or (grid[0][1] > 1 and grid[1][0] > 1):\n return -1\n\n rows, cols = len(grid), len(grid[0])\n directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]\n pq = [(0, 0, 0)] # (time, row, col)\n visited = [[float(\"inf\")] * cols for _ in range(rows)]\n visited[0][0] = 0\n\n while pq:\n time, r, c = heappop(pq)\n\n if r == rows - 1 and c == cols - 1:\n return time\n\n for dr, dc in directions:\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n # Calculate the earliest time we can visit the cell\n new_time = time + 1\n if new_time < grid[nr][nc]:\n new_time = (\n grid[nr][nc]\n if (grid[nr][nc] - new_time) % 2 == 0\n else grid[nr][nc] + 1\n )\n if new_time < visited[nr][nc]:\n visited[nr][nc] = new_time\n heappush(pq, (new_time, nr, nc))\n\n return -1\n","runtime":"1324"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n rows,cols=len(grid),len(grid[0])\n \n if grid[0][1]>1 and grid[1][0]>1:\n return -1\n \n visited=[[False for i in range(cols)] for i in range(rows)]\n \n # curtime, cell\n pq=[(0,0,0)]\n heapq.heapify(pq)\n \n while pq:\n curTime,x,y=heapq.heappop(pq)\n if x==rows-1 and y==cols-1:\n return curTime\n for di in [(0,1),(0,-1),(1,0),(-1,0)]:\n nx=x+di[0]\n ny=y+di[1]\n \n if not (0<=nx<rows and 0<=ny<cols):\n continue\n if visited[nx][ny]:\n continue\n diff=grid[nx][ny]-curTime\n wait= 1 if (diff%2==0) else 0\n \n heapq.heappush(pq, ((max(curTime+1,grid[nx][ny]+wait), nx,ny)) )\n visited[nx][ny]=True\n return -1 \n \n \n \n \n \n \n \n \n \n \n \n \n ","runtime":"1342"},{"code":"import heapq\nfrom typing import List\n\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n\n if (grid[0][1] > 1 and grid[1][0] > 1):\n return -1\n \n pq = [(0, 0, 0)]\n min_time = [[float('inf')] * n for _ in range(m)]\n min_time[0][0] = 0\n \n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n\n while pq:\n current_time, r, c = heapq.heappop(pq)\n \n if r == m-1 and c == n-1:\n return current_time\n \n for dr, dc in directions:\n nr, nc = r + dr, c + dc\n \n if 0 <= nr < m and 0 <= nc < n:\n next_time = current_time + 1\n \n if grid[nr][nc] > next_time:\n wait_time = grid[nr][nc] - next_time\n if wait_time % 2 == 1:\n wait_time += 1\n else:\n wait_time = 0\n \n new_time = next_time + wait_time\n \n if new_time < min_time[nr][nc]:\n min_time[nr][nc] = new_time\n heapq.heappush(pq, (new_time, nr, nc))\n \n return -1","runtime":"1361"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n dist = [[inf] * n for _ in range(m)]\n dist[0][0] = 0\n q = [(0, 0, 0)]\n dirs = (-1, 0, 1, 0, -1)\n while 1:\n t, i, j = heappop(q)\n if i == m - 1 and j == n - 1:\n return t\n for a, b in pairwise(dirs):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n:\n nt = t + 1\n if nt < grid[x][y]:\n nt = grid[x][y] + (grid[x][y] - nt) % 2\n if nt < dist[x][y]:\n dist[x][y] = nt\n heappush(q, (nt, x, y))","runtime":"1380"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n n = len(grid)\n m = len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = set()\n visited.add((0,0))\n heap = [(0,0,0)]\n moves = ((-1,0),(1,0),(0,-1),(0,1))\n while heap:\n node = heappop(heap)\n time = node[0]\n r = node[1]\n c = node[2]\n if r == n-1 and c == m-1:\n return time\n for x,y in moves:\n row = r+x\n col = c+y\n if 0<=row<n and 0<=col<m and (row,col) not in visited:\n visited.add((row,col))\n if grid[row][col] <= node[0]:\n heappush(heap,(time+1,row,col))\n elif (grid[row][col] - node[0]) % 2 == 0:\n heappush(heap,(grid[row][col]+1,row,col))\n else:\n heappush(heap,(grid[row][col],row,col))","runtime":"1398"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n dist = [[inf] * n for _ in range(m)]\n dist[0][0] = 0\n q = [(0, 0, 0)]\n dirs = (-1, 0, 1, 0, -1)\n while 1:\n t, i, j = heappop(q)\n if i == m - 1 and j == n - 1:\n return t\n for a, b in pairwise(dirs):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n:\n nt = t + 1\n if nt < grid[x][y]:\n nt = grid[x][y] + (grid[x][y] - nt) % 2\n if nt < dist[x][y]:\n dist[x][y] = nt\n heappush(q, (nt, x, y))","runtime":"1417"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n dist = [[inf] * n for _ in range(m)]\n dist[0][0] = 0\n q = [(0, 0, 0)]\n dirs = (-1, 0, 1, 0, -1)\n while 1:\n t, i, j = heappop(q)\n if i == m - 1 and j == n - 1:\n return t\n for a, b in pairwise(dirs):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n:\n nt = t + 1\n if nt < grid[x][y]:\n nt = grid[x][y] + (grid[x][y] - nt) % 2\n if nt < dist[x][y]:\n dist[x][y] = nt\n heappush(q, (nt, x, y))","runtime":"1435"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = set((0, 0))\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n or (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))\n ","runtime":"1454"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # base\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n m, n = len(grid), len(grid[0])\n\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\n visited = {(0, 0)} # trace back visited cell\n\n while minhpq:\n time, i, j = heappop(minhpq)\n\n # stop; found a solution\n if i == m - 1 and j == n - 1:\n return time\n\n for di, dj in dirs:\n di, dj = i + di, j + dj\n \n # pass; infeasible or seen before\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\n continue\n\n # wait is at max 1 to move from (i, j) to (di, dj)\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\n\n # take the max for the next possible valid time\n next_time = max(time + 1, grid[di][dj] + wait)\n\n # push the new cell into min heap\n heappush(minhpq, (next_time, di, dj))\n visited.add((di, dj))\n\n return -1","runtime":"1473"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","runtime":"1473"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","runtime":"1491"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # base\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n m, n = len(grid), len(grid[0])\n\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\n visited = {(0, 0)} # trace back visited cell\n\n while minhpq:\n time, i, j = heappop(minhpq)\n\n # stop; found a solution\n if i == m - 1 and j == n - 1:\n return time\n\n for di, dj in dirs:\n di, dj = i + di, j + dj\n \n # pass; infeasible or seen before\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\n continue\n\n # wait is at max 1 to move from (i, j) to (di, dj)\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\n\n # take the max for the next possible valid time\n next_time = max(time + 1, grid[di][dj] + wait)\n\n # push the new cell into min heap\n heappush(minhpq, (next_time, di, dj))\n visited.add((di, dj))\n\n return -1","runtime":"1510"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m=len(grid)\n n=len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n heap=[(0,0,0)]\n directions=[[-1,0],[1,0],[0,1],[0,-1]]\n visit=set()\n visit.add((0,0))\n while heap:\n d,r,c=heapq.heappop(heap)\n if r==m-1 and c==n-1:\n return d\n # d+=1\n for dx,dy in directions:\n row=dx+r\n col=dy+c\n if row<0 or row==m or col<0 or col==n or (row,col) in visit :\n continue\n wait = 1 if (grid[row][col] - d) % 2 == 0 else 0\n time = max(d + 1, grid[row][col] + wait)\n visit.add((row,col))\n heapq.heappush(heap,(time,row,col))\n return -1\n","runtime":"1510"},{"code":"import heapq\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n n,m = len(grid),len(grid[0])\n dirc = [(-1,0), (0,1), (1,0), (0,-1)]\n dist = [[float('inf')]*m for _ in range(n)]\n pq = [(0,0,0)]\n dist[0][0] = 0\n isValid = lambda nr,nc: nr >= 0 and nr<n and nc >= 0 and nc < m\n while pq:\n time,row,col = heapq.heappop(pq)\n if row == n-1 and col == m-1: \n return time\n for delRow,delCol in dirc:\n nr = delRow+row\n nc = delCol+col\n if isValid(nr,nc):\n if 1+time >= grid[nr][nc]:\n if dist[nr][nc] > 1+time:\n dist[nr][nc] = time+1\n heapq.heappush(pq,(1+time,nr,nc))\n else:\n diff = grid[nr][nc]-time\n if diff&1 == 0: diff += 1\n if dist[nr][nc] > time+diff:\n dist[nr][nc] = time+diff\n heapq.heappush(pq,(time+diff,nr,nc))\n return -1","runtime":"1529"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n fringe = [(0, 0, 0)] #time, row, col\n heapq.heapify(fringe)\n\n seen = {(0, 0)} #(row, col)\n\n # max_val = max(max(row) for row in grid)\n # max_t = max_val + len(grid) + len(grid[0])\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\n return -1\n\n while fringe:\n t, r, c = heapq.heappop(fringe)\n # if t >= max_t:\n # continue\n\n # new_t = t + 1\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if new_r < 0 or new_r >= len(grid):\n continue\n if new_c < 0 or new_c >= len(grid[r]):\n continue\n\n if grid[new_r][new_c] <= t+1:\n new_t = t+1\n else:\n diff = grid[new_r][new_c] - t\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\n\n if (new_r, new_c) in seen:\n continue\n\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\n return new_t\n\n\n heapq.heappush(fringe, (new_t, new_r, new_c))\n seen.add((new_r, new_c))\n\n return -1","runtime":"1529"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","runtime":"1547"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # base\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n m, n = len(grid), len(grid[0])\n\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\n visited = {(0, 0)}\n\n while minhpq:\n time, i, j = heappop(minhpq)\n\n # stop; found a solution\n if i == m - 1 and j == n - 1:\n return time\n\n for di, dj in dirs:\n di, dj = i + di, j + dj\n \n # pass; infeasible or seen before\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\n continue\n\n # wait is at max 1 to move from (i, j) to (di, dj)\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\n\n # take the max for the next possible valid time\n next_time = max(time + 1, grid[di][dj] + wait)\n\n # push the new cell into min heap\n heappush(minhpq, (next_time, di, dj))\n visited.add((di, dj))\n\n return -1","runtime":"1547"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n heap = [(0, 0, 0)]\n visited = {(0, 0)}\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n visited.add((nr, nc))\n return -1","runtime":"1566"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n rowLen, colLen = len(grid), len(grid[0])\n moves = ((0, 1), (1, 0), (0, -1), (-1, 0))\n heap = [(0, (0, 0))]\n visited = {(0, 0)}\n\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\n\n while heap:\n time, (x, y) = heapq.heappop(heap)\n if x == rowLen - 1 and y == colLen - 1:\n return time\n for move in moves:\n newX, newY = x + move[0], y + move[1]\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\n if grid[newX][newY] <= time + 1:\n heapq.heappush(heap, (time + 1, (newX, newY)))\n elif canMove:\n timeNeeded = grid[newX][newY] - time - 1\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\n heapq.heappush(heap, (totalTime, (newX, newY)))\n visited.add((newX, newY))\n return -1","runtime":"1566"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","runtime":"1584"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\n\n m, n = len(grid), len(grid[0])\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\n dis = [[inf for _ in range(n)] for _ in range(m)]\n dis[0][0] = 0\n h = [(0, 0, 0)]\n while h:\n d, i, j = heapq.heappop(h)\n if i == m - 1 and j == n - 1:\n return d\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\n if 0 <= x < m and 0 <= y < n:\n nd = max(d + 1, grid[x][y])\n nd += (nd - x - y) % 2\n if nd < dis[x][y]:\n dis[x][y] = nd\n heappush(h, (nd, x, y))\n\n ","runtime":"1584"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n fringe = [(0, 0, 0)] #time, row, col\n heapq.heapify(fringe)\n\n seen = {(0, 0)} #(row, col)\n\n # max_val = max(max(row) for row in grid)\n # max_t = max_val + len(grid) + len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n while fringe:\n t, r, c = heapq.heappop(fringe)\n # if t >= max_t:\n # continue\n\n # new_t = t + 1\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if new_r < 0 or new_r >= len(grid):\n continue\n if new_c < 0 or new_c >= len(grid[r]):\n continue\n\n if grid[new_r][new_c] <= t+1:\n new_t = t+1\n else:\n diff = grid[new_r][new_c] - t\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\n\n if (new_r, new_c) in seen:\n continue\n\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\n return new_t\n\n\n heapq.heappush(fringe, (new_t, new_r, new_c))\n seen.add((new_r, new_c))\n\n return -1","runtime":"1603"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n rowLen, colLen = len(grid), len(grid[0])\n heap = [(0, (0, 0))] # time, (x, y)\n visited = {(0, 0)}\n\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\n\n while heap:\n time, (x, y) = heapq.heappop(heap)\n if x == rowLen - 1 and y == colLen - 1:\n return time\n\n for move in moves:\n newX, newY = x + move[0], y + move[1]\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\n if grid[newX][newY] <= time + 1:\n heapq.heappush(heap, (time + 1, (newX, newY)))\n elif canMove:\n timeNeeded = grid[newX][newY] - time - 1\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\n heapq.heappush(heap, (totalTime, (newX, newY)))\n visited.add((newX, newY))\n return -1\n","runtime":"1603"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1","runtime":"1622"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1\n","runtime":"1640"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1","runtime":"1659"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/2500-2599/2577.Minimum%20Time%20to%20Visit%20a%20Cell%20In%20a%20Grid\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1\n ","runtime":"1677"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n if mem[(r, c)] < t:\n continue\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n else:\n nt = grid[nr][nc] + ((t + 1) % 2 != grid[nr][nc] % 2)\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n return -1\n","runtime":"1696"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m = len(grid)\n n = len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n visited = [[False] * n for _ in range(m)]\n\n queue = [(0, 0, 0)] # time, i ,j\n\n while queue:\n time, i, j = heappop(queue)\n if [i, j] == [m-1, n-1]:\n return time\n if visited[i][j]:\n continue\n visited[i][j] = True\n for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n newi = i + di\n newj = j + dj\n if 0 <= newi < m and 0 <= newj < n and not visited[newi][newj]:\n if grid[newi][newj] <= time + 1:\n heappush(queue, (time+1, newi, newj))\n else:\n diff = grid[newi][newj] - time\n if diff%2 == 0:\n heappush(queue, (grid[newi][newj]+1, newi, newj))\n else:\n heappush(queue, (grid[newi][newj], newi, newj))\n \n return -1","runtime":"1696"},{"code":"'''\nO(mn log mn) O(Elogv)\nBrute Force:\nif t >= grid[i][j] then we can use the cell.\nI can go to 4 options at one point. O(n^3), memo of 3d.\nDijkestra's algo: we can go back to the time stamp with min. no. at the same time we can keep the nodes\nwith higher time stamps in the queue as well\nplay ping pong till the time>= the grid value of the target cell.\n'''\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] >1:\n return -1\n vis = set()\n min_heap = [ (grid[0][0], 0, 0) ]\n while min_heap:\n time, x, y = heapq.heappop(min_heap)\n if x == m-1 and y == n-1: return time\n if (x,y) in vis:\n continue\n vis.add((x,y))\n for dx, dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n n_x, n_y = x+dx, y+dy\n n_cost = time + 1\n if 0<=n_x<m and 0<=n_y<n and (n_x, n_y) not in vis:\n if grid[n_x][n_y] >1+time:\n if (grid[n_x][n_y] - time)%2 == 0:\n n_cost = grid[n_x][n_y] + 1\n else:\n n_cost = grid[n_x][n_y]\n heapq.heappush(min_heap, (n_cost, n_x, n_y))\n return -1\n \n \n ","runtime":"1715"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n\n if mem[(r, c)] < t:\n continue\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n elif (t + 1) % 2 == grid[nr][nc] % 2:\n nt = grid[nr][nc]\n else:\n nt = grid[nr][nc] + 1\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n\n return -1\n\n\n\n\n\n","runtime":"1715"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)]\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1","runtime":"1733"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/2500-2599/2577.Minimum%20Time%20to%20Visit%20a%20Cell%20In%20a%20Grid\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1\n ","runtime":"1733"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1","runtime":"1752"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m = len(grid)\n n = len(grid[0])\n PQ = [[0, 0, 0]]\n D = [[-1, 0], [0, -1], [0, 1], [1, 0]]\n times = [[-1 for _ in range(n)] for _ in range(m)]\n times[0][0] = 0\n while PQ:\n time, i, j = heappop(PQ)\n if i == m - 1 and j == n - 1: return time\n for d in D:\n x = i + d[0]\n y = j + d[1]\n if x < 0 or x == m: continue\n if y < 0 or y == n: continue\n if times[x][y] != -1 and times[x][y] <= time + 1: continue\n if grid[x][y] <= time + 1: times[x][y] = time + 1\n else: times[x][y] = grid[x][y] + (grid[x][y] - time - 1) % 2\n heappush(PQ, [times[x][y], x, y])","runtime":"1771"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n\n heap = [(grid[0][0], 0, 0)]\n # visited.add((0, 0))\n\n ans = -1\n\n while heap:\n time, row, col = heapq.heappop(heap)\n\n if row == rows-1 and col == cols-1:\n return time\n \n if (row, col) in visited: continue\n\n visited.add((row, col))\n \n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\n wait = 1 if ((grid[new_row][new_col] - time) % 2 == 0) else 0\n\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\n \n\n\n\n\n\n","runtime":"1789"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\n if grid[dr][dc] > curTime+1:\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","runtime":"1808"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n def bounds(r, c):\n return 0<=r<len(grid) and 0<=c<len(grid[0])\n\n if grid[0][0]+1 < grid[0][1] and grid[0][0]+1 < grid[1][0]:\n return -1 \n\n q = []\n visited = set()\n time = 0\n if grid[0][0] <= time:\n q.append((time,0,0))\n visited.add((0,0))\n res = float(\"inf\")\n while(len(q)):\n # print(q)\n time,r,c = heapq.heappop(q)\n if r == len(grid)-1 and c == len(grid[0])-1:\n return time\n\n for d in [(0,1), (0,-1), (-1, 0), (1,0)]:\n nr, nc = r+d[0],c+d[1]\n # print(r,c, nr,nc)\n if bounds(nr, nc):\n if time >= grid[nr][nc] and (nr,nc) not in visited:\n visited.add((nr,nc))\n heapq.heappush(q, (time+1, nr, nc))\n elif (nr,nc) not in visited:\n visited.add((nr,nc))\n newTime = grid[nr][nc] if (grid[nr][nc]-time) %2 == 1 else grid[nr][nc]+1\n heapq.heappush(q, (newTime, nr, nc))\n \n return -1 if res == float(\"inf\") else res\n\n\n\n \n \n \n ","runtime":"1826"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n seen = set()\n heap = [(0, 0, 0)]\n while heap:\n time, row, col = heapq.heappop(heap)\n if row == m - 1 and col == n - 1:\n return time\n if (row, col) in seen: \n continue\n seen.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in seen:\n if time + 1 >= grid[r][c]:\n heapq.heappush(heap, (time + 1, r, c))\n else:\n wait = 1 if (grid[r][c] - time) % 2 == 0 else 0\n heapq.heappush(heap, (grid[r][c] + wait, r, c))","runtime":"1826"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m,n = len(grid),len(grid[0])\n if grid[0][1]>1 and grid[1][0]>1: return -1 \n Q = [(0,0,0)] #t,i,j\n visited = set()\n while Q:\n t,i,j = heapq.heappop(Q) \n if (i,j) in visited: continue\n visited.add((i,j))\n if i==m-1 and j==n-1: return t\n for [ii,jj] in [[i+1,j],[i,j+1],[i-1,j],[i,j-1]]:\n if (ii,jj) in visited: continue\n if ii<0 or jj<0 or ii>m-1 or jj>n-1: continue\n if t+1<grid[ii][jj]: \n new_t = grid[ii][jj]+(grid[ii][jj]-t+1)%2\n else:\n new_t = t+1 \n heapq.heappush(Q,(new_t,ii,jj)) \n # print(Q)\n return -1\n\n","runtime":"1845"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n \n # If the immediate neighbor (1, 0) or (0, 1) is not reachable, we cannot start the BFS.\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n # Priority queue to store cells with their corresponding times\n heap = [(0, 0, 0)] # (time, row, col)\n visited = set()\n \n while heap:\n time, row, col = heapq.heappop(heap)\n \n # If we reached the bottom-right cell, return the current time\n if row == m - 1 and col == n - 1:\n return time\n \n # If the cell is already visited, skip it\n if (row, col) in visited:\n continue\n visited.add((row, col))\n \n # Add neighboring cells to the heap\n for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n # If the neighboring cell is reachable at the current time + 1, add it to the heap\n if grid[r][c] <= time + 1:\n heapq.heappush(heap, (time + 1, r, c))\n else:\n # If the neighboring cell is not reachable yet, we need to wait until it is\n # The wait time can be calculated as the time required by the cell + 1 if it is odd, or directly + 1 if it is even\n wait_time = grid[r][c] + (1 if grid[r][c] % 2 == time % 2 else 0)\n heapq.heappush(heap, (wait_time, r, c))\n \n # If we haven't found a path to the bottom-right cell, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\nprint(solution.minimumTime(grid)) # Output: 7\n\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\nprint(solution.minimumTime(grid)) # Output: -1","runtime":"1845"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n m, n = len(grid), len(grid[0])\n\n pq = [(0, 0, 0)]\n visited = set()\n\n while pq:\n time, r, c = heappop(pq)\n if r == m - 1 and c == n - 1:\n return time\n if (r, c) in visited:\n continue\n visited.add((r, c))\n # print(visited, pq)\n for dr, dc in [[-1, 0], [1, 0], [0, -1], [0, 1]]:\n new_r, new_c = r + dr, c + dc\n if 0 <= new_r < m and 0 <= new_c < n and (new_r, new_c) not in visited:\n wait = 0 if (grid[new_r][new_c] - time) % 2 else 1\n heappush(pq, (max(time + 1, grid[new_r][new_c] + wait), new_r, new_c))\n \n return time","runtime":"1864"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n\n heap = [(grid[0][0], 0, 0)]\n # visited.add((0, 0))\n\n ans = -1\n\n while heap:\n time, row, col = heapq.heappop(heap)\n\n if row == rows-1 and col == cols-1:\n return time\n \n if (row, col) in visited: continue\n\n visited.add((row, col))\n \n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\n wait = 1 if (grid[new_row][new_col] - time) % 2 == 0 else 0\n\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\n \n\n\n\n\n\n","runtime":"1864"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n length = len(grid[0])\n width = len(grid)\n\n min_time = [[float('inf')] * length for _ in range(width)]\n min_heap = []\n\n min_time[0][0] = 0\n heapq.heappush(min_heap, (0, (0,0))) # (min_time, index)\n\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n while min_heap:\n \n min_t, min_t_index = heapq.heappop(min_heap)\n min_t_x, min_t_y = min_t_index\n if min_t > min_time[min_t_x][min_t_y]: continue\n if min_t_index == (width-1, length-1): return min_t\n\n directions = [(1,0), (-1,0),(0,1),(0,-1)]\n\n for dx, dy in directions:\n next_x = min_t_x + dx\n next_y = min_t_y + dy\n if next_x in range(width) and next_y in range(length):\n cur_time = min_t + 1\n grid_value = grid[next_x][next_y]\n\n if grid_value <= cur_time:\n if cur_time < min_time[next_x][next_y]:\n min_time[next_x][next_y] = cur_time\n heapq.heappush(min_heap, (cur_time, (next_x, next_y)))\n else:\n if (next_x + next_y) % 2 == grid_value % 2:\n if grid_value < min_time[next_x][next_y]:\n min_time[next_x][next_y] = grid_value\n heapq.heappush(min_heap, (grid_value, (next_x, next_y)))\n else:\n if grid_value + 1 < min_time[next_x][next_y]:\n min_time[next_x][next_y] = grid_value + 1\n heapq.heappush(min_heap, (grid_value+1, (next_x, next_y)))","runtime":"1882"},{"code":"from typing import List\nimport heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n heap = [(0, 0, 0)] # time, row, col\n visited = set()\n\n while heap:\n time, row, col = heapq.heappop(heap)\n if (row, col) in visited:\n continue\n visited.add((row, col))\n if row == m - 1 and col == n - 1:\n return time\n for dr, dc in directions:\n new_row, new_col = row + dr, col + dc\n if 0 <= new_row < m and 0 <= new_col < n and (new_row, new_col) not in visited:\n wait_time = max(0, grid[new_row][new_col] - (time + 1))\n if wait_time % 2 == 1:\n wait_time += 1\n heapq.heappush(heap, (time + wait_time + 1, new_row, new_col))\n\n return -1","runtime":"1882"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n #dijikstras, state (max(prevcell+1,nexsteptime)r,c)\n #we pop the next earliest time, and add its adjacent cells. we either make prevt+1 or nxt time as when we can access it\n\n #if nxt time is greater than 1 + cur time,\n # even difference: nxttime +1 :: back,original,nxt 2 -> 3 seconds\n # odd difference: nxttime :: back, orginal,nxt -> 3 = 3 seconds\n\n def inbounds(r,c):\n if r < 0 or c < 0 or r == rows or c == cols:\n return False\n return True\n\n #cant ping pong around\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n rows,cols = len(grid),len(grid[0])\n \n minheap = [(grid[0][0],0,0)]\n \n dirs = [[0,1],[-1,0],[1,0],[0,-1]]\n \n time_to = defaultdict(lambda: float('inf'))\n \n while minheap:\n time,r,c = heapq.heappop(minheap)\n if time_to[(r,c)] < time:\n continue\n \n time_to[(r,c)] = time\n \n if (r,c) == (rows-1,cols-1):\n return time\n \n for dr,dc in dirs:\n nr,nc = dr+r,dc+c\n if not inbounds(nr,nc):\n continue\n\n nxt_time = time + 1 #defacto after next step\n\n if nxt_time < grid[nr][nc]: #if goal cell time to large (ping,pong)\n if (grid[nr][nc] - time)%2:\n nxt_time = grid[nr][nc]\n else:\n nxt_time = grid[nr][nc] + 1\n\n if time_to[(nr,nc)] > nxt_time:\n time_to[(nr,nc)] = nxt_time\n heapq.heappush(minheap,(nxt_time,nr,nc))\n \n return -1 \n \n ","runtime":"1901"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] <= 1 or grid[1][0] <= 1: \n m, n = len(grid), len(grid[0])\n pq = [(0, 0, 0)]\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\n while pq: \n x, i, j = heappop(pq)\n if (i, j) == (m-1, n-1): return x \n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \n if 0 <= ii < m and 0 <= jj < n: \n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \n if dist[ii, jj] > xx: \n heappush(pq, (xx, ii, jj))\n dist[ii, jj] = xx \n return -1 ","runtime":"1919"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \"\"\"\n Intuition:\n - Starting with the first node, we are to look at the adjacent neighbors\n - if the adjacent neighbor is not an edge (fall off the grid) and fit the condition <= t\n - NOTE: that t is the current time step that increment everytime we take a step\n - we then add 1 to our t, \n - We reach the end whe or coordinate reach the bottom right of the graph \n - we then mark the visited node so that we don't have to visit it again\n - if the visited neighboring node is larger than the current condition+1 step\n - we need some way to reverse back to the original cell and recompute the time \n \"\"\"\n\n\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1","runtime":"1919"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R, C = 0, 1\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1","runtime":"1938"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # Return -1 immediately if we can't move at the start\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n m, n = len(grid), len(grid[0])\n dirs = [(0, -1), (0, 1), (1, 0), (-1, 0)]\n visited = set()\n pq = [(0, 0, 0)] # time, row, column\n while pq:\n t, r, c = heapq.heappop(pq)\n if r == m - 1 and c == n - 1:\n return t\n if (r, c) in visited:\n continue\n visited.add((r, c))\n for dx, dy in dirs:\n nx, ny = r + dx, c + dy\n if 0 > nx or nx >= m or 0 > ny or ny >= n or (nx, ny) in visited:\n continue\n wait = 1 if (grid[nx][ny] - t) % 2 == 0 else 0\n nt = max(grid[nx][ny] + wait, t + 1)\n heapq.heappush(pq, (nt, nx, ny))\n return -1\n\n ","runtime":"1938"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n n = len(grid)\n m = len(grid[0])\n\n # Early exit check\n if not (grid[0][1] - grid[0][0] <= 1) and not (grid[1][0] - grid[0][0] <= 1):\n return -1\n\n # Priority queue (min-heap), storing (current_time, row, column)\n pq = [(0, 0, 0)] # Initialize heap with (time, row, column)\n rec = [[float('inf')] * m for _ in range(n)]\n rec[0][0] = 0\n\n # Directions for moving in the grid\n dx = [1, -1, 0, 0]\n dy = [0, 0, 1, -1]\n\n while pq:\n val, r, c = heapq.heappop(pq) # Pop the cell with the smallest current_time\n\n for i in range(4):\n nr = r + dx[i]\n nc = c + dy[i]\n if 0 <= nr < n and 0 <= nc < m:\n diff = grid[nr][nc] - val\n if diff <= 0:\n if rec[nr][nc] > val + 1:\n heapq.heappush(pq, (val + 1, nr, nc))\n rec[nr][nc] = val + 1\n continue\n\n # Adjust diff if it's even\n diff = diff + 1 if diff % 2 == 0 else diff\n if rec[nr][nc] > val + diff:\n heapq.heappush(pq, (val + diff, nr, nc))\n rec[nr][nc] = val + diff\n\n return rec[n - 1][m - 1] if rec[n - 1][m - 1] != float('inf') else -1\n","runtime":"1957"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n #cannot reach destination \n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n m = len(grid)\n n = len(grid[0])\n dirs = [(0,1), (1,0), (-1,0), (0,-1)]\n heap = [(grid[0][0], 0, 0)]\n visited = set((0,0))\n\n while heap: \n curTime, row, col = heapq.heappop(heap)\n if row == m-1 and col == n-1:\n return curTime \n \n if (row,col) in visited: \n continue \n\n visited.add((row,col))\n\n for dirX, dirY in dirs: \n nr = row + dirX\n nc = col + dirY\n\n if nr<0 or nr>=m or nc<0 or nc>=n or (nr,nc) in visited: \n continue \n \n extraTime = 1 if (grid[nr][nc] - curTime) % 2 == 0 else 0\n\n heapq.heappush(heap, (max(grid[nr][nc] + extraTime, curTime + 1), nr, nc))\n return -1 \n \n \n\n \n \n\n ","runtime":"1957"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \"\"\"\n Intuition:\n - Starting with the first node, we are to look at the adjacent neighbors\n - if the adjacent neighbor is not an edge (fall off the grid) and fit the condition <= t\n - NOTE: that t is the current time step that increment everytime we take a step\n - we then add 1 to our t, \n - We reach the end whe or coordinate reach the bottom right of the graph \n - we then mark the visited node so that we don't have to visit it again \n \"\"\"\n\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1\n\n\n","runtime":"1975"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R, C = 0, 1\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1","runtime":"1975"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R, C = 0, 1\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1","runtime":"1994"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: \n return -1\n heap = []\n heapq.heappush(heap, (0, 0, 0))\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n seen = set()\n n = len(grid) - 1\n m = len(grid[0]) - 1\n \n while heap:\n time, r, c = heapq.heappop(heap)\n\n if r == n and c == m:\n return time\n if (r, c) in seen:\n continue\n seen.add((r, c))\n \n for dr, dc in directions:\n nr = r + dr\n nc = c + dc\n \n if (nr, nc) not in seen and nr >= 0 and nr <= n and nc >= 0 and nc <= m:\n wait = 0\n if (grid[nr][nc] - time) % 2 == 0:\n wait = 1\n heapq.heappush(heap, (max(time + 1, grid[nr][nc] + wait), nr, nc)) \n \n ","runtime":"1994"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R, C = 0, 1\n nr, nc = len(grid), len(grid[0])\n\n def get_nx(r, c):\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\n yield r_nx, c_nx\n\n # main\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n start, end = (0, 0), (nr-1, nc-1)\n t_to_cells = defaultdict(set)\n t = 0\n t_to_cells[t].add(start)\n visited = {start}\n while True:\n for r, c in t_to_cells[t]:\n for r_nx, c_nx in get_nx(r, c):\n if (r_nx, c_nx) in visited:\n continue\n if grid[r_nx][c_nx] > t+1:\n t_diff = grid[r_nx][c_nx] - t\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\n else:\n t_nx = t+1\n if (r_nx, c_nx) == end:\n return t_nx\n t_to_cells[t_nx].add((r_nx, c_nx))\n visited.add((r_nx, c_nx))\n t += 1","runtime":"2012"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m=len(grid)\n n=len(grid[0])\n if grid[1][0]>1 and grid[0][1]>1:\n return -1\n minheap=[(0,0,0)]\n seen=set() \n directions=[(0,1),(1,0),(-1,0),(0,-1)]\n while minheap:\n d,r,c=heapq.heappop(minheap)\n if (r,c)==(m-1,n-1):\n return d\n if (r,c) in seen:\n continue\n seen.add((r,c))\n for dr,dc in directions:\n if 0<=r+dr<m and 0<=c+dc<n and (r+dr,c+dc) not in seen:\n if d>=grid[r+dr][c+dc]:\n heapq.heappush(minheap,(d+1,r+dr,c+dc))\n elif (grid[r+dr][c+dc]-d)%2==0:\n heapq.heappush(minheap,(grid[r+dr][c+dc]+1,r+dr,c+dc))\n else:\n heapq.heappush(minheap,(grid[r+dr][c+dc],r+dr,c+dc))","runtime":"2012"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] <= 1 or grid[1][0] <= 1: \n m, n = len(grid), len(grid[0])\n pq = [(0, 0, 0)]\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\n while pq: \n x, i, j = heappop(pq)\n if (i, j) == (m-1, n-1): return x \n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \n if 0 <= ii < m and 0 <= jj < n: \n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \n if dist[ii, jj] > xx: \n heappush(pq, (xx, ii, jj))\n dist[ii, jj] = xx \n return -1","runtime":"2031"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n m = len(grid)\n n = len(grid[0])\n\n moves = [\n (0, 1),\n (0, -1),\n (1, 0),\n (-1, 0),\n ]\n \n heap = [(0, 0, 0)]\n visited = set()\n\n\n while heap:\n curr_time, r, c = heappop(heap)\n if (r, c) in visited:\n continue\n \n if r == m-1 and c == n-1:\n return curr_time\n \n visited.add((r, c))\n for move in moves:\n nr, nc = r + move[0], c + move[1]\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\n ","runtime":"2031"},{"code":"from heapq import heappush,heappop\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R = len(grid)\n C = len(grid[0])\n # Check if there is a path exist\n has_path = False\n for r,c in ((0,1),(1,0)):\n if 0<=r<R and 0<=c<C:\n if grid[r][c] <= 1 :\n has_path = True\n if not has_path : return -1\n heap = [(0,0,0)]\n dist = {}\n dist[(0,0)] = 0\n visited = set()\n while heap:\n _,r,c = heappop(heap)\n if (r,c) in visited: continue\n if r == R-1 and c == C-1:\n break\n visited.add((r,c))\n cur_time = dist[(r,c)]\n for nr,nc in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if (nr,nc) in visited : continue\n if 0<=nr<R and 0<=nc<C:\n cost = None\n if grid[nr][nc] <= cur_time + 1:\n cost = 1\n else:\n cost = grid[nr][nc] - cur_time\n if cost%2 == 0 :\n cost += 1\n if cost:\n if cur_time + cost < dist.get((nr,nc),float('inf')):\n dist[(nr,nc)] = cur_time + cost\n heappush(heap,(dist[(nr,nc)],nr,nc))\n return dist[(R-1,C-1)]","runtime":"2050"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n seen = set()\n pq = [(grid[0][0], 0, 0)]\n while pq:\n time, row, col = heappop(pq)\n if row == m - 1 and col == n - 1:\n return time\n if (row, col) in seen: \n continue\n seen.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in seen:\n wait = 1 if (grid[r][c] - time) % 2 == 0 else 0\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))","runtime":"2050"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n m = len(grid)\n n = len(grid[0])\n\n moves = [\n (0, 1),\n (0, -1),\n (1, 0),\n (-1, 0),\n ]\n \n heap = [(0, 0, 0)]\n visited = set([0, 0])\n\n\n while heap:\n curr_time, r, c = heappop(heap)\n if (r, c) in visited:\n continue\n \n if r == m-1 and c == n-1:\n return curr_time\n \n visited.add((r, c))\n for move in moves:\n nr, nc = r + move[0], c + move[1]\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\n \n return -1","runtime":"2068"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n DX = [0, 1, 0, -1]\n DY = [-1, 0, 1, 0]\n row = len(grid)\n col = len(grid[0])\n\n pq = []\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\n\n vis = [[0 for i in range(col)] for i in range(row)]\n\n while pq:\n d, i, j = heapq.heappop(pq)\n \n if (i == (row - 1)) and (j == (col - 1)):\n return d\n\n if vis[i][j] == 1:\n continue\n vis[i][j] = 1\n\n\n if i == 0 and j == 0:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n for k in range(4):\n ni = i + DX[k]\n nj = j + DY[k]\n\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\n if d + 1 >= grid[ni][nj]:\n heapq.heappush(pq, ((d + 1), ni, nj))\n else:\n diff = grid[ni][nj] - d\n extra = 1 if diff % 2 == 0 else 0\n\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\n\n return -1","runtime":"2068"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:return -1\n m, n = len(grid), len(grid[0])\n visit = set()\n pq = [(grid[0][0], 0, 0)]\n\n while pq:\n time, row, col = heappop(pq)\n if row == m - 1 and col == n-1:return time \n if (row, col) in visit:continue\n visit.add((row, col))\n for dr, dc in [[0, 1], [1, 0], [0, -1], [-1, 0]]:\n r, c = row + dr, col + dc \n if 0 <= r < m and 0 <= c < n and (r, c) not in visit:\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0 \n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\n ","runtime":"2087"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n\n if mem[(r, c)] < t:\n continue\n print(t, r, c)\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n elif (t + 1) % 2 == grid[nr][nc] % 2:\n nt = grid[nr][nc]\n else:\n nt = grid[nr][nc] + 1\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n\n return -1\n\n\n\n\n\n","runtime":"2087"},{"code":"from heapq import heappush, heappop\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1: \n return -1\n heap = [(0,0,0)]\n visited = set()\n while heap:\n d, i, j = heappop(heap)\n if (i, j) in visited: continue\n visited.add((i,j))\n if (i, j) == (m-1, n-1): return d\n for di, dj in [[-1,0], [1,0], [0,-1], [0,1]]:\n if 0 <= i + di < m and 0 <= j + dj < n and (i + di, j + dj) not in visited:\n t = grid[i+di][j+dj]\n gap = max(t-(d+1), 0)\n heappush(heap, (d + 1 + gap + (gap%2), i + di, j + dj))","runtime":"2106"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n R,C = len(grid), len(grid[0])\n self.mn = float('inf')\n directions = [(1,0), (0,1), (-1,0), (0,-1)]\n\n heap = [(grid[0][0], 0, 0)]\n visited = set()\n while heap:\n t, r, c = heappop(heap)\n\n if (r,c) == (R-1,C-1): return t\n\n if (r,c) in visited: continue\n\n visited.add((r,c))\n\n for dr,dc in directions:\n nr, nc = r+dr, c+dc\n\n if nr < 0 or nr > R - 1 or nc < 0 or nc > C - 1 or (nr,nc) in visited:\n continue\n \n heappush(heap, (max(t+1, grid[nr][nc] + (1 if (grid[nr][nc] - t) % 2 == 0 else 0)), nr, nc))\n \n\n ","runtime":"2106"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n R,C = len(grid), len(grid[0])\n self.mn = float('inf')\n directions = [(1,0), (0,1), (-1,0), (0,-1)]\n\n heap = [(grid[0][0], 0, 0)]\n visited = set()\n while heap:\n t, r, c = heappop(heap)\n\n if (r,c) == (R-1,C-1): return t\n\n if (r,c) in visited: continue\n\n visited.add((r,c))\n\n for dr,dc in directions:\n nr, nc = r+dr, c+dc\n\n if nr < 0 or nr > R - 1 or nc < 0 or nc > C - 1 or (nr,nc) in visited:\n continue\n \n heappush(heap, (max(t+1, grid[nr][nc] + (1 if (grid[nr][nc] - t) % 2 == 0 else 0)), nr, nc))\n \n\n ","runtime":"2124"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n '''\n * top left to bottom in right in minimum time -> each move is 1 second.. \n * can move to a cell only if grid[i][j] time has elapsed.. \n * in each move.. the ball must be moved somewhere.. so If I didn't meet the 'elapsed' time for the neigboring.. I have to keep bouncing from where I came from to my current position.. till I can move to the next position..\n ====\n * min time -> djikstras? \n * how many time will I have to bounce? \n * each bounce to previous will elapse me 1 second.. so If the time gap is even.. I bounce even number of times between where I came from and current.. basically at the exact time 't' required to make a move.. I will be at the same current cell (because even bounces) and I need to take one more bounce to move to the new adjacent for which I met the time 'elapsed time' requirement.. \n * but if the time gap is odd.. then I bounce till the closest even.. end up in the same spot as current cell.. and then already made a move to the neighboring cell.. so need to take an extra bounce.. \n '''\n if grid[0][1] > 1 and grid[1][0] > 1: return -1 # edge case.. I must make a move! but if both right and down to the starting cell needs over a second.. there is no where for me to bounce (I cant bounce in the same cell..).. so no way I can make even the first move..\n start_time = grid[0][0]\n pq = [(start_time, 0, 0)]\n seen = set()\n while pq: \n t, i, j = heapq.heappop(pq)\n if i == len(grid)-1 and j == len(grid[0])-1: return t # reached the end.. \n if (i, j) in seen: continue # if seen, continue\n seen.add((i, j))\n for di, dj in [[-1, 0], [0, 1], [1, 0], [0, -1]]: \n ni, nj = i + di, j + dj\n if 0 <= ni < len(grid) and 0 <= nj < len(grid[0]) and (ni, nj) not in seen: \n time_gap = grid[ni][nj] - t # ie., number of bounces I need to make till I meet the time elapsed requirement.. \n need_one_extra = 0\n if time_gap % 2 == 0: \n need_one_extra = 1 # need extra bounce\n # else: # redundant; no extra step necessary for odd bounces.. I can make the final bounce to nei directly..\n # need_one_extra = 0 \n heapq.heappush(pq, (max(t + 1, grid[ni][nj] + need_one_extra), ni, nj)) # wait or t + 1.. the max of both is the time it will take me to take this next step and get to (ni, nj)\n \n return -1 ","runtime":"2143"},{"code":"from heapq import heappush, heappop\nfrom typing import List\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n m, n = len(grid), len(grid[0])\n heap = [(0, 0, 0)] # time, row, col\n visited = set()\n \n while heap:\n time, row, col = heappop(heap)\n \n if (row, col) in visited:\n continue\n visited.add((row, col))\n \n if (row, col) == (m - 1, n - 1):\n return time\n \n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n wait = (grid[r][c] - time) % 2 == 0 # ensure parity\n heappush(heap, (max(time + 1, grid[r][c] + wait), r, c))\n \n return -1","runtime":"2161"},{"code":"import heapq\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n rows = len(grid)\n cols = len(grid[0])\n \n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\n time_to_reach[0][0] = 0\n \n q = [(0, 0, 0)] # (time, row, col)\n \n neighbours = [\n (0, 1),\n (1, 0),\n (0, -1),\n (-1, 0)\n ]\n \n while q:\n cur_time, cur_row, cur_col = heapq.heappop(q)\n \n for dr, dc in neighbours:\n r, c = cur_row + dr, cur_col + dc\n if r < 0 or r >= rows or c < 0 or c >= cols:\n continue\n \n wait_time = max(0, grid[r][c] - cur_time - 1)\n if wait_time % 2 != 0:\n wait_time += 1\n \n new_time = cur_time + wait_time + 1\n if time_to_reach[r][c] > new_time:\n time_to_reach[r][c] = new_time\n heapq.heappush(q, (new_time, r, c))\n \n return time_to_reach[rows-1][cols-1]\n","runtime":"2161"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if len(grid) > 1 and len(grid[0]) > 1: \n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n elif len(grid) > 1 and grid[1][0] > 1:\n return -1\n elif len(grid[0]) > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == 1:\n if grid[a][b] % 2 == 1:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][1] > nexto:\n shortests[a][b][1] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][1] > nexto:\n shortests[a][b][1] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n if grid[a][b] % 2 == 1:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][0] > nexto:\n shortests[a][b][0] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][0] > nexto:\n shortests[a][b][0] = nexto\n heappush(prioQ, (nexto, a, b))\n return -1\n\n ","runtime":"2180"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n ## adjusted Dijkstra's algo\n if grid[1][0] > 1 and grid[0][1] > 1: \n return -1\n import heapq\n from collections import defaultdict\n m, n = len(grid), len(grid[0])\n dis = defaultdict(lambda: float('inf'))\n dis[(0, 0)] = 0\n queue = [[0, (0, 0)]]\n heapq.heapify(queue)\n seen = set()\n directions = [\n [-1, 0], \n [1, 0], \n [0, -1], \n [0, 1]\n ]\n while queue: \n dis_curr, (x, y) = heapq.heappop(queue)\n seen.add((x, y))\n if x == m - 1 and y == n - 1: \n return dis_curr\n for dx, dy in directions: \n xx = x + dx\n yy = y + dy\n if 0 <= xx < m and 0 <= yy < n: \n if dis_curr + 1 >= grid[xx][yy]: \n if dis_curr + 1 < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\n else: \n diff = grid[xx][yy] - (dis_curr + 1)\n if diff % 2 == 1: \n diff += 1\n if dis_curr + 1 + diff < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1 + diff\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\n \n return -1 \n \n \n ","runtime":"2199"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == grid[a][b] % 2:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][grid[a][b] % 2] > nexto:\n shortests[a][b][grid[a][b] % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][(currTime+1) % 2] > nexto:\n shortests[a][b][(currTime+1) % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n\n ","runtime":"2217"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if len(grid) > 1 and len(grid[0]) > 1: \n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n elif len(grid) > 1 and grid[1][0] > 1:\n return -1\n elif len(grid[0]) > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == grid[a][b] % 2:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][grid[a][b] % 2] > nexto:\n shortests[a][b][grid[a][b] % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][(currTime+1) % 2] > nexto:\n shortests[a][b][(currTime+1) % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n return -1\n\n ","runtime":"2217"},{"code":"class Solution:\n def minimumTime(self, matrix: List[List[int]]) -> int:\n m = len(matrix)\n n = len(matrix[0])\n if matrix[0][1] > 1 and matrix[1][0] > 1: \n return -1\n \n h = [(matrix[0][0], 0, 0)]\n X = [-1, 0, 1, 0]\n Y = [0, -1, 0, 1]\n res = [[2 ** 31 for i in range (n)] for j in range (m)]\n res[0][0] = matrix[0][0]\n visited = set()\n while h:\n cur_time, curX, curY = heapq.heappop(h)\n if curX == m - 1 and curY == n - 1:\n return cur_time\n if (curX, curY) in visited:\n continue\n visited.add((curX, curY))\n for i in range (4):\n neighborX = curX + X[i]\n neighborY = curY + Y[i]\n if 0 <= neighborX < m and 0 <= neighborY < n and (neighborX, neighborY) not in visited:\n waitTime = 0\n if (matrix[neighborX][neighborY] - cur_time) % 2 == 0:\n waitTime = 1\n res[neighborX][neighborY] = max(cur_time + 1, waitTime + matrix[neighborX][neighborY])\n heapq.heappush(h, (res[neighborX][neighborY], neighborX, neighborY))\n \n return -1\n ","runtime":"2236"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m, n = len(grid), len(grid[0])\n visited = set()\n pq = [(grid[0][0], 0, 0)]\n\n while pq:\n time, row, col = heappop(pq)\n if row == m-1 and col == n-1: return time\n if (row, col) in visited: continue\n visited.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c)) ","runtime":"2236"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n DX = [0, 1, 0, -1]\n DY = [-1, 0, 1, 0]\n row = len(grid)\n col = len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n pq = []\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\n\n vis = [[0 for i in range(col)] for i in range(row)]\n\n while pq:\n d, i, j = heapq.heappop(pq)\n\n if (i == (row - 1)) and (j == (col - 1)):\n return d\n\n if vis[i][j] == 1:\n continue\n vis[i][j] = 1\n\n for k in range(4):\n ni = i + DX[k]\n nj = j + DY[k]\n\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\n if d + 1 >= grid[ni][nj]:\n heapq.heappush(pq, ((d + 1), ni, nj))\n else:\n diff = grid[ni][nj] - d\n extra = 1 if diff % 2 == 0 else 0\n\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\n\n return -1","runtime":"2254"},{"code":"import heapq as hq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n \n nrow = len(grid)\n ncol = len(grid[0])\n\n visited = set()\n heap = [(0,0,0)] # distance, row, col\n\n def helper(distance, row, col):\n newdist = max(distance + 1, grid[row][col])\n if newdist % 2 != (row + col) % 2:\n newdist += 1\n\n hq.heappush(heap, (newdist, row, col))\n\n\n while heap:\n distance, row, col = hq.heappop(heap)\n if (row, col) in visited: continue\n visited.add((row, col))\n if row == nrow - 1 and col == ncol - 1: return distance\n\n if row > 0: helper(distance, row-1, col)\n if row < nrow-1: helper(distance, row+1, col)\n if col > 0: helper(distance, row, col-1)\n if col < ncol - 1: helper(distance, row, col+1)\n\n return -1\n \n","runtime":"2273"},{"code":"import heapq\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n rows = len(grid)\n cols = len(grid[0])\n \n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\n time_to_reach[0][0] = 0\n \n q = [(0, 0, 0)] # (time, row, col)\n \n neighbours = [\n (0, 1),\n (1, 0),\n (0, -1),\n (-1, 0)\n ]\n \n while q:\n cur_time, cur_row, cur_col = heapq.heappop(q)\n \n for dr, dc in neighbours:\n r, c = cur_row + dr, cur_col + dc\n if r < 0 or r >= rows or c < 0 or c >= cols:\n continue\n \n wait_time = max(0, grid[r][c] - cur_time - 1)\n if wait_time % 2 != 0:\n wait_time += 1\n \n new_time = cur_time + wait_time + 1\n if time_to_reach[r][c] > new_time:\n time_to_reach[r][c] = new_time\n heapq.heappush(q, (new_time, r, c))\n \n return time_to_reach[rows-1][cols-1]\n","runtime":"2292"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n DX = [0, 1, 0, -1]\n DY = [-1, 0, 1, 0]\n row = len(grid)\n col = len(grid[0])\n\n pq = []\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\n\n vis = [[0 for i in range(col)] for i in range(row)]\n\n while pq:\n d, i, j = heapq.heappop(pq)\n\n if i == 0 and j == 0:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n if (i == (row - 1)) and (j == (col - 1)):\n return d\n\n if vis[i][j] == 1:\n continue\n vis[i][j] = 1\n\n for k in range(4):\n ni = i + DX[k]\n nj = j + DY[k]\n\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\n if d + 1 >= grid[ni][nj]:\n heapq.heappush(pq, ((d + 1), ni, nj))\n else:\n diff = grid[ni][nj] - d\n extra = 1 if diff % 2 == 0 else 0\n\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\n\n return -1","runtime":"2310"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\n if grid[dr][dc] > curTime+1:\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","runtime":"2329"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # there's one trick:\n # if we are stuck at a cell because all unvisited neighbors \n # have a timestamp which is too high,\n # then we return to the previous cell and return to the current cell again:\n # playing ping-pong ! this requires two steps per iteration.\n # if the difference is high then there's no need to actually perform the moves:\n # we will arrive at the next cell in an odd or even number of steps.\n height = len(grid)\n width = len(grid[0])\n\n # obvious this fail in the very first step\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n todo = [ ( 0, 0, 0 ) ] # min-heap: timestamp, x, y\n deltas = ( 0, +1, 0, -1, 0 ) # compressed deltas\n while todo:\n now, x, y = heappop(todo)\n\n # arrived\n if x == width - 1 and y == height - 1:\n return now\n\n # placeholder, means \"already visited\"\n if grid[y][x] < 0:\n continue\n grid[y][x] = -1\n\n # need one unit to travel\n now += 1\n # hello neighbors !\n for dx, dy in zip(deltas, deltas[1 :]):\n nx = x + dx\n ny = y + dy\n\n if 0 <= nx < width and 0 <= ny < height:\n arrive = max(now, grid[ny][nx])\n # already seen\n if arrive < 0:\n continue\n\n if arrive > now:\n # need to wait\n pingpong = arrive - now\n arrive += pingpong & 1\n\n heappush(todo, ( arrive, nx, ny ))\n\n return -1 # never reached","runtime":"2329"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n ROWS, COLS = len(grid), len(grid[0])\n heap = [(0, 0, 0)]\n visited = set()\n while heap:\n time, row, col = heapq.heappop(heap)\n if row == ROWS - 1 and col == COLS - 1:\n return time\n if (row, col) in visited:\n continue\n visited.add((row, col))\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n r = row + dr\n c = col + dc\n if not 0 <= r < ROWS or not 0 <= c < COLS:\n continue\n if grid[r][c] <= time + 1:\n heapq.heappush(heap, (time + 1, r, c))\n else:\n diff = grid[r][c] - time\n nextTime = grid[r][c]\n if diff % 2 == 0:\n nextTime += 1\n heapq.heappush(heap, (nextTime, r, c))\n ","runtime":"2347"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\n if grid[dr][dc] > curTime+1:\n waitTime = ((grid[dr][dc] - curTime)//2 * 2) + 1\n tt = waitTime + curTime\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n \n return minTime\n\n\n\"\"\"\nq = [(0,0,0)]\n\n\nt+1 >= next -> move\n\nt+1 < next and row and col != 0\n\n\n1 < 5\n1 < 4\n3-1 = 2\n4-1 = 3\n5-1 = 4/2 = 2*2\n5-1 = 4/2= 2*(swap)\n4-1 = 3/2 = 1*(swap)\n\nt + 1swap(2) + 1\nt + 1swap(2) + 1\n\n\"\"\"\n","runtime":"2347"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\n if grid[dr][dc] > curTime+1:\n waitTime = ((grid[dr][dc] - curTime)//2 * 2) + 1\n tt = waitTime + curTime\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","runtime":"2366"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # It is always possible to reach the end as long as we have a valid parent, in the beginning at (0,0) we don't have a valid parent so this position might get blocked otherwise we can always reach.\n \n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n m = len(grid)\n n = len(grid[0])\n start = (0, 0)\n dist = defaultdict(lambda: float('inf'))\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, (0, 0, 0))\n dist[0, 0] = 0\n\n while len(pq) > 0:\n w, x, y = heapq.heappop(pq)\n if dist[x, y] < w: continue\n if (x, y) == (m - 1, n - 1): return dist[x, y]\n\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n for direction in dirs:\n newX, newY = x + direction[0], y + direction[1]\n if 0 <= newX < m and 0 <= newY < n:\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\n dist[newX, newY] = dist[x, y] + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif grid[newX][newY] > dist[x, y] + 1:\n wait = grid[newX][newY] - dist[x, y]\n\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\n dist[newX, newY] = dist[x, y] + wait + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\n dist[newX, newY] = dist[x, y] + wait\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n \n return -1\n","runtime":"2385"},{"code":"from collections import deque\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n seen = set()\n heap = []\n heapq.heappush(heap, [0, 0, 0])\n seen.add((0, 0))\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1]]\n\n def isValid(r, c):\n return 0 <= r < len(grid) and 0 <= c < len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n while heap:\n time, row, col = heapq.heappop(heap)\n if row == len(grid) - 1 and col == len(grid[0]) - 1:\n return time\n \n for dx, dy in directions:\n newRow, newCol = row + dx, col + dy\n if isValid(newRow, newCol):\n if time + 1 >= grid[newRow][newCol] and (newRow, newCol) not in seen:\n heapq.heappush(heap, [time + 1, newRow, newCol])\n elif time + 1 < grid[newRow][newCol]:\n diff = grid[newRow][newCol] - time\n if diff % 2 == 0:\n heapq.heappush(heap, [grid[newRow][newCol] + 1, newRow, newCol])\n else:\n heapq.heappush(heap, [grid[newRow][newCol], newRow, newCol])\n seen.add((newRow, newCol))\n\n return -1\n\n ","runtime":"2403"},{"code":"import heapq as hq\nclass Solution:\n def validCell(self, nRow, nCol, n, m):\n return nRow >= 0 and nRow < n and nCol >= 0 and nCol < m\n\n def minimumTime(self, grid: List[List[int]]) -> int:\n n, m = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n heap = []\n hq.heappush(heap, [0,0,0])\n dist = [[math.inf for _ in range(m)] for _ in range(n)]\n dist[0][0] = 0\n\n delRow = [1,-1,0,0]\n delCol = [0,0,1,-1]\n while heap:\n time, i, j = hq.heappop(heap)\n\n for k in range(4):\n nRow = i + delRow[k]\n nCol = j + delCol[k]\n\n if self.validCell(nRow, nCol, n, m):\n adjEle = grid[nRow][nCol]\n increment = max(1, adjEle - time + ((adjEle - time)%2 == 0))\n currTime = time + increment\n\n if dist[nRow][nCol] > currTime:\n dist[nRow][nCol] = currTime\n hq.heappush(heap, [currTime, nRow, nCol])\n return dist[n-1][m-1]","runtime":"2422"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n m = len(grid)\n n = len(grid[0])\n start = (0, 0)\n dist = defaultdict(lambda: float('inf'))\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, (0, 0, 0))\n dist[0, 0] = 0\n\n while len(pq) > 0:\n w, x, y = heapq.heappop(pq)\n if dist[x, y] < w: continue\n if (x, y) == (m - 1, n - 1): return dist[x, y]\n\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n for direction in dirs:\n newX, newY = x + direction[0], y + direction[1]\n if 0 <= newX < m and 0 <= newY < n:\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\n dist[newX, newY] = dist[x, y] + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif grid[newX][newY] > dist[x, y] + 1:\n wait = grid[newX][newY] - dist[x, y]\n\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\n dist[newX, newY] = dist[x, y] + wait + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\n dist[newX, newY] = dist[x, y] + wait\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n \n return -1\n","runtime":"2441"},{"code":"import heapq\nfrom typing import List\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n \n # If we cannot even start from the top-left cell, return -1\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n # Directions to move in the grid: up, down, left, right\n directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n \n # Min-heap to store the cells to visit, along with the time taken to reach them\n heap = [(0, 0, 0)] # (time, row, col)\n \n # Set to store the visited cells\n visited = set()\n \n while heap:\n time, row, col = heapq.heappop(heap)\n \n # If we have reached the bottom-right cell, return the current time\n if row == m - 1 and col == n - 1:\n return time\n \n # If the cell is already visited, continue\n if (row, col) in visited:\n continue\n \n # Mark the cell as visited\n visited.add((row, col))\n \n # Explore all adjacent cells\n for dr, dc in directions:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n:\n # Calculate the waiting time if needed\n wait_time = (grid[r][c] - time) % 2 == 0\n new_time = max(time + 1, grid[r][c] + wait_time)\n heapq.heappush(heap, (new_time, r, c))\n \n # If we cannot reach the bottom-right cell, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\nprint(solution.minimumTime(grid)) # Output: 7\n\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\nprint(solution.minimumTime(grid)) # Output: -1","runtime":"2459"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m, n = len(grid), len(grid[0])\n visited = set()\n pq = [(grid[0][0], 0, 0)]\n \n while pq:\n time, row, col = heappop(pq)\n if row == m-1 and col == n-1: return time\n if (row, col) in visited: continue\n visited.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\n return -1\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n\n tgt = (m-1, n-1)\n src = (0, 0)\n\n que = [(0, src)]\n seen = defaultdict(int)\n seen[src] = 0\n\n if grid[0][0] > 0: return -1\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n while que:\n cur_time, (x,y) = heappop(que) \n if (x, y) == tgt: return cur_time\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n xx, yy = dx + x, dy + y\n\n if 0<= xx < m and 0 <= yy < n and ((xx, yy) not in seen or seen[(xx, yy)] > cur_time + 1):\n #update the modified origin if there is one\n tmp = cur_time\n modified_origin = False\n if tmp + 1 < grid[xx][yy]:\n tmp = (grid[xx][yy] - 1) if (grid[xx][yy] - 1 - tmp) %2 == 0 else grid[xx][yy]\n modified_origin = True\n\n if tmp + 1 >= grid[xx][yy] and ((xx, yy) not in seen or seen[(xx, yy)] > tmp +1):\n seen[(xx, yy)] = tmp + 1\n heappush(que, (tmp + 1, (xx, yy)))\n\n if modified_origin:\n heappush(que, (tmp, (x, y)))\n return -1\n\n","runtime":"2478"},{"code":"from collections import deque\nfrom itertools import starmap\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\n visited = set()\n rows = len(grid)\n cols = len(grid[0])\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\n costs = defaultdict(lambda : float('inf'))\n\n heap = [(0,(0,0))]\n\n\n while heap:\n cur_time, (r,c) = heapq.heappop(heap)\n if (r,c) in visited:\n continue\n visited.add((r,c))\n if (r,c) == (rows-1, cols-1):\n return cur_time\n possible_vertices = valid_movements(r,c)\n for r_nxt, c_nxt in possible_vertices:\n if grid[r_nxt][c_nxt] > cur_time + 1:\n # we need to wait # we can assume we can flip flop between the parent and this cell.\n time_needed = grid[r_nxt][c_nxt] - (cur_time+1)\n flip_flops_needed = time_needed//2 + time_needed%2\n heapq.heappush(heap, (cur_time+1+flip_flops_needed*2, (r_nxt, c_nxt)))\n elif grid[r_nxt][c_nxt] <= cur_time + 1:\n heapq.heappush(heap, (cur_time+1, (r_nxt, c_nxt)))\n \n \n return -1\n \n\n","runtime":"2496"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, [0, 0, 0])\n \n # visited is needed\n visited = [[False]*n for _ in range(m)]\n \n canHold = False\n \n while pq: \n t, r, c = heapq.heappop(pq)\n \n if visited[r][c]:\n continue\n visited[r][c] = True\n\n if r == m-1 and c == n-1:\n return t \n \n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\n \n for r2, c2 in allNbr:\n if t+1 >= grid[r2][c2]:\n canHold = True\n \n \n \n for newR, newC in allNbr:\n if grid[newR][newC] > t+1:\n if not(canHold):\n continue\n diff = grid[newR][newC] - (t+1)\n else:\n diff = 0\n \n stall = math.ceil(diff/2) * 2\n \n heapq.heappush(pq, [t+1+stall, newR, newC])\n \n return -1\n \n ","runtime":"2515"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n q = [(0, 0, 0)]\\n while True:\\n t, r, c = heappop(q)\\n t += 1\\n for i, j in ((r-1,c), (r+1,c), (r, c-1), (r, c+1)):\\n if i<0 or i>=m or j<0 or j>=n or grid[i][j] == -1: continue\\n when = max(t, grid[i][j] + (1 if (t+grid[i][j])%2 else 0 ) )\\n if i == m-1 and j == n-1: return when\\n heappush(q, (when, i, j))\\n grid[i][j] = -1\",\n \"runtime\": \"1324\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if not grid or not grid[0] or (grid[0][1] > 1 and grid[1][0] > 1):\\n return -1\\n\\n rows, cols = len(grid), len(grid[0])\\n directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]\\n pq = [(0, 0, 0)] # (time, row, col)\\n visited = [[float(\\\"inf\\\")] * cols for _ in range(rows)]\\n visited[0][0] = 0\\n\\n while pq:\\n time, r, c = heappop(pq)\\n\\n if r == rows - 1 and c == cols - 1:\\n return time\\n\\n for dr, dc in directions:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n # Calculate the earliest time we can visit the cell\\n new_time = time + 1\\n if new_time < grid[nr][nc]:\\n new_time = (\\n grid[nr][nc]\\n if (grid[nr][nc] - new_time) % 2 == 0\\n else grid[nr][nc] + 1\\n )\\n if new_time < visited[nr][nc]:\\n visited[nr][nc] = new_time\\n heappush(pq, (new_time, nr, nc))\\n\\n return -1\\n\",\n \"runtime\": \"1324\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n rows,cols=len(grid),len(grid[0])\\n \\n if grid[0][1]>1 and grid[1][0]>1:\\n return -1\\n \\n visited=[[False for i in range(cols)] for i in range(rows)]\\n \\n # curtime, cell\\n pq=[(0,0,0)]\\n heapq.heapify(pq)\\n \\n while pq:\\n curTime,x,y=heapq.heappop(pq)\\n if x==rows-1 and y==cols-1:\\n return curTime\\n for di in [(0,1),(0,-1),(1,0),(-1,0)]:\\n nx=x+di[0]\\n ny=y+di[1]\\n \\n if not (0<=nx<rows and 0<=ny<cols):\\n continue\\n if visited[nx][ny]:\\n continue\\n diff=grid[nx][ny]-curTime\\n wait= 1 if (diff%2==0) else 0\\n \\n heapq.heappush(pq, ((max(curTime+1,grid[nx][ny]+wait), nx,ny)) )\\n visited[nx][ny]=True\\n return -1 \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"1342\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n\\n if (grid[0][1] > 1 and grid[1][0] > 1):\\n return -1\\n \\n pq = [(0, 0, 0)]\\n min_time = [[float('inf')] * n for _ in range(m)]\\n min_time[0][0] = 0\\n \\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n\\n while pq:\\n current_time, r, c = heapq.heappop(pq)\\n \\n if r == m-1 and c == n-1:\\n return current_time\\n \\n for dr, dc in directions:\\n nr, nc = r + dr, c + dc\\n \\n if 0 <= nr < m and 0 <= nc < n:\\n next_time = current_time + 1\\n \\n if grid[nr][nc] > next_time:\\n wait_time = grid[nr][nc] - next_time\\n if wait_time % 2 == 1:\\n wait_time += 1\\n else:\\n wait_time = 0\\n \\n new_time = next_time + wait_time\\n \\n if new_time < min_time[nr][nc]:\\n min_time[nr][nc] = new_time\\n heapq.heappush(pq, (new_time, nr, nc))\\n \\n return -1\",\n \"runtime\": \"1361\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n dist = [[inf] * n for _ in range(m)]\\n dist[0][0] = 0\\n q = [(0, 0, 0)]\\n dirs = (-1, 0, 1, 0, -1)\\n while 1:\\n t, i, j = heappop(q)\\n if i == m - 1 and j == n - 1:\\n return t\\n for a, b in pairwise(dirs):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n:\\n nt = t + 1\\n if nt < grid[x][y]:\\n nt = grid[x][y] + (grid[x][y] - nt) % 2\\n if nt < dist[x][y]:\\n dist[x][y] = nt\\n heappush(q, (nt, x, y))\",\n \"runtime\": \"1380\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n n = len(grid)\\n m = len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = set()\\n visited.add((0,0))\\n heap = [(0,0,0)]\\n moves = ((-1,0),(1,0),(0,-1),(0,1))\\n while heap:\\n node = heappop(heap)\\n time = node[0]\\n r = node[1]\\n c = node[2]\\n if r == n-1 and c == m-1:\\n return time\\n for x,y in moves:\\n row = r+x\\n col = c+y\\n if 0<=row<n and 0<=col<m and (row,col) not in visited:\\n visited.add((row,col))\\n if grid[row][col] <= node[0]:\\n heappush(heap,(time+1,row,col))\\n elif (grid[row][col] - node[0]) % 2 == 0:\\n heappush(heap,(grid[row][col]+1,row,col))\\n else:\\n heappush(heap,(grid[row][col],row,col))\",\n \"runtime\": \"1398\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n dist = [[inf] * n for _ in range(m)]\\n dist[0][0] = 0\\n q = [(0, 0, 0)]\\n dirs = (-1, 0, 1, 0, -1)\\n while 1:\\n t, i, j = heappop(q)\\n if i == m - 1 and j == n - 1:\\n return t\\n for a, b in pairwise(dirs):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n:\\n nt = t + 1\\n if nt < grid[x][y]:\\n nt = grid[x][y] + (grid[x][y] - nt) % 2\\n if nt < dist[x][y]:\\n dist[x][y] = nt\\n heappush(q, (nt, x, y))\",\n \"runtime\": \"1417\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n dist = [[inf] * n for _ in range(m)]\\n dist[0][0] = 0\\n q = [(0, 0, 0)]\\n dirs = (-1, 0, 1, 0, -1)\\n while 1:\\n t, i, j = heappop(q)\\n if i == m - 1 and j == n - 1:\\n return t\\n for a, b in pairwise(dirs):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n:\\n nt = t + 1\\n if nt < grid[x][y]:\\n nt = grid[x][y] + (grid[x][y] - nt) % 2\\n if nt < dist[x][y]:\\n dist[x][y] = nt\\n heappush(q, (nt, x, y))\",\n \"runtime\": \"1435\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = set((0, 0))\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n or (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\\n \",\n \"runtime\": \"1454\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # base\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n m, n = len(grid), len(grid[0])\\n\\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\\n visited = {(0, 0)} # trace back visited cell\\n\\n while minhpq:\\n time, i, j = heappop(minhpq)\\n\\n # stop; found a solution\\n if i == m - 1 and j == n - 1:\\n return time\\n\\n for di, dj in dirs:\\n di, dj = i + di, j + dj\\n \\n # pass; infeasible or seen before\\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\\n continue\\n\\n # wait is at max 1 to move from (i, j) to (di, dj)\\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\\n\\n # take the max for the next possible valid time\\n next_time = max(time + 1, grid[di][dj] + wait)\\n\\n # push the new cell into min heap\\n heappush(minhpq, (next_time, di, dj))\\n visited.add((di, dj))\\n\\n return -1\",\n \"runtime\": \"1473\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"runtime\": \"1473\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"runtime\": \"1491\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # base\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n m, n = len(grid), len(grid[0])\\n\\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\\n visited = {(0, 0)} # trace back visited cell\\n\\n while minhpq:\\n time, i, j = heappop(minhpq)\\n\\n # stop; found a solution\\n if i == m - 1 and j == n - 1:\\n return time\\n\\n for di, dj in dirs:\\n di, dj = i + di, j + dj\\n \\n # pass; infeasible or seen before\\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\\n continue\\n\\n # wait is at max 1 to move from (i, j) to (di, dj)\\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\\n\\n # take the max for the next possible valid time\\n next_time = max(time + 1, grid[di][dj] + wait)\\n\\n # push the new cell into min heap\\n heappush(minhpq, (next_time, di, dj))\\n visited.add((di, dj))\\n\\n return -1\",\n \"runtime\": \"1510\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m=len(grid)\\n n=len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n heap=[(0,0,0)]\\n directions=[[-1,0],[1,0],[0,1],[0,-1]]\\n visit=set()\\n visit.add((0,0))\\n while heap:\\n d,r,c=heapq.heappop(heap)\\n if r==m-1 and c==n-1:\\n return d\\n # d+=1\\n for dx,dy in directions:\\n row=dx+r\\n col=dy+c\\n if row<0 or row==m or col<0 or col==n or (row,col) in visit :\\n continue\\n wait = 1 if (grid[row][col] - d) % 2 == 0 else 0\\n time = max(d + 1, grid[row][col] + wait)\\n visit.add((row,col))\\n heapq.heappush(heap,(time,row,col))\\n return -1\\n\",\n \"runtime\": \"1510\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n n,m = len(grid),len(grid[0])\\n dirc = [(-1,0), (0,1), (1,0), (0,-1)]\\n dist = [[float('inf')]*m for _ in range(n)]\\n pq = [(0,0,0)]\\n dist[0][0] = 0\\n isValid = lambda nr,nc: nr >= 0 and nr<n and nc >= 0 and nc < m\\n while pq:\\n time,row,col = heapq.heappop(pq)\\n if row == n-1 and col == m-1: \\n return time\\n for delRow,delCol in dirc:\\n nr = delRow+row\\n nc = delCol+col\\n if isValid(nr,nc):\\n if 1+time >= grid[nr][nc]:\\n if dist[nr][nc] > 1+time:\\n dist[nr][nc] = time+1\\n heapq.heappush(pq,(1+time,nr,nc))\\n else:\\n diff = grid[nr][nc]-time\\n if diff&1 == 0: diff += 1\\n if dist[nr][nc] > time+diff:\\n dist[nr][nc] = time+diff\\n heapq.heappush(pq,(time+diff,nr,nc))\\n return -1\",\n \"runtime\": \"1529\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n fringe = [(0, 0, 0)] #time, row, col\\n heapq.heapify(fringe)\\n\\n seen = {(0, 0)} #(row, col)\\n\\n # max_val = max(max(row) for row in grid)\\n # max_t = max_val + len(grid) + len(grid[0])\\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\\n return -1\\n\\n while fringe:\\n t, r, c = heapq.heappop(fringe)\\n # if t >= max_t:\\n # continue\\n\\n # new_t = t + 1\\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if new_r < 0 or new_r >= len(grid):\\n continue\\n if new_c < 0 or new_c >= len(grid[r]):\\n continue\\n\\n if grid[new_r][new_c] <= t+1:\\n new_t = t+1\\n else:\\n diff = grid[new_r][new_c] - t\\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\\n\\n if (new_r, new_c) in seen:\\n continue\\n\\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\\n return new_t\\n\\n\\n heapq.heappush(fringe, (new_t, new_r, new_c))\\n seen.add((new_r, new_c))\\n\\n return -1\",\n \"runtime\": \"1529\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"runtime\": \"1547\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # base\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n m, n = len(grid), len(grid[0])\\n\\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\\n visited = {(0, 0)}\\n\\n while minhpq:\\n time, i, j = heappop(minhpq)\\n\\n # stop; found a solution\\n if i == m - 1 and j == n - 1:\\n return time\\n\\n for di, dj in dirs:\\n di, dj = i + di, j + dj\\n \\n # pass; infeasible or seen before\\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\\n continue\\n\\n # wait is at max 1 to move from (i, j) to (di, dj)\\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\\n\\n # take the max for the next possible valid time\\n next_time = max(time + 1, grid[di][dj] + wait)\\n\\n # push the new cell into min heap\\n heappush(minhpq, (next_time, di, dj))\\n visited.add((di, dj))\\n\\n return -1\",\n \"runtime\": \"1547\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n heap = [(0, 0, 0)]\\n visited = {(0, 0)}\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n visited.add((nr, nc))\\n return -1\",\n \"runtime\": \"1566\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n rowLen, colLen = len(grid), len(grid[0])\\n moves = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n heap = [(0, (0, 0))]\\n visited = {(0, 0)}\\n\\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\\n\\n while heap:\\n time, (x, y) = heapq.heappop(heap)\\n if x == rowLen - 1 and y == colLen - 1:\\n return time\\n for move in moves:\\n newX, newY = x + move[0], y + move[1]\\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\\n if grid[newX][newY] <= time + 1:\\n heapq.heappush(heap, (time + 1, (newX, newY)))\\n elif canMove:\\n timeNeeded = grid[newX][newY] - time - 1\\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\\n heapq.heappush(heap, (totalTime, (newX, newY)))\\n visited.add((newX, newY))\\n return -1\",\n \"runtime\": \"1566\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"runtime\": \"1584\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\\n\\n m, n = len(grid), len(grid[0])\\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\\n dis = [[inf for _ in range(n)] for _ in range(m)]\\n dis[0][0] = 0\\n h = [(0, 0, 0)]\\n while h:\\n d, i, j = heapq.heappop(h)\\n if i == m - 1 and j == n - 1:\\n return d\\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\\n if 0 <= x < m and 0 <= y < n:\\n nd = max(d + 1, grid[x][y])\\n nd += (nd - x - y) % 2\\n if nd < dis[x][y]:\\n dis[x][y] = nd\\n heappush(h, (nd, x, y))\\n\\n \",\n \"runtime\": \"1584\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n fringe = [(0, 0, 0)] #time, row, col\\n heapq.heapify(fringe)\\n\\n seen = {(0, 0)} #(row, col)\\n\\n # max_val = max(max(row) for row in grid)\\n # max_t = max_val + len(grid) + len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n while fringe:\\n t, r, c = heapq.heappop(fringe)\\n # if t >= max_t:\\n # continue\\n\\n # new_t = t + 1\\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if new_r < 0 or new_r >= len(grid):\\n continue\\n if new_c < 0 or new_c >= len(grid[r]):\\n continue\\n\\n if grid[new_r][new_c] <= t+1:\\n new_t = t+1\\n else:\\n diff = grid[new_r][new_c] - t\\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\\n\\n if (new_r, new_c) in seen:\\n continue\\n\\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\\n return new_t\\n\\n\\n heapq.heappush(fringe, (new_t, new_r, new_c))\\n seen.add((new_r, new_c))\\n\\n return -1\",\n \"runtime\": \"1603\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n rowLen, colLen = len(grid), len(grid[0])\\n heap = [(0, (0, 0))] # time, (x, y)\\n visited = {(0, 0)}\\n\\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\\n\\n while heap:\\n time, (x, y) = heapq.heappop(heap)\\n if x == rowLen - 1 and y == colLen - 1:\\n return time\\n\\n for move in moves:\\n newX, newY = x + move[0], y + move[1]\\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\\n if grid[newX][newY] <= time + 1:\\n heapq.heappush(heap, (time + 1, (newX, newY)))\\n elif canMove:\\n timeNeeded = grid[newX][newY] - time - 1\\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\\n heapq.heappush(heap, (totalTime, (newX, newY)))\\n visited.add((newX, newY))\\n return -1\\n\",\n \"runtime\": \"1603\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\",\n \"runtime\": \"1622\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\\n\",\n \"runtime\": \"1640\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\",\n \"runtime\": \"1659\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/2500-2599/2577.Minimum%20Time%20to%20Visit%20a%20Cell%20In%20a%20Grid\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\\n \",\n \"runtime\": \"1677\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n if mem[(r, c)] < t:\\n continue\\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n else:\\n nt = grid[nr][nc] + ((t + 1) % 2 != grid[nr][nc] % 2)\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n return -1\\n\",\n \"runtime\": \"1696\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m = len(grid)\\n n = len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n visited = [[False] * n for _ in range(m)]\\n\\n queue = [(0, 0, 0)] # time, i ,j\\n\\n while queue:\\n time, i, j = heappop(queue)\\n if [i, j] == [m-1, n-1]:\\n return time\\n if visited[i][j]:\\n continue\\n visited[i][j] = True\\n for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n newi = i + di\\n newj = j + dj\\n if 0 <= newi < m and 0 <= newj < n and not visited[newi][newj]:\\n if grid[newi][newj] <= time + 1:\\n heappush(queue, (time+1, newi, newj))\\n else:\\n diff = grid[newi][newj] - time\\n if diff%2 == 0:\\n heappush(queue, (grid[newi][newj]+1, newi, newj))\\n else:\\n heappush(queue, (grid[newi][newj], newi, newj))\\n \\n return -1\",\n \"runtime\": \"1696\"\n },\n {\n \"code\": \"'''\\nO(mn log mn) O(Elogv)\\nBrute Force:\\nif t >= grid[i][j] then we can use the cell.\\nI can go to 4 options at one point. O(n^3), memo of 3d.\\nDijkestra's algo: we can go back to the time stamp with min. no. at the same time we can keep the nodes\\nwith higher time stamps in the queue as well\\nplay ping pong till the time>= the grid value of the target cell.\\n'''\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] >1:\\n return -1\\n vis = set()\\n min_heap = [ (grid[0][0], 0, 0) ]\\n while min_heap:\\n time, x, y = heapq.heappop(min_heap)\\n if x == m-1 and y == n-1: return time\\n if (x,y) in vis:\\n continue\\n vis.add((x,y))\\n for dx, dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n n_x, n_y = x+dx, y+dy\\n n_cost = time + 1\\n if 0<=n_x<m and 0<=n_y<n and (n_x, n_y) not in vis:\\n if grid[n_x][n_y] >1+time:\\n if (grid[n_x][n_y] - time)%2 == 0:\\n n_cost = grid[n_x][n_y] + 1\\n else:\\n n_cost = grid[n_x][n_y]\\n heapq.heappush(min_heap, (n_cost, n_x, n_y))\\n return -1\\n \\n \\n \",\n \"runtime\": \"1715\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n\\n if mem[(r, c)] < t:\\n continue\\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n elif (t + 1) % 2 == grid[nr][nc] % 2:\\n nt = grid[nr][nc]\\n else:\\n nt = grid[nr][nc] + 1\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n\\n return -1\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"1715\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)]\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\",\n \"runtime\": \"1733\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/2500-2599/2577.Minimum%20Time%20to%20Visit%20a%20Cell%20In%20a%20Grid\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\\n \",\n \"runtime\": \"1733\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\",\n \"runtime\": \"1752\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m = len(grid)\\n n = len(grid[0])\\n PQ = [[0, 0, 0]]\\n D = [[-1, 0], [0, -1], [0, 1], [1, 0]]\\n times = [[-1 for _ in range(n)] for _ in range(m)]\\n times[0][0] = 0\\n while PQ:\\n time, i, j = heappop(PQ)\\n if i == m - 1 and j == n - 1: return time\\n for d in D:\\n x = i + d[0]\\n y = j + d[1]\\n if x < 0 or x == m: continue\\n if y < 0 or y == n: continue\\n if times[x][y] != -1 and times[x][y] <= time + 1: continue\\n if grid[x][y] <= time + 1: times[x][y] = time + 1\\n else: times[x][y] = grid[x][y] + (grid[x][y] - time - 1) % 2\\n heappush(PQ, [times[x][y], x, y])\",\n \"runtime\": \"1771\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n\\n heap = [(grid[0][0], 0, 0)]\\n # visited.add((0, 0))\\n\\n ans = -1\\n\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n\\n if row == rows-1 and col == cols-1:\\n return time\\n \\n if (row, col) in visited: continue\\n\\n visited.add((row, col))\\n \\n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\\n wait = 1 if ((grid[new_row][new_col] - time) % 2 == 0) else 0\\n\\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\\n \\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"1789\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\\n if grid[dr][dc] > curTime+1:\\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"runtime\": \"1808\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n def bounds(r, c):\\n return 0<=r<len(grid) and 0<=c<len(grid[0])\\n\\n if grid[0][0]+1 < grid[0][1] and grid[0][0]+1 < grid[1][0]:\\n return -1 \\n\\n q = []\\n visited = set()\\n time = 0\\n if grid[0][0] <= time:\\n q.append((time,0,0))\\n visited.add((0,0))\\n res = float(\\\"inf\\\")\\n while(len(q)):\\n # print(q)\\n time,r,c = heapq.heappop(q)\\n if r == len(grid)-1 and c == len(grid[0])-1:\\n return time\\n\\n for d in [(0,1), (0,-1), (-1, 0), (1,0)]:\\n nr, nc = r+d[0],c+d[1]\\n # print(r,c, nr,nc)\\n if bounds(nr, nc):\\n if time >= grid[nr][nc] and (nr,nc) not in visited:\\n visited.add((nr,nc))\\n heapq.heappush(q, (time+1, nr, nc))\\n elif (nr,nc) not in visited:\\n visited.add((nr,nc))\\n newTime = grid[nr][nc] if (grid[nr][nc]-time) %2 == 1 else grid[nr][nc]+1\\n heapq.heappush(q, (newTime, nr, nc))\\n \\n return -1 if res == float(\\\"inf\\\") else res\\n\\n\\n\\n \\n \\n \\n \",\n \"runtime\": \"1826\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n seen = set()\\n heap = [(0, 0, 0)]\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n if row == m - 1 and col == n - 1:\\n return time\\n if (row, col) in seen: \\n continue\\n seen.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in seen:\\n if time + 1 >= grid[r][c]:\\n heapq.heappush(heap, (time + 1, r, c))\\n else:\\n wait = 1 if (grid[r][c] - time) % 2 == 0 else 0\\n heapq.heappush(heap, (grid[r][c] + wait, r, c))\",\n \"runtime\": \"1826\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m,n = len(grid),len(grid[0])\\n if grid[0][1]>1 and grid[1][0]>1: return -1 \\n Q = [(0,0,0)] #t,i,j\\n visited = set()\\n while Q:\\n t,i,j = heapq.heappop(Q) \\n if (i,j) in visited: continue\\n visited.add((i,j))\\n if i==m-1 and j==n-1: return t\\n for [ii,jj] in [[i+1,j],[i,j+1],[i-1,j],[i,j-1]]:\\n if (ii,jj) in visited: continue\\n if ii<0 or jj<0 or ii>m-1 or jj>n-1: continue\\n if t+1<grid[ii][jj]: \\n new_t = grid[ii][jj]+(grid[ii][jj]-t+1)%2\\n else:\\n new_t = t+1 \\n heapq.heappush(Q,(new_t,ii,jj)) \\n # print(Q)\\n return -1\\n\\n\",\n \"runtime\": \"1845\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n \\n # If the immediate neighbor (1, 0) or (0, 1) is not reachable, we cannot start the BFS.\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n # Priority queue to store cells with their corresponding times\\n heap = [(0, 0, 0)] # (time, row, col)\\n visited = set()\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n \\n # If we reached the bottom-right cell, return the current time\\n if row == m - 1 and col == n - 1:\\n return time\\n \\n # If the cell is already visited, skip it\\n if (row, col) in visited:\\n continue\\n visited.add((row, col))\\n \\n # Add neighboring cells to the heap\\n for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n # If the neighboring cell is reachable at the current time + 1, add it to the heap\\n if grid[r][c] <= time + 1:\\n heapq.heappush(heap, (time + 1, r, c))\\n else:\\n # If the neighboring cell is not reachable yet, we need to wait until it is\\n # The wait time can be calculated as the time required by the cell + 1 if it is odd, or directly + 1 if it is even\\n wait_time = grid[r][c] + (1 if grid[r][c] % 2 == time % 2 else 0)\\n heapq.heappush(heap, (wait_time, r, c))\\n \\n # If we haven't found a path to the bottom-right cell, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\\nprint(solution.minimumTime(grid)) # Output: 7\\n\\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\\nprint(solution.minimumTime(grid)) # Output: -1\",\n \"runtime\": \"1845\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n m, n = len(grid), len(grid[0])\\n\\n pq = [(0, 0, 0)]\\n visited = set()\\n\\n while pq:\\n time, r, c = heappop(pq)\\n if r == m - 1 and c == n - 1:\\n return time\\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n # print(visited, pq)\\n for dr, dc in [[-1, 0], [1, 0], [0, -1], [0, 1]]:\\n new_r, new_c = r + dr, c + dc\\n if 0 <= new_r < m and 0 <= new_c < n and (new_r, new_c) not in visited:\\n wait = 0 if (grid[new_r][new_c] - time) % 2 else 1\\n heappush(pq, (max(time + 1, grid[new_r][new_c] + wait), new_r, new_c))\\n \\n return time\",\n \"runtime\": \"1864\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n\\n heap = [(grid[0][0], 0, 0)]\\n # visited.add((0, 0))\\n\\n ans = -1\\n\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n\\n if row == rows-1 and col == cols-1:\\n return time\\n \\n if (row, col) in visited: continue\\n\\n visited.add((row, col))\\n \\n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\\n wait = 1 if (grid[new_row][new_col] - time) % 2 == 0 else 0\\n\\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\\n \\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"1864\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n length = len(grid[0])\\n width = len(grid)\\n\\n min_time = [[float('inf')] * length for _ in range(width)]\\n min_heap = []\\n\\n min_time[0][0] = 0\\n heapq.heappush(min_heap, (0, (0,0))) # (min_time, index)\\n\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n while min_heap:\\n \\n min_t, min_t_index = heapq.heappop(min_heap)\\n min_t_x, min_t_y = min_t_index\\n if min_t > min_time[min_t_x][min_t_y]: continue\\n if min_t_index == (width-1, length-1): return min_t\\n\\n directions = [(1,0), (-1,0),(0,1),(0,-1)]\\n\\n for dx, dy in directions:\\n next_x = min_t_x + dx\\n next_y = min_t_y + dy\\n if next_x in range(width) and next_y in range(length):\\n cur_time = min_t + 1\\n grid_value = grid[next_x][next_y]\\n\\n if grid_value <= cur_time:\\n if cur_time < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = cur_time\\n heapq.heappush(min_heap, (cur_time, (next_x, next_y)))\\n else:\\n if (next_x + next_y) % 2 == grid_value % 2:\\n if grid_value < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = grid_value\\n heapq.heappush(min_heap, (grid_value, (next_x, next_y)))\\n else:\\n if grid_value + 1 < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = grid_value + 1\\n heapq.heappush(min_heap, (grid_value+1, (next_x, next_y)))\",\n \"runtime\": \"1882\"\n },\n {\n \"code\": \"from typing import List\\nimport heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n heap = [(0, 0, 0)] # time, row, col\\n visited = set()\\n\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n if (row, col) in visited:\\n continue\\n visited.add((row, col))\\n if row == m - 1 and col == n - 1:\\n return time\\n for dr, dc in directions:\\n new_row, new_col = row + dr, col + dc\\n if 0 <= new_row < m and 0 <= new_col < n and (new_row, new_col) not in visited:\\n wait_time = max(0, grid[new_row][new_col] - (time + 1))\\n if wait_time % 2 == 1:\\n wait_time += 1\\n heapq.heappush(heap, (time + wait_time + 1, new_row, new_col))\\n\\n return -1\",\n \"runtime\": \"1882\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n #dijikstras, state (max(prevcell+1,nexsteptime)r,c)\\n #we pop the next earliest time, and add its adjacent cells. we either make prevt+1 or nxt time as when we can access it\\n\\n #if nxt time is greater than 1 + cur time,\\n # even difference: nxttime +1 :: back,original,nxt 2 -> 3 seconds\\n # odd difference: nxttime :: back, orginal,nxt -> 3 = 3 seconds\\n\\n def inbounds(r,c):\\n if r < 0 or c < 0 or r == rows or c == cols:\\n return False\\n return True\\n\\n #cant ping pong around\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n rows,cols = len(grid),len(grid[0])\\n \\n minheap = [(grid[0][0],0,0)]\\n \\n dirs = [[0,1],[-1,0],[1,0],[0,-1]]\\n \\n time_to = defaultdict(lambda: float('inf'))\\n \\n while minheap:\\n time,r,c = heapq.heappop(minheap)\\n if time_to[(r,c)] < time:\\n continue\\n \\n time_to[(r,c)] = time\\n \\n if (r,c) == (rows-1,cols-1):\\n return time\\n \\n for dr,dc in dirs:\\n nr,nc = dr+r,dc+c\\n if not inbounds(nr,nc):\\n continue\\n\\n nxt_time = time + 1 #defacto after next step\\n\\n if nxt_time < grid[nr][nc]: #if goal cell time to large (ping,pong)\\n if (grid[nr][nc] - time)%2:\\n nxt_time = grid[nr][nc]\\n else:\\n nxt_time = grid[nr][nc] + 1\\n\\n if time_to[(nr,nc)] > nxt_time:\\n time_to[(nr,nc)] = nxt_time\\n heapq.heappush(minheap,(nxt_time,nr,nc))\\n \\n return -1 \\n \\n \",\n \"runtime\": \"1901\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] <= 1 or grid[1][0] <= 1: \\n m, n = len(grid), len(grid[0])\\n pq = [(0, 0, 0)]\\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\\n while pq: \\n x, i, j = heappop(pq)\\n if (i, j) == (m-1, n-1): return x \\n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \\n if 0 <= ii < m and 0 <= jj < n: \\n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \\n if dist[ii, jj] > xx: \\n heappush(pq, (xx, ii, jj))\\n dist[ii, jj] = xx \\n return -1 \",\n \"runtime\": \"1919\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n Intuition:\\n - Starting with the first node, we are to look at the adjacent neighbors\\n - if the adjacent neighbor is not an edge (fall off the grid) and fit the condition <= t\\n - NOTE: that t is the current time step that increment everytime we take a step\\n - we then add 1 to our t, \\n - We reach the end whe or coordinate reach the bottom right of the graph \\n - we then mark the visited node so that we don't have to visit it again\\n - if the visited neighboring node is larger than the current condition+1 step\\n - we need some way to reverse back to the original cell and recompute the time \\n \\\"\\\"\\\"\\n\\n\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\",\n \"runtime\": \"1919\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R, C = 0, 1\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\",\n \"runtime\": \"1938\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # Return -1 immediately if we can't move at the start\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n m, n = len(grid), len(grid[0])\\n dirs = [(0, -1), (0, 1), (1, 0), (-1, 0)]\\n visited = set()\\n pq = [(0, 0, 0)] # time, row, column\\n while pq:\\n t, r, c = heapq.heappop(pq)\\n if r == m - 1 and c == n - 1:\\n return t\\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n for dx, dy in dirs:\\n nx, ny = r + dx, c + dy\\n if 0 > nx or nx >= m or 0 > ny or ny >= n or (nx, ny) in visited:\\n continue\\n wait = 1 if (grid[nx][ny] - t) % 2 == 0 else 0\\n nt = max(grid[nx][ny] + wait, t + 1)\\n heapq.heappush(pq, (nt, nx, ny))\\n return -1\\n\\n \",\n \"runtime\": \"1938\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n n = len(grid)\\n m = len(grid[0])\\n\\n # Early exit check\\n if not (grid[0][1] - grid[0][0] <= 1) and not (grid[1][0] - grid[0][0] <= 1):\\n return -1\\n\\n # Priority queue (min-heap), storing (current_time, row, column)\\n pq = [(0, 0, 0)] # Initialize heap with (time, row, column)\\n rec = [[float('inf')] * m for _ in range(n)]\\n rec[0][0] = 0\\n\\n # Directions for moving in the grid\\n dx = [1, -1, 0, 0]\\n dy = [0, 0, 1, -1]\\n\\n while pq:\\n val, r, c = heapq.heappop(pq) # Pop the cell with the smallest current_time\\n\\n for i in range(4):\\n nr = r + dx[i]\\n nc = c + dy[i]\\n if 0 <= nr < n and 0 <= nc < m:\\n diff = grid[nr][nc] - val\\n if diff <= 0:\\n if rec[nr][nc] > val + 1:\\n heapq.heappush(pq, (val + 1, nr, nc))\\n rec[nr][nc] = val + 1\\n continue\\n\\n # Adjust diff if it's even\\n diff = diff + 1 if diff % 2 == 0 else diff\\n if rec[nr][nc] > val + diff:\\n heapq.heappush(pq, (val + diff, nr, nc))\\n rec[nr][nc] = val + diff\\n\\n return rec[n - 1][m - 1] if rec[n - 1][m - 1] != float('inf') else -1\\n\",\n \"runtime\": \"1957\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n #cannot reach destination \\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n m = len(grid)\\n n = len(grid[0])\\n dirs = [(0,1), (1,0), (-1,0), (0,-1)]\\n heap = [(grid[0][0], 0, 0)]\\n visited = set((0,0))\\n\\n while heap: \\n curTime, row, col = heapq.heappop(heap)\\n if row == m-1 and col == n-1:\\n return curTime \\n \\n if (row,col) in visited: \\n continue \\n\\n visited.add((row,col))\\n\\n for dirX, dirY in dirs: \\n nr = row + dirX\\n nc = col + dirY\\n\\n if nr<0 or nr>=m or nc<0 or nc>=n or (nr,nc) in visited: \\n continue \\n \\n extraTime = 1 if (grid[nr][nc] - curTime) % 2 == 0 else 0\\n\\n heapq.heappush(heap, (max(grid[nr][nc] + extraTime, curTime + 1), nr, nc))\\n return -1 \\n \\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1957\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\\"\\\"\\\"\\n Intuition:\\n - Starting with the first node, we are to look at the adjacent neighbors\\n - if the adjacent neighbor is not an edge (fall off the grid) and fit the condition <= t\\n - NOTE: that t is the current time step that increment everytime we take a step\\n - we then add 1 to our t, \\n - We reach the end whe or coordinate reach the bottom right of the graph \\n - we then mark the visited node so that we don't have to visit it again \\n \\\"\\\"\\\"\\n\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\\n\\n\\n\",\n \"runtime\": \"1975\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R, C = 0, 1\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\",\n \"runtime\": \"1975\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R, C = 0, 1\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\",\n \"runtime\": \"1994\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: \\n return -1\\n heap = []\\n heapq.heappush(heap, (0, 0, 0))\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]\\n seen = set()\\n n = len(grid) - 1\\n m = len(grid[0]) - 1\\n \\n while heap:\\n time, r, c = heapq.heappop(heap)\\n\\n if r == n and c == m:\\n return time\\n if (r, c) in seen:\\n continue\\n seen.add((r, c))\\n \\n for dr, dc in directions:\\n nr = r + dr\\n nc = c + dc\\n \\n if (nr, nc) not in seen and nr >= 0 and nr <= n and nc >= 0 and nc <= m:\\n wait = 0\\n if (grid[nr][nc] - time) % 2 == 0:\\n wait = 1\\n heapq.heappush(heap, (max(time + 1, grid[nr][nc] + wait), nr, nc)) \\n \\n \",\n \"runtime\": \"1994\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R, C = 0, 1\\n nr, nc = len(grid), len(grid[0])\\n\\n def get_nx(r, c):\\n for r_nx, c_nx in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if 0 <= r_nx <= nr-1 and 0 <= c_nx <= nc-1:\\n yield r_nx, c_nx\\n\\n # main\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n start, end = (0, 0), (nr-1, nc-1)\\n t_to_cells = defaultdict(set)\\n t = 0\\n t_to_cells[t].add(start)\\n visited = {start}\\n while True:\\n for r, c in t_to_cells[t]:\\n for r_nx, c_nx in get_nx(r, c):\\n if (r_nx, c_nx) in visited:\\n continue\\n if grid[r_nx][c_nx] > t+1:\\n t_diff = grid[r_nx][c_nx] - t\\n t_nx = t + t_diff if t_diff % 2 == 1 else t + t_diff + 1\\n else:\\n t_nx = t+1\\n if (r_nx, c_nx) == end:\\n return t_nx\\n t_to_cells[t_nx].add((r_nx, c_nx))\\n visited.add((r_nx, c_nx))\\n t += 1\",\n \"runtime\": \"2012\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m=len(grid)\\n n=len(grid[0])\\n if grid[1][0]>1 and grid[0][1]>1:\\n return -1\\n minheap=[(0,0,0)]\\n seen=set() \\n directions=[(0,1),(1,0),(-1,0),(0,-1)]\\n while minheap:\\n d,r,c=heapq.heappop(minheap)\\n if (r,c)==(m-1,n-1):\\n return d\\n if (r,c) in seen:\\n continue\\n seen.add((r,c))\\n for dr,dc in directions:\\n if 0<=r+dr<m and 0<=c+dc<n and (r+dr,c+dc) not in seen:\\n if d>=grid[r+dr][c+dc]:\\n heapq.heappush(minheap,(d+1,r+dr,c+dc))\\n elif (grid[r+dr][c+dc]-d)%2==0:\\n heapq.heappush(minheap,(grid[r+dr][c+dc]+1,r+dr,c+dc))\\n else:\\n heapq.heappush(minheap,(grid[r+dr][c+dc],r+dr,c+dc))\",\n \"runtime\": \"2012\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] <= 1 or grid[1][0] <= 1: \\n m, n = len(grid), len(grid[0])\\n pq = [(0, 0, 0)]\\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\\n while pq: \\n x, i, j = heappop(pq)\\n if (i, j) == (m-1, n-1): return x \\n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \\n if 0 <= ii < m and 0 <= jj < n: \\n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \\n if dist[ii, jj] > xx: \\n heappush(pq, (xx, ii, jj))\\n dist[ii, jj] = xx \\n return -1\",\n \"runtime\": \"2031\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n m = len(grid)\\n n = len(grid[0])\\n\\n moves = [\\n (0, 1),\\n (0, -1),\\n (1, 0),\\n (-1, 0),\\n ]\\n \\n heap = [(0, 0, 0)]\\n visited = set()\\n\\n\\n while heap:\\n curr_time, r, c = heappop(heap)\\n if (r, c) in visited:\\n continue\\n \\n if r == m-1 and c == n-1:\\n return curr_time\\n \\n visited.add((r, c))\\n for move in moves:\\n nr, nc = r + move[0], c + move[1]\\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\\n \",\n \"runtime\": \"2031\"\n },\n {\n \"code\": \"from heapq import heappush,heappop\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R = len(grid)\\n C = len(grid[0])\\n # Check if there is a path exist\\n has_path = False\\n for r,c in ((0,1),(1,0)):\\n if 0<=r<R and 0<=c<C:\\n if grid[r][c] <= 1 :\\n has_path = True\\n if not has_path : return -1\\n heap = [(0,0,0)]\\n dist = {}\\n dist[(0,0)] = 0\\n visited = set()\\n while heap:\\n _,r,c = heappop(heap)\\n if (r,c) in visited: continue\\n if r == R-1 and c == C-1:\\n break\\n visited.add((r,c))\\n cur_time = dist[(r,c)]\\n for nr,nc in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if (nr,nc) in visited : continue\\n if 0<=nr<R and 0<=nc<C:\\n cost = None\\n if grid[nr][nc] <= cur_time + 1:\\n cost = 1\\n else:\\n cost = grid[nr][nc] - cur_time\\n if cost%2 == 0 :\\n cost += 1\\n if cost:\\n if cur_time + cost < dist.get((nr,nc),float('inf')):\\n dist[(nr,nc)] = cur_time + cost\\n heappush(heap,(dist[(nr,nc)],nr,nc))\\n return dist[(R-1,C-1)]\",\n \"runtime\": \"2050\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n seen = set()\\n pq = [(grid[0][0], 0, 0)]\\n while pq:\\n time, row, col = heappop(pq)\\n if row == m - 1 and col == n - 1:\\n return time\\n if (row, col) in seen: \\n continue\\n seen.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in seen:\\n wait = 1 if (grid[r][c] - time) % 2 == 0 else 0\\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\",\n \"runtime\": \"2050\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n m = len(grid)\\n n = len(grid[0])\\n\\n moves = [\\n (0, 1),\\n (0, -1),\\n (1, 0),\\n (-1, 0),\\n ]\\n \\n heap = [(0, 0, 0)]\\n visited = set([0, 0])\\n\\n\\n while heap:\\n curr_time, r, c = heappop(heap)\\n if (r, c) in visited:\\n continue\\n \\n if r == m-1 and c == n-1:\\n return curr_time\\n \\n visited.add((r, c))\\n for move in moves:\\n nr, nc = r + move[0], c + move[1]\\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\\n \\n return -1\",\n \"runtime\": \"2068\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n DX = [0, 1, 0, -1]\\n DY = [-1, 0, 1, 0]\\n row = len(grid)\\n col = len(grid[0])\\n\\n pq = []\\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\\n\\n vis = [[0 for i in range(col)] for i in range(row)]\\n\\n while pq:\\n d, i, j = heapq.heappop(pq)\\n \\n if (i == (row - 1)) and (j == (col - 1)):\\n return d\\n\\n if vis[i][j] == 1:\\n continue\\n vis[i][j] = 1\\n\\n\\n if i == 0 and j == 0:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n for k in range(4):\\n ni = i + DX[k]\\n nj = j + DY[k]\\n\\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\\n if d + 1 >= grid[ni][nj]:\\n heapq.heappush(pq, ((d + 1), ni, nj))\\n else:\\n diff = grid[ni][nj] - d\\n extra = 1 if diff % 2 == 0 else 0\\n\\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\\n\\n return -1\",\n \"runtime\": \"2068\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:return -1\\n m, n = len(grid), len(grid[0])\\n visit = set()\\n pq = [(grid[0][0], 0, 0)]\\n\\n while pq:\\n time, row, col = heappop(pq)\\n if row == m - 1 and col == n-1:return time \\n if (row, col) in visit:continue\\n visit.add((row, col))\\n for dr, dc in [[0, 1], [1, 0], [0, -1], [-1, 0]]:\\n r, c = row + dr, col + dc \\n if 0 <= r < m and 0 <= c < n and (r, c) not in visit:\\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0 \\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\\n \",\n \"runtime\": \"2087\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n\\n if mem[(r, c)] < t:\\n continue\\n print(t, r, c)\\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n elif (t + 1) % 2 == grid[nr][nc] % 2:\\n nt = grid[nr][nc]\\n else:\\n nt = grid[nr][nc] + 1\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n\\n return -1\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"2087\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1: \\n return -1\\n heap = [(0,0,0)]\\n visited = set()\\n while heap:\\n d, i, j = heappop(heap)\\n if (i, j) in visited: continue\\n visited.add((i,j))\\n if (i, j) == (m-1, n-1): return d\\n for di, dj in [[-1,0], [1,0], [0,-1], [0,1]]:\\n if 0 <= i + di < m and 0 <= j + dj < n and (i + di, j + dj) not in visited:\\n t = grid[i+di][j+dj]\\n gap = max(t-(d+1), 0)\\n heappush(heap, (d + 1 + gap + (gap%2), i + di, j + dj))\",\n \"runtime\": \"2106\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n R,C = len(grid), len(grid[0])\\n self.mn = float('inf')\\n directions = [(1,0), (0,1), (-1,0), (0,-1)]\\n\\n heap = [(grid[0][0], 0, 0)]\\n visited = set()\\n while heap:\\n t, r, c = heappop(heap)\\n\\n if (r,c) == (R-1,C-1): return t\\n\\n if (r,c) in visited: continue\\n\\n visited.add((r,c))\\n\\n for dr,dc in directions:\\n nr, nc = r+dr, c+dc\\n\\n if nr < 0 or nr > R - 1 or nc < 0 or nc > C - 1 or (nr,nc) in visited:\\n continue\\n \\n heappush(heap, (max(t+1, grid[nr][nc] + (1 if (grid[nr][nc] - t) % 2 == 0 else 0)), nr, nc))\\n \\n\\n \",\n \"runtime\": \"2106\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n R,C = len(grid), len(grid[0])\\n self.mn = float('inf')\\n directions = [(1,0), (0,1), (-1,0), (0,-1)]\\n\\n heap = [(grid[0][0], 0, 0)]\\n visited = set()\\n while heap:\\n t, r, c = heappop(heap)\\n\\n if (r,c) == (R-1,C-1): return t\\n\\n if (r,c) in visited: continue\\n\\n visited.add((r,c))\\n\\n for dr,dc in directions:\\n nr, nc = r+dr, c+dc\\n\\n if nr < 0 or nr > R - 1 or nc < 0 or nc > C - 1 or (nr,nc) in visited:\\n continue\\n \\n heappush(heap, (max(t+1, grid[nr][nc] + (1 if (grid[nr][nc] - t) % 2 == 0 else 0)), nr, nc))\\n \\n\\n \",\n \"runtime\": \"2124\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n '''\\n * top left to bottom in right in minimum time -> each move is 1 second.. \\n * can move to a cell only if grid[i][j] time has elapsed.. \\n * in each move.. the ball must be moved somewhere.. so If I didn't meet the 'elapsed' time for the neigboring.. I have to keep bouncing from where I came from to my current position.. till I can move to the next position..\\n ====\\n * min time -> djikstras? \\n * how many time will I have to bounce? \\n * each bounce to previous will elapse me 1 second.. so If the time gap is even.. I bounce even number of times between where I came from and current.. basically at the exact time 't' required to make a move.. I will be at the same current cell (because even bounces) and I need to take one more bounce to move to the new adjacent for which I met the time 'elapsed time' requirement.. \\n * but if the time gap is odd.. then I bounce till the closest even.. end up in the same spot as current cell.. and then already made a move to the neighboring cell.. so need to take an extra bounce.. \\n '''\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1 # edge case.. I must make a move! but if both right and down to the starting cell needs over a second.. there is no where for me to bounce (I cant bounce in the same cell..).. so no way I can make even the first move..\\n start_time = grid[0][0]\\n pq = [(start_time, 0, 0)]\\n seen = set()\\n while pq: \\n t, i, j = heapq.heappop(pq)\\n if i == len(grid)-1 and j == len(grid[0])-1: return t # reached the end.. \\n if (i, j) in seen: continue # if seen, continue\\n seen.add((i, j))\\n for di, dj in [[-1, 0], [0, 1], [1, 0], [0, -1]]: \\n ni, nj = i + di, j + dj\\n if 0 <= ni < len(grid) and 0 <= nj < len(grid[0]) and (ni, nj) not in seen: \\n time_gap = grid[ni][nj] - t # ie., number of bounces I need to make till I meet the time elapsed requirement.. \\n need_one_extra = 0\\n if time_gap % 2 == 0: \\n need_one_extra = 1 # need extra bounce\\n # else: # redundant; no extra step necessary for odd bounces.. I can make the final bounce to nei directly..\\n # need_one_extra = 0 \\n heapq.heappush(pq, (max(t + 1, grid[ni][nj] + need_one_extra), ni, nj)) # wait or t + 1.. the max of both is the time it will take me to take this next step and get to (ni, nj)\\n \\n return -1 \",\n \"runtime\": \"2143\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\nfrom typing import List\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n m, n = len(grid), len(grid[0])\\n heap = [(0, 0, 0)] # time, row, col\\n visited = set()\\n \\n while heap:\\n time, row, col = heappop(heap)\\n \\n if (row, col) in visited:\\n continue\\n visited.add((row, col))\\n \\n if (row, col) == (m - 1, n - 1):\\n return time\\n \\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n wait = (grid[r][c] - time) % 2 == 0 # ensure parity\\n heappush(heap, (max(time + 1, grid[r][c] + wait), r, c))\\n \\n return -1\",\n \"runtime\": \"2161\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n rows = len(grid)\\n cols = len(grid[0])\\n \\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\\n time_to_reach[0][0] = 0\\n \\n q = [(0, 0, 0)] # (time, row, col)\\n \\n neighbours = [\\n (0, 1),\\n (1, 0),\\n (0, -1),\\n (-1, 0)\\n ]\\n \\n while q:\\n cur_time, cur_row, cur_col = heapq.heappop(q)\\n \\n for dr, dc in neighbours:\\n r, c = cur_row + dr, cur_col + dc\\n if r < 0 or r >= rows or c < 0 or c >= cols:\\n continue\\n \\n wait_time = max(0, grid[r][c] - cur_time - 1)\\n if wait_time % 2 != 0:\\n wait_time += 1\\n \\n new_time = cur_time + wait_time + 1\\n if time_to_reach[r][c] > new_time:\\n time_to_reach[r][c] = new_time\\n heapq.heappush(q, (new_time, r, c))\\n \\n return time_to_reach[rows-1][cols-1]\\n\",\n \"runtime\": \"2161\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if len(grid) > 1 and len(grid[0]) > 1: \\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n elif len(grid) > 1 and grid[1][0] > 1:\\n return -1\\n elif len(grid[0]) > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == 1:\\n if grid[a][b] % 2 == 1:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][1] > nexto:\\n shortests[a][b][1] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][1] > nexto:\\n shortests[a][b][1] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n if grid[a][b] % 2 == 1:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][0] > nexto:\\n shortests[a][b][0] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][0] > nexto:\\n shortests[a][b][0] = nexto\\n heappush(prioQ, (nexto, a, b))\\n return -1\\n\\n \",\n \"runtime\": \"2180\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n ## adjusted Dijkstra's algo\\n if grid[1][0] > 1 and grid[0][1] > 1: \\n return -1\\n import heapq\\n from collections import defaultdict\\n m, n = len(grid), len(grid[0])\\n dis = defaultdict(lambda: float('inf'))\\n dis[(0, 0)] = 0\\n queue = [[0, (0, 0)]]\\n heapq.heapify(queue)\\n seen = set()\\n directions = [\\n [-1, 0], \\n [1, 0], \\n [0, -1], \\n [0, 1]\\n ]\\n while queue: \\n dis_curr, (x, y) = heapq.heappop(queue)\\n seen.add((x, y))\\n if x == m - 1 and y == n - 1: \\n return dis_curr\\n for dx, dy in directions: \\n xx = x + dx\\n yy = y + dy\\n if 0 <= xx < m and 0 <= yy < n: \\n if dis_curr + 1 >= grid[xx][yy]: \\n if dis_curr + 1 < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1\\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\\n else: \\n diff = grid[xx][yy] - (dis_curr + 1)\\n if diff % 2 == 1: \\n diff += 1\\n if dis_curr + 1 + diff < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1 + diff\\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\\n \\n return -1 \\n \\n \\n \",\n \"runtime\": \"2199\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == grid[a][b] % 2:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][grid[a][b] % 2] > nexto:\\n shortests[a][b][grid[a][b] % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][(currTime+1) % 2] > nexto:\\n shortests[a][b][(currTime+1) % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n\\n \",\n \"runtime\": \"2217\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if len(grid) > 1 and len(grid[0]) > 1: \\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n elif len(grid) > 1 and grid[1][0] > 1:\\n return -1\\n elif len(grid[0]) > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == grid[a][b] % 2:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][grid[a][b] % 2] > nexto:\\n shortests[a][b][grid[a][b] % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][(currTime+1) % 2] > nexto:\\n shortests[a][b][(currTime+1) % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n return -1\\n\\n \",\n \"runtime\": \"2217\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, matrix: List[List[int]]) -> int:\\n m = len(matrix)\\n n = len(matrix[0])\\n if matrix[0][1] > 1 and matrix[1][0] > 1: \\n return -1\\n \\n h = [(matrix[0][0], 0, 0)]\\n X = [-1, 0, 1, 0]\\n Y = [0, -1, 0, 1]\\n res = [[2 ** 31 for i in range (n)] for j in range (m)]\\n res[0][0] = matrix[0][0]\\n visited = set()\\n while h:\\n cur_time, curX, curY = heapq.heappop(h)\\n if curX == m - 1 and curY == n - 1:\\n return cur_time\\n if (curX, curY) in visited:\\n continue\\n visited.add((curX, curY))\\n for i in range (4):\\n neighborX = curX + X[i]\\n neighborY = curY + Y[i]\\n if 0 <= neighborX < m and 0 <= neighborY < n and (neighborX, neighborY) not in visited:\\n waitTime = 0\\n if (matrix[neighborX][neighborY] - cur_time) % 2 == 0:\\n waitTime = 1\\n res[neighborX][neighborY] = max(cur_time + 1, waitTime + matrix[neighborX][neighborY])\\n heapq.heappush(h, (res[neighborX][neighborY], neighborX, neighborY))\\n \\n return -1\\n \",\n \"runtime\": \"2236\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m, n = len(grid), len(grid[0])\\n visited = set()\\n pq = [(grid[0][0], 0, 0)]\\n\\n while pq:\\n time, row, col = heappop(pq)\\n if row == m-1 and col == n-1: return time\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c)) \",\n \"runtime\": \"2236\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n DX = [0, 1, 0, -1]\\n DY = [-1, 0, 1, 0]\\n row = len(grid)\\n col = len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n pq = []\\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\\n\\n vis = [[0 for i in range(col)] for i in range(row)]\\n\\n while pq:\\n d, i, j = heapq.heappop(pq)\\n\\n if (i == (row - 1)) and (j == (col - 1)):\\n return d\\n\\n if vis[i][j] == 1:\\n continue\\n vis[i][j] = 1\\n\\n for k in range(4):\\n ni = i + DX[k]\\n nj = j + DY[k]\\n\\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\\n if d + 1 >= grid[ni][nj]:\\n heapq.heappush(pq, ((d + 1), ni, nj))\\n else:\\n diff = grid[ni][nj] - d\\n extra = 1 if diff % 2 == 0 else 0\\n\\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\\n\\n return -1\",\n \"runtime\": \"2254\"\n },\n {\n \"code\": \"import heapq as hq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n \\n nrow = len(grid)\\n ncol = len(grid[0])\\n\\n visited = set()\\n heap = [(0,0,0)] # distance, row, col\\n\\n def helper(distance, row, col):\\n newdist = max(distance + 1, grid[row][col])\\n if newdist % 2 != (row + col) % 2:\\n newdist += 1\\n\\n hq.heappush(heap, (newdist, row, col))\\n\\n\\n while heap:\\n distance, row, col = hq.heappop(heap)\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n if row == nrow - 1 and col == ncol - 1: return distance\\n\\n if row > 0: helper(distance, row-1, col)\\n if row < nrow-1: helper(distance, row+1, col)\\n if col > 0: helper(distance, row, col-1)\\n if col < ncol - 1: helper(distance, row, col+1)\\n\\n return -1\\n \\n\",\n \"runtime\": \"2273\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n rows = len(grid)\\n cols = len(grid[0])\\n \\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\\n time_to_reach[0][0] = 0\\n \\n q = [(0, 0, 0)] # (time, row, col)\\n \\n neighbours = [\\n (0, 1),\\n (1, 0),\\n (0, -1),\\n (-1, 0)\\n ]\\n \\n while q:\\n cur_time, cur_row, cur_col = heapq.heappop(q)\\n \\n for dr, dc in neighbours:\\n r, c = cur_row + dr, cur_col + dc\\n if r < 0 or r >= rows or c < 0 or c >= cols:\\n continue\\n \\n wait_time = max(0, grid[r][c] - cur_time - 1)\\n if wait_time % 2 != 0:\\n wait_time += 1\\n \\n new_time = cur_time + wait_time + 1\\n if time_to_reach[r][c] > new_time:\\n time_to_reach[r][c] = new_time\\n heapq.heappush(q, (new_time, r, c))\\n \\n return time_to_reach[rows-1][cols-1]\\n\",\n \"runtime\": \"2292\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n DX = [0, 1, 0, -1]\\n DY = [-1, 0, 1, 0]\\n row = len(grid)\\n col = len(grid[0])\\n\\n pq = []\\n heapq.heappush(pq, (0,0,0)) # (wt, i, j)\\n\\n vis = [[0 for i in range(col)] for i in range(row)]\\n\\n while pq:\\n d, i, j = heapq.heappop(pq)\\n\\n if i == 0 and j == 0:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n if (i == (row - 1)) and (j == (col - 1)):\\n return d\\n\\n if vis[i][j] == 1:\\n continue\\n vis[i][j] = 1\\n\\n for k in range(4):\\n ni = i + DX[k]\\n nj = j + DY[k]\\n\\n if 0 <= ni and ni < row and 0 <= nj and nj < col:\\n if d + 1 >= grid[ni][nj]:\\n heapq.heappush(pq, ((d + 1), ni, nj))\\n else:\\n diff = grid[ni][nj] - d\\n extra = 1 if diff % 2 == 0 else 0\\n\\n heapq.heappush(pq, (grid[ni][nj] + extra, ni, nj))\\n\\n return -1\",\n \"runtime\": \"2310\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\\n if grid[dr][dc] > curTime+1:\\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"runtime\": \"2329\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # there's one trick:\\n # if we are stuck at a cell because all unvisited neighbors \\n # have a timestamp which is too high,\\n # then we return to the previous cell and return to the current cell again:\\n # playing ping-pong ! this requires two steps per iteration.\\n # if the difference is high then there's no need to actually perform the moves:\\n # we will arrive at the next cell in an odd or even number of steps.\\n height = len(grid)\\n width = len(grid[0])\\n\\n # obvious this fail in the very first step\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n todo = [ ( 0, 0, 0 ) ] # min-heap: timestamp, x, y\\n deltas = ( 0, +1, 0, -1, 0 ) # compressed deltas\\n while todo:\\n now, x, y = heappop(todo)\\n\\n # arrived\\n if x == width - 1 and y == height - 1:\\n return now\\n\\n # placeholder, means \\\"already visited\\\"\\n if grid[y][x] < 0:\\n continue\\n grid[y][x] = -1\\n\\n # need one unit to travel\\n now += 1\\n # hello neighbors !\\n for dx, dy in zip(deltas, deltas[1 :]):\\n nx = x + dx\\n ny = y + dy\\n\\n if 0 <= nx < width and 0 <= ny < height:\\n arrive = max(now, grid[ny][nx])\\n # already seen\\n if arrive < 0:\\n continue\\n\\n if arrive > now:\\n # need to wait\\n pingpong = arrive - now\\n arrive += pingpong & 1\\n\\n heappush(todo, ( arrive, nx, ny ))\\n\\n return -1 # never reached\",\n \"runtime\": \"2329\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n ROWS, COLS = len(grid), len(grid[0])\\n heap = [(0, 0, 0)]\\n visited = set()\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n if row == ROWS - 1 and col == COLS - 1:\\n return time\\n if (row, col) in visited:\\n continue\\n visited.add((row, col))\\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n r = row + dr\\n c = col + dc\\n if not 0 <= r < ROWS or not 0 <= c < COLS:\\n continue\\n if grid[r][c] <= time + 1:\\n heapq.heappush(heap, (time + 1, r, c))\\n else:\\n diff = grid[r][c] - time\\n nextTime = grid[r][c]\\n if diff % 2 == 0:\\n nextTime += 1\\n heapq.heappush(heap, (nextTime, r, c))\\n \",\n \"runtime\": \"2347\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\\n if grid[dr][dc] > curTime+1:\\n waitTime = ((grid[dr][dc] - curTime)//2 * 2) + 1\\n tt = waitTime + curTime\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n \\n return minTime\\n\\n\\n\\\"\\\"\\\"\\nq = [(0,0,0)]\\n\\n\\nt+1 >= next -> move\\n\\nt+1 < next and row and col != 0\\n\\n\\n1 < 5\\n1 < 4\\n3-1 = 2\\n4-1 = 3\\n5-1 = 4/2 = 2*2\\n5-1 = 4/2= 2*(swap)\\n4-1 = 3/2 = 1*(swap)\\n\\nt + 1swap(2) + 1\\nt + 1swap(2) + 1\\n\\n\\\"\\\"\\\"\\n\",\n \"runtime\": \"2347\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\\n if grid[dr][dc] > curTime+1:\\n waitTime = ((grid[dr][dc] - curTime)//2 * 2) + 1\\n tt = waitTime + curTime\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"runtime\": \"2366\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # It is always possible to reach the end as long as we have a valid parent, in the beginning at (0,0) we don't have a valid parent so this position might get blocked otherwise we can always reach.\\n \\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n m = len(grid)\\n n = len(grid[0])\\n start = (0, 0)\\n dist = defaultdict(lambda: float('inf'))\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, (0, 0, 0))\\n dist[0, 0] = 0\\n\\n while len(pq) > 0:\\n w, x, y = heapq.heappop(pq)\\n if dist[x, y] < w: continue\\n if (x, y) == (m - 1, n - 1): return dist[x, y]\\n\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n for direction in dirs:\\n newX, newY = x + direction[0], y + direction[1]\\n if 0 <= newX < m and 0 <= newY < n:\\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\\n dist[newX, newY] = dist[x, y] + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif grid[newX][newY] > dist[x, y] + 1:\\n wait = grid[newX][newY] - dist[x, y]\\n\\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\\n dist[newX, newY] = dist[x, y] + wait + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\\n dist[newX, newY] = dist[x, y] + wait\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n \\n return -1\\n\",\n \"runtime\": \"2385\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n seen = set()\\n heap = []\\n heapq.heappush(heap, [0, 0, 0])\\n seen.add((0, 0))\\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1]]\\n\\n def isValid(r, c):\\n return 0 <= r < len(grid) and 0 <= c < len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n if row == len(grid) - 1 and col == len(grid[0]) - 1:\\n return time\\n \\n for dx, dy in directions:\\n newRow, newCol = row + dx, col + dy\\n if isValid(newRow, newCol):\\n if time + 1 >= grid[newRow][newCol] and (newRow, newCol) not in seen:\\n heapq.heappush(heap, [time + 1, newRow, newCol])\\n elif time + 1 < grid[newRow][newCol]:\\n diff = grid[newRow][newCol] - time\\n if diff % 2 == 0:\\n heapq.heappush(heap, [grid[newRow][newCol] + 1, newRow, newCol])\\n else:\\n heapq.heappush(heap, [grid[newRow][newCol], newRow, newCol])\\n seen.add((newRow, newCol))\\n\\n return -1\\n\\n \",\n \"runtime\": \"2403\"\n },\n {\n \"code\": \"import heapq as hq\\nclass Solution:\\n def validCell(self, nRow, nCol, n, m):\\n return nRow >= 0 and nRow < n and nCol >= 0 and nCol < m\\n\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n n, m = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n heap = []\\n hq.heappush(heap, [0,0,0])\\n dist = [[math.inf for _ in range(m)] for _ in range(n)]\\n dist[0][0] = 0\\n\\n delRow = [1,-1,0,0]\\n delCol = [0,0,1,-1]\\n while heap:\\n time, i, j = hq.heappop(heap)\\n\\n for k in range(4):\\n nRow = i + delRow[k]\\n nCol = j + delCol[k]\\n\\n if self.validCell(nRow, nCol, n, m):\\n adjEle = grid[nRow][nCol]\\n increment = max(1, adjEle - time + ((adjEle - time)%2 == 0))\\n currTime = time + increment\\n\\n if dist[nRow][nCol] > currTime:\\n dist[nRow][nCol] = currTime\\n hq.heappush(heap, [currTime, nRow, nCol])\\n return dist[n-1][m-1]\",\n \"runtime\": \"2422\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n m = len(grid)\\n n = len(grid[0])\\n start = (0, 0)\\n dist = defaultdict(lambda: float('inf'))\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, (0, 0, 0))\\n dist[0, 0] = 0\\n\\n while len(pq) > 0:\\n w, x, y = heapq.heappop(pq)\\n if dist[x, y] < w: continue\\n if (x, y) == (m - 1, n - 1): return dist[x, y]\\n\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n for direction in dirs:\\n newX, newY = x + direction[0], y + direction[1]\\n if 0 <= newX < m and 0 <= newY < n:\\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\\n dist[newX, newY] = dist[x, y] + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif grid[newX][newY] > dist[x, y] + 1:\\n wait = grid[newX][newY] - dist[x, y]\\n\\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\\n dist[newX, newY] = dist[x, y] + wait + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\\n dist[newX, newY] = dist[x, y] + wait\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n \\n return -1\\n\",\n \"runtime\": \"2441\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n \\n # If we cannot even start from the top-left cell, return -1\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n # Directions to move in the grid: up, down, left, right\\n directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n \\n # Min-heap to store the cells to visit, along with the time taken to reach them\\n heap = [(0, 0, 0)] # (time, row, col)\\n \\n # Set to store the visited cells\\n visited = set()\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n \\n # If we have reached the bottom-right cell, return the current time\\n if row == m - 1 and col == n - 1:\\n return time\\n \\n # If the cell is already visited, continue\\n if (row, col) in visited:\\n continue\\n \\n # Mark the cell as visited\\n visited.add((row, col))\\n \\n # Explore all adjacent cells\\n for dr, dc in directions:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n:\\n # Calculate the waiting time if needed\\n wait_time = (grid[r][c] - time) % 2 == 0\\n new_time = max(time + 1, grid[r][c] + wait_time)\\n heapq.heappush(heap, (new_time, r, c))\\n \\n # If we cannot reach the bottom-right cell, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\\nprint(solution.minimumTime(grid)) # Output: 7\\n\\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\\nprint(solution.minimumTime(grid)) # Output: -1\",\n \"runtime\": \"2459\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m, n = len(grid), len(grid[0])\\n visited = set()\\n pq = [(grid[0][0], 0, 0)]\\n \\n while pq:\\n time, row, col = heappop(pq)\\n if row == m-1 and col == n-1: return time\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\\n return -1\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n\\n tgt = (m-1, n-1)\\n src = (0, 0)\\n\\n que = [(0, src)]\\n seen = defaultdict(int)\\n seen[src] = 0\\n\\n if grid[0][0] > 0: return -1\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n while que:\\n cur_time, (x,y) = heappop(que) \\n if (x, y) == tgt: return cur_time\\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n xx, yy = dx + x, dy + y\\n\\n if 0<= xx < m and 0 <= yy < n and ((xx, yy) not in seen or seen[(xx, yy)] > cur_time + 1):\\n #update the modified origin if there is one\\n tmp = cur_time\\n modified_origin = False\\n if tmp + 1 < grid[xx][yy]:\\n tmp = (grid[xx][yy] - 1) if (grid[xx][yy] - 1 - tmp) %2 == 0 else grid[xx][yy]\\n modified_origin = True\\n\\n if tmp + 1 >= grid[xx][yy] and ((xx, yy) not in seen or seen[(xx, yy)] > tmp +1):\\n seen[(xx, yy)] = tmp + 1\\n heappush(que, (tmp + 1, (xx, yy)))\\n\\n if modified_origin:\\n heappush(que, (tmp, (x, y)))\\n return -1\\n\\n\",\n \"runtime\": \"2478\"\n },\n {\n \"code\": \"from collections import deque\\nfrom itertools import starmap\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\\n visited = set()\\n rows = len(grid)\\n cols = len(grid[0])\\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\\n costs = defaultdict(lambda : float('inf'))\\n\\n heap = [(0,(0,0))]\\n\\n\\n while heap:\\n cur_time, (r,c) = heapq.heappop(heap)\\n if (r,c) in visited:\\n continue\\n visited.add((r,c))\\n if (r,c) == (rows-1, cols-1):\\n return cur_time\\n possible_vertices = valid_movements(r,c)\\n for r_nxt, c_nxt in possible_vertices:\\n if grid[r_nxt][c_nxt] > cur_time + 1:\\n # we need to wait # we can assume we can flip flop between the parent and this cell.\\n time_needed = grid[r_nxt][c_nxt] - (cur_time+1)\\n flip_flops_needed = time_needed//2 + time_needed%2\\n heapq.heappush(heap, (cur_time+1+flip_flops_needed*2, (r_nxt, c_nxt)))\\n elif grid[r_nxt][c_nxt] <= cur_time + 1:\\n heapq.heappush(heap, (cur_time+1, (r_nxt, c_nxt)))\\n \\n \\n return -1\\n \\n\\n\",\n \"runtime\": \"2496\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, [0, 0, 0])\\n \\n # visited is needed\\n visited = [[False]*n for _ in range(m)]\\n \\n canHold = False\\n \\n while pq: \\n t, r, c = heapq.heappop(pq)\\n \\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n\\n if r == m-1 and c == n-1:\\n return t \\n \\n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\\n \\n for r2, c2 in allNbr:\\n if t+1 >= grid[r2][c2]:\\n canHold = True\\n \\n \\n \\n for newR, newC in allNbr:\\n if grid[newR][newC] > t+1:\\n if not(canHold):\\n continue\\n diff = grid[newR][newC] - (t+1)\\n else:\\n diff = 0\\n \\n stall = math.ceil(diff/2) * 2\\n \\n heapq.heappush(pq, [t+1+stall, newR, newC])\\n \\n return -1\\n \\n \",\n \"runtime\": \"2515\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":96,"string":"96"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n q = [(0, 0, 0)]\n while True:\n t, r, c = heappop(q)\n t += 1\n for i, j in ((r-1,c), (r+1,c), (r, c-1), (r, c+1)):\n if i<0 or i>=m or j<0 or j>=n or grid[i][j] == -1: continue\n when = max(t, grid[i][j] + (1 if (t+grid[i][j])%2 else 0 ) )\n if i == m-1 and j == n-1: return when\n heappush(q, (when, i, j))\n grid[i][j] = -1","memory":"29200"},{"code":"import heapq as hq\nclass Solution:\n def validCell(self, nRow, nCol, n, m):\n return nRow >= 0 and nRow < n and nCol >= 0 and nCol < m\n\n def minimumTime(self, grid: List[List[int]]) -> int:\n n, m = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n heap = []\n hq.heappush(heap, [0,0,0])\n dist = [[math.inf for _ in range(m)] for _ in range(n)]\n dist[0][0] = 0\n\n delRow = [1,-1,0,0]\n delCol = [0,0,1,-1]\n while heap:\n time, i, j = hq.heappop(heap)\n\n for k in range(4):\n nRow = i + delRow[k]\n nCol = j + delCol[k]\n\n if self.validCell(nRow, nCol, n, m):\n adjEle = grid[nRow][nCol]\n increment = max(1, adjEle - time + ((adjEle - time)%2 == 0))\n currTime = time + increment\n\n if dist[nRow][nCol] > currTime:\n dist[nRow][nCol] = currTime\n hq.heappush(heap, [currTime, nRow, nCol])\n return dist[n-1][m-1]","memory":"31000"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n \n # If the starting cell is not reachable immediately, return -1\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n # Initialize the distance array with infinity\n dist = [[float('inf')] * n for _ in range(m)]\n dist[0][0] = 0\n \n # Priority queue to store cells with the smallest time\n pq = [(0, 0, 0)] # (time, row, col)\n \n while pq:\n time, row, col = heapq.heappop(pq)\n \n # If we reached the bottom-right cell, return the time\n if row == m - 1 and col == n - 1:\n return time\n \n # Explore the four directions: up, down, left, right\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n \n # Check if the new cell is within bounds\n if 0 <= r < m and 0 <= c < n:\n # Calculate the waiting time if needed\n wait = (grid[r][c] - time) % 2 == 0\n new_time = max(time + 1, grid[r][c] + wait)\n \n # If the new time is smaller, update and add to the queue\n if new_time < dist[r][c]:\n dist[r][c] = new_time\n heapq.heappush(pq, (new_time, r, c))\n \n # If we couldn't reach the bottom-right cell, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\nprint(solution.minimumTime(grid)) # Output: 7","memory":"31500"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n rows,cols=len(grid),len(grid[0])\n \n if grid[0][1]>1 and grid[1][0]>1:\n return -1\n \n visited=[[False for i in range(cols)] for i in range(rows)]\n \n # curtime, cell\n pq=[(0,0,0)]\n heapq.heapify(pq)\n \n while pq:\n curTime,x,y=heapq.heappop(pq)\n if x==rows-1 and y==cols-1:\n return curTime\n for di in [(0,1),(0,-1),(1,0),(-1,0)]:\n nx=x+di[0]\n ny=y+di[1]\n \n if not (0<=nx<rows and 0<=ny<cols):\n continue\n if visited[nx][ny]:\n continue\n diff=grid[nx][ny]-curTime\n wait= 1 if (diff%2==0) else 0\n \n heapq.heappush(pq, ((max(curTime+1,grid[nx][ny]+wait), nx,ny)) )\n visited[nx][ny]=True\n return -1 \n \n \n \n \n \n \n \n \n \n \n \n \n ","memory":"31600"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\n\n m, n = len(grid), len(grid[0])\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\n dis = [[inf for _ in range(n)] for _ in range(m)]\n dis[0][0] = 0\n h = [(0, 0, 0)]\n while h:\n d, i, j = heapq.heappop(h)\n if i == m - 1 and j == n - 1:\n return d\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\n if 0 <= x < m and 0 <= y < n:\n nd = max(d + 1, grid[x][y])\n nd += (nd - x - y) % 2\n if nd < dis[x][y]:\n dis[x][y] = nd\n heappush(h, (nd, x, y))\n\n ","memory":"31700"},{"code":"import heapq\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n n,m = len(grid),len(grid[0])\n dirc = [(-1,0), (0,1), (1,0), (0,-1)]\n dist = [[float('inf')]*m for _ in range(n)]\n pq = [(0,0,0)]\n dist[0][0] = 0\n isValid = lambda nr,nc: nr >= 0 and nr<n and nc >= 0 and nc < m\n while pq:\n time,row,col = heapq.heappop(pq)\n if row == n-1 and col == m-1: \n return time\n for delRow,delCol in dirc:\n nr = delRow+row\n nc = delCol+col\n if isValid(nr,nc):\n if 1+time >= grid[nr][nc]:\n if dist[nr][nc] > 1+time:\n dist[nr][nc] = time+1\n heapq.heappush(pq,(1+time,nr,nc))\n else:\n diff = grid[nr][nc]-time\n if diff&1 == 0: diff += 1\n if dist[nr][nc] > time+diff:\n dist[nr][nc] = time+diff\n heapq.heappush(pq,(time+diff,nr,nc))\n return -1","memory":"31800"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n dist = [[inf] * n for _ in range(m)]\n dist[0][0] = 0\n q = [(0, 0, 0)]\n dirs = (-1, 0, 1, 0, -1)\n while 1:\n t, i, j = heappop(q)\n if i == m - 1 and j == n - 1:\n return t\n for a, b in pairwise(dirs):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n:\n nt = t + 1\n if nt < grid[x][y]:\n nt = grid[x][y] + (grid[x][y] - nt) % 2\n if nt < dist[x][y]:\n dist[x][y] = nt\n heappush(q, (nt, x, y))","memory":"31900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n m, n = len(grid), len(grid[0])\n dist = [[inf] * n for _ in range(m)]\n dist[0][0] = 0\n q = [(0, 0, 0)]\n dirs = (-1, 0, 1, 0, -1)\n while 1:\n t, i, j = heappop(q)\n if i == m - 1 and j == n - 1:\n return t\n for a, b in pairwise(dirs):\n x, y = i + a, j + b\n if 0 <= x < m and 0 <= y < n:\n nt = t + 1\n if nt < grid[x][y]:\n nt = grid[x][y] + (grid[x][y] - nt) % 2\n if nt < dist[x][y]:\n dist[x][y] = nt\n heappush(q, (nt, x, y))","memory":"32000"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n n = len(grid)\n m = len(grid[0])\n\n # Early exit check\n if not (grid[0][1] - grid[0][0] <= 1) and not (grid[1][0] - grid[0][0] <= 1):\n return -1\n\n # Priority queue (min-heap), storing (current_time, row, column)\n pq = [(0, 0, 0)] # Initialize heap with (time, row, column)\n rec = [[float('inf')] * m for _ in range(n)]\n rec[0][0] = 0\n\n # Directions for moving in the grid\n dx = [1, -1, 0, 0]\n dy = [0, 0, 1, -1]\n\n while pq:\n val, r, c = heapq.heappop(pq) # Pop the cell with the smallest current_time\n\n for i in range(4):\n nr = r + dx[i]\n nc = c + dy[i]\n if 0 <= nr < n and 0 <= nc < m:\n diff = grid[nr][nc] - val\n if diff <= 0:\n if rec[nr][nc] > val + 1:\n heapq.heappush(pq, (val + 1, nr, nc))\n rec[nr][nc] = val + 1\n continue\n\n # Adjust diff if it's even\n diff = diff + 1 if diff % 2 == 0 else diff\n if rec[nr][nc] > val + diff:\n heapq.heappush(pq, (val + diff, nr, nc))\n rec[nr][nc] = val + diff\n\n return rec[n - 1][m - 1] if rec[n - 1][m - 1] != float('inf') else -1\n","memory":"32200"},{"code":"import heapq\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n \n rows = len(grid)\n cols = len(grid[0])\n \n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\n time_to_reach[0][0] = 0\n \n q = [(0, 0, 0)] # (time, row, col)\n \n neighbours = [\n (0, 1),\n (1, 0),\n (0, -1),\n (-1, 0)\n ]\n \n while q:\n cur_time, cur_row, cur_col = heapq.heappop(q)\n \n for dr, dc in neighbours:\n r, c = cur_row + dr, cur_col + dc\n if r < 0 or r >= rows or c < 0 or c >= cols:\n continue\n \n wait_time = max(0, grid[r][c] - cur_time - 1)\n if wait_time % 2 != 0:\n wait_time += 1\n \n new_time = cur_time + wait_time + 1\n if time_to_reach[r][c] > new_time:\n time_to_reach[r][c] = new_time\n heapq.heappush(q, (new_time, r, c))\n \n return time_to_reach[rows-1][cols-1]\n","memory":"32299"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n length = len(grid[0])\n width = len(grid)\n\n min_time = [[float('inf')] * length for _ in range(width)]\n min_heap = []\n\n min_time[0][0] = 0\n heapq.heappush(min_heap, (0, (0,0))) # (min_time, index)\n\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n while min_heap:\n \n min_t, min_t_index = heapq.heappop(min_heap)\n min_t_x, min_t_y = min_t_index\n if min_t > min_time[min_t_x][min_t_y]: continue\n if min_t_index == (width-1, length-1): return min_t\n\n directions = [(1,0), (-1,0),(0,1),(0,-1)]\n\n for dx, dy in directions:\n next_x = min_t_x + dx\n next_y = min_t_y + dy\n if next_x in range(width) and next_y in range(length):\n cur_time = min_t + 1\n grid_value = grid[next_x][next_y]\n\n if grid_value <= cur_time:\n if cur_time < min_time[next_x][next_y]:\n min_time[next_x][next_y] = cur_time\n heapq.heappush(min_heap, (cur_time, (next_x, next_y)))\n else:\n if (next_x + next_y) % 2 == grid_value % 2:\n if grid_value < min_time[next_x][next_y]:\n min_time[next_x][next_y] = grid_value\n heapq.heappush(min_heap, (grid_value, (next_x, next_y)))\n else:\n if grid_value + 1 < min_time[next_x][next_y]:\n min_time[next_x][next_y] = grid_value + 1\n heapq.heappush(min_heap, (grid_value+1, (next_x, next_y)))","memory":"32400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1","memory":"33900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1\n","memory":"34000"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False] * n for _ in range(m)]\n heap = [(0, 0, 0)] # (t, r, c)\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n if visited[r][c]:\n continue\n visited[r][c] = True\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\n continue\n wait = 0 if (grid[nr][nc] - t) % 2 else 1\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n return -1\n","memory":"34100"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n visited = [[False]*n for _ in range(m)]\n heap = [(0, 0, 0)]\n\n while heap:\n t, x, y = heappop(heap)\n \n if x == m - 1 and y == n - 1:\n return t\n \n if visited[x][y]:\n continue\n visited[x][y] = True\n \n for dx, dy in [(0,1), (0,-1), (1,0), (-1,0)]:\n nx, ny = x+dx, y+dy\n\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\n wait = (grid[nx][ny] - t) % 2 == 0\n nt = max(grid[nx][ny] + wait, t + 1)\n heappush(heap, (nt, nx, ny))\n return -1","memory":"34200"},{"code":"from queue import PriorityQueue\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[1][0]>1 and grid[0][1]>1:\n return -1 \n \n pq = PriorityQueue()\n direction = [[1,0],[0,1],[-1,0],[0,-1]]\n row, col = len(grid), len(grid[0])\n pq.put([grid[0][0],0,0])\n visited = [[0] * col for _ in range(row)]\n\n while not pq.empty():\n time, r, c = pq.get()\n\n if r == row-1 and c == col-1:\n return time \n \n if visited[r][c]:\n continue \n \n visited[r][c]+=1\n\n for R,C in direction:\n newRow, newCol = r + R, c + C\n\n if newRow<0 or newRow>=row or newCol<0 or newCol>=col or visited[newRow][newCol]:\n continue \n \n check = (grid[newRow][newCol]-time)%2==0 #if true add 1 else as it is means if number odd \n\n pq.put([max(grid[newRow][newCol]+check,time+1),newRow,newCol])\n \n return -1 \n \n\n\n\n ","memory":"36400"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, [0, 0, 0])\n \n # visited is needed\n visited = [[False]*n for _ in range(m)]\n \n canHold = False\n \n while pq: \n t, r, c = heapq.heappop(pq)\n \n if visited[r][c]:\n continue\n visited[r][c] = True\n\n if r == m-1 and c == n-1:\n return t \n \n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\n \n for r2, c2 in allNbr:\n if t+1 >= grid[r2][c2]:\n canHold = True\n \n \n \n for newR, newC in allNbr:\n if grid[newR][newC] > t+1:\n if not(canHold):\n continue\n diff = grid[newR][newC] - (t+1)\n else:\n diff = 0\n \n stall = math.ceil(diff/2) * 2\n \n heapq.heappush(pq, [t+1+stall, newR, newC])\n \n return -1\n \n ","memory":"36700"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, [0, 0, 0])\n \n # visited is needed\n visited = [[False]*n for _ in range(m)]\n \n canHold = False\n \n while pq: \n t, r, c = heapq.heappop(pq)\n \n if visited[r][c]:\n continue\n visited[r][c] = True\n\n if r == m-1 and c == n-1:\n return t \n \n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\n \n for r2, c2 in allNbr:\n if t+1 >= grid[r2][c2]:\n canHold = True\n \n nbrs = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n and (grid[x[0]][x[1]] <= t + 1 and not(canHold) or canHold),\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\n \n \n for newR, newC in nbrs:\n if grid[newR][newC] > t+1:\n diff = grid[newR][newC] - (t+1)\n else:\n diff = 0\n \n stall = math.ceil(diff/2) * 2\n \n heapq.heappush(pq, [t+1+stall, newR, newC])\n \n return -1\n \n ","memory":"37000"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n m, n = len(grid), len(grid[0])\n heap = [(0, 0, 0)]\n min_time = [[inf] * n for _ in range(m)]\n min_time[0][0] = 0\n \n while heap:\n curr_time, r, c = heappop(heap)\n for dr, dc in [[-1, 0], [1, 0], [0, -1], [0, 1]]:\n if 0 <= r + dr < m and 0 <= c + dc < n:\n if curr_time + 1 >= min_time[r + dr][c + dc]:\n continue\n else:\n if (curr_time + 1 - grid[r + dr][c + dc]) % 2 == 0:\n min_time[r + dr][c + dc] = max(curr_time + 1, grid[r + dr][c + dc])\n else:\n min_time[r + dr][c + dc] = max(curr_time + 1, grid[r + dr][c + dc] + 1)\n heappush(heap, (min_time[r + dr][c + dc], r + dr, c + dc))\n return min_time[-1][-1]","memory":"37400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m = len(grid)\n n = len(grid[0])\n PQ = [[0, 0, 0]]\n D = [[-1, 0], [0, -1], [0, 1], [1, 0]]\n times = [[-1 for _ in range(n)] for _ in range(m)]\n times[0][0] = 0\n while PQ:\n time, i, j = heappop(PQ)\n if i == m - 1 and j == n - 1: return time\n for d in D:\n x = i + d[0]\n y = j + d[1]\n if x < 0 or x == m: continue\n if y < 0 or y == n: continue\n if times[x][y] != -1 and times[x][y] <= time + 1: continue\n if grid[x][y] <= time + 1: times[x][y] = time + 1\n else: times[x][y] = grid[x][y] + (grid[x][y] - time - 1) % 2\n heappush(PQ, [times[x][y], x, y])","memory":"38700"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n time = 0\n q = [(time, 0, 0)]\n visited = set()\n m = len(grid)\n n = len(grid[0])\n blocked = (grid[0][1]>1 and grid[1][0]>1)\n if blocked:\n return -1\n while q:\n time, i, j = heapq.heappop(q)\n if i==(m-1) and j==(n-1):\n return time\n if (i,j) in visited:\n continue\n visited.add((i,j))\n #print(f\"process {i, j}, time={time}\")\n time += 1\n for I, J in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\n if I>=0 and I<m and J>=0 and J<n:\n if (time)>=grid[I][J]:\n heapq.heappush(q, (time, I, J))\n next_time = time\n else:\n if (grid[I][J]-time)%2 == 0:\n heapq.heappush(q, (grid[I][J], I, J))\n next_time = grid[I][J]\n else:\n heapq.heappush(q, (grid[I][J]+1, I, J))\n next_time = grid[I][J]+1\n #print(f\"push {I, J, next_time}\")\n\n return -1\n ","memory":"39900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if len(grid) > 1 and len(grid[0]) > 1: \n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n elif len(grid) > 1 and grid[1][0] > 1:\n return -1\n elif len(grid[0]) > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == grid[a][b] % 2:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][grid[a][b] % 2] > nexto:\n shortests[a][b][grid[a][b] % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][(currTime+1) % 2] > nexto:\n shortests[a][b][(currTime+1) % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n return -1\n\n ","memory":"40100"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == grid[a][b] % 2:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][grid[a][b] % 2] > nexto:\n shortests[a][b][grid[a][b] % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][(currTime+1) % 2] > nexto:\n shortests[a][b][(currTime+1) % 2] = nexto\n heappush(prioQ, (nexto, a, b))\n\n ","memory":"40200"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if len(grid) > 1 and len(grid[0]) > 1: \n if grid[1][0] > 1 and grid[0][1] > 1:\n return -1\n elif len(grid) > 1 and grid[1][0] > 1:\n return -1\n elif len(grid[0]) > 1 and grid[0][1] > 1:\n return -1\n shortests = [[[float(\"inf\"), float(\"inf\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\n prioQ = []\n shortests[0][0][0] = 0\n heappush(prioQ, (0, 0, 0))\n while prioQ:\n currTime, i, j = heappop(prioQ)\n if i == len(grid)-1 and j == len(grid[0])-1:\n return currTime\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\n if (currTime+1) % 2 == 1:\n if grid[a][b] % 2 == 1:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][1] > nexto:\n shortests[a][b][1] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][1] > nexto:\n shortests[a][b][1] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n if grid[a][b] % 2 == 1:\n nexto = max(currTime+1, grid[a][b]+1)\n if shortests[a][b][0] > nexto:\n shortests[a][b][0] = nexto\n heappush(prioQ, (nexto, a, b))\n else:\n nexto = max(currTime+1, grid[a][b])\n if shortests[a][b][0] > nexto:\n shortests[a][b][0] = nexto\n heappush(prioQ, (nexto, a, b))\n return -1\n\n ","memory":"40300"},{"code":"import heapq as hq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n \n nrow = len(grid)\n ncol = len(grid[0])\n\n visited = set()\n heap = [(0,0,0)] # distance, row, col\n\n def helper(distance, row, col):\n newdist = max(distance + 1, grid[row][col])\n if newdist % 2 != (row + col) % 2:\n newdist += 1\n\n hq.heappush(heap, (newdist, row, col))\n\n\n while heap:\n distance, row, col = hq.heappop(heap)\n if (row, col) in visited: continue\n visited.add((row, col))\n if row == nrow - 1 and col == ncol - 1: return distance\n\n if row > 0: helper(distance, row-1, col)\n if row < nrow-1: helper(distance, row+1, col)\n if col > 0: helper(distance, row, col-1)\n if col < ncol - 1: helper(distance, row, col+1)\n\n return -1\n \n","memory":"40600"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n\n heap = [(grid[0][0], 0, 0)]\n # visited.add((0, 0))\n\n ans = -1\n\n while heap:\n time, row, col = heapq.heappop(heap)\n\n if row == rows-1 and col == cols-1:\n return time\n \n if (row, col) in visited: continue\n\n visited.add((row, col))\n \n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\n wait = 0\n if (grid[new_row][new_col] - time) % 2 == 0:\n wait = 1\n\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\n \n\n\n\n\n\n","memory":"40700"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n m = len(grid)\n n = len(grid[0])\n moves = [\n (0, 1),\n (0, -1),\n (1, 0),\n (-1, 0),\n ]\n heap = [(0, 0, 0)]\n visited = set([0, 0])\n while heap:\n curr_time, r, c = heappop(heap) \n if (r, c) in visited:\n continue\n \n if r == m - 1 and c == n - 1:\n return curr_time\n \n visited.add((r, c))\n \n for move in moves:\n nr, nc = r + move[0], c + move[1]\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\n\n","memory":"40800"},{"code":"'''\nO(mn log mn) O(Elogv)\nBrute Force:\nif t >= grid[i][j] then we can use the cell.\nI can go to 4 options at one point. O(n^3), memo of 3d.\nDijkestra's algo: we can go back to the time stamp with min. no. at the same time we can keep the nodes\nwith higher time stamps in the queue as well\nplay ping pong till the time>= the grid value of the target cell.\n'''\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] >1:\n return -1\n vis = set()\n min_heap = [ (grid[0][0], 0, 0) ]\n while min_heap:\n time, x, y = heapq.heappop(min_heap)\n if x == m-1 and y == n-1: return time\n if (x,y) in vis:\n continue\n vis.add((x,y))\n for dx, dy in [(1,0),(0,1),(-1,0),(0,-1)]:\n n_x, n_y = x+dx, y+dy\n n_cost = time + 1\n if 0<=n_x<m and 0<=n_y<n and (n_x, n_y) not in vis:\n if grid[n_x][n_y] >1+time:\n if (grid[n_x][n_y] - time)%2 == 0:\n n_cost = grid[n_x][n_y] + 1\n else:\n n_cost = grid[n_x][n_y]\n heapq.heappush(min_heap, (n_cost, n_x, n_y))\n return -1\n \n \n ","memory":"40900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n rows = len(grid)\n cols = len(grid[0])\n\n visited = set()\n\n heap = [(grid[0][0], 0, 0)]\n # visited.add((0, 0))\n\n ans = -1\n\n while heap:\n time, row, col = heapq.heappop(heap)\n\n if row == rows-1 and col == cols-1:\n return time\n \n if (row, col) in visited: continue\n\n visited.add((row, col))\n \n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\n wait = 1 if (grid[new_row][new_col] - time) % 2 == 0 else 0\n\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\n \n\n\n\n\n\n","memory":"41000"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n m, n = len(grid), len(grid[0])\n heap = [(0, 0, 0)]\n visited = set()\n \n while heap:\n t, r, c = heapq.heappop(heap)\n \n if (r, c) in visited:\n continue\n visited.add((r, c))\n \n if r == m - 1 and c == n - 1:\n return t\n \n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n \n return -1","memory":"41200"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n \n # If the immediate neighbor (1, 0) or (0, 1) is not reachable, we cannot start the BFS.\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n # Priority queue to store cells with their corresponding times\n heap = [(0, 0, 0)] # (time, row, col)\n visited = set()\n \n while heap:\n time, row, col = heapq.heappop(heap)\n \n # If we reached the bottom-right cell, return the current time\n if row == m - 1 and col == n - 1:\n return time\n \n # If the cell is already visited, skip it\n if (row, col) in visited:\n continue\n visited.add((row, col))\n \n # Add neighboring cells to the heap\n for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n # If the neighboring cell is reachable at the current time + 1, add it to the heap\n if grid[r][c] <= time + 1:\n heapq.heappush(heap, (time + 1, r, c))\n else:\n # If the neighboring cell is not reachable yet, we need to wait until it is\n # The wait time can be calculated as the time required by the cell + 1 if it is odd, or directly + 1 if it is even\n wait_time = grid[r][c] + (1 if grid[r][c] % 2 == time % 2 else 0)\n heapq.heappush(heap, (wait_time, r, c))\n \n # If we haven't found a path to the bottom-right cell, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\nprint(solution.minimumTime(grid)) # Output: 7\n\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\nprint(solution.minimumTime(grid)) # Output: -1","memory":"41400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m, n = len(grid), len(grid[0])\n visited = set()\n pq = [(grid[0][0], 0, 0)]\n\n while pq:\n time, row, col = heappop(pq)\n if row == m-1 and col == n-1: return time\n if (row, col) in visited: continue\n visited.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c)) ","memory":"41500"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\n if grid[dr][dc] > curTime+1:\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","memory":"41600"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # Return -1 immediately if we can't move at the start\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n m, n = len(grid), len(grid[0])\n dirs = [(0, -1), (0, 1), (1, 0), (-1, 0)]\n visited = set()\n pq = [(0, 0, 0)] # time, row, column\n while pq:\n t, r, c = heapq.heappop(pq)\n if r == m - 1 and c == n - 1:\n return t\n if (r, c) in visited:\n continue\n visited.add((r, c))\n for dx, dy in dirs:\n nx, ny = r + dx, c + dy\n if 0 > nx or nx >= m or 0 > ny or ny >= n or (nx, ny) in visited:\n continue\n wait = 1 if (grid[nx][ny] - t) % 2 == 0 else 0\n nt = max(grid[nx][ny] + wait, t + 1)\n heapq.heappush(pq, (nt, nx, ny))\n return -1\n\n ","memory":"41700"},{"code":"from queue import PriorityQueue\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if (grid[0][1] > 1 and grid[1][0] > 1):\n return -1\n\n m = len(grid)\n n = len(grid[0])\n pq = PriorityQueue()\n pq.put((0, 0, 0))\n vis = set()\n dirs = ((0, -1), (0, 1), (-1, 0), (1, 0))\n while pq.qsize():\n t, r, c = pq.get()\n if r == m - 1 and c == n - 1:\n return t\n if (r, c) in vis:\n continue\n vis.add((r, c))\n for x, y in dirs:\n nr = r + x\n nc = c + y\n if nr >= 0 and nc >= 0 and nr < m and nc < n and (nr, nc) not in vis:\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n pq.put((nt, nr, nc))\n \n return -1\n","memory":"41800"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\n if grid[dr][dc] > curTime+1:\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","memory":"41900"},{"code":"## Time O(M*N*log(M*N)) || Space O(M*N)\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1 \n\n visited = set()\n minTime = -1\n\n q = [(0,0,0)]\n\n while q:\n curTime, row, col = heapq.heappop(q)\n if row == len(grid)-1 and col == len(grid[0])-1:\n return curTime\n if (row,col) in visited:\n continue\n visited.add((row,col))\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\n dr, dc = row+r, col+c\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\n if grid[dr][dc] > curTime+1:\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\n heapq.heappush(q, (tt, dr,dc))\n else:\n heapq.heappush(q, (curTime+1, dr,dc))\n \n return minTime","memory":"41900"},{"code":"import heapq\nfrom typing import List\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n \n # If we cannot even start from the top-left cell, return -1\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n # Directions to move in the grid: up, down, left, right\n directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n \n # Min-heap to store the cells to visit, along with the time taken to reach them\n heap = [(0, 0, 0)] # (time, row, col)\n \n # Set to store the visited cells\n visited = set()\n \n while heap:\n time, row, col = heapq.heappop(heap)\n \n # If we have reached the bottom-right cell, return the current time\n if row == m - 1 and col == n - 1:\n return time\n \n # If the cell is already visited, continue\n if (row, col) in visited:\n continue\n \n # Mark the cell as visited\n visited.add((row, col))\n \n # Explore all adjacent cells\n for dr, dc in directions:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n:\n # Calculate the waiting time if needed\n wait_time = (grid[r][c] - time) % 2 == 0\n new_time = max(time + 1, grid[r][c] + wait_time)\n heapq.heappush(heap, (new_time, r, c))\n \n # If we cannot reach the bottom-right cell, return -1\n return -1\n\n# Example usage:\nsolution = Solution()\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\nprint(solution.minimumTime(grid)) # Output: 7\n\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\nprint(solution.minimumTime(grid)) # Output: -1","memory":"42000"},{"code":"import heapq\nfrom typing import List\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n m, n = len(grid), len(grid[0])\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n \n def is_valid(x, y):\n return 0 <= x < m and 0 <= y < n\n \n min_heap = [(0, 0, 0)] # (time, row, col)\n visited = set()\n\n while min_heap:\n time, x, y = heapq.heappop(min_heap)\n if (x, y) == (m-1, n-1):\n return time\n if (x, y) in visited:\n continue\n visited.add((x, y))\n\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if is_valid(nx, ny) and (nx, ny) not in visited:\n wait_time = max(0, grid[nx][ny] - (time + 1))\n if wait_time % 2 == 0:\n heapq.heappush(min_heap, (time + 1 + wait_time, nx, ny))\n else:\n heapq.heappush(min_heap, (time + 2 + wait_time, nx, ny))\n\n return -1","memory":"42100"},{"code":"from queue import Queue\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m=len(grid)\n n=len(grid[0])\n mx=10**9\n if grid[0][1]>1 and grid[1][0]>1:\n return -1\n dir=[[-1,0],[1,0],[0,-1],[0,1]]\n pq=[(grid[0][0],0,0)]\n vis=set()\n \n while pq:\n time,curx,cury=heappop(pq)\n if curx==m-1 and cury==n-1:\n return time\n if (curx,cury) in vis:\n continue\n vis.add((curx,cury))\n \n for i in range(4):\n nx=curx+dir[i][0]\n ny=cury+dir[i][1]\n if nx>=0 and nx<m and ny>=0 and ny<n and (nx,ny) not in vis:\n wait=0\n if grid[nx][ny]>time:\n wait=(grid[nx][ny]-time)\n if wait%2==1:\n wait-=1\n heappush(pq,(max(1+time,time+1+wait),nx,ny))\n return -1\n \n ","memory":"42400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n rowLen, colLen = len(grid), len(grid[0])\n heap = [(0, (0, 0))] # time, (x, y)\n visited = {(0, 0)}\n\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\n\n while heap:\n time, (x, y) = heapq.heappop(heap)\n if x == rowLen - 1 and y == colLen - 1:\n return time\n\n for move in moves:\n newX, newY = x + move[0], y + move[1]\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\n if grid[newX][newY] <= time + 1:\n heapq.heappush(heap, (time + 1, (newX, newY)))\n elif canMove:\n timeNeeded = grid[newX][newY] - time - 1\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\n heapq.heappush(heap, (totalTime, (newX, newY)))\n visited.add((newX, newY))\n return -1\n","memory":"42900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n def bounds(r, c):\n return 0<=r<len(grid) and 0<=c<len(grid[0])\n\n if grid[0][0]+1 < grid[0][1] and grid[0][0]+1 < grid[1][0]:\n return -1 \n\n q = []\n visited = set()\n time = 0\n if grid[0][0] <= time:\n q.append((time,0,0))\n visited.add((0,0))\n res = float(\"inf\")\n while(len(q)):\n # print(q)\n time,r,c = heapq.heappop(q)\n if r == len(grid)-1 and c == len(grid[0])-1:\n return time\n\n for d in [(0,1), (0,-1), (-1, 0), (1,0)]:\n nr, nc = r+d[0],c+d[1]\n # print(r,c, nr,nc)\n if bounds(nr, nc):\n if time >= grid[nr][nc] and (nr,nc) not in visited:\n visited.add((nr,nc))\n heapq.heappush(q, (time+1, nr, nc))\n elif (nr,nc) not in visited:\n visited.add((nr,nc))\n newTime = grid[nr][nc] if (grid[nr][nc]-time) %2 == 1 else grid[nr][nc]+1\n heapq.heappush(q, (newTime, nr, nc))\n \n return -1 if res == float(\"inf\") else res\n\n\n\n \n \n \n ","memory":"43100"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n rowLen, colLen = len(grid), len(grid[0])\n moves = ((0, 1), (1, 0), (0, -1), (-1, 0))\n heap = [(0, (0, 0))]\n visited = {(0, 0)}\n\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\n\n while heap:\n time, (x, y) = heapq.heappop(heap)\n if x == rowLen - 1 and y == colLen - 1:\n return time\n for move in moves:\n newX, newY = x + move[0], y + move[1]\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\n if grid[newX][newY] <= time + 1:\n heapq.heappush(heap, (time + 1, (newX, newY)))\n elif canMove:\n timeNeeded = grid[newX][newY] - time - 1\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\n heapq.heappush(heap, (totalTime, (newX, newY)))\n visited.add((newX, newY))\n return -1","memory":"43400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # base\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n m, n = len(grid), len(grid[0])\n\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\n visited = {(0, 0)} # trace back visited cell\n\n while minhpq:\n time, i, j = heappop(minhpq)\n\n # stop; found a solution\n if i == m - 1 and j == n - 1:\n return time\n\n for di, dj in dirs:\n di, dj = i + di, j + dj\n \n # pass; infeasible or seen before\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\n continue\n\n # wait is at max 1 to move from (i, j) to (di, dj)\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\n\n # take the max for the next possible valid time\n next_time = max(time + 1, grid[di][dj] + wait)\n\n # push the new cell into min heap\n heappush(minhpq, (next_time, di, dj))\n visited.add((di, dj))\n\n return -1","memory":"43500"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","memory":"43600"},{"code":"class Solution:\n def minimumTime(self, grid: list[list[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\n m = len(grid)\n n = len(grid[0])\n minHeap = [(0, 0, 0)] # (time, i, j)\n seen = {(0, 0)}\n\n while minHeap:\n time, i, j = heapq.heappop(minHeap)\n if i == m - 1 and j == n - 1:\n return time\n for dx, dy in dirs:\n x = i + dx\n y = j + dy\n if x < 0 or x == m or y < 0 or y == n:\n continue\n if (x, y) in seen:\n continue\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\n nextTime = max(time + 1, grid[x][y] + extraWait)\n heapq.heappush(minHeap, (nextTime, x, y))\n seen.add((x, y))","memory":"43700"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # base\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\n m, n = len(grid), len(grid[0])\n\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\n visited = {(0, 0)} # trace back visited cell\n\n while minhpq:\n time, i, j = heappop(minhpq)\n\n # stop; found a solution\n if i == m - 1 and j == n - 1:\n return time\n\n for di, dj in dirs:\n di, dj = i + di, j + dj\n \n # pass; infeasible or seen before\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\n continue\n\n # wait is at max 1 to move from (i, j) to (di, dj)\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\n\n # take the max for the next possible valid time\n next_time = max(time + 1, grid[di][dj] + wait)\n\n # push the new cell into min heap\n heappush(minhpq, (next_time, di, dj))\n visited.add((di, dj))\n\n return -1","memory":"43800"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n heap = [(0, 0, 0)]\n visited = {(0, 0)}\n while heap:\n t, r, c = heapq.heappop(heap)\n if r == m - 1 and c == n - 1:\n return t\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\n nr, nc = r + dr, c + dc\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\n continue\n wait = (grid[nr][nc] - t) % 2 == 0\n nt = max(grid[nr][nc] + wait, t + 1)\n heapq.heappush(heap, (nt, nr, nc))\n visited.add((nr, nc))\n return -1","memory":"43900"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n fringe = [(0, 0, 0)] #time, row, col\n heapq.heapify(fringe)\n\n seen = {(0, 0): 0} #(row, col): time\n\n # max_val = max(max(row) for row in grid)\n # max_t = max_val + len(grid) + len(grid[0])\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\n return -1\n\n while fringe:\n t, r, c = heapq.heappop(fringe)\n # if t >= max_t:\n # continue\n\n # new_t = t + 1\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if new_r < 0 or new_r >= len(grid):\n continue\n if new_c < 0 or new_c >= len(grid[r]):\n continue\n\n if grid[new_r][new_c] <= t+1:\n new_t = t+1\n else:\n diff = grid[new_r][new_c] - t\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\n\n if (new_r, new_c) in seen and seen[(new_r, new_c)] <= new_t:\n continue\n\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\n return new_t\n\n\n heapq.heappush(fringe, (new_t, new_r, new_c))\n seen[(new_r, new_c)] = new_t\n\n return -1","memory":"45100"},{"code":"import heapq\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n fringe = [(0, 0, 0)] #time, row, col\n heapq.heapify(fringe)\n\n seen = {(0, 0): 0} #(row, col): time\n\n # max_val = max(max(row) for row in grid)\n # max_t = max_val + len(grid) + len(grid[0])\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\n return -1\n\n while fringe:\n t, r, c = heapq.heappop(fringe)\n # if t >= max_t:\n # continue\n\n # new_t = t + 1\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if new_r < 0 or new_r >= len(grid):\n continue\n if new_c < 0 or new_c >= len(grid[r]):\n continue\n\n if grid[new_r][new_c] <= t+1:\n new_t = t+1\n else:\n diff = grid[new_r][new_c] - t\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\n\n if (new_r, new_c) in seen and seen[(new_r, new_c)] <= new_t:\n continue\n\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\n return new_t\n\n\n heapq.heappush(fringe, (new_t, new_r, new_c))\n seen[(new_r, new_c)] = new_t\n\n return -1","memory":"45100"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # ye15: Dijkstra's algo - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3230926/python3-dijkstra-s-algo/\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\n # BFS with priority queue; Explained - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3235344/python-bfs-with-priority-queue-explained/\n \n if grid[0][1] <= 1 or grid[1][0] <= 1: \n m, n = len(grid), len(grid[0])\n pq = [(0, 0, 0)]\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\n while pq: \n x, i, j = heappop(pq)\n if (i, j) == (m-1, n-1): return x \n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \n if 0 <= ii < m and 0 <= jj < n: \n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \n if dist[ii, jj] > xx: \n heappush(pq, (xx, ii, jj))\n dist[ii, jj] = xx \n return -1 \n\n m, n = len(grid), len(grid[0])\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\n dis = [[inf for _ in range(n)] for _ in range(m)]\n dis[0][0] = 0\n pq = [(0, 0, 0)]\n while pq:\n d, i, j = heapq.heappop(pq)\n if i == m - 1 and j == n - 1:\n return d\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\n if 0 <= x < m and 0 <= y < n:\n nd = max(d + 1, grid[x][y])\n nd += (nd - x - y) % 2\n if nd < dis[x][y]:\n dis[x][y] = nd\n heappush(pq, (nd, x, y))\n\n \n # Wrong Answer - 37 / 41 testcases passed\n nrow = len(grid)\n ncol = len(grid[0])\n \n visited = set()\n visit_queue = [(0, 0, 0)]\n visited.add((0, 0))\n \n ans = -1\n while visit_queue:\n visit_time, r, c = heapq.heappop(visit_queue)\n if r == nrow - 1 and c == ncol - 1:\n ans = visit_time\n break\n \n for ncell in {(0, 1), (1, 0), (0, -1), (-1, 0)}:\n nr = r + ncell[0]\n nc = c + ncell[1]\n if nr >= 0 and nr < nrow and nc >= 0 and nc < ncol and (nr, nc) not in visited:\n if grid[nr][nc] <= visit_time + 1:\n heapq.heappush(visit_queue, (visit_time + 1, nr, nc))\n visited.add((nr, nc))\n elif len(visited) >= 2:\n if (grid[nr][nc] - visit_time) % 2 == 0:\n heapq.heappush(visit_queue, (grid[nr][nc] + 1, nr, nc))\n else:\n heapq.heappush(visit_queue, (grid[nr][nc], nr, nc))\n visited.add((nr, nc))\n \n return ans \n\n\n\n \n\n ","memory":"45300"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] <= 1 or grid[1][0] <= 1: \n m, n = len(grid), len(grid[0])\n pq = [(0, 0, 0)]\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\n while pq: \n x, i, j = heappop(pq)\n if (i, j) == (m-1, n-1): return x \n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \n if 0 <= ii < m and 0 <= jj < n: \n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \n if dist[ii, jj] > xx: \n heappush(pq, (xx, ii, jj))\n dist[ii, jj] = xx \n return -1 ","memory":"45400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] <= 1 or grid[1][0] <= 1: \n m, n = len(grid), len(grid[0])\n pq = [(0, 0, 0)]\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\n while pq: \n x, i, j = heappop(pq)\n if (i, j) == (m-1, n-1): return x \n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \n if 0 <= ii < m and 0 <= jj < n: \n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \n if dist[ii, jj] > xx: \n heappush(pq, (xx, ii, jj))\n dist[ii, jj] = xx \n return -1","memory":"45500"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n\n if mem[(r, c)] < t:\n continue\n print(t, r, c)\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n elif (t + 1) % 2 == grid[nr][nc] % 2:\n nt = grid[nr][nc]\n else:\n nt = grid[nr][nc] + 1\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n\n return -1\n\n\n\n\n\n","memory":"45700"},{"code":"from collections import deque\nfrom itertools import starmap\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\n visited = set()\n rows = len(grid)\n cols = len(grid[0])\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\n costs = defaultdict(lambda : float('inf'))\n\n heap = [(0,(0,0))]\n\n\n while heap:\n cur_time, (r,c) = heapq.heappop(heap)\n if (r,c) in visited:\n continue\n visited.add((r,c))\n if (r,c) == (rows-1, cols-1):\n return cur_time\n possible_vertices = valid_movements(r,c)\n for r_nxt, c_nxt in possible_vertices:\n # Get the time needed move to the next cell. sometimes the next cell will be low value so floor it to 0\n time_diff = max(0, (grid[r_nxt][c_nxt] - (cur_time+1)))\n base = cur_time + 1\n wait = time_diff + time_diff%2 # time_diff//2 * 2 = time_diff each flip-flop is 2 seconds.\n heapq.heappush(heap, (base + wait, (r_nxt, c_nxt)))\n \n \n return -1\n \n\n","memory":"45800"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n if mem[(r, c)] < t:\n continue\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n elif (t + 1) % 2 == grid[nr][nc] % 2:\n nt = grid[nr][nc]\n else:\n nt = grid[nr][nc] + 1\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n return -1\n","memory":"46000"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n\n if mem[(r, c)] < t:\n continue\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n elif (t + 1) % 2 == grid[nr][nc] % 2:\n nt = grid[nr][nc]\n else:\n nt = grid[nr][nc] + 1\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n\n return -1\n\n\n\n\n\n","memory":"46100"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n\n h = [(0,0,0)]\n mem = defaultdict(lambda : inf)\n mem[(0,0)] = 0\n rows, cols = len(grid), len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n while h:\n t, r, c = heappop(h)\n if (r, c) == (rows - 1, cols - 1):\n return t\n if mem[(r, c)] < t:\n continue\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n if t + 1 >= grid[nr][nc]:\n nt = t + 1\n else:\n nt = grid[nr][nc] + ((t + 1) % 2 != grid[nr][nc] % 2)\n if mem[(nr, nc)] > nt:\n mem[(nr, nc)] = nt\n heappush(h, (nt, nr, nc))\n return -1\n","memory":"46500"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n m = len(grid)\n n = len(grid[0])\n start = (0, 0)\n dist = defaultdict(lambda: float('inf'))\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, (0, 0, 0))\n dist[0, 0] = 0\n\n while len(pq) > 0:\n w, x, y = heapq.heappop(pq)\n if dist[x, y] < w: continue\n if (x, y) == (m - 1, n - 1): return dist[x, y]\n\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n for direction in dirs:\n newX, newY = x + direction[0], y + direction[1]\n if 0 <= newX < m and 0 <= newY < n:\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\n dist[newX, newY] = dist[x, y] + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif grid[newX][newY] > dist[x, y] + 1:\n wait = grid[newX][newY] - dist[x, y]\n\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\n dist[newX, newY] = dist[x, y] + wait + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\n dist[newX, newY] = dist[x, y] + wait\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n \n return -1\n","memory":"46600"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n # It is always possible to reach the end as long as we have a valid parent, in the beginning at (0,0) we don't have a valid parent so this position might get blocked otherwise we can always reach.\n \n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n m = len(grid)\n n = len(grid[0])\n start = (0, 0)\n dist = defaultdict(lambda: float('inf'))\n pq = []\n heapq.heapify(pq)\n heapq.heappush(pq, (0, 0, 0))\n dist[0, 0] = 0\n\n while len(pq) > 0:\n w, x, y = heapq.heappop(pq)\n if dist[x, y] < w: continue\n if (x, y) == (m - 1, n - 1): return dist[x, y]\n\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n for direction in dirs:\n newX, newY = x + direction[0], y + direction[1]\n if 0 <= newX < m and 0 <= newY < n:\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\n dist[newX, newY] = dist[x, y] + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif grid[newX][newY] > dist[x, y] + 1:\n wait = grid[newX][newY] - dist[x, y]\n\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\n dist[newX, newY] = dist[x, y] + wait + 1\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\n dist[newX, newY] = dist[x, y] + wait\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\n \n return -1\n","memory":"46700"},{"code":"from collections import deque\nfrom itertools import starmap\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\n visited = set()\n rows = len(grid)\n cols = len(grid[0])\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\n costs = defaultdict(lambda : float('inf'))\n\n heap = [(0,(0,0))]\n\n\n while heap:\n cur_time, (r,c) = heapq.heappop(heap)\n if (r,c) in visited:\n continue\n visited.add((r,c))\n if (r,c) == (rows-1, cols-1):\n return cur_time\n possible_vertices = valid_movements(r,c)\n for r_nxt, c_nxt in possible_vertices:\n if grid[r_nxt][c_nxt] > cur_time + 1:\n # we need to wait # we can assume we can flip flop between the parent and this cell.\n time_needed = grid[r_nxt][c_nxt] - (cur_time+1)\n flip_flops_needed = time_needed//2 + time_needed%2\n heapq.heappush(heap, (cur_time+1+flip_flops_needed*2, (r_nxt, c_nxt)))\n elif grid[r_nxt][c_nxt] <= cur_time + 1:\n heapq.heappush(heap, (cur_time+1, (r_nxt, c_nxt)))\n \n \n return -1\n \n\n","memory":"47300"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n ## adjusted Dijkstra's algo\n if grid[1][0] > 1 and grid[0][1] > 1: \n return -1\n import heapq\n from collections import defaultdict\n m, n = len(grid), len(grid[0])\n dis = defaultdict(lambda: float('inf'))\n dis[(0, 0)] = 0\n queue = [[0, (0, 0)]]\n heapq.heapify(queue)\n directions = [\n [-1, 0], \n [1, 0], \n [0, -1], \n [0, 1]\n ]\n while queue: \n dis_curr, (x, y) = heapq.heappop(queue)\n if x == m - 1 and y == n - 1: \n return dis_curr\n for dx, dy in directions: \n xx = x + dx\n yy = y + dy\n if 0 <= xx < m and 0 <= yy < n: \n if dis_curr + 1 >= grid[xx][yy]:\n val = dis_curr + 1\n if val < dis[(xx, yy)]: \n dis[(xx, yy)] = val\n heapq.heappush(queue, [val, (xx, yy)])\n else: \n diff = grid[xx][yy] - (dis_curr + 1)\n if diff % 2 == 1: \n diff += 1\n val = dis_curr + 1 + diff\n if val < dis[(xx, yy)]: \n dis[(xx, yy)] = val\n heapq.heappush(queue, [val, (xx, yy)])\n \n return -1 \n \n \n ","memory":"49200"},{"code":"from collections import deque\n\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n seen = set()\n heap = []\n heapq.heappush(heap, [0, 0, 0])\n seen.add((0, 0))\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1]]\n\n def isValid(r, c):\n return 0 <= r < len(grid) and 0 <= c < len(grid[0])\n\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n \n while heap:\n time, row, col = heapq.heappop(heap)\n if row == len(grid) - 1 and col == len(grid[0]) - 1:\n return time\n \n for dx, dy in directions:\n newRow, newCol = row + dx, col + dy\n if isValid(newRow, newCol):\n if time + 1 >= grid[newRow][newCol] and (newRow, newCol) not in seen:\n heapq.heappush(heap, [time + 1, newRow, newCol])\n elif time + 1 < grid[newRow][newCol]:\n diff = grid[newRow][newCol] - time\n if diff % 2 == 0:\n heapq.heappush(heap, [grid[newRow][newCol] + 1, newRow, newCol])\n else:\n heapq.heappush(heap, [grid[newRow][newCol], newRow, newCol])\n seen.add((newRow, newCol))\n\n return -1\n\n ","memory":"49300"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n ## adjusted Dijkstra's algo\n if grid[1][0] > 1 and grid[0][1] > 1: \n return -1\n import heapq\n from collections import defaultdict\n m, n = len(grid), len(grid[0])\n dis = defaultdict(lambda: float('inf'))\n dis[(0, 0)] = 0\n queue = [[0, (0, 0)]]\n heapq.heapify(queue)\n directions = [\n [-1, 0], \n [1, 0], \n [0, -1], \n [0, 1]\n ]\n while queue: \n dis_curr, (x, y) = heapq.heappop(queue)\n if x == m - 1 and y == n - 1: \n return dis_curr\n for dx, dy in directions: \n xx = x + dx\n yy = y + dy\n if 0 <= xx < m and 0 <= yy < n: \n if dis_curr + 1 >= grid[xx][yy]: \n if dis_curr + 1 < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\n else: \n diff = grid[xx][yy] - (dis_curr + 1)\n if diff % 2 == 1: \n diff += 1\n if dis_curr + 1 + diff < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1 + diff\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\n \n return -1 \n \n \n ","memory":"50200"},{"code":"from heapq import heappush,heappop\nclass Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n R = len(grid)\n C = len(grid[0])\n # Check if there is a path exist\n has_path = False\n for r,c in ((0,1),(1,0)):\n if 0<=r<R and 0<=c<C:\n if grid[r][c] <= 1 :\n has_path = True\n if not has_path : return -1\n heap = [(0,0,0)]\n dist = {}\n dist[(0,0)] = 0\n visited = set()\n while heap:\n _,r,c = heappop(heap)\n if (r,c) in visited: continue\n if r == R-1 and c == C-1:\n break\n visited.add((r,c))\n cur_time = dist[(r,c)]\n for nr,nc in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\n if (nr,nc) in visited : continue\n if 0<=nr<R and 0<=nc<C:\n cost = None\n if grid[nr][nc] <= cur_time + 1:\n cost = 1\n else:\n cost = grid[nr][nc] - cur_time\n if cost%2 == 0 :\n cost += 1\n if cost:\n if cur_time + cost < dist.get((nr,nc),float('inf')):\n dist[(nr,nc)] = cur_time + cost\n heappush(heap,(dist[(nr,nc)],nr,nc))\n return dist[(R-1,C-1)]","memory":"51700"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n kRows = len(grid)\n kCols = len(grid[0])\n\n graph = Grid(kRows, kCols)\n\n mcfs = BoundedMCFS(graph, ToTarget(graph.vertex_count() - 1))\n\n def get_attrs(r1, c1, r2, c2):\n edge_len = max(grid[r2][c2] - mcfs.costs[graph.coor2idx(r1, c1)], 0)\n if edge_len % 2 == 0:\n edge_len += 1\n return edge_len\n\n graph.get_attrs = get_attrs\n\n mcfs.run(0)\n\n return mcfs.costs[-1]\n\n\nfrom dataclasses import dataclass, astuple\nfrom typing import Any\n\n\n@dataclass\nclass Edge:\n source: int\n target: int\n attrs: Any = ()\n handle: Any = None\n\n\nclass Graph:\n \"\"\"Graph ABC.\n\n This class assumes that vertices are indexed 0, 1, 2, ..., vertex_count-1.\n \"\"\"\n\n def __init__(self, vertex_count):\n \"\"\"Initialize the graph with the given number of vertices.\"\"\"\n assert vertex_count > 0\n self._vertex_count = vertex_count\n\n # --------------------------------------------------------------------------\n\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\n \"\"\"Add a directed edge from source to target with given attributes.\n\n Returns: edge handle that can be used in `get` and 'remove' operations.\n \"\"\"\n raise NotImplementedError()\n\n def add_undirected_edge(self, u: int, v: int, attrs=None, **kwargs):\n \"\"\"Add an undirected edge between u and v with the given attributes.\n\n Returns: edge handles that can be used in `get` and 'remove' operations.\n \"\"\"\n handle_uv = self.add_edge(u, v, attrs, **kwargs)\n handle_vu = self.add_edge(v, u, attrs, **kwargs)\n return handle_uv, handle_vu\n\n def get_edge(self, source: int, target: int, handle=None):\n \"\"\"Retrieve a directed edge from source to target.\n\n Returns: Edge object.\n \"\"\"\n raise NotImplementedError()\n\n def remove_edge(self, source: int, target: int, handle=None):\n \"\"\"Remove a directed edge from source to target.\"\"\"\n raise NotImplementedError()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n raise NotImplementedError()\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n for edge in self.edges():\n if edge.target == target:\n yield edge\n\n def edges(self):\n \"\"\"Generate all edges in the graph.\"\"\"\n for source in self.vertices():\n yield from self.out_edges(source)\n\n def vertices(self):\n \"\"\"Generate all vertices in the graph.\"\"\"\n return range(self._vertex_count)\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n return len(list(self.out_edges(source)))\n\n def out_degrees(self) -> list[int]:\n \"\"\"Get the list of out-degrees of all vertices in the graph.\"\"\"\n return [self.out_degree(source) for source in self.vertices()]\n\n def in_degree(self, target: int) -> int:\n \"\"\"Get the in-degree of a given target vertex.\"\"\"\n return len(list(self.in_edges(target)))\n\n def in_degrees(self) -> list[int]:\n \"\"\"Get the list of in-degrees of all vertices in the graph.\"\"\"\n in_degs = [0] * self.vertex_count()\n for edge in self.edges():\n in_degs[edge.target] += 1\n return in_degs\n\n # --------------------------------------------------------------------------\n\n def edge_count(self) -> int:\n \"\"\"Get the number of edges in the graph.\"\"\"\n return sum(self.out_degrees())\n\n def vertex_count(self) -> int:\n \"\"\"Get the number of vertices in the graph.\"\"\"\n return self._vertex_count\n\n # --------------------------------------------------------------------------\n\n def add_edges(self, edges):\n \"\"\"Add directed edges with optional attributes.\"\"\"\n for edge in edges:\n source, target, *attrs = edge\n self.add_edge(source, target, self._seq2attrs(attrs))\n\n def add_undirected_edges(self, edges):\n \"\"\"Add undirected edges with optional attributes.\"\"\"\n for edge in edges:\n source, target, *attrs = edge\n self.add_undirected_edge(source, target, self._seq2attrs(attrs))\n\n def _seq2attrs(self, attrs):\n match len(attrs):\n case 0: return Edge.attrs # default empty tuple\n case 1: return attrs[0]\n case _: return attrs\n\n # --------------------------------------------------------------------------\n\n def _get_attrs(self, attrs, kwargs):\n \"\"\"Build edge attrs object from `add_[undirected_]edge` method args.\"\"\"\n if attrs is None:\n if kwargs:\n # TODO: Convert to a named tuple?\n attrs = kwargs\n else:\n attrs = Edge.attrs\n return attrs\n\n\ndef transposed(graph):\n \"\"\"Transpose (reverse the direction of all edges in) the given graph.\"\"\"\n transposed = type(graph)(graph.vertex_count())\n for source, target, attrs, _ in graph.edges():\n transposed.add_edge(target, source, attrs)\n return transposed\n\n\n# ----------------------------------------------------------------------------\n# Concrete Graph Classes\n# ----------------------------------------------------------------------------\n\n\nclass AdjacencyList():\n\n def __init__(self):\n \"\"\"Initialize an empty adjacency list.\"\"\"\n self._out_edges = []\n self._size = 0\n\n def add(self, target: int, attrs) -> int:\n \"\"\"Add a new edge to the end of the adjacency list.\n\n Returns: index of the added edge.\n \"\"\"\n if len(self._out_edges) == self._size:\n self._out_edges.append((target, attrs))\n else:\n # assert len(self._out_edges) > self._size\n assert self._out_edges[self._size] is None\n self._out_edges[self._size] = (target, attrs)\n self._size += 1\n return self._size - 1\n\n def get(self, source: int, target: int, idx: int = None):\n \"\"\"Retrieve an / the edge pointing at vertex `target`.\"\"\"\n idx = self._index(target, idx)\n return Edge(source, target, self._out_edges[idx][1], idx)\n\n def remove(self, target: int, idx: int = None):\n \"\"\"Remove an / the edge pointing at vertex `target`.\"\"\"\n idx = self._index(target, idx)\n self._size -= 1\n self._out_edges[idx] = self._out_edges[self._size]\n self._out_edges[self._size] = idx\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges.\"\"\"\n for idx, (target, attrs) in enumerate(self._out_edges[:self._size]):\n yield Edge(source, target, attrs, idx)\n\n def __len__(self):\n \"\"\"Return the number of edges in this adjacency list.\"\"\"\n return self._size\n\n def _index(self, target: int, idx: int = None):\n \"\"\"Return index of an / the edge pointing at vertex `target`.\n\n Raise a ValueError if there is no such edge.\n\n If `idx` is None, return index of the first edge pointing at `target`.\n Otherwise, return current index of the edge that originally sat at `idx`.\n \"\"\"\n if idx is None:\n for idx in range(self._size):\n if self._out_edges[idx][0] == target:\n return idx\n else:\n assert 0 <= idx < len(self._out_edges)\n while idx >= self._size:\n idx, self._out_edges[idx] = self._out_edges[idx], None\n if target is None or self._out_edges[idx][0] == target:\n return idx\n raise ValueError('vertex {} is not in adjacency list'.format(target))\n\n\nclass AdjacencyLists(Graph):\n\n def __init__(self, vertex_count, make_list=None):\n \"\"\"Initialize the graph with the given number of vertices.\"\"\"\n super().__init__(vertex_count)\n self._make_list = make_list if make_list is not None else AdjacencyList\n self._adj_lists = [self._make_list() for _ in range(vertex_count)]\n\n # --------------------------------------------------------------------------\n\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\n \"\"\"Add a directed edge from source to target with given attributes.\n\n Returns: edge handle that can be used in `remove` and 'get' methods.\n \"\"\"\n attrs = self._get_attrs(attrs, kwargs)\n return self._adj_lists[source].add(target, attrs)\n\n def get_edge(self, source: int, target: int, handle=None):\n \"\"\"Retrieve a directed edge from source to target.\n\n Returns: tuple[edge attrs, edge handle]\n \"\"\"\n return self._adj_lists[source].get(source, target, handle)\n\n def remove_edge(self, source: int, target: int, handle=None):\n \"\"\"Remove a directed edge from source to target.\"\"\"\n self._adj_lists[source].remove(target, handle)\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n yield from self._adj_lists[source].out_edges(source)\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n return len(self._adj_lists[source])\n\n\nclass Clique(Graph):\n\n def __init__(self, vertex_count, get_attrs=None):\n \"\"\"Initialize the clique with the given number of rows and columns.\"\"\"\n super().__init__(vertex_count)\n # Returns attributes of the edge between vertices u and v.\n self.get_attrs = (get_attrs if get_attrs is not None else\n lambda u, v: Edge.attrs)\n\n # --------------------------------------------------------------------------\n\n # TODO get_edge()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n for target in self.vertices():\n if source != target:\n yield Edge(source, target, self.get_attrs(source, target))\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n for source in self.vertices():\n if source != target:\n yield Edge(source, target, self.get_attrs(source, target))\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n return self._vertex_count - 1\n\n def out_degrees(self) -> list[int]:\n \"\"\"Get the list of out-degrees of all vertices in the graph.\"\"\"\n return [self._vertex_count - 1 for source in self.vertices()]\n\n def in_degree(self, target: int) -> int:\n \"\"\"Get the in-degree of a given target vertex.\"\"\"\n return self._vertex_count - 1\n\n def in_degrees(self) -> list[int]:\n \"\"\"Get the list of in-degrees of all vertices in the graph.\"\"\"\n return [self._vertex_count - 1 for source in self.vertices()]\n\n # --------------------------------------------------------------------------\n\n def edge_count(self) -> int:\n \"\"\"Get the number of edges in the graph.\"\"\"\n raise self._vertex_count * (self._vertex_count - 1)\n\n\nimport enum\n\n\nclass Grid(Graph):\n\n class Type(enum.Enum):\n k4Way = 1 # default\n k8Way = 2\n\n def __init__(self, rows=0, cols=0, grid_type=None, get_attrs=None):\n \"\"\"Initialize the grid with the given number of rows and columns.\"\"\"\n super().__init__(rows * cols)\n self.rows = rows\n self.cols = cols\n # Returns attributes of the edge between cells (r1,c1) and (r2,c2):\n self.get_attrs = (get_attrs if get_attrs is not None else\n lambda r1, c1, r2, c2: Edge.attrs)\n # Implementation details:\n self._neighborhood = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n if grid_type == self.Type.k8Way:\n self._neighborhood += [(1, 1), (1, -1), (-1, 1), (-1, -1)]\n\n # --------------------------------------------------------------------------\n\n # TODO get_edge()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n sr, sc = self.idx2coor(source)\n for tr, tc in self._get_neighbor_cells(sr, sc):\n attrs = self.get_attrs(sr, sc, tr, tc)\n if attrs is not None:\n yield Edge(source, self.coor2idx(tr, tc), attrs)\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n # assert 0 <= target < self.vertex_count()\n tr, tc = self.idx2coor(target)\n for sr, sc in self._get_neighbor_cells(tr, tc):\n attrs = self.get_attrs(sr, sc, tr, tc)\n if attrs is not None:\n yield Edge(self.coor2idx(sr, sc), target, attrs)\n\n def _get_neighbor_cells(self, r1: int, c1: int) -> list[tuple[int, int]]:\n \"\"\"Generate the valid neighboring cells for a given grid cell.\"\"\"\n for dr, dc in self._neighborhood:\n r2, c2 = r1 + dr, c1 + dc\n if (0 <= r2 < self.rows) and (0 <= c2 < self.cols):\n yield r2, c2\n\n # --------------------------------------------------------------------------\n\n def coor2idx(self, r: int, c: int) -> int:\n \"\"\"Convert a pair of grid coordinates to a linear index.\"\"\"\n return r * self.cols + c\n\n def idx2coor(self, idx: int) -> tuple[int, int]:\n \"\"\"Convert a linear index to a pair of grid coordinates.\"\"\"\n return (idx // self.cols, idx % self.cols)\n\n\nclass VertexMap:\n \"\"\"A utility class to map vertex labels to int indices and vice versa.\"\"\"\n\n def __init__(self):\n self.l2i = {} # label to index map\n self.i2l = [] # index to label map\n self._vertex_count = 0\n\n def add_vertex(self, label):\n \"\"\"\n Add a vertex with the given label to the map.\n If label already exists, return its index.\n \"\"\"\n return self.get_index(label)\n\n def get_index(self, label) -> int:\n \"\"\"\n Get the index corresponding to the given label.\n If label doesn't exist, create an entry for it.\n \"\"\"\n idx = self.l2i.setdefault(label, self.vertex_count())\n if idx == self._vertex_count:\n self.i2l.append(label)\n self._vertex_count += 1\n return idx\n\n def get_label(self, v: int):\n \"\"\"Get the label corresponding to the given index.\"\"\"\n assert 0 <= v < self._vertex_count\n return self.i2l[v]\n\n def vertex_count(self) -> int:\n \"\"\"Get the number of vertices in the map.\"\"\"\n return self._vertex_count\n\n\n# ----------------------------------------------------------------------------\n# Breath-First Search (BFS)\n# ----------------------------------------------------------------------------\n\nimport collections\nimport enum\nimport math\n\n\nclass BFS:\n \"\"\"Breath-First Search (BFS)\"\"\"\n\n class Observer:\n\n def init(self, traversal):\n self.traversal = traversal\n self.graph = traversal.graph\n\n def start_traversal(self, sources: list[int]):\n ...\n\n def finish_traversal(self):\n ...\n\n def stop_traversal(self):\n ...\n\n def enter_vertex(self, u: int, cost_u):\n ...\n\n def exit_vertex(self, u: int):\n ...\n\n def traverse_tree_edge(self, edge: Edge, target_cost):\n ...\n\n def visit_edge(self, edge: Edge, target_cost):\n ...\n\n\n class StopTraversal(Exception):\n ...\n\n class SkipVertex(Exception):\n ...\n\n class VStatus(enum.Enum):\n UNDISCOVERED = 1\n ENQUEUED = 2\n EXITED = 3\n\n def __init__(self, graph, observer=None, get_cost=None, make_queue=None):\n # Traversal state:\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\n self.costs = [math.inf] * graph.vertex_count()\n self.queue = None\n self.stopped = False\n # Traversal parameters:\n self.graph = graph\n self.observer = observer if observer is not None else self.Observer()\n self.get_cost = get_cost if get_cost is not None else self.cost\n self.make_queue = make_queue if make_queue is not None else self.Queue\n self.observer.init(self)\n\n # -- Cost & Queue Definitions ----------------------------------------------\n\n @staticmethod\n def cost(cost_u, attrs_uv):\n return cost_u + 1\n\n class Queue:\n\n def __init__(self):\n self._queue = collections.deque()\n\n def put(self, edge: Edge, target_cost):\n self._queue.append((edge, target_cost))\n\n def pop(self):\n # assert len(self._queue) > 0\n return self._queue.popleft()\n\n def __len__(self):\n return len(self._queue)\n\n # -- Traversal Configuration -----------------------------------------------\n\n # If you are getting TLE, consider inlining the config methods, especially\n # `_visit_edge` and `_enqueue`.\n\n def _enter_vertex(self, u: int, cost_u):\n # assert self.statuses[v] == self.VStatus.ENQUEUED\n self.costs[u] = cost_u\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\n self._enqueue(edge, target_cost)\n\n def _enqueue(self, edge: Edge, target_cost):\n # UNDISCOVERED -> ENQUEUED\n self.statuses[edge.target] = self.VStatus.ENQUEUED\n self.queue.put(edge, target_cost)\n\n def _exit_vertex(self, u: int):\n # ENQUEUED -> EXITED\n self.statuses[u] = self.VStatus.EXITED\n\n # -- Traversal -------------------------------------------------------------\n\n def run(self, sources: list[int], source_cost=0):\n if isinstance(sources, int):\n sources = [sources]\n self.queue = self.make_queue()\n self.stopped = False\n for u in sources:\n self._visit_edge(Edge(source=-1, target=u), source_cost)\n if not self.queue:\n return\n try:\n self.observer.start_traversal(sources)\n while self.queue:\n try:\n in_edge, cost_u = self.queue.pop()\n u = in_edge.target\n if in_edge.source >= 0:\n self.observer.traverse_tree_edge(in_edge, cost_u)\n self._enter_vertex(u, cost_u)\n self.observer.enter_vertex(u, cost_u)\n for out_edge in self.graph.out_edges(u):\n cost_v = self.get_cost(cost_u, out_edge.attrs)\n self.observer.visit_edge(out_edge, cost_v)\n self._visit_edge(out_edge, cost_v)\n self.observer.exit_vertex(u)\n self._exit_vertex(u)\n except self.SkipVertex:\n ...\n except self.StopTraversal:\n self.observer.stop_traversal()\n self.stopped = True\n else:\n self.observer.finish_traversal()\n\n\n# ----------------------------------------------------------------------------\n# BFS Variants\n# ----------------------------------------------------------------------------\n\n\nclass TopologicalBFS(BFS):\n\n def __init__(self, graph, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.in_degs = graph.in_degrees()\n\n def _visit_edge(self, edge: Edge, target_cost):\n self.in_degs[edge.target] -= 1\n if self.in_degs[edge.target] <= 0:\n self._enqueue(edge, target_cost)\n\n def run(self):\n super().run([u for u in self.graph.vertices() if self.in_degs[u] == 0])\n\n\nclass RestrictedBFS(BFS):\n\n class VStatus(enum.Enum):\n UNDISCOVERED = 1\n DISCOVERED = 2\n ENQUEUED = 3\n EXITED = 4\n\n def __init__(self, graph, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.open = [True] * graph.vertex_count()\n self.in_edges = [None] * graph.vertex_count()\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\n if self.open[edge.target]:\n # UNDISCOVERED -> ENQUEUED\n self._enqueue(edge, target_cost)\n else:\n # UNDISCOVERED -> DISCOVERED\n self.statuses[edge.target] = self.VStatus.DISCOVERED\n if self.statuses[edge.target] == self.VStatus.DISCOVERED:\n # assert not self.open[edge.target]\n self.in_edges[edge.target] = edge \n self.costs[edge.target] = target_cost\n\n def unlock(self, u: int):\n self.open[u] = True\n if self.statuses[u] == self.VStatus.DISCOVERED:\n # DISCOVERED -> ENQUEUED\n self._enqueue(self.in_edges[u], self.costs[u])\n\n\nclass MultiEntryBFS(BFS):\n\n def __init__(self, graph, max_entry_count=1, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.max_entry_count = max_entry_count\n self.entry_counts = [0] * graph.vertex_count()\n\n def _enter_vertex(self, u: int, cost_u):\n # assert self.costs[u] <= cost_u\n # TODO: multiple entries with the same cost -> add a config param\n if self.statuses[u] == self.VStatus.EXITED or self.costs[u] == cost_u:\n raise self.SkipVertex\n self.costs[u] = cost_u\n self.entry_counts[u] += 1\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] != self.VStatus.EXITED:\n self._enqueue(edge, target_cost)\n\n def _exit_vertex(self, u: int):\n if self.entry_counts[u] >= self.max_entry_count:\n self.statuses[u] = self.VStatus.EXITED\n\n\n# ----------------------------------------------------------------------------\n# BFS Observers\n# ----------------------------------------------------------------------------\n\n\nclass ToTarget(BFS.Observer):\n\n def __init__(self, target: int):\n self.target = target\n\n def init(self, traversal):\n super().init(traversal)\n if self.target < 0:\n self.target += self.graph.vertex_count()\n assert 0 <= self.target < self.graph.vertex_count()\n\n def enter_vertex(self, u: int, cost_u):\n if u == self.target:\n raise self.traversal.StopTraversal\n\n\nclass ToCost(BFS.Observer):\n\n def __init__(self, target_cost):\n self.target_cost = target_cost\n\n def enter_vertex(self, u: int, cost_u):\n if cost_u > self.target_cost:\n raise self.traversal.SkipVertex\n\n\nclass InEdges(BFS.Observer):\n\n def init(self, traversal):\n super().init(traversal)\n self.in_edges = [None] * self.graph.vertex_count()\n\n def traverse_tree_edge(self, edge: Edge, target_cost):\n self.in_edges[edge.target] = edge\n\n\n# ----------------------------------------------------------------------------\n# BFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n\ndef find_cc(graph):\n\n class ConnectedComponents(BFS.Observer):\n\n def __init__(self):\n self.count = 0\n self.vertex2comp = [-1] * graph.vertex_count()\n self.comp2vertices = collections.defaultdict(list)\n\n def start_traversal(self, sources):\n self.count += 1\n\n def enter_vertex(self, u, cost_u):\n self.vertex2comp[u] = self.count - 1\n self.comp2vertices[self.count - 1].append(u)\n\n cc = ConnectedComponents()\n bfs = BFS(graph, cc)\n for v in graph.vertices():\n bfs.run(v)\n return cc\n\n\ndef find_layers(graph):\n\n class Layers(BFS.Observer):\n\n def __init__(self):\n self.vertex2layer = [-1] * graph.vertex_count()\n self.layer2vertices = collections.defaultdict(list)\n\n def start_traversal(self, sources):\n for u in sources:\n self.vertex2layer[u] = 0\n\n def enter_vertex(self, u, cost_u):\n self.layer2vertices[self.vertex2layer[u]].append(u)\n\n def visit_edge(self, edge: Edge, target_cost):\n self.vertex2layer[edge.target] = max(self.vertex2layer[edge.target],\n self.vertex2layer[edge.source] + 1)\n\n layers = Layers()\n TopologicalBFS(graph, layers).run()\n return layers\n\n\ndef sort_topologically(graph, bfs_cls=TopologicalBFS):\n\n class Order(BFS.Observer):\n\n def __init__(self):\n self.vertices = []\n\n def enter_vertex(self, u, cost_u):\n self.vertices.append(u)\n\n obs = Order()\n bfs_cls(graph, obs).run()\n return obs.vertices\n\n\n# ----------------------------------------------------------------------------\n# MinCost-First Search (MCFS)\n# ----------------------------------------------------------------------------\n\nimport sortedcontainers\n\n\nclass MCFS(BFS):\n \"\"\"MinCost-First Search (MCFS)\"\"\"\n\n @staticmethod\n def cost(cost_u, attr_uv):\n return cost_u + attr_uv\n\n class Queue:\n\n def __init__(self):\n self._items = sortedcontainers.SortedSet()\n\n def put(self, edge, target_cost):\n self._items.add(self._Item(target_cost, edge))\n\n def pop(self):\n # assert len(self._items) > 1\n item = self._items.pop(0)\n return item.edge, item.target_cost\n\n def __len__(self):\n return len(self._items)\n\n @dataclass\n class _Item:\n target_cost: Any\n edge: Any\n\n def __lt__(self, other):\n return self.target_cost < other.target_cost\n\n def __hash__(self):\n return hash(self.target_cost)\n\n def _enter_vertex(self, u: int, cost_u):\n if self.statuses[u] == self.VStatus.EXITED:\n raise self.SkipVertex\n self.costs[u] = cost_u\n\n def _visit_edge(self, edge, target_cost):\n if self.costs[edge.target] > target_cost:\n self.costs[edge.target] = target_cost\n self._enqueue(edge, target_cost)\n\n\n# ----------------------------------------------------------------------------\n# MCFS Variants\n# ----------------------------------------------------------------------------\n\n\nclass BinaryMCFS(MCFS):\n \"\"\"Works for graphs where each edge's cost is either 0 or 1.\"\"\"\n\n class Queue(BFS.Queue):\n\n def put(self, edge, target_cost):\n if self._queue and self._queue[-1][1] <= target_cost:\n self._queue.append((edge, target_cost))\n else:\n self._queue.appendleft((edge, target_cost))\n\n\nclass BoundedMCFS(MCFS):\n \"\"\"Works for graphs where max vertex's cost is ~ O(graph.edge_count()).\"\"\"\n\n class Queue:\n\n def __init__(self):\n self._queue = []\n self._size = 0\n self._cost = 0\n\n def put(self, edge: Edge, target_cost):\n # assert target_cost >= self._cost\n queue_len = len(self._queue)\n if target_cost >= queue_len:\n self._queue.extend([[] for _ in range(target_cost - queue_len + 1)])\n self._queue[target_cost].append(edge)\n self._size += 1\n\n def pop(self):\n # assert self._size > 0\n while not self._queue[self._cost]:\n self._cost += 1\n edge = self._queue[self._cost].pop()\n self._size -= 1\n return edge, self._cost\n\n def __len__(self):\n return self._size\n\n\nclass MultiEntryMCFS(MultiEntryBFS):\n\n cost = MCFS.cost\n\n Queue = MCFS.Queue\n\n\n# ----------------------------------------------------------------------------\n# MCFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n# TODO: implement\n\n\n# ----------------------------------------------------------------------------\n# Depth-First Search\n# ----------------------------------------------------------------------------\n\nimport enum\n\n\nclass DFS:\n \"\"\"Depth-first Search (DFS)\"\"\"\n\n class Observer:\n\n def init(self, traversal):\n self.traversal = traversal\n self.graph = traversal.graph\n\n # -- Event Handlers ------------------------------------------------------\n\n def start_traversal(self, source: int):\n ...\n\n def finish_traversal(self):\n ...\n\n def stop_traversal(self):\n ...\n\n def enter_vertex(self, u: int):\n ...\n\n def exit_vertex(self, u: int):\n ...\n\n def traverse_tree_edge(self, edge: Edge):\n ...\n\n def retrace_tree_edge(self, edge: Edge):\n ...\n\n def visit_backward_edge(self, edge: Edge):\n # Hint: Check if edge.target == self.traversal.parents[edge.source].\n ...\n\n def visit_forward_edge(self, edge: Edge):\n ...\n\n def visit_cross_edge(self, edge: Edge):\n ...\n\n class StopTraversal(Exception):\n ...\n\n class VStatus(enum.Enum):\n UNDISCOVERED = 1\n ENTERED = 2\n EXITED = 3\n\n def __init__(self, graph, observer=None):\n # Traversal state:\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\n self.entry_times = [0] * graph.vertex_count()\n self.parents = [-1] * graph.vertex_count()\n self.time = 0\n self.stack = None\n self.stopped = False\n self._out_edges = [graph.out_edges(v) for v in graph.vertices()]\n # Traversal parameters:\n self.graph = graph\n self.observer = observer if observer is not None else self.Observer()\n self.observer.init(self)\n\n # -- Traversal Configuration -----------------------------------------------\n\n def _enter_vertex(self, v: int):\n # UNDISCOVERED -> ENTERED\n self.statuses[v] = self.VStatus.ENTERED\n self.time += 1\n self.entry_times[v] = self.time\n\n def _exit_vertex(self, v: int):\n # ENTERED -> EXITED\n self.statuses[v] = self.VStatus.EXITED\n\n # -- Traversal -------------------------------------------------------------\n\n def run(self, source: int):\n if self.statuses[source] != self.VStatus.UNDISCOVERED:\n return\n stack = [Edge(source=-1, target=source)]\n self.stopped = False\n try:\n self.observer.start_traversal(source)\n while stack:\n edge = stack[-1]\n p = edge.source # previous vertex\n u = edge.target\n match self.statuses[u]:\n case self.VStatus.UNDISCOVERED:\n self.parents[u] = p\n if p >= 0:\n self.observer.traverse_tree_edge(edge)\n self._enter_vertex(u)\n self.observer.enter_vertex(u)\n case self.VStatus.EXITED:\n stack.pop()\n if self.entry_times[u] > self.entry_times[p]:\n self.observer.visit_forward_edge(edge)\n else:\n self.observer.visit_cross_edge(edge)\n case self.VStatus.ENTERED:\n if p >= 0 and self.entry_times[u] < self.entry_times[p]:\n stack.pop()\n self.observer.visit_backward_edge(edge)\n else:\n try:\n stack.append(next(self._out_edges[u]))\n except StopIteration:\n self.observer.exit_vertex(u)\n self._exit_vertex(u)\n stack.pop()\n if p >= 0:\n self.observer.retrace_tree_edge(edge)\n except self.StopTraversal:\n self.stopped = True\n self.observer.stop_traversal()\n else:\n self.observer.finish_traversal()\n\n\n# ----------------------------------------------------------------------------\n# DFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n\ndef find_scc(graph):\n\n class Pass1(DFS.Observer):\n\n def __init__(self):\n self.order = []\n\n def exit_vertex(self, u):\n self.order.append(u)\n\n pass1 = Pass1()\n dfs1 = DFS(graph, pass1)\n for v in graph.vertices():\n dfs1.run(v)\n\n class StronglyConnectedComponents(DFS.Observer):\n\n def __init__(self):\n self.count = 0\n self.vertex2comp = [-1] * graph.vertex_count()\n self.comp2vertices = collections.defaultdict(list)\n\n def start_traversal(self, source):\n self.count += 1\n\n def enter_vertex(self, u):\n self.vertex2comp[u] = self.count - 1\n self.comp2vertices[self.count - 1].append(u)\n\n scc = StronglyConnectedComponents()\n dfs2 = DFS(transposed(graph), scc)\n for v in reversed(pass1.order):\n dfs2.run(v)\n return scc\n\n\ndef build_condensation_graph(graph, scc=None):\n if scc is None:\n scc = find_scc(graph)\n edges = set()\n for c in range(scc.count):\n for u in scc.comp2vertices[c]:\n for v, _ in graph.out_edges(u):\n if scc.vertex2comp[v] == c: continue\n edges.add((c, scc.vertex2comp[v]))\n cond_graph = AdjacencyLists(scc.count)\n cond_graph.add_edges(edges)\n return cond_graph\n\n\ndef find_bridges_and_cutpoints(graph):\n\n class Finder(DFS.Observer):\n\n def __init__(self):\n self.low = [graph.vertex_count() + 1] * graph.vertex_count()\n self.bridges = []\n self.is_cutpoint = [False] * graph.vertex_count()\n\n def start_traversal(self, source):\n self.root = source\n\n def finish_traversal(self):\n if self.traversal.parents.count(self.root) > 1:\n self.is_cutpoint[self.root] = True\n\n def enter_vertex(self, u):\n self.low[u] = self.traversal.entry_times[u]\n\n def visit_backward_edge(self, edge: Edge):\n u, v, _, _ = astuple(edge)\n if v == self.traversal.parents[u]: return\n self.low[u] = min(self.low[u], self.traversal.entry_times[v]) \n\n def retrace_tree_edge(self, edge: Edge):\n u, v, _, _ = astuple(edge)\n self.low[u] = min(self.low[u], self.low[v])\n if self.low[v] >= self.traversal.entry_times[v]:\n self.bridges.append(edge)\n if self.low[v] >= self.traversal.entry_times[u] and u != self.root:\n self.is_cutpoint[u] = True\n\n finder = Finder()\n dfs = DFS(graph, finder)\n for v in graph.vertices():\n dfs.run(v)\n\n return finder.bridges, finder.is_cutpoint","memory":"54900"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1:\n return -1\n\n kRows = len(grid)\n kCols = len(grid[0])\n\n graph = Grid(kRows, kCols)\n\n mcfs = BoundedMCFS(graph, ToTarget(graph.vertex_count() - 1))\n\n def get_attrs(r1, c1, r2, c2):\n edge_len = max(grid[r2][c2] - mcfs.costs[graph.coor2idx(r1, c1)], 0)\n if edge_len % 2 == 0:\n edge_len += 1\n return edge_len\n\n graph.get_attrs = get_attrs\n\n mcfs.run(0)\n\n return mcfs.costs[-1]\n\n\nfrom dataclasses import dataclass, astuple\nfrom typing import Any\n\n\n@dataclass\nclass Edge:\n source: int\n target: int\n attrs: Any = ()\n handle: Any = None\n\n\nclass Graph:\n \"\"\"Graph ABC.\n\n This class assumes that vertices are indexed 0, 1, 2, ..., vertex_count-1.\n \"\"\"\n\n def __init__(self, vertex_count):\n \"\"\"Initialize the graph with the given number of vertices.\"\"\"\n assert vertex_count > 0\n self._vertex_count = vertex_count\n\n # --------------------------------------------------------------------------\n\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\n \"\"\"Add a directed edge from source to target with given attributes.\n\n Returns: edge handle that can be used in `get` and 'remove' operations.\n \"\"\"\n raise NotImplementedError()\n\n def add_undirected_edge(self, u: int, v: int, attrs=None, **kwargs):\n \"\"\"Add an undirected edge between u and v with the given attributes.\n\n Returns: edge handles that can be used in `get` and 'remove' operations.\n \"\"\"\n handle_uv = self.add_edge(u, v, attrs, **kwargs)\n handle_vu = self.add_edge(v, u, attrs, **kwargs)\n return handle_uv, handle_vu\n\n def get_edge(self, source: int, target: int, handle=None):\n \"\"\"Retrieve a directed edge from source to target.\n\n Returns: Edge object.\n \"\"\"\n raise NotImplementedError()\n\n def remove_edge(self, source: int, target: int, handle=None):\n \"\"\"Remove a directed edge from source to target.\"\"\"\n raise NotImplementedError()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n raise NotImplementedError()\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n for edge in self.edges():\n if edge.target == target:\n yield edge\n\n def edges(self):\n \"\"\"Generate all edges in the graph.\"\"\"\n for source in self.vertices():\n yield from self.out_edges(source)\n\n def vertices(self):\n \"\"\"Generate all vertices in the graph.\"\"\"\n return range(self._vertex_count)\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n return len(list(self.out_edges(source)))\n\n def out_degrees(self) -> list[int]:\n \"\"\"Get the list of out-degrees of all vertices in the graph.\"\"\"\n return [self.out_degree(source) for source in self.vertices()]\n\n def in_degree(self, target: int) -> int:\n \"\"\"Get the in-degree of a given target vertex.\"\"\"\n return len(list(self.in_edges(target)))\n\n def in_degrees(self) -> list[int]:\n \"\"\"Get the list of in-degrees of all vertices in the graph.\"\"\"\n in_degs = [0] * self.vertex_count()\n for edge in self.edges():\n in_degs[edge.target] += 1\n return in_degs\n\n # --------------------------------------------------------------------------\n\n def edge_count(self) -> int:\n \"\"\"Get the number of edges in the graph.\"\"\"\n return sum(self.out_degrees())\n\n def vertex_count(self) -> int:\n \"\"\"Get the number of vertices in the graph.\"\"\"\n return self._vertex_count\n\n # --------------------------------------------------------------------------\n\n def add_edges(self, edges):\n \"\"\"Add directed edges with optional attributes.\"\"\"\n for edge in edges:\n source, target, *attrs = edge\n self.add_edge(source, target, self._seq2attrs(attrs))\n\n def add_undirected_edges(self, edges):\n \"\"\"Add undirected edges with optional attributes.\"\"\"\n for edge in edges:\n source, target, *attrs = edge\n self.add_undirected_edge(source, target, self._seq2attrs(attrs))\n\n def _seq2attrs(self, attrs):\n match len(attrs):\n case 0: return Edge.attrs # default empty tuple\n case 1: return attrs[0]\n case _: return attrs\n\n # --------------------------------------------------------------------------\n\n def _get_attrs(self, attrs, kwargs):\n \"\"\"Build edge attrs object from `add_[undirected_]edge` method args.\"\"\"\n if attrs is None:\n if kwargs:\n # TODO: Convert to a named tuple?\n attrs = kwargs\n else:\n attrs = Edge.attrs\n return attrs\n\n\ndef transposed(graph):\n \"\"\"Transpose (reverse the direction of all edges in) the given graph.\"\"\"\n transposed = type(graph)(graph.vertex_count())\n for source, target, attrs, _ in graph.edges():\n transposed.add_edge(target, source, attrs)\n return transposed\n\n\n# ----------------------------------------------------------------------------\n# Concrete Graph Classes\n# ----------------------------------------------------------------------------\n\n\nclass AdjacencyList():\n\n def __init__(self):\n \"\"\"Initialize an empty adjacency list.\"\"\"\n self._out_edges = []\n self._size = 0\n\n def add(self, target: int, attrs) -> int:\n \"\"\"Add a new edge to the end of the adjacency list.\n\n Returns: index of the added edge.\n \"\"\"\n if len(self._out_edges) == self._size:\n self._out_edges.append((target, attrs))\n else:\n # assert len(self._out_edges) > self._size\n assert self._out_edges[self._size] is None\n self._out_edges[self._size] = (target, attrs)\n self._size += 1\n return self._size - 1\n\n def get(self, source: int, target: int, idx: int = None):\n \"\"\"Retrieve an / the edge pointing at vertex `target`.\"\"\"\n idx = self._index(target, idx)\n return Edge(source, target, self._out_edges[idx][1], idx)\n\n def remove(self, target: int, idx: int = None):\n \"\"\"Remove an / the edge pointing at vertex `target`.\"\"\"\n idx = self._index(target, idx)\n self._size -= 1\n self._out_edges[idx] = self._out_edges[self._size]\n self._out_edges[self._size] = idx\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges.\"\"\"\n for idx, (target, attrs) in enumerate(self._out_edges[:self._size]):\n yield Edge(source, target, attrs, idx)\n\n def __len__(self):\n \"\"\"Return the number of edges in this adjacency list.\"\"\"\n return self._size\n\n def _index(self, target: int, idx: int = None):\n \"\"\"Return index of an / the edge pointing at vertex `target`.\n\n Raise a ValueError if there is no such edge.\n\n If `idx` is None, return index of the first edge pointing at `target`.\n Otherwise, return current index of the edge that originally sat at `idx`.\n \"\"\"\n if idx is None:\n for idx in range(self._size):\n if self._out_edges[idx][0] == target:\n return idx\n else:\n assert 0 <= idx < len(self._out_edges)\n while idx >= self._size:\n idx, self._out_edges[idx] = self._out_edges[idx], None\n if target is None or self._out_edges[idx][0] == target:\n return idx\n raise ValueError('vertex {} is not in adjacency list'.format(target))\n\n\nclass AdjacencyLists(Graph):\n\n def __init__(self, vertex_count, make_list=None):\n \"\"\"Initialize the graph with the given number of vertices.\"\"\"\n super().__init__(vertex_count)\n self._make_list = make_list if make_list is not None else AdjacencyList\n self._adj_lists = [self._make_list() for _ in range(vertex_count)]\n\n # --------------------------------------------------------------------------\n\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\n \"\"\"Add a directed edge from source to target with given attributes.\n\n Returns: edge handle that can be used in `remove` and 'get' methods.\n \"\"\"\n attrs = self._get_attrs(attrs, kwargs)\n return self._adj_lists[source].add(target, attrs)\n\n def get_edge(self, source: int, target: int, handle=None):\n \"\"\"Retrieve a directed edge from source to target.\n\n Returns: tuple[edge attrs, edge handle]\n \"\"\"\n return self._adj_lists[source].get(source, target, handle)\n\n def remove_edge(self, source: int, target: int, handle=None):\n \"\"\"Remove a directed edge from source to target.\"\"\"\n self._adj_lists[source].remove(target, handle)\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n yield from self._adj_lists[source].out_edges(source)\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n return len(self._adj_lists[source])\n\n\nclass Clique(Graph):\n\n def __init__(self, vertex_count, get_attrs=None):\n \"\"\"Initialize the clique with the given number of rows and columns.\"\"\"\n super().__init__(vertex_count)\n # Returns attributes of the edge between vertices u and v.\n self.get_attrs = (get_attrs if get_attrs is not None else\n lambda u, v: Edge.attrs)\n\n # --------------------------------------------------------------------------\n\n # TODO get_edge()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n for target in self.vertices():\n if source != target:\n yield Edge(source, target, self.get_attrs(source, target))\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n for source in self.vertices():\n if source != target:\n yield Edge(source, target, self.get_attrs(source, target))\n\n # --------------------------------------------------------------------------\n\n def out_degree(self, source: int) -> int:\n \"\"\"Get the out-degree of a given source vertex.\"\"\"\n return self._vertex_count - 1\n\n def out_degrees(self) -> list[int]:\n \"\"\"Get the list of out-degrees of all vertices in the graph.\"\"\"\n return [self._vertex_count - 1 for source in self.vertices()]\n\n def in_degree(self, target: int) -> int:\n \"\"\"Get the in-degree of a given target vertex.\"\"\"\n return self._vertex_count - 1\n\n def in_degrees(self) -> list[int]:\n \"\"\"Get the list of in-degrees of all vertices in the graph.\"\"\"\n return [self._vertex_count - 1 for source in self.vertices()]\n\n # --------------------------------------------------------------------------\n\n def edge_count(self) -> int:\n \"\"\"Get the number of edges in the graph.\"\"\"\n raise self._vertex_count * (self._vertex_count - 1)\n\n\nclass Grid(Graph):\n\n class Type:\n k4Way = 1 # default\n k8Way = 2\n\n def __init__(self, rows=0, cols=0, grid_type=None, get_attrs=None):\n \"\"\"Initialize the grid with the given number of rows and columns.\"\"\"\n super().__init__(rows * cols)\n self.rows = rows\n self.cols = cols\n # Returns attributes of the edge between cells (r1,c1) and (r2,c2):\n self.get_attrs = (get_attrs if get_attrs is not None else\n lambda r1, c1, r2, c2: Edge.attrs)\n # Implementation details:\n self._neighborhood = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n if grid_type == self.Type.k8Way:\n self._neighborhood += [(1, 1), (1, -1), (-1, 1), (-1, -1)]\n\n # --------------------------------------------------------------------------\n\n # TODO get_edge()\n\n # --------------------------------------------------------------------------\n\n def out_edges(self, source: int):\n \"\"\"Generate all outgoing edges from a given source vertex.\"\"\"\n # assert 0 <= source < self.vertex_count()\n sr, sc = self.idx2coor(source)\n for tr, tc in self._get_neighbor_cells(sr, sc):\n attrs = self.get_attrs(sr, sc, tr, tc)\n if attrs is not None:\n yield Edge(source, self.coor2idx(tr, tc), attrs)\n\n def in_edges(self, target: int):\n \"\"\"Generate all incoming edges to a given target vertex.\"\"\"\n # assert 0 <= target < self.vertex_count()\n tr, tc = self.idx2coor(target)\n for sr, sc in self._get_neighbor_cells(tr, tc):\n attrs = self.get_attrs(sr, sc, tr, tc)\n if attrs is not None:\n yield Edge(self.coor2idx(sr, sc), target, attrs)\n\n def _get_neighbor_cells(self, r1: int, c1: int) -> list[tuple[int, int]]:\n \"\"\"Generate the valid neighboring cells for a given grid cell.\"\"\"\n for dr, dc in self._neighborhood:\n r2, c2 = r1 + dr, c1 + dc\n if (0 <= r2 < self.rows) and (0 <= c2 < self.cols):\n yield r2, c2\n\n # --------------------------------------------------------------------------\n\n def coor2idx(self, r: int, c: int) -> int:\n \"\"\"Convert a pair of grid coordinates to a linear index.\"\"\"\n return r * self.cols + c\n\n def idx2coor(self, idx: int) -> tuple[int, int]:\n \"\"\"Convert a linear index to a pair of grid coordinates.\"\"\"\n return (idx // self.cols, idx % self.cols)\n\n\nclass VertexMap:\n \"\"\"A utility class to map vertex labels to int indices and vice versa.\"\"\"\n\n def __init__(self):\n self.l2i = {} # label to index map\n self.i2l = [] # index to label map\n self._vertex_count = 0\n\n def add_vertex(self, label):\n \"\"\"\n Add a vertex with the given label to the map.\n If label already exists, return its index.\n \"\"\"\n return self.get_index(label)\n\n def get_index(self, label) -> int:\n \"\"\"\n Get the index corresponding to the given label.\n If label doesn't exist, create an entry for it.\n \"\"\"\n idx = self.l2i.setdefault(label, self.vertex_count())\n if idx == self._vertex_count:\n self.i2l.append(label)\n self._vertex_count += 1\n return idx\n\n def get_label(self, v: int):\n \"\"\"Get the label corresponding to the given index.\"\"\"\n assert 0 <= v < self._vertex_count\n return self.i2l[v]\n\n def vertex_count(self) -> int:\n \"\"\"Get the number of vertices in the map.\"\"\"\n return self._vertex_count\n\n\n# ----------------------------------------------------------------------------\n# Breath-First Search (BFS)\n# ----------------------------------------------------------------------------\n\nimport collections\nimport math\n\n\nclass BFS:\n \"\"\"Breath-First Search (BFS)\"\"\"\n\n class Observer:\n\n def init(self, traversal):\n self.traversal = traversal\n self.graph = traversal.graph\n\n def start_traversal(self, sources: list[int]):\n ...\n\n def finish_traversal(self):\n ...\n\n def stop_traversal(self):\n ...\n\n def enter_vertex(self, u: int, cost_u):\n ...\n\n def exit_vertex(self, u: int):\n ...\n\n def traverse_tree_edge(self, edge: Edge, target_cost):\n ...\n\n def visit_edge(self, edge: Edge, target_cost):\n ...\n\n\n class StopTraversal(Exception):\n ...\n\n class SkipVertex(Exception):\n ...\n\n class VStatus:\n UNDISCOVERED = 1\n ENQUEUED = 2\n EXITED = 3\n\n def __init__(self, graph, observer=None, get_cost=None, make_queue=None):\n # Traversal state:\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\n self.costs = [math.inf] * graph.vertex_count()\n self.queue = None\n self.stopped = False\n # Traversal parameters:\n self.graph = graph\n self.observer = observer if observer is not None else self.Observer()\n self.get_cost = get_cost if get_cost is not None else self.cost\n self.make_queue = make_queue if make_queue is not None else self.Queue\n self.observer.init(self)\n\n # -- Cost & Queue Definitions ----------------------------------------------\n\n @staticmethod\n def cost(cost_u, attrs_uv):\n return cost_u + 1\n\n class Queue:\n\n def __init__(self):\n self._queue = collections.deque()\n\n def put(self, edge: Edge, target_cost):\n self._queue.append((edge, target_cost))\n\n def pop(self):\n # assert len(self._queue) > 0\n return self._queue.popleft()\n\n def __len__(self):\n return len(self._queue)\n\n # -- Traversal Configuration -----------------------------------------------\n\n # If you are getting TLE, consider inlining the config methods, especially\n # `_visit_edge` and `_enqueue`.\n\n def _enter_vertex(self, u: int, cost_u):\n # assert self.statuses[v] == self.VStatus.ENQUEUED\n self.costs[u] = cost_u\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\n self._enqueue(edge, target_cost)\n\n def _enqueue(self, edge: Edge, target_cost):\n # UNDISCOVERED -> ENQUEUED\n self.statuses[edge.target] = self.VStatus.ENQUEUED\n self.queue.put(edge, target_cost)\n\n def _exit_vertex(self, u: int):\n # ENQUEUED -> EXITED\n self.statuses[u] = self.VStatus.EXITED\n\n # -- Traversal -------------------------------------------------------------\n\n def run(self, sources: list[int], source_cost=0):\n if isinstance(sources, int):\n sources = [sources]\n self.queue = self.make_queue()\n self.stopped = False\n for u in sources:\n self._visit_edge(Edge(source=-1, target=u), source_cost)\n if not self.queue:\n return\n try:\n self.observer.start_traversal(sources)\n while self.queue:\n try:\n in_edge, cost_u = self.queue.pop()\n u = in_edge.target\n if in_edge.source >= 0:\n self.observer.traverse_tree_edge(in_edge, cost_u)\n self._enter_vertex(u, cost_u)\n self.observer.enter_vertex(u, cost_u)\n for out_edge in self.graph.out_edges(u):\n cost_v = self.get_cost(cost_u, out_edge.attrs)\n self.observer.visit_edge(out_edge, cost_v)\n self._visit_edge(out_edge, cost_v)\n self.observer.exit_vertex(u)\n self._exit_vertex(u)\n except self.SkipVertex:\n ...\n except self.StopTraversal:\n self.observer.stop_traversal()\n self.stopped = True\n else:\n self.observer.finish_traversal()\n\n\n# ----------------------------------------------------------------------------\n# BFS Variants\n# ----------------------------------------------------------------------------\n\n\nclass TopologicalBFS(BFS):\n\n def __init__(self, graph, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.in_degs = graph.in_degrees()\n\n def _visit_edge(self, edge: Edge, target_cost):\n self.in_degs[edge.target] -= 1\n if self.in_degs[edge.target] <= 0:\n self._enqueue(edge, target_cost)\n\n def run(self):\n super().run([u for u in self.graph.vertices() if self.in_degs[u] == 0])\n\n\nclass RestrictedBFS(BFS):\n\n class VStatus:\n UNDISCOVERED = 1\n DISCOVERED = 2\n ENQUEUED = 3\n EXITED = 4\n\n def __init__(self, graph, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.open = [True] * graph.vertex_count()\n self.in_edges = [None] * graph.vertex_count()\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\n if self.open[edge.target]:\n # UNDISCOVERED -> ENQUEUED\n self._enqueue(edge, target_cost)\n else:\n # UNDISCOVERED -> DISCOVERED\n self.statuses[edge.target] = self.VStatus.DISCOVERED\n if self.statuses[edge.target] == self.VStatus.DISCOVERED:\n # assert not self.open[edge.target]\n self.in_edges[edge.target] = edge \n self.costs[edge.target] = target_cost\n\n def unlock(self, u: int):\n self.open[u] = True\n if self.statuses[u] == self.VStatus.DISCOVERED:\n # DISCOVERED -> ENQUEUED\n self._enqueue(self.in_edges[u], self.costs[u])\n\n\nclass MultiEntryBFS(BFS):\n\n def __init__(self, graph, max_entry_count=1, *args, **kwargs):\n super().__init__(graph, *args, **kwargs)\n self.max_entry_count = max_entry_count\n self.entry_counts = [0] * graph.vertex_count()\n\n def _enter_vertex(self, u: int, cost_u):\n # assert self.costs[u] <= cost_u\n # TODO: multiple entries with the same cost -> add a config param\n if self.statuses[u] == self.VStatus.EXITED or self.costs[u] == cost_u:\n raise self.SkipVertex\n self.costs[u] = cost_u\n self.entry_counts[u] += 1\n\n def _visit_edge(self, edge: Edge, target_cost):\n if self.statuses[edge.target] != self.VStatus.EXITED:\n self._enqueue(edge, target_cost)\n\n def _exit_vertex(self, u: int):\n if self.entry_counts[u] >= self.max_entry_count:\n self.statuses[u] = self.VStatus.EXITED\n\n\n# ----------------------------------------------------------------------------\n# BFS Observers\n# ----------------------------------------------------------------------------\n\n\nclass ToTarget(BFS.Observer):\n\n def __init__(self, target: int):\n self.target = target\n\n def init(self, traversal):\n super().init(traversal)\n if self.target < 0:\n self.target += self.graph.vertex_count()\n assert 0 <= self.target < self.graph.vertex_count()\n\n def enter_vertex(self, u: int, cost_u):\n if u == self.target:\n raise self.traversal.StopTraversal\n\n\nclass ToCost(BFS.Observer):\n\n def __init__(self, target_cost):\n self.target_cost = target_cost\n\n def enter_vertex(self, u: int, cost_u):\n if cost_u > self.target_cost:\n raise self.traversal.SkipVertex\n\n\nclass InEdges(BFS.Observer):\n\n def init(self, traversal):\n super().init(traversal)\n self.in_edges = [None] * self.graph.vertex_count()\n\n def traverse_tree_edge(self, edge: Edge, target_cost):\n self.in_edges[edge.target] = edge\n\n\n# ----------------------------------------------------------------------------\n# BFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n\ndef find_cc(graph):\n\n class ConnectedComponents(BFS.Observer):\n\n def __init__(self):\n self.count = 0\n self.vertex2comp = [-1] * graph.vertex_count()\n self.comp2vertices = collections.defaultdict(list)\n\n def start_traversal(self, sources):\n self.count += 1\n\n def enter_vertex(self, u, cost_u):\n self.vertex2comp[u] = self.count - 1\n self.comp2vertices[self.count - 1].append(u)\n\n cc = ConnectedComponents()\n bfs = BFS(graph, cc)\n for v in graph.vertices():\n bfs.run(v)\n return cc\n\n\ndef find_layers(graph):\n\n class Layers(BFS.Observer):\n\n def __init__(self):\n self.vertex2layer = [-1] * graph.vertex_count()\n self.layer2vertices = collections.defaultdict(list)\n\n def start_traversal(self, sources):\n for u in sources:\n self.vertex2layer[u] = 0\n\n def enter_vertex(self, u, cost_u):\n self.layer2vertices[self.vertex2layer[u]].append(u)\n\n def visit_edge(self, edge: Edge, target_cost):\n self.vertex2layer[edge.target] = max(self.vertex2layer[edge.target],\n self.vertex2layer[edge.source] + 1)\n\n layers = Layers()\n TopologicalBFS(graph, layers).run()\n return layers\n\n\ndef sort_topologically(graph, bfs_cls=TopologicalBFS):\n\n class Order(BFS.Observer):\n\n def __init__(self):\n self.vertices = []\n\n def enter_vertex(self, u, cost_u):\n self.vertices.append(u)\n\n obs = Order()\n bfs_cls(graph, obs).run()\n return obs.vertices\n\n\n# ----------------------------------------------------------------------------\n# MinCost-First Search (MCFS)\n# ----------------------------------------------------------------------------\n\nimport sortedcontainers\n\n\nclass MCFS(BFS):\n \"\"\"MinCost-First Search (MCFS)\"\"\"\n\n @staticmethod\n def cost(cost_u, attr_uv):\n return cost_u + attr_uv\n\n class Queue:\n\n def __init__(self):\n self._items = sortedcontainers.SortedSet()\n\n def put(self, edge, target_cost):\n self._items.add(self._Item(target_cost, edge))\n\n def pop(self):\n # assert len(self._items) > 1\n item = self._items.pop(0)\n return item.edge, item.target_cost\n\n def __len__(self):\n return len(self._items)\n\n @dataclass\n class _Item:\n target_cost: Any\n edge: Any\n\n def __lt__(self, other):\n return self.target_cost < other.target_cost\n\n def __hash__(self):\n return hash(self.target_cost)\n\n def _enter_vertex(self, u: int, cost_u):\n if self.statuses[u] == self.VStatus.EXITED:\n raise self.SkipVertex\n self.costs[u] = cost_u\n\n def _visit_edge(self, edge, target_cost):\n if self.costs[edge.target] > target_cost:\n self.costs[edge.target] = target_cost\n self._enqueue(edge, target_cost)\n\n\n# ----------------------------------------------------------------------------\n# MCFS Variants\n# ----------------------------------------------------------------------------\n\n\nclass BinaryMCFS(MCFS):\n \"\"\"Works for graphs where each edge's cost is either 0 or 1.\"\"\"\n\n class Queue(BFS.Queue):\n\n def put(self, edge, target_cost):\n if self._queue and self._queue[-1][1] <= target_cost:\n self._queue.append((edge, target_cost))\n else:\n self._queue.appendleft((edge, target_cost))\n\n\nclass BoundedMCFS(MCFS):\n \"\"\"Works for graphs where max vertex's cost is ~ O(graph.edge_count()).\"\"\"\n\n class Queue:\n\n def __init__(self):\n self._queue = []\n self._size = 0\n self._cost = 0\n\n def put(self, edge: Edge, target_cost):\n # assert target_cost >= self._cost\n queue_len = len(self._queue)\n if target_cost >= queue_len:\n self._queue.extend([[] for _ in range(target_cost - queue_len + 1)])\n self._queue[target_cost].append(edge)\n self._size += 1\n\n def pop(self):\n # assert self._size > 0\n while not self._queue[self._cost]:\n self._cost += 1\n edge = self._queue[self._cost].pop()\n self._size -= 1\n return edge, self._cost\n\n def __len__(self):\n return self._size\n\n\nclass MultiEntryMCFS(MultiEntryBFS):\n\n cost = MCFS.cost\n\n Queue = MCFS.Queue\n\n\n# ----------------------------------------------------------------------------\n# MCFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n# TODO: implement\n\n\n# ----------------------------------------------------------------------------\n# Depth-First Search\n# ----------------------------------------------------------------------------\n\nimport enum\n\n\nclass DFS:\n \"\"\"Depth-first Search (DFS)\"\"\"\n\n class Observer:\n\n def init(self, traversal):\n self.traversal = traversal\n self.graph = traversal.graph\n\n # -- Event Handlers ------------------------------------------------------\n\n def start_traversal(self, source: int):\n ...\n\n def finish_traversal(self):\n ...\n\n def stop_traversal(self):\n ...\n\n def enter_vertex(self, u: int):\n ...\n\n def exit_vertex(self, u: int):\n ...\n\n def traverse_tree_edge(self, edge: Edge):\n ...\n\n def retrace_tree_edge(self, edge: Edge):\n ...\n\n def visit_backward_edge(self, edge: Edge):\n # Hint: Check if edge.target == self.traversal.parents[edge.source].\n ...\n\n def visit_forward_edge(self, edge: Edge):\n ...\n\n def visit_cross_edge(self, edge: Edge):\n ...\n\n class StopTraversal(Exception):\n ...\n\n class VStatus(enum.Enum):\n UNDISCOVERED = 1\n ENTERED = 2\n EXITED = 3\n\n def __init__(self, graph, observer=None):\n # Traversal state:\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\n self.entry_times = [0] * graph.vertex_count()\n self.parents = [-1] * graph.vertex_count()\n self.time = 0\n self.stack = None\n self.stopped = False\n self._out_edges = [graph.out_edges(v) for v in graph.vertices()]\n # Traversal parameters:\n self.graph = graph\n self.observer = observer if observer is not None else self.Observer()\n self.observer.init(self)\n\n # -- Traversal Configuration -----------------------------------------------\n\n def _enter_vertex(self, v: int):\n # UNDISCOVERED -> ENTERED\n self.statuses[v] = self.VStatus.ENTERED\n self.time += 1\n self.entry_times[v] = self.time\n\n def _exit_vertex(self, v: int):\n # ENTERED -> EXITED\n self.statuses[v] = self.VStatus.EXITED\n\n # -- Traversal -------------------------------------------------------------\n\n def run(self, source: int):\n if self.statuses[source] != self.VStatus.UNDISCOVERED:\n return\n stack = [Edge(source=-1, target=source)]\n self.stopped = False\n try:\n self.observer.start_traversal(source)\n while stack:\n edge = stack[-1]\n p = edge.source # previous vertex\n u = edge.target\n match self.statuses[u]:\n case self.VStatus.UNDISCOVERED:\n self.parents[u] = p\n if p >= 0:\n self.observer.traverse_tree_edge(edge)\n self._enter_vertex(u)\n self.observer.enter_vertex(u)\n case self.VStatus.EXITED:\n stack.pop()\n if self.entry_times[u] > self.entry_times[p]:\n self.observer.visit_forward_edge(edge)\n else:\n self.observer.visit_cross_edge(edge)\n case self.VStatus.ENTERED:\n if p >= 0 and self.entry_times[u] < self.entry_times[p]:\n stack.pop()\n self.observer.visit_backward_edge(edge)\n else:\n try:\n stack.append(next(self._out_edges[u]))\n except StopIteration:\n self.observer.exit_vertex(u)\n self._exit_vertex(u)\n stack.pop()\n if p >= 0:\n self.observer.retrace_tree_edge(edge)\n except self.StopTraversal:\n self.stopped = True\n self.observer.stop_traversal()\n else:\n self.observer.finish_traversal()\n\n\n# ----------------------------------------------------------------------------\n# DFS-based Algorithms\n# ----------------------------------------------------------------------------\n\n\ndef find_scc(graph):\n\n class Pass1(DFS.Observer):\n\n def __init__(self):\n self.order = []\n\n def exit_vertex(self, u):\n self.order.append(u)\n\n pass1 = Pass1()\n dfs1 = DFS(graph, pass1)\n for v in graph.vertices():\n dfs1.run(v)\n\n class StronglyConnectedComponents(DFS.Observer):\n\n def __init__(self):\n self.count = 0\n self.vertex2comp = [-1] * graph.vertex_count()\n self.comp2vertices = collections.defaultdict(list)\n\n def start_traversal(self, source):\n self.count += 1\n\n def enter_vertex(self, u):\n self.vertex2comp[u] = self.count - 1\n self.comp2vertices[self.count - 1].append(u)\n\n scc = StronglyConnectedComponents()\n dfs2 = DFS(transposed(graph), scc)\n for v in reversed(pass1.order):\n dfs2.run(v)\n return scc\n\n\ndef build_condensation_graph(graph, scc=None):\n if scc is None:\n scc = find_scc(graph)\n edges = set()\n for c in range(scc.count):\n for u in scc.comp2vertices[c]:\n for v, _ in graph.out_edges(u):\n if scc.vertex2comp[v] == c: continue\n edges.add((c, scc.vertex2comp[v]))\n cond_graph = AdjacencyLists(scc.count)\n cond_graph.add_edges(edges)\n return cond_graph\n\n\ndef find_bridges_and_cutpoints(graph):\n\n class Finder(DFS.Observer):\n\n def __init__(self):\n self.low = [graph.vertex_count() + 1] * graph.vertex_count()\n self.bridges = []\n self.is_cutpoint = [False] * graph.vertex_count()\n\n def start_traversal(self, source):\n self.root = source\n\n def finish_traversal(self):\n if self.traversal.parents.count(self.root) > 1:\n self.is_cutpoint[self.root] = True\n\n def enter_vertex(self, u):\n self.low[u] = self.traversal.entry_times[u]\n\n def visit_backward_edge(self, edge: Edge):\n u, v, _, _ = astuple(edge)\n if v == self.traversal.parents[u]: return\n self.low[u] = min(self.low[u], self.traversal.entry_times[v]) \n\n def retrace_tree_edge(self, edge: Edge):\n u, v, _, _ = astuple(edge)\n self.low[u] = min(self.low[u], self.low[v])\n if self.low[v] >= self.traversal.entry_times[v]:\n self.bridges.append(edge)\n if self.low[v] >= self.traversal.entry_times[u] and u != self.root:\n self.is_cutpoint[u] = True\n\n finder = Finder()\n dfs = DFS(graph, finder)\n for v in graph.vertices():\n dfs.run(v)\n\n return finder.bridges, finder.is_cutpoint","memory":"55300"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[1][0] > 1 and grid[0][1] > 1: \n return -1\n import heapq\n from collections import defaultdict\n m, n = len(grid), len(grid[0])\n dis = defaultdict(lambda: float('inf'))\n dis[(0, 0)] = 0\n queue = [[0, (0, 0)]]\n heapq.heapify(queue)\n seen = set()\n directions = [\n [-1, 0], \n [1, 0], \n [0, -1], \n [0, 1]\n ]\n while queue: \n dis_curr, (x, y) = heapq.heappop(queue)\n seen.add((x, y))\n if x == m - 1 and y == n - 1: \n return dis_curr\n for dx, dy in directions: \n xx = x + dx\n yy = y + dy\n if 0 <= xx < m and 0 <= yy < n: \n if dis_curr + 1 >= grid[xx][yy]: \n if dis_curr + 1 < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\n else: \n diff = grid[xx][yy] - (dis_curr + 1)\n if diff % 2 == 1: \n diff += 1\n if dis_curr + 1 + diff < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1 + diff\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\n \n print(dis)\n return -1 \n \n \n ","memory":"56400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n ## adjusted Dijkstra's algo\n if grid[1][0] > 1 and grid[0][1] > 1: \n return -1\n import heapq\n from collections import defaultdict\n m, n = len(grid), len(grid[0])\n dis = defaultdict(lambda: float('inf'))\n dis[(0, 0)] = 0\n queue = [[0, (0, 0)]]\n heapq.heapify(queue)\n seen = set()\n directions = [\n [-1, 0], \n [1, 0], \n [0, -1], \n [0, 1]\n ]\n while queue: \n dis_curr, (x, y) = heapq.heappop(queue)\n seen.add((x, y))\n if x == m - 1 and y == n - 1: \n return dis_curr\n for dx, dy in directions: \n xx = x + dx\n yy = y + dy\n if 0 <= xx < m and 0 <= yy < n: \n if dis_curr + 1 >= grid[xx][yy]: \n if dis_curr + 1 < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\n else: \n diff = grid[xx][yy] - (dis_curr + 1)\n if diff % 2 == 1: \n diff += 1\n if dis_curr + 1 + diff < dis[(xx, yy)]: \n dis[(xx, yy)] = dis_curr + 1 + diff\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\n \n return -1 \n \n \n ","memory":"56400"},{"code":"class Solution:\n def minimumTime(self, grid: List[List[int]]) -> int:\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n m, n = len(grid), len(grid[0])\n visited = set()\n pq = [(grid[0][0], 0, 0)]\n \n while pq:\n time, row, col = heappop(pq)\n if row == m-1 and col == n-1: return time\n if (row, col) in visited: continue\n visited.add((row, col))\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n r, c = row + dr, col + dc\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\n return -1\n def minimumTime(self, grid: List[List[int]]) -> int:\n m, n = len(grid), len(grid[0])\n\n tgt = (m-1, n-1)\n src = (0, 0)\n\n que = [(0, src)]\n seen = defaultdict(int)\n seen[src] = 0\n\n if grid[0][0] > 0: return -1\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\n\n while que:\n cur_time, (x,y) = heappop(que) \n if (x, y) == tgt: return cur_time\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\n xx, yy = dx + x, dy + y\n\n if 0<= xx < m and 0 <= yy < n and ((xx, yy) not in seen or seen[(xx, yy)] > cur_time + 1):\n #update the modified origin if there is one\n tmp = cur_time\n modified_origin = False\n if tmp + 1 < grid[xx][yy]:\n tmp = (grid[xx][yy] - 1) if (grid[xx][yy] - 1 - tmp) %2 == 0 else grid[xx][yy]\n modified_origin = True\n\n if tmp + 1 >= grid[xx][yy] and ((xx, yy) not in seen or seen[(xx, yy)] > tmp +1):\n seen[(xx, yy)] = tmp + 1\n heappush(que, (tmp + 1, (xx, yy)))\n\n if modified_origin:\n heappush(que, (tmp, (x, y)))\n return -1\n\n","memory":"61000"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n q = [(0, 0, 0)]\\n while True:\\n t, r, c = heappop(q)\\n t += 1\\n for i, j in ((r-1,c), (r+1,c), (r, c-1), (r, c+1)):\\n if i<0 or i>=m or j<0 or j>=n or grid[i][j] == -1: continue\\n when = max(t, grid[i][j] + (1 if (t+grid[i][j])%2 else 0 ) )\\n if i == m-1 and j == n-1: return when\\n heappush(q, (when, i, j))\\n grid[i][j] = -1\",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"import heapq as hq\\nclass Solution:\\n def validCell(self, nRow, nCol, n, m):\\n return nRow >= 0 and nRow < n and nCol >= 0 and nCol < m\\n\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n n, m = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n heap = []\\n hq.heappush(heap, [0,0,0])\\n dist = [[math.inf for _ in range(m)] for _ in range(n)]\\n dist[0][0] = 0\\n\\n delRow = [1,-1,0,0]\\n delCol = [0,0,1,-1]\\n while heap:\\n time, i, j = hq.heappop(heap)\\n\\n for k in range(4):\\n nRow = i + delRow[k]\\n nCol = j + delCol[k]\\n\\n if self.validCell(nRow, nCol, n, m):\\n adjEle = grid[nRow][nCol]\\n increment = max(1, adjEle - time + ((adjEle - time)%2 == 0))\\n currTime = time + increment\\n\\n if dist[nRow][nCol] > currTime:\\n dist[nRow][nCol] = currTime\\n hq.heappush(heap, [currTime, nRow, nCol])\\n return dist[n-1][m-1]\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n \\n # If the starting cell is not reachable immediately, return -1\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n # Initialize the distance array with infinity\\n dist = [[float('inf')] * n for _ in range(m)]\\n dist[0][0] = 0\\n \\n # Priority queue to store cells with the smallest time\\n pq = [(0, 0, 0)] # (time, row, col)\\n \\n while pq:\\n time, row, col = heapq.heappop(pq)\\n \\n # If we reached the bottom-right cell, return the time\\n if row == m - 1 and col == n - 1:\\n return time\\n \\n # Explore the four directions: up, down, left, right\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n \\n # Check if the new cell is within bounds\\n if 0 <= r < m and 0 <= c < n:\\n # Calculate the waiting time if needed\\n wait = (grid[r][c] - time) % 2 == 0\\n new_time = max(time + 1, grid[r][c] + wait)\\n \\n # If the new time is smaller, update and add to the queue\\n if new_time < dist[r][c]:\\n dist[r][c] = new_time\\n heapq.heappush(pq, (new_time, r, c))\\n \\n # If we couldn't reach the bottom-right cell, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\\nprint(solution.minimumTime(grid)) # Output: 7\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n rows,cols=len(grid),len(grid[0])\\n \\n if grid[0][1]>1 and grid[1][0]>1:\\n return -1\\n \\n visited=[[False for i in range(cols)] for i in range(rows)]\\n \\n # curtime, cell\\n pq=[(0,0,0)]\\n heapq.heapify(pq)\\n \\n while pq:\\n curTime,x,y=heapq.heappop(pq)\\n if x==rows-1 and y==cols-1:\\n return curTime\\n for di in [(0,1),(0,-1),(1,0),(-1,0)]:\\n nx=x+di[0]\\n ny=y+di[1]\\n \\n if not (0<=nx<rows and 0<=ny<cols):\\n continue\\n if visited[nx][ny]:\\n continue\\n diff=grid[nx][ny]-curTime\\n wait= 1 if (diff%2==0) else 0\\n \\n heapq.heappush(pq, ((max(curTime+1,grid[nx][ny]+wait), nx,ny)) )\\n visited[nx][ny]=True\\n return -1 \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\\n\\n m, n = len(grid), len(grid[0])\\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\\n dis = [[inf for _ in range(n)] for _ in range(m)]\\n dis[0][0] = 0\\n h = [(0, 0, 0)]\\n while h:\\n d, i, j = heapq.heappop(h)\\n if i == m - 1 and j == n - 1:\\n return d\\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\\n if 0 <= x < m and 0 <= y < n:\\n nd = max(d + 1, grid[x][y])\\n nd += (nd - x - y) % 2\\n if nd < dis[x][y]:\\n dis[x][y] = nd\\n heappush(h, (nd, x, y))\\n\\n \",\n \"memory\": \"31700\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n n,m = len(grid),len(grid[0])\\n dirc = [(-1,0), (0,1), (1,0), (0,-1)]\\n dist = [[float('inf')]*m for _ in range(n)]\\n pq = [(0,0,0)]\\n dist[0][0] = 0\\n isValid = lambda nr,nc: nr >= 0 and nr<n and nc >= 0 and nc < m\\n while pq:\\n time,row,col = heapq.heappop(pq)\\n if row == n-1 and col == m-1: \\n return time\\n for delRow,delCol in dirc:\\n nr = delRow+row\\n nc = delCol+col\\n if isValid(nr,nc):\\n if 1+time >= grid[nr][nc]:\\n if dist[nr][nc] > 1+time:\\n dist[nr][nc] = time+1\\n heapq.heappush(pq,(1+time,nr,nc))\\n else:\\n diff = grid[nr][nc]-time\\n if diff&1 == 0: diff += 1\\n if dist[nr][nc] > time+diff:\\n dist[nr][nc] = time+diff\\n heapq.heappush(pq,(time+diff,nr,nc))\\n return -1\",\n \"memory\": \"31800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n dist = [[inf] * n for _ in range(m)]\\n dist[0][0] = 0\\n q = [(0, 0, 0)]\\n dirs = (-1, 0, 1, 0, -1)\\n while 1:\\n t, i, j = heappop(q)\\n if i == m - 1 and j == n - 1:\\n return t\\n for a, b in pairwise(dirs):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n:\\n nt = t + 1\\n if nt < grid[x][y]:\\n nt = grid[x][y] + (grid[x][y] - nt) % 2\\n if nt < dist[x][y]:\\n dist[x][y] = nt\\n heappush(q, (nt, x, y))\",\n \"memory\": \"31900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n m, n = len(grid), len(grid[0])\\n dist = [[inf] * n for _ in range(m)]\\n dist[0][0] = 0\\n q = [(0, 0, 0)]\\n dirs = (-1, 0, 1, 0, -1)\\n while 1:\\n t, i, j = heappop(q)\\n if i == m - 1 and j == n - 1:\\n return t\\n for a, b in pairwise(dirs):\\n x, y = i + a, j + b\\n if 0 <= x < m and 0 <= y < n:\\n nt = t + 1\\n if nt < grid[x][y]:\\n nt = grid[x][y] + (grid[x][y] - nt) % 2\\n if nt < dist[x][y]:\\n dist[x][y] = nt\\n heappush(q, (nt, x, y))\",\n \"memory\": \"32000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n n = len(grid)\\n m = len(grid[0])\\n\\n # Early exit check\\n if not (grid[0][1] - grid[0][0] <= 1) and not (grid[1][0] - grid[0][0] <= 1):\\n return -1\\n\\n # Priority queue (min-heap), storing (current_time, row, column)\\n pq = [(0, 0, 0)] # Initialize heap with (time, row, column)\\n rec = [[float('inf')] * m for _ in range(n)]\\n rec[0][0] = 0\\n\\n # Directions for moving in the grid\\n dx = [1, -1, 0, 0]\\n dy = [0, 0, 1, -1]\\n\\n while pq:\\n val, r, c = heapq.heappop(pq) # Pop the cell with the smallest current_time\\n\\n for i in range(4):\\n nr = r + dx[i]\\n nc = c + dy[i]\\n if 0 <= nr < n and 0 <= nc < m:\\n diff = grid[nr][nc] - val\\n if diff <= 0:\\n if rec[nr][nc] > val + 1:\\n heapq.heappush(pq, (val + 1, nr, nc))\\n rec[nr][nc] = val + 1\\n continue\\n\\n # Adjust diff if it's even\\n diff = diff + 1 if diff % 2 == 0 else diff\\n if rec[nr][nc] > val + diff:\\n heapq.heappush(pq, (val + diff, nr, nc))\\n rec[nr][nc] = val + diff\\n\\n return rec[n - 1][m - 1] if rec[n - 1][m - 1] != float('inf') else -1\\n\",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"import heapq\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n \\n rows = len(grid)\\n cols = len(grid[0])\\n \\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n time_to_reach = [[float('inf')] * cols for _ in range(rows)]\\n time_to_reach[0][0] = 0\\n \\n q = [(0, 0, 0)] # (time, row, col)\\n \\n neighbours = [\\n (0, 1),\\n (1, 0),\\n (0, -1),\\n (-1, 0)\\n ]\\n \\n while q:\\n cur_time, cur_row, cur_col = heapq.heappop(q)\\n \\n for dr, dc in neighbours:\\n r, c = cur_row + dr, cur_col + dc\\n if r < 0 or r >= rows or c < 0 or c >= cols:\\n continue\\n \\n wait_time = max(0, grid[r][c] - cur_time - 1)\\n if wait_time % 2 != 0:\\n wait_time += 1\\n \\n new_time = cur_time + wait_time + 1\\n if time_to_reach[r][c] > new_time:\\n time_to_reach[r][c] = new_time\\n heapq.heappush(q, (new_time, r, c))\\n \\n return time_to_reach[rows-1][cols-1]\\n\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n length = len(grid[0])\\n width = len(grid)\\n\\n min_time = [[float('inf')] * length for _ in range(width)]\\n min_heap = []\\n\\n min_time[0][0] = 0\\n heapq.heappush(min_heap, (0, (0,0))) # (min_time, index)\\n\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n while min_heap:\\n \\n min_t, min_t_index = heapq.heappop(min_heap)\\n min_t_x, min_t_y = min_t_index\\n if min_t > min_time[min_t_x][min_t_y]: continue\\n if min_t_index == (width-1, length-1): return min_t\\n\\n directions = [(1,0), (-1,0),(0,1),(0,-1)]\\n\\n for dx, dy in directions:\\n next_x = min_t_x + dx\\n next_y = min_t_y + dy\\n if next_x in range(width) and next_y in range(length):\\n cur_time = min_t + 1\\n grid_value = grid[next_x][next_y]\\n\\n if grid_value <= cur_time:\\n if cur_time < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = cur_time\\n heapq.heappush(min_heap, (cur_time, (next_x, next_y)))\\n else:\\n if (next_x + next_y) % 2 == grid_value % 2:\\n if grid_value < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = grid_value\\n heapq.heappush(min_heap, (grid_value, (next_x, next_y)))\\n else:\\n if grid_value + 1 < min_time[next_x][next_y]:\\n min_time[next_x][next_y] = grid_value + 1\\n heapq.heappush(min_heap, (grid_value+1, (next_x, next_y)))\",\n \"memory\": \"32400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\\n\",\n \"memory\": \"34000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False] * n for _ in range(m)]\\n heap = [(0, 0, 0)] # (t, r, c)\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or visited[nr][nc]:\\n continue\\n wait = 0 if (grid[nr][nc] - t) % 2 else 1\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n return -1\\n\",\n \"memory\": \"34100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n visited = [[False]*n for _ in range(m)]\\n heap = [(0, 0, 0)]\\n\\n while heap:\\n t, x, y = heappop(heap)\\n \\n if x == m - 1 and y == n - 1:\\n return t\\n \\n if visited[x][y]:\\n continue\\n visited[x][y] = True\\n \\n for dx, dy in [(0,1), (0,-1), (1,0), (-1,0)]:\\n nx, ny = x+dx, y+dy\\n\\n if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny]:\\n wait = (grid[nx][ny] - t) % 2 == 0\\n nt = max(grid[nx][ny] + wait, t + 1)\\n heappush(heap, (nt, nx, ny))\\n return -1\",\n \"memory\": \"34200\"\n },\n {\n \"code\": \"from queue import PriorityQueue\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[1][0]>1 and grid[0][1]>1:\\n return -1 \\n \\n pq = PriorityQueue()\\n direction = [[1,0],[0,1],[-1,0],[0,-1]]\\n row, col = len(grid), len(grid[0])\\n pq.put([grid[0][0],0,0])\\n visited = [[0] * col for _ in range(row)]\\n\\n while not pq.empty():\\n time, r, c = pq.get()\\n\\n if r == row-1 and c == col-1:\\n return time \\n \\n if visited[r][c]:\\n continue \\n \\n visited[r][c]+=1\\n\\n for R,C in direction:\\n newRow, newCol = r + R, c + C\\n\\n if newRow<0 or newRow>=row or newCol<0 or newCol>=col or visited[newRow][newCol]:\\n continue \\n \\n check = (grid[newRow][newCol]-time)%2==0 #if true add 1 else as it is means if number odd \\n\\n pq.put([max(grid[newRow][newCol]+check,time+1),newRow,newCol])\\n \\n return -1 \\n \\n\\n\\n\\n \",\n \"memory\": \"36400\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, [0, 0, 0])\\n \\n # visited is needed\\n visited = [[False]*n for _ in range(m)]\\n \\n canHold = False\\n \\n while pq: \\n t, r, c = heapq.heappop(pq)\\n \\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n\\n if r == m-1 and c == n-1:\\n return t \\n \\n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\\n \\n for r2, c2 in allNbr:\\n if t+1 >= grid[r2][c2]:\\n canHold = True\\n \\n \\n \\n for newR, newC in allNbr:\\n if grid[newR][newC] > t+1:\\n if not(canHold):\\n continue\\n diff = grid[newR][newC] - (t+1)\\n else:\\n diff = 0\\n \\n stall = math.ceil(diff/2) * 2\\n \\n heapq.heappush(pq, [t+1+stall, newR, newC])\\n \\n return -1\\n \\n \",\n \"memory\": \"36700\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, [0, 0, 0])\\n \\n # visited is needed\\n visited = [[False]*n for _ in range(m)]\\n \\n canHold = False\\n \\n while pq: \\n t, r, c = heapq.heappop(pq)\\n \\n if visited[r][c]:\\n continue\\n visited[r][c] = True\\n\\n if r == m-1 and c == n-1:\\n return t \\n \\n allNbr = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n,\\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\\n \\n for r2, c2 in allNbr:\\n if t+1 >= grid[r2][c2]:\\n canHold = True\\n \\n nbrs = list(filter(lambda x: 0 <= x[0] < m and 0 <= x[1] < n and (grid[x[0]][x[1]] <= t + 1 and not(canHold) or canHold),\\n [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]))\\n \\n \\n for newR, newC in nbrs:\\n if grid[newR][newC] > t+1:\\n diff = grid[newR][newC] - (t+1)\\n else:\\n diff = 0\\n \\n stall = math.ceil(diff/2) * 2\\n \\n heapq.heappush(pq, [t+1+stall, newR, newC])\\n \\n return -1\\n \\n \",\n \"memory\": \"37000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n m, n = len(grid), len(grid[0])\\n heap = [(0, 0, 0)]\\n min_time = [[inf] * n for _ in range(m)]\\n min_time[0][0] = 0\\n \\n while heap:\\n curr_time, r, c = heappop(heap)\\n for dr, dc in [[-1, 0], [1, 0], [0, -1], [0, 1]]:\\n if 0 <= r + dr < m and 0 <= c + dc < n:\\n if curr_time + 1 >= min_time[r + dr][c + dc]:\\n continue\\n else:\\n if (curr_time + 1 - grid[r + dr][c + dc]) % 2 == 0:\\n min_time[r + dr][c + dc] = max(curr_time + 1, grid[r + dr][c + dc])\\n else:\\n min_time[r + dr][c + dc] = max(curr_time + 1, grid[r + dr][c + dc] + 1)\\n heappush(heap, (min_time[r + dr][c + dc], r + dr, c + dc))\\n return min_time[-1][-1]\",\n \"memory\": \"37400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m = len(grid)\\n n = len(grid[0])\\n PQ = [[0, 0, 0]]\\n D = [[-1, 0], [0, -1], [0, 1], [1, 0]]\\n times = [[-1 for _ in range(n)] for _ in range(m)]\\n times[0][0] = 0\\n while PQ:\\n time, i, j = heappop(PQ)\\n if i == m - 1 and j == n - 1: return time\\n for d in D:\\n x = i + d[0]\\n y = j + d[1]\\n if x < 0 or x == m: continue\\n if y < 0 or y == n: continue\\n if times[x][y] != -1 and times[x][y] <= time + 1: continue\\n if grid[x][y] <= time + 1: times[x][y] = time + 1\\n else: times[x][y] = grid[x][y] + (grid[x][y] - time - 1) % 2\\n heappush(PQ, [times[x][y], x, y])\",\n \"memory\": \"38700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n time = 0\\n q = [(time, 0, 0)]\\n visited = set()\\n m = len(grid)\\n n = len(grid[0])\\n blocked = (grid[0][1]>1 and grid[1][0]>1)\\n if blocked:\\n return -1\\n while q:\\n time, i, j = heapq.heappop(q)\\n if i==(m-1) and j==(n-1):\\n return time\\n if (i,j) in visited:\\n continue\\n visited.add((i,j))\\n #print(f\\\"process {i, j}, time={time}\\\")\\n time += 1\\n for I, J in [(i+1,j), (i-1,j), (i,j+1), (i,j-1)]:\\n if I>=0 and I<m and J>=0 and J<n:\\n if (time)>=grid[I][J]:\\n heapq.heappush(q, (time, I, J))\\n next_time = time\\n else:\\n if (grid[I][J]-time)%2 == 0:\\n heapq.heappush(q, (grid[I][J], I, J))\\n next_time = grid[I][J]\\n else:\\n heapq.heappush(q, (grid[I][J]+1, I, J))\\n next_time = grid[I][J]+1\\n #print(f\\\"push {I, J, next_time}\\\")\\n\\n return -1\\n \",\n \"memory\": \"39900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if len(grid) > 1 and len(grid[0]) > 1: \\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n elif len(grid) > 1 and grid[1][0] > 1:\\n return -1\\n elif len(grid[0]) > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == grid[a][b] % 2:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][grid[a][b] % 2] > nexto:\\n shortests[a][b][grid[a][b] % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][(currTime+1) % 2] > nexto:\\n shortests[a][b][(currTime+1) % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n return -1\\n\\n \",\n \"memory\": \"40100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == grid[a][b] % 2:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][grid[a][b] % 2] > nexto:\\n shortests[a][b][grid[a][b] % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][(currTime+1) % 2] > nexto:\\n shortests[a][b][(currTime+1) % 2] = nexto\\n heappush(prioQ, (nexto, a, b))\\n\\n \",\n \"memory\": \"40200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if len(grid) > 1 and len(grid[0]) > 1: \\n if grid[1][0] > 1 and grid[0][1] > 1:\\n return -1\\n elif len(grid) > 1 and grid[1][0] > 1:\\n return -1\\n elif len(grid[0]) > 1 and grid[0][1] > 1:\\n return -1\\n shortests = [[[float(\\\"inf\\\"), float(\\\"inf\\\")] for _ in range(len(grid[0]))] for _ in range(len(grid))]\\n prioQ = []\\n shortests[0][0][0] = 0\\n heappush(prioQ, (0, 0, 0))\\n while prioQ:\\n currTime, i, j = heappop(prioQ)\\n if i == len(grid)-1 and j == len(grid[0])-1:\\n return currTime\\n for a, b in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):\\n if a > -1 and a < len(grid) and b > -1 and b < len(grid[0]):\\n if (currTime+1) % 2 == 1:\\n if grid[a][b] % 2 == 1:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][1] > nexto:\\n shortests[a][b][1] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][1] > nexto:\\n shortests[a][b][1] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n if grid[a][b] % 2 == 1:\\n nexto = max(currTime+1, grid[a][b]+1)\\n if shortests[a][b][0] > nexto:\\n shortests[a][b][0] = nexto\\n heappush(prioQ, (nexto, a, b))\\n else:\\n nexto = max(currTime+1, grid[a][b])\\n if shortests[a][b][0] > nexto:\\n shortests[a][b][0] = nexto\\n heappush(prioQ, (nexto, a, b))\\n return -1\\n\\n \",\n \"memory\": \"40300\"\n },\n {\n \"code\": \"import heapq as hq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n \\n nrow = len(grid)\\n ncol = len(grid[0])\\n\\n visited = set()\\n heap = [(0,0,0)] # distance, row, col\\n\\n def helper(distance, row, col):\\n newdist = max(distance + 1, grid[row][col])\\n if newdist % 2 != (row + col) % 2:\\n newdist += 1\\n\\n hq.heappush(heap, (newdist, row, col))\\n\\n\\n while heap:\\n distance, row, col = hq.heappop(heap)\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n if row == nrow - 1 and col == ncol - 1: return distance\\n\\n if row > 0: helper(distance, row-1, col)\\n if row < nrow-1: helper(distance, row+1, col)\\n if col > 0: helper(distance, row, col-1)\\n if col < ncol - 1: helper(distance, row, col+1)\\n\\n return -1\\n \\n\",\n \"memory\": \"40600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n\\n heap = [(grid[0][0], 0, 0)]\\n # visited.add((0, 0))\\n\\n ans = -1\\n\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n\\n if row == rows-1 and col == cols-1:\\n return time\\n \\n if (row, col) in visited: continue\\n\\n visited.add((row, col))\\n \\n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\\n wait = 0\\n if (grid[new_row][new_col] - time) % 2 == 0:\\n wait = 1\\n\\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\\n \\n\\n\\n\\n\\n\\n\",\n \"memory\": \"40700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n m = len(grid)\\n n = len(grid[0])\\n moves = [\\n (0, 1),\\n (0, -1),\\n (1, 0),\\n (-1, 0),\\n ]\\n heap = [(0, 0, 0)]\\n visited = set([0, 0])\\n while heap:\\n curr_time, r, c = heappop(heap) \\n if (r, c) in visited:\\n continue\\n \\n if r == m - 1 and c == n - 1:\\n return curr_time\\n \\n visited.add((r, c))\\n \\n for move in moves:\\n nr, nc = r + move[0], c + move[1]\\n if 0 <= nr < m and 0 <= nc < n and (nr, nc) not in visited:\\n wait = 1 if (grid[nr][nc] - curr_time) % 2 == 0 else 0\\n heappush(heap, (max(curr_time + 1, grid[nr][nc] + wait), nr, nc))\\n\\n\",\n \"memory\": \"40800\"\n },\n {\n \"code\": \"'''\\nO(mn log mn) O(Elogv)\\nBrute Force:\\nif t >= grid[i][j] then we can use the cell.\\nI can go to 4 options at one point. O(n^3), memo of 3d.\\nDijkestra's algo: we can go back to the time stamp with min. no. at the same time we can keep the nodes\\nwith higher time stamps in the queue as well\\nplay ping pong till the time>= the grid value of the target cell.\\n'''\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] >1:\\n return -1\\n vis = set()\\n min_heap = [ (grid[0][0], 0, 0) ]\\n while min_heap:\\n time, x, y = heapq.heappop(min_heap)\\n if x == m-1 and y == n-1: return time\\n if (x,y) in vis:\\n continue\\n vis.add((x,y))\\n for dx, dy in [(1,0),(0,1),(-1,0),(0,-1)]:\\n n_x, n_y = x+dx, y+dy\\n n_cost = time + 1\\n if 0<=n_x<m and 0<=n_y<n and (n_x, n_y) not in vis:\\n if grid[n_x][n_y] >1+time:\\n if (grid[n_x][n_y] - time)%2 == 0:\\n n_cost = grid[n_x][n_y] + 1\\n else:\\n n_cost = grid[n_x][n_y]\\n heapq.heappush(min_heap, (n_cost, n_x, n_y))\\n return -1\\n \\n \\n \",\n \"memory\": \"40900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n rows = len(grid)\\n cols = len(grid[0])\\n\\n visited = set()\\n\\n heap = [(grid[0][0], 0, 0)]\\n # visited.add((0, 0))\\n\\n ans = -1\\n\\n while heap:\\n time, row, col = heapq.heappop(heap)\\n\\n if row == rows-1 and col == cols-1:\\n return time\\n \\n if (row, col) in visited: continue\\n\\n visited.add((row, col))\\n \\n for new_row, new_col in [(row+1, col), (row-1, col), (row, col+1), (row, col-1)]:\\n if new_row >= 0 and new_row < rows and new_col >= 0 and new_col < cols and (new_row, new_col) not in visited:\\n wait = 1 if (grid[new_row][new_col] - time) % 2 == 0 else 0\\n\\n heappush(heap, (max(time+1, grid[new_row][new_col]+wait), new_row, new_col))\\n \\n\\n\\n\\n\\n\\n\",\n \"memory\": \"41000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n m, n = len(grid), len(grid[0])\\n heap = [(0, 0, 0)]\\n visited = set()\\n \\n while heap:\\n t, r, c = heapq.heappop(heap)\\n \\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n \\n if r == m - 1 and c == n - 1:\\n return t\\n \\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n \\n return -1\",\n \"memory\": \"41200\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n \\n # If the immediate neighbor (1, 0) or (0, 1) is not reachable, we cannot start the BFS.\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n # Priority queue to store cells with their corresponding times\\n heap = [(0, 0, 0)] # (time, row, col)\\n visited = set()\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n \\n # If we reached the bottom-right cell, return the current time\\n if row == m - 1 and col == n - 1:\\n return time\\n \\n # If the cell is already visited, skip it\\n if (row, col) in visited:\\n continue\\n visited.add((row, col))\\n \\n # Add neighboring cells to the heap\\n for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n # If the neighboring cell is reachable at the current time + 1, add it to the heap\\n if grid[r][c] <= time + 1:\\n heapq.heappush(heap, (time + 1, r, c))\\n else:\\n # If the neighboring cell is not reachable yet, we need to wait until it is\\n # The wait time can be calculated as the time required by the cell + 1 if it is odd, or directly + 1 if it is even\\n wait_time = grid[r][c] + (1 if grid[r][c] % 2 == time % 2 else 0)\\n heapq.heappush(heap, (wait_time, r, c))\\n \\n # If we haven't found a path to the bottom-right cell, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\\nprint(solution.minimumTime(grid)) # Output: 7\\n\\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\\nprint(solution.minimumTime(grid)) # Output: -1\",\n \"memory\": \"41400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m, n = len(grid), len(grid[0])\\n visited = set()\\n pq = [(grid[0][0], 0, 0)]\\n\\n while pq:\\n time, row, col = heappop(pq)\\n if row == m-1 and col == n-1: return time\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c)) \",\n \"memory\": \"41500\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\\n if grid[dr][dc] > curTime+1:\\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"memory\": \"41600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # Return -1 immediately if we can't move at the start\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n m, n = len(grid), len(grid[0])\\n dirs = [(0, -1), (0, 1), (1, 0), (-1, 0)]\\n visited = set()\\n pq = [(0, 0, 0)] # time, row, column\\n while pq:\\n t, r, c = heapq.heappop(pq)\\n if r == m - 1 and c == n - 1:\\n return t\\n if (r, c) in visited:\\n continue\\n visited.add((r, c))\\n for dx, dy in dirs:\\n nx, ny = r + dx, c + dy\\n if 0 > nx or nx >= m or 0 > ny or ny >= n or (nx, ny) in visited:\\n continue\\n wait = 1 if (grid[nx][ny] - t) % 2 == 0 else 0\\n nt = max(grid[nx][ny] + wait, t + 1)\\n heapq.heappush(pq, (nt, nx, ny))\\n return -1\\n\\n \",\n \"memory\": \"41700\"\n },\n {\n \"code\": \"from queue import PriorityQueue\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if (grid[0][1] > 1 and grid[1][0] > 1):\\n return -1\\n\\n m = len(grid)\\n n = len(grid[0])\\n pq = PriorityQueue()\\n pq.put((0, 0, 0))\\n vis = set()\\n dirs = ((0, -1), (0, 1), (-1, 0), (1, 0))\\n while pq.qsize():\\n t, r, c = pq.get()\\n if r == m - 1 and c == n - 1:\\n return t\\n if (r, c) in vis:\\n continue\\n vis.add((r, c))\\n for x, y in dirs:\\n nr = r + x\\n nc = c + y\\n if nr >= 0 and nc >= 0 and nr < m and nc < n and (nr, nc) not in vis:\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n pq.put((nt, nr, nc))\\n \\n return -1\\n\",\n \"memory\": \"41800\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]):\\n if grid[dr][dc] > curTime+1:\\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"memory\": \"41900\"\n },\n {\n \"code\": \"## Time O(M*N*log(M*N)) || Space O(M*N)\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1 \\n\\n visited = set()\\n minTime = -1\\n\\n q = [(0,0,0)]\\n\\n while q:\\n curTime, row, col = heapq.heappop(q)\\n if row == len(grid)-1 and col == len(grid[0])-1:\\n return curTime\\n if (row,col) in visited:\\n continue\\n visited.add((row,col))\\n for r, c in [(0,1),(1,0),(0,-1),(-1,0)]:\\n dr, dc = row+r, col+c\\n if 0 <= dr < len(grid) and 0 <= dc < len(grid[0]) and (dr,dc) not in visited:\\n if grid[dr][dc] > curTime+1:\\n tt = curTime + ((grid[dr][dc] - curTime)//2 * 2) + 1\\n heapq.heappush(q, (tt, dr,dc))\\n else:\\n heapq.heappush(q, (curTime+1, dr,dc))\\n \\n return minTime\",\n \"memory\": \"41900\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n \\n # If we cannot even start from the top-left cell, return -1\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n # Directions to move in the grid: up, down, left, right\\n directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n \\n # Min-heap to store the cells to visit, along with the time taken to reach them\\n heap = [(0, 0, 0)] # (time, row, col)\\n \\n # Set to store the visited cells\\n visited = set()\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n \\n # If we have reached the bottom-right cell, return the current time\\n if row == m - 1 and col == n - 1:\\n return time\\n \\n # If the cell is already visited, continue\\n if (row, col) in visited:\\n continue\\n \\n # Mark the cell as visited\\n visited.add((row, col))\\n \\n # Explore all adjacent cells\\n for dr, dc in directions:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n:\\n # Calculate the waiting time if needed\\n wait_time = (grid[r][c] - time) % 2 == 0\\n new_time = max(time + 1, grid[r][c] + wait_time)\\n heapq.heappush(heap, (new_time, r, c))\\n \\n # If we cannot reach the bottom-right cell, return -1\\n return -1\\n\\n# Example usage:\\nsolution = Solution()\\ngrid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]\\nprint(solution.minimumTime(grid)) # Output: 7\\n\\ngrid = [[0,2,4],[3,2,1],[1,0,4]]\\nprint(solution.minimumTime(grid)) # Output: -1\",\n \"memory\": \"42000\"\n },\n {\n \"code\": \"import heapq\\nfrom typing import List\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n m, n = len(grid), len(grid[0])\\n directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n \\n def is_valid(x, y):\\n return 0 <= x < m and 0 <= y < n\\n \\n min_heap = [(0, 0, 0)] # (time, row, col)\\n visited = set()\\n\\n while min_heap:\\n time, x, y = heapq.heappop(min_heap)\\n if (x, y) == (m-1, n-1):\\n return time\\n if (x, y) in visited:\\n continue\\n visited.add((x, y))\\n\\n for dx, dy in directions:\\n nx, ny = x + dx, y + dy\\n if is_valid(nx, ny) and (nx, ny) not in visited:\\n wait_time = max(0, grid[nx][ny] - (time + 1))\\n if wait_time % 2 == 0:\\n heapq.heappush(min_heap, (time + 1 + wait_time, nx, ny))\\n else:\\n heapq.heappush(min_heap, (time + 2 + wait_time, nx, ny))\\n\\n return -1\",\n \"memory\": \"42100\"\n },\n {\n \"code\": \"from queue import Queue\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m=len(grid)\\n n=len(grid[0])\\n mx=10**9\\n if grid[0][1]>1 and grid[1][0]>1:\\n return -1\\n dir=[[-1,0],[1,0],[0,-1],[0,1]]\\n pq=[(grid[0][0],0,0)]\\n vis=set()\\n \\n while pq:\\n time,curx,cury=heappop(pq)\\n if curx==m-1 and cury==n-1:\\n return time\\n if (curx,cury) in vis:\\n continue\\n vis.add((curx,cury))\\n \\n for i in range(4):\\n nx=curx+dir[i][0]\\n ny=cury+dir[i][1]\\n if nx>=0 and nx<m and ny>=0 and ny<n and (nx,ny) not in vis:\\n wait=0\\n if grid[nx][ny]>time:\\n wait=(grid[nx][ny]-time)\\n if wait%2==1:\\n wait-=1\\n heappush(pq,(max(1+time,time+1+wait),nx,ny))\\n return -1\\n \\n \",\n \"memory\": \"42400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n rowLen, colLen = len(grid), len(grid[0])\\n heap = [(0, (0, 0))] # time, (x, y)\\n visited = {(0, 0)}\\n\\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\\n\\n while heap:\\n time, (x, y) = heapq.heappop(heap)\\n if x == rowLen - 1 and y == colLen - 1:\\n return time\\n\\n for move in moves:\\n newX, newY = x + move[0], y + move[1]\\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\\n if grid[newX][newY] <= time + 1:\\n heapq.heappush(heap, (time + 1, (newX, newY)))\\n elif canMove:\\n timeNeeded = grid[newX][newY] - time - 1\\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\\n heapq.heappush(heap, (totalTime, (newX, newY)))\\n visited.add((newX, newY))\\n return -1\\n\",\n \"memory\": \"42900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n def bounds(r, c):\\n return 0<=r<len(grid) and 0<=c<len(grid[0])\\n\\n if grid[0][0]+1 < grid[0][1] and grid[0][0]+1 < grid[1][0]:\\n return -1 \\n\\n q = []\\n visited = set()\\n time = 0\\n if grid[0][0] <= time:\\n q.append((time,0,0))\\n visited.add((0,0))\\n res = float(\\\"inf\\\")\\n while(len(q)):\\n # print(q)\\n time,r,c = heapq.heappop(q)\\n if r == len(grid)-1 and c == len(grid[0])-1:\\n return time\\n\\n for d in [(0,1), (0,-1), (-1, 0), (1,0)]:\\n nr, nc = r+d[0],c+d[1]\\n # print(r,c, nr,nc)\\n if bounds(nr, nc):\\n if time >= grid[nr][nc] and (nr,nc) not in visited:\\n visited.add((nr,nc))\\n heapq.heappush(q, (time+1, nr, nc))\\n elif (nr,nc) not in visited:\\n visited.add((nr,nc))\\n newTime = grid[nr][nc] if (grid[nr][nc]-time) %2 == 1 else grid[nr][nc]+1\\n heapq.heappush(q, (newTime, nr, nc))\\n \\n return -1 if res == float(\\\"inf\\\") else res\\n\\n\\n\\n \\n \\n \\n \",\n \"memory\": \"43100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n rowLen, colLen = len(grid), len(grid[0])\\n moves = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n heap = [(0, (0, 0))]\\n visited = {(0, 0)}\\n\\n canMove = True if grid[0][1] <= 1 or grid[1][0] <= 1 else False\\n\\n while heap:\\n time, (x, y) = heapq.heappop(heap)\\n if x == rowLen - 1 and y == colLen - 1:\\n return time\\n for move in moves:\\n newX, newY = x + move[0], y + move[1]\\n if 0 <= newX < rowLen and 0 <= newY < colLen and (newX, newY) not in visited:\\n if grid[newX][newY] <= time + 1:\\n heapq.heappush(heap, (time + 1, (newX, newY)))\\n elif canMove:\\n timeNeeded = grid[newX][newY] - time - 1\\n totalTime = grid[newX][newY] + 1 if timeNeeded % 2 else grid[newX][newY]\\n heapq.heappush(heap, (totalTime, (newX, newY)))\\n visited.add((newX, newY))\\n return -1\",\n \"memory\": \"43400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # base\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n m, n = len(grid), len(grid[0])\\n\\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\\n visited = {(0, 0)} # trace back visited cell\\n\\n while minhpq:\\n time, i, j = heappop(minhpq)\\n\\n # stop; found a solution\\n if i == m - 1 and j == n - 1:\\n return time\\n\\n for di, dj in dirs:\\n di, dj = i + di, j + dj\\n \\n # pass; infeasible or seen before\\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\\n continue\\n\\n # wait is at max 1 to move from (i, j) to (di, dj)\\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\\n\\n # take the max for the next possible valid time\\n next_time = max(time + 1, grid[di][dj] + wait)\\n\\n # push the new cell into min heap\\n heappush(minhpq, (next_time, di, dj))\\n visited.add((di, dj))\\n\\n return -1\",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"memory\": \"43600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: list[list[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))\\n m = len(grid)\\n n = len(grid[0])\\n minHeap = [(0, 0, 0)] # (time, i, j)\\n seen = {(0, 0)}\\n\\n while minHeap:\\n time, i, j = heapq.heappop(minHeap)\\n if i == m - 1 and j == n - 1:\\n return time\\n for dx, dy in dirs:\\n x = i + dx\\n y = j + dy\\n if x < 0 or x == m or y < 0 or y == n:\\n continue\\n if (x, y) in seen:\\n continue\\n extraWait = 1 if (grid[x][y] - time) % 2 == 0 else 0\\n nextTime = max(time + 1, grid[x][y] + extraWait)\\n heapq.heappush(minHeap, (nextTime, x, y))\\n seen.add((x, y))\",\n \"memory\": \"43700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # base\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]\\n m, n = len(grid), len(grid[0])\\n\\n minhpq = [(0, 0, 0)] # stores (time, i, j) increasngly\\n visited = {(0, 0)} # trace back visited cell\\n\\n while minhpq:\\n time, i, j = heappop(minhpq)\\n\\n # stop; found a solution\\n if i == m - 1 and j == n - 1:\\n return time\\n\\n for di, dj in dirs:\\n di, dj = i + di, j + dj\\n \\n # pass; infeasible or seen before\\n if di < 0 or di >= m or dj < 0 or dj >= n or (di, dj) in visited:\\n continue\\n\\n # wait is at max 1 to move from (i, j) to (di, dj)\\n wait = 1 if (grid[di][dj] - time) % 2 == 0 else 0\\n\\n # take the max for the next possible valid time\\n next_time = max(time + 1, grid[di][dj] + wait)\\n\\n # push the new cell into min heap\\n heappush(minhpq, (next_time, di, dj))\\n visited.add((di, dj))\\n\\n return -1\",\n \"memory\": \"43800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n heap = [(0, 0, 0)]\\n visited = {(0, 0)}\\n while heap:\\n t, r, c = heapq.heappop(heap)\\n if r == m - 1 and c == n - 1:\\n return t\\n for dr, dc in ((0, 1), (0, -1), (1, 0), (-1, 0)):\\n nr, nc = r + dr, c + dc\\n if nr < 0 or nr >= m or nc < 0 or nc >= n or (nr, nc) in visited:\\n continue\\n wait = (grid[nr][nc] - t) % 2 == 0\\n nt = max(grid[nr][nc] + wait, t + 1)\\n heapq.heappush(heap, (nt, nr, nc))\\n visited.add((nr, nc))\\n return -1\",\n \"memory\": \"43900\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n fringe = [(0, 0, 0)] #time, row, col\\n heapq.heapify(fringe)\\n\\n seen = {(0, 0): 0} #(row, col): time\\n\\n # max_val = max(max(row) for row in grid)\\n # max_t = max_val + len(grid) + len(grid[0])\\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\\n return -1\\n\\n while fringe:\\n t, r, c = heapq.heappop(fringe)\\n # if t >= max_t:\\n # continue\\n\\n # new_t = t + 1\\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if new_r < 0 or new_r >= len(grid):\\n continue\\n if new_c < 0 or new_c >= len(grid[r]):\\n continue\\n\\n if grid[new_r][new_c] <= t+1:\\n new_t = t+1\\n else:\\n diff = grid[new_r][new_c] - t\\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\\n\\n if (new_r, new_c) in seen and seen[(new_r, new_c)] <= new_t:\\n continue\\n\\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\\n return new_t\\n\\n\\n heapq.heappush(fringe, (new_t, new_r, new_c))\\n seen[(new_r, new_c)] = new_t\\n\\n return -1\",\n \"memory\": \"45100\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n fringe = [(0, 0, 0)] #time, row, col\\n heapq.heapify(fringe)\\n\\n seen = {(0, 0): 0} #(row, col): time\\n\\n # max_val = max(max(row) for row in grid)\\n # max_t = max_val + len(grid) + len(grid[0])\\n if 1 not in [grid[0][1], grid[1][0]] and 0 not in [grid[0][1], grid[1][0]]:\\n return -1\\n\\n while fringe:\\n t, r, c = heapq.heappop(fringe)\\n # if t >= max_t:\\n # continue\\n\\n # new_t = t + 1\\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if new_r < 0 or new_r >= len(grid):\\n continue\\n if new_c < 0 or new_c >= len(grid[r]):\\n continue\\n\\n if grid[new_r][new_c] <= t+1:\\n new_t = t+1\\n else:\\n diff = grid[new_r][new_c] - t\\n new_t = grid[new_r][new_c] + ((diff+1) % 2)\\n\\n if (new_r, new_c) in seen and seen[(new_r, new_c)] <= new_t:\\n continue\\n\\n if new_r == len(grid)-1 and new_c == len(grid[r]) - 1:\\n return new_t\\n\\n\\n heapq.heappush(fringe, (new_t, new_r, new_c))\\n seen[(new_r, new_c)] = new_t\\n\\n return -1\",\n \"memory\": \"45100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # ye15: Dijkstra's algo - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3230926/python3-dijkstra-s-algo/\\n # Matrix/Dikstra/time - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3236725/matrix-dikstra-time/\\n # BFS with priority queue; Explained - https://leetcode.com/problems/minimum-time-to-visit-a-cell-in-a-grid/solutions/3235344/python-bfs-with-priority-queue-explained/\\n \\n if grid[0][1] <= 1 or grid[1][0] <= 1: \\n m, n = len(grid), len(grid[0])\\n pq = [(0, 0, 0)]\\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\\n while pq: \\n x, i, j = heappop(pq)\\n if (i, j) == (m-1, n-1): return x \\n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \\n if 0 <= ii < m and 0 <= jj < n: \\n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \\n if dist[ii, jj] > xx: \\n heappush(pq, (xx, ii, jj))\\n dist[ii, jj] = xx \\n return -1 \\n\\n m, n = len(grid), len(grid[0])\\n if grid[1][0] > 1 and grid[0][1] > 1: return -1\\n dis = [[inf for _ in range(n)] for _ in range(m)]\\n dis[0][0] = 0\\n pq = [(0, 0, 0)]\\n while pq:\\n d, i, j = heapq.heappop(pq)\\n if i == m - 1 and j == n - 1:\\n return d\\n for x, y in (i+1, j), (i, j+1), (i-1, j), (i, j-1):\\n if 0 <= x < m and 0 <= y < n:\\n nd = max(d + 1, grid[x][y])\\n nd += (nd - x - y) % 2\\n if nd < dis[x][y]:\\n dis[x][y] = nd\\n heappush(pq, (nd, x, y))\\n\\n \\n # Wrong Answer - 37 / 41 testcases passed\\n nrow = len(grid)\\n ncol = len(grid[0])\\n \\n visited = set()\\n visit_queue = [(0, 0, 0)]\\n visited.add((0, 0))\\n \\n ans = -1\\n while visit_queue:\\n visit_time, r, c = heapq.heappop(visit_queue)\\n if r == nrow - 1 and c == ncol - 1:\\n ans = visit_time\\n break\\n \\n for ncell in {(0, 1), (1, 0), (0, -1), (-1, 0)}:\\n nr = r + ncell[0]\\n nc = c + ncell[1]\\n if nr >= 0 and nr < nrow and nc >= 0 and nc < ncol and (nr, nc) not in visited:\\n if grid[nr][nc] <= visit_time + 1:\\n heapq.heappush(visit_queue, (visit_time + 1, nr, nc))\\n visited.add((nr, nc))\\n elif len(visited) >= 2:\\n if (grid[nr][nc] - visit_time) % 2 == 0:\\n heapq.heappush(visit_queue, (grid[nr][nc] + 1, nr, nc))\\n else:\\n heapq.heappush(visit_queue, (grid[nr][nc], nr, nc))\\n visited.add((nr, nc))\\n \\n return ans \\n\\n\\n\\n \\n\\n \",\n \"memory\": \"45300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] <= 1 or grid[1][0] <= 1: \\n m, n = len(grid), len(grid[0])\\n pq = [(0, 0, 0)]\\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\\n while pq: \\n x, i, j = heappop(pq)\\n if (i, j) == (m-1, n-1): return x \\n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \\n if 0 <= ii < m and 0 <= jj < n: \\n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \\n if dist[ii, jj] > xx: \\n heappush(pq, (xx, ii, jj))\\n dist[ii, jj] = xx \\n return -1 \",\n \"memory\": \"45400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] <= 1 or grid[1][0] <= 1: \\n m, n = len(grid), len(grid[0])\\n pq = [(0, 0, 0)]\\n dist = defaultdict(lambda : inf, {(0, 0) : 0})\\n while pq: \\n x, i, j = heappop(pq)\\n if (i, j) == (m-1, n-1): return x \\n for ii, jj in (i-1, j), (i, j-1), (i, j+1), (i+1, j): \\n if 0 <= ii < m and 0 <= jj < n: \\n xx = x + 1 + max(0, (grid[ii][jj] - x)//2*2) \\n if dist[ii, jj] > xx: \\n heappush(pq, (xx, ii, jj))\\n dist[ii, jj] = xx \\n return -1\",\n \"memory\": \"45500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n\\n if mem[(r, c)] < t:\\n continue\\n print(t, r, c)\\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n elif (t + 1) % 2 == grid[nr][nc] % 2:\\n nt = grid[nr][nc]\\n else:\\n nt = grid[nr][nc] + 1\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n\\n return -1\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"45700\"\n },\n {\n \"code\": \"from collections import deque\\nfrom itertools import starmap\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\\n visited = set()\\n rows = len(grid)\\n cols = len(grid[0])\\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\\n costs = defaultdict(lambda : float('inf'))\\n\\n heap = [(0,(0,0))]\\n\\n\\n while heap:\\n cur_time, (r,c) = heapq.heappop(heap)\\n if (r,c) in visited:\\n continue\\n visited.add((r,c))\\n if (r,c) == (rows-1, cols-1):\\n return cur_time\\n possible_vertices = valid_movements(r,c)\\n for r_nxt, c_nxt in possible_vertices:\\n # Get the time needed move to the next cell. sometimes the next cell will be low value so floor it to 0\\n time_diff = max(0, (grid[r_nxt][c_nxt] - (cur_time+1)))\\n base = cur_time + 1\\n wait = time_diff + time_diff%2 # time_diff//2 * 2 = time_diff each flip-flop is 2 seconds.\\n heapq.heappush(heap, (base + wait, (r_nxt, c_nxt)))\\n \\n \\n return -1\\n \\n\\n\",\n \"memory\": \"45800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n if mem[(r, c)] < t:\\n continue\\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n elif (t + 1) % 2 == grid[nr][nc] % 2:\\n nt = grid[nr][nc]\\n else:\\n nt = grid[nr][nc] + 1\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n return -1\\n\",\n \"memory\": \"46000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n\\n if mem[(r, c)] < t:\\n continue\\n for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n elif (t + 1) % 2 == grid[nr][nc] % 2:\\n nt = grid[nr][nc]\\n else:\\n nt = grid[nr][nc] + 1\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n\\n return -1\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"46100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n\\n h = [(0,0,0)]\\n mem = defaultdict(lambda : inf)\\n mem[(0,0)] = 0\\n rows, cols = len(grid), len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n while h:\\n t, r, c = heappop(h)\\n if (r, c) == (rows - 1, cols - 1):\\n return t\\n if mem[(r, c)] < t:\\n continue\\n for dr, dc in (0, 1), (1, 0), (0, -1), (-1, 0):\\n nr, nc = r + dr, c + dc\\n if 0 <= nr < rows and 0 <= nc < cols:\\n if t + 1 >= grid[nr][nc]:\\n nt = t + 1\\n else:\\n nt = grid[nr][nc] + ((t + 1) % 2 != grid[nr][nc] % 2)\\n if mem[(nr, nc)] > nt:\\n mem[(nr, nc)] = nt\\n heappush(h, (nt, nr, nc))\\n return -1\\n\",\n \"memory\": \"46500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n m = len(grid)\\n n = len(grid[0])\\n start = (0, 0)\\n dist = defaultdict(lambda: float('inf'))\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, (0, 0, 0))\\n dist[0, 0] = 0\\n\\n while len(pq) > 0:\\n w, x, y = heapq.heappop(pq)\\n if dist[x, y] < w: continue\\n if (x, y) == (m - 1, n - 1): return dist[x, y]\\n\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n for direction in dirs:\\n newX, newY = x + direction[0], y + direction[1]\\n if 0 <= newX < m and 0 <= newY < n:\\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\\n dist[newX, newY] = dist[x, y] + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif grid[newX][newY] > dist[x, y] + 1:\\n wait = grid[newX][newY] - dist[x, y]\\n\\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\\n dist[newX, newY] = dist[x, y] + wait + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\\n dist[newX, newY] = dist[x, y] + wait\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n \\n return -1\\n\",\n \"memory\": \"46600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n # It is always possible to reach the end as long as we have a valid parent, in the beginning at (0,0) we don't have a valid parent so this position might get blocked otherwise we can always reach.\\n \\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n m = len(grid)\\n n = len(grid[0])\\n start = (0, 0)\\n dist = defaultdict(lambda: float('inf'))\\n pq = []\\n heapq.heapify(pq)\\n heapq.heappush(pq, (0, 0, 0))\\n dist[0, 0] = 0\\n\\n while len(pq) > 0:\\n w, x, y = heapq.heappop(pq)\\n if dist[x, y] < w: continue\\n if (x, y) == (m - 1, n - 1): return dist[x, y]\\n\\n dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n for direction in dirs:\\n newX, newY = x + direction[0], y + direction[1]\\n if 0 <= newX < m and 0 <= newY < n:\\n if dist[newX, newY] > dist[x, y] + 1 and dist[x, y] + 1 >= grid[newX][newY]:\\n dist[newX, newY] = dist[x, y] + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif grid[newX][newY] > dist[x, y] + 1:\\n wait = grid[newX][newY] - dist[x, y]\\n\\n if wait % 2 == 0 and dist[newX, newY] > dist[x, y] + wait + 1:\\n dist[newX, newY] = dist[x, y] + wait + 1\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n elif wait % 2 == 1 and dist[newX, newY] > dist[x, y] + wait:\\n dist[newX, newY] = dist[x, y] + wait\\n heapq.heappush(pq, (dist[newX, newY], newX, newY))\\n \\n return -1\\n\",\n \"memory\": \"46700\"\n },\n {\n \"code\": \"from collections import deque\\nfrom itertools import starmap\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n directions = [[0,1], [1,0], [-1,0], [0,-1]]\\n visited = set()\\n rows = len(grid)\\n cols = len(grid[0])\\n movements = lambda r,c: starmap(lambda rm,cm: [rm+r, cm+c], directions)\\n is_valid = lambda r,c: 0 <= r < rows and 0 <= c < cols and (r,c) not in visited\\n valid_movements = lambda r,c: [m for m in movements(r,c) if is_valid(m[0], m[1])]\\n costs = defaultdict(lambda : float('inf'))\\n\\n heap = [(0,(0,0))]\\n\\n\\n while heap:\\n cur_time, (r,c) = heapq.heappop(heap)\\n if (r,c) in visited:\\n continue\\n visited.add((r,c))\\n if (r,c) == (rows-1, cols-1):\\n return cur_time\\n possible_vertices = valid_movements(r,c)\\n for r_nxt, c_nxt in possible_vertices:\\n if grid[r_nxt][c_nxt] > cur_time + 1:\\n # we need to wait # we can assume we can flip flop between the parent and this cell.\\n time_needed = grid[r_nxt][c_nxt] - (cur_time+1)\\n flip_flops_needed = time_needed//2 + time_needed%2\\n heapq.heappush(heap, (cur_time+1+flip_flops_needed*2, (r_nxt, c_nxt)))\\n elif grid[r_nxt][c_nxt] <= cur_time + 1:\\n heapq.heappush(heap, (cur_time+1, (r_nxt, c_nxt)))\\n \\n \\n return -1\\n \\n\\n\",\n \"memory\": \"47300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n ## adjusted Dijkstra's algo\\n if grid[1][0] > 1 and grid[0][1] > 1: \\n return -1\\n import heapq\\n from collections import defaultdict\\n m, n = len(grid), len(grid[0])\\n dis = defaultdict(lambda: float('inf'))\\n dis[(0, 0)] = 0\\n queue = [[0, (0, 0)]]\\n heapq.heapify(queue)\\n directions = [\\n [-1, 0], \\n [1, 0], \\n [0, -1], \\n [0, 1]\\n ]\\n while queue: \\n dis_curr, (x, y) = heapq.heappop(queue)\\n if x == m - 1 and y == n - 1: \\n return dis_curr\\n for dx, dy in directions: \\n xx = x + dx\\n yy = y + dy\\n if 0 <= xx < m and 0 <= yy < n: \\n if dis_curr + 1 >= grid[xx][yy]:\\n val = dis_curr + 1\\n if val < dis[(xx, yy)]: \\n dis[(xx, yy)] = val\\n heapq.heappush(queue, [val, (xx, yy)])\\n else: \\n diff = grid[xx][yy] - (dis_curr + 1)\\n if diff % 2 == 1: \\n diff += 1\\n val = dis_curr + 1 + diff\\n if val < dis[(xx, yy)]: \\n dis[(xx, yy)] = val\\n heapq.heappush(queue, [val, (xx, yy)])\\n \\n return -1 \\n \\n \\n \",\n \"memory\": \"49200\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n seen = set()\\n heap = []\\n heapq.heappush(heap, [0, 0, 0])\\n seen.add((0, 0))\\n directions = [[1, 0], [0, 1], [-1, 0], [0, -1]]\\n\\n def isValid(r, c):\\n return 0 <= r < len(grid) and 0 <= c < len(grid[0])\\n\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n \\n while heap:\\n time, row, col = heapq.heappop(heap)\\n if row == len(grid) - 1 and col == len(grid[0]) - 1:\\n return time\\n \\n for dx, dy in directions:\\n newRow, newCol = row + dx, col + dy\\n if isValid(newRow, newCol):\\n if time + 1 >= grid[newRow][newCol] and (newRow, newCol) not in seen:\\n heapq.heappush(heap, [time + 1, newRow, newCol])\\n elif time + 1 < grid[newRow][newCol]:\\n diff = grid[newRow][newCol] - time\\n if diff % 2 == 0:\\n heapq.heappush(heap, [grid[newRow][newCol] + 1, newRow, newCol])\\n else:\\n heapq.heappush(heap, [grid[newRow][newCol], newRow, newCol])\\n seen.add((newRow, newCol))\\n\\n return -1\\n\\n \",\n \"memory\": \"49300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n ## adjusted Dijkstra's algo\\n if grid[1][0] > 1 and grid[0][1] > 1: \\n return -1\\n import heapq\\n from collections import defaultdict\\n m, n = len(grid), len(grid[0])\\n dis = defaultdict(lambda: float('inf'))\\n dis[(0, 0)] = 0\\n queue = [[0, (0, 0)]]\\n heapq.heapify(queue)\\n directions = [\\n [-1, 0], \\n [1, 0], \\n [0, -1], \\n [0, 1]\\n ]\\n while queue: \\n dis_curr, (x, y) = heapq.heappop(queue)\\n if x == m - 1 and y == n - 1: \\n return dis_curr\\n for dx, dy in directions: \\n xx = x + dx\\n yy = y + dy\\n if 0 <= xx < m and 0 <= yy < n: \\n if dis_curr + 1 >= grid[xx][yy]: \\n if dis_curr + 1 < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1\\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\\n else: \\n diff = grid[xx][yy] - (dis_curr + 1)\\n if diff % 2 == 1: \\n diff += 1\\n if dis_curr + 1 + diff < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1 + diff\\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\\n \\n return -1 \\n \\n \\n \",\n \"memory\": \"50200\"\n },\n {\n \"code\": \"from heapq import heappush,heappop\\nclass Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n R = len(grid)\\n C = len(grid[0])\\n # Check if there is a path exist\\n has_path = False\\n for r,c in ((0,1),(1,0)):\\n if 0<=r<R and 0<=c<C:\\n if grid[r][c] <= 1 :\\n has_path = True\\n if not has_path : return -1\\n heap = [(0,0,0)]\\n dist = {}\\n dist[(0,0)] = 0\\n visited = set()\\n while heap:\\n _,r,c = heappop(heap)\\n if (r,c) in visited: continue\\n if r == R-1 and c == C-1:\\n break\\n visited.add((r,c))\\n cur_time = dist[(r,c)]\\n for nr,nc in ((r+1,c),(r-1,c),(r,c+1),(r,c-1)):\\n if (nr,nc) in visited : continue\\n if 0<=nr<R and 0<=nc<C:\\n cost = None\\n if grid[nr][nc] <= cur_time + 1:\\n cost = 1\\n else:\\n cost = grid[nr][nc] - cur_time\\n if cost%2 == 0 :\\n cost += 1\\n if cost:\\n if cur_time + cost < dist.get((nr,nc),float('inf')):\\n dist[(nr,nc)] = cur_time + cost\\n heappush(heap,(dist[(nr,nc)],nr,nc))\\n return dist[(R-1,C-1)]\",\n \"memory\": \"51700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n kRows = len(grid)\\n kCols = len(grid[0])\\n\\n graph = Grid(kRows, kCols)\\n\\n mcfs = BoundedMCFS(graph, ToTarget(graph.vertex_count() - 1))\\n\\n def get_attrs(r1, c1, r2, c2):\\n edge_len = max(grid[r2][c2] - mcfs.costs[graph.coor2idx(r1, c1)], 0)\\n if edge_len % 2 == 0:\\n edge_len += 1\\n return edge_len\\n\\n graph.get_attrs = get_attrs\\n\\n mcfs.run(0)\\n\\n return mcfs.costs[-1]\\n\\n\\nfrom dataclasses import dataclass, astuple\\nfrom typing import Any\\n\\n\\n@dataclass\\nclass Edge:\\n source: int\\n target: int\\n attrs: Any = ()\\n handle: Any = None\\n\\n\\nclass Graph:\\n \\\"\\\"\\\"Graph ABC.\\n\\n This class assumes that vertices are indexed 0, 1, 2, ..., vertex_count-1.\\n \\\"\\\"\\\"\\n\\n def __init__(self, vertex_count):\\n \\\"\\\"\\\"Initialize the graph with the given number of vertices.\\\"\\\"\\\"\\n assert vertex_count > 0\\n self._vertex_count = vertex_count\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add a directed edge from source to target with given attributes.\\n\\n Returns: edge handle that can be used in `get` and 'remove' operations.\\n \\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def add_undirected_edge(self, u: int, v: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add an undirected edge between u and v with the given attributes.\\n\\n Returns: edge handles that can be used in `get` and 'remove' operations.\\n \\\"\\\"\\\"\\n handle_uv = self.add_edge(u, v, attrs, **kwargs)\\n handle_vu = self.add_edge(v, u, attrs, **kwargs)\\n return handle_uv, handle_vu\\n\\n def get_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Retrieve a directed edge from source to target.\\n\\n Returns: Edge object.\\n \\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def remove_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Remove a directed edge from source to target.\\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n for edge in self.edges():\\n if edge.target == target:\\n yield edge\\n\\n def edges(self):\\n \\\"\\\"\\\"Generate all edges in the graph.\\\"\\\"\\\"\\n for source in self.vertices():\\n yield from self.out_edges(source)\\n\\n def vertices(self):\\n \\\"\\\"\\\"Generate all vertices in the graph.\\\"\\\"\\\"\\n return range(self._vertex_count)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n return len(list(self.out_edges(source)))\\n\\n def out_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of out-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self.out_degree(source) for source in self.vertices()]\\n\\n def in_degree(self, target: int) -> int:\\n \\\"\\\"\\\"Get the in-degree of a given target vertex.\\\"\\\"\\\"\\n return len(list(self.in_edges(target)))\\n\\n def in_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of in-degrees of all vertices in the graph.\\\"\\\"\\\"\\n in_degs = [0] * self.vertex_count()\\n for edge in self.edges():\\n in_degs[edge.target] += 1\\n return in_degs\\n\\n # --------------------------------------------------------------------------\\n\\n def edge_count(self) -> int:\\n \\\"\\\"\\\"Get the number of edges in the graph.\\\"\\\"\\\"\\n return sum(self.out_degrees())\\n\\n def vertex_count(self) -> int:\\n \\\"\\\"\\\"Get the number of vertices in the graph.\\\"\\\"\\\"\\n return self._vertex_count\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edges(self, edges):\\n \\\"\\\"\\\"Add directed edges with optional attributes.\\\"\\\"\\\"\\n for edge in edges:\\n source, target, *attrs = edge\\n self.add_edge(source, target, self._seq2attrs(attrs))\\n\\n def add_undirected_edges(self, edges):\\n \\\"\\\"\\\"Add undirected edges with optional attributes.\\\"\\\"\\\"\\n for edge in edges:\\n source, target, *attrs = edge\\n self.add_undirected_edge(source, target, self._seq2attrs(attrs))\\n\\n def _seq2attrs(self, attrs):\\n match len(attrs):\\n case 0: return Edge.attrs # default empty tuple\\n case 1: return attrs[0]\\n case _: return attrs\\n\\n # --------------------------------------------------------------------------\\n\\n def _get_attrs(self, attrs, kwargs):\\n \\\"\\\"\\\"Build edge attrs object from `add_[undirected_]edge` method args.\\\"\\\"\\\"\\n if attrs is None:\\n if kwargs:\\n # TODO: Convert to a named tuple?\\n attrs = kwargs\\n else:\\n attrs = Edge.attrs\\n return attrs\\n\\n\\ndef transposed(graph):\\n \\\"\\\"\\\"Transpose (reverse the direction of all edges in) the given graph.\\\"\\\"\\\"\\n transposed = type(graph)(graph.vertex_count())\\n for source, target, attrs, _ in graph.edges():\\n transposed.add_edge(target, source, attrs)\\n return transposed\\n\\n\\n# ----------------------------------------------------------------------------\\n# Concrete Graph Classes\\n# ----------------------------------------------------------------------------\\n\\n\\nclass AdjacencyList():\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize an empty adjacency list.\\\"\\\"\\\"\\n self._out_edges = []\\n self._size = 0\\n\\n def add(self, target: int, attrs) -> int:\\n \\\"\\\"\\\"Add a new edge to the end of the adjacency list.\\n\\n Returns: index of the added edge.\\n \\\"\\\"\\\"\\n if len(self._out_edges) == self._size:\\n self._out_edges.append((target, attrs))\\n else:\\n # assert len(self._out_edges) > self._size\\n assert self._out_edges[self._size] is None\\n self._out_edges[self._size] = (target, attrs)\\n self._size += 1\\n return self._size - 1\\n\\n def get(self, source: int, target: int, idx: int = None):\\n \\\"\\\"\\\"Retrieve an / the edge pointing at vertex `target`.\\\"\\\"\\\"\\n idx = self._index(target, idx)\\n return Edge(source, target, self._out_edges[idx][1], idx)\\n\\n def remove(self, target: int, idx: int = None):\\n \\\"\\\"\\\"Remove an / the edge pointing at vertex `target`.\\\"\\\"\\\"\\n idx = self._index(target, idx)\\n self._size -= 1\\n self._out_edges[idx] = self._out_edges[self._size]\\n self._out_edges[self._size] = idx\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges.\\\"\\\"\\\"\\n for idx, (target, attrs) in enumerate(self._out_edges[:self._size]):\\n yield Edge(source, target, attrs, idx)\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the number of edges in this adjacency list.\\\"\\\"\\\"\\n return self._size\\n\\n def _index(self, target: int, idx: int = None):\\n \\\"\\\"\\\"Return index of an / the edge pointing at vertex `target`.\\n\\n Raise a ValueError if there is no such edge.\\n\\n If `idx` is None, return index of the first edge pointing at `target`.\\n Otherwise, return current index of the edge that originally sat at `idx`.\\n \\\"\\\"\\\"\\n if idx is None:\\n for idx in range(self._size):\\n if self._out_edges[idx][0] == target:\\n return idx\\n else:\\n assert 0 <= idx < len(self._out_edges)\\n while idx >= self._size:\\n idx, self._out_edges[idx] = self._out_edges[idx], None\\n if target is None or self._out_edges[idx][0] == target:\\n return idx\\n raise ValueError('vertex {} is not in adjacency list'.format(target))\\n\\n\\nclass AdjacencyLists(Graph):\\n\\n def __init__(self, vertex_count, make_list=None):\\n \\\"\\\"\\\"Initialize the graph with the given number of vertices.\\\"\\\"\\\"\\n super().__init__(vertex_count)\\n self._make_list = make_list if make_list is not None else AdjacencyList\\n self._adj_lists = [self._make_list() for _ in range(vertex_count)]\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add a directed edge from source to target with given attributes.\\n\\n Returns: edge handle that can be used in `remove` and 'get' methods.\\n \\\"\\\"\\\"\\n attrs = self._get_attrs(attrs, kwargs)\\n return self._adj_lists[source].add(target, attrs)\\n\\n def get_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Retrieve a directed edge from source to target.\\n\\n Returns: tuple[edge attrs, edge handle]\\n \\\"\\\"\\\"\\n return self._adj_lists[source].get(source, target, handle)\\n\\n def remove_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Remove a directed edge from source to target.\\\"\\\"\\\"\\n self._adj_lists[source].remove(target, handle)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n yield from self._adj_lists[source].out_edges(source)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n return len(self._adj_lists[source])\\n\\n\\nclass Clique(Graph):\\n\\n def __init__(self, vertex_count, get_attrs=None):\\n \\\"\\\"\\\"Initialize the clique with the given number of rows and columns.\\\"\\\"\\\"\\n super().__init__(vertex_count)\\n # Returns attributes of the edge between vertices u and v.\\n self.get_attrs = (get_attrs if get_attrs is not None else\\n lambda u, v: Edge.attrs)\\n\\n # --------------------------------------------------------------------------\\n\\n # TODO get_edge()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n for target in self.vertices():\\n if source != target:\\n yield Edge(source, target, self.get_attrs(source, target))\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n for source in self.vertices():\\n if source != target:\\n yield Edge(source, target, self.get_attrs(source, target))\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n return self._vertex_count - 1\\n\\n def out_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of out-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self._vertex_count - 1 for source in self.vertices()]\\n\\n def in_degree(self, target: int) -> int:\\n \\\"\\\"\\\"Get the in-degree of a given target vertex.\\\"\\\"\\\"\\n return self._vertex_count - 1\\n\\n def in_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of in-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self._vertex_count - 1 for source in self.vertices()]\\n\\n # --------------------------------------------------------------------------\\n\\n def edge_count(self) -> int:\\n \\\"\\\"\\\"Get the number of edges in the graph.\\\"\\\"\\\"\\n raise self._vertex_count * (self._vertex_count - 1)\\n\\n\\nimport enum\\n\\n\\nclass Grid(Graph):\\n\\n class Type(enum.Enum):\\n k4Way = 1 # default\\n k8Way = 2\\n\\n def __init__(self, rows=0, cols=0, grid_type=None, get_attrs=None):\\n \\\"\\\"\\\"Initialize the grid with the given number of rows and columns.\\\"\\\"\\\"\\n super().__init__(rows * cols)\\n self.rows = rows\\n self.cols = cols\\n # Returns attributes of the edge between cells (r1,c1) and (r2,c2):\\n self.get_attrs = (get_attrs if get_attrs is not None else\\n lambda r1, c1, r2, c2: Edge.attrs)\\n # Implementation details:\\n self._neighborhood = [(1, 0), (0, 1), (-1, 0), (0, -1)]\\n if grid_type == self.Type.k8Way:\\n self._neighborhood += [(1, 1), (1, -1), (-1, 1), (-1, -1)]\\n\\n # --------------------------------------------------------------------------\\n\\n # TODO get_edge()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n sr, sc = self.idx2coor(source)\\n for tr, tc in self._get_neighbor_cells(sr, sc):\\n attrs = self.get_attrs(sr, sc, tr, tc)\\n if attrs is not None:\\n yield Edge(source, self.coor2idx(tr, tc), attrs)\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n # assert 0 <= target < self.vertex_count()\\n tr, tc = self.idx2coor(target)\\n for sr, sc in self._get_neighbor_cells(tr, tc):\\n attrs = self.get_attrs(sr, sc, tr, tc)\\n if attrs is not None:\\n yield Edge(self.coor2idx(sr, sc), target, attrs)\\n\\n def _get_neighbor_cells(self, r1: int, c1: int) -> list[tuple[int, int]]:\\n \\\"\\\"\\\"Generate the valid neighboring cells for a given grid cell.\\\"\\\"\\\"\\n for dr, dc in self._neighborhood:\\n r2, c2 = r1 + dr, c1 + dc\\n if (0 <= r2 < self.rows) and (0 <= c2 < self.cols):\\n yield r2, c2\\n\\n # --------------------------------------------------------------------------\\n\\n def coor2idx(self, r: int, c: int) -> int:\\n \\\"\\\"\\\"Convert a pair of grid coordinates to a linear index.\\\"\\\"\\\"\\n return r * self.cols + c\\n\\n def idx2coor(self, idx: int) -> tuple[int, int]:\\n \\\"\\\"\\\"Convert a linear index to a pair of grid coordinates.\\\"\\\"\\\"\\n return (idx // self.cols, idx % self.cols)\\n\\n\\nclass VertexMap:\\n \\\"\\\"\\\"A utility class to map vertex labels to int indices and vice versa.\\\"\\\"\\\"\\n\\n def __init__(self):\\n self.l2i = {} # label to index map\\n self.i2l = [] # index to label map\\n self._vertex_count = 0\\n\\n def add_vertex(self, label):\\n \\\"\\\"\\\"\\n Add a vertex with the given label to the map.\\n If label already exists, return its index.\\n \\\"\\\"\\\"\\n return self.get_index(label)\\n\\n def get_index(self, label) -> int:\\n \\\"\\\"\\\"\\n Get the index corresponding to the given label.\\n If label doesn't exist, create an entry for it.\\n \\\"\\\"\\\"\\n idx = self.l2i.setdefault(label, self.vertex_count())\\n if idx == self._vertex_count:\\n self.i2l.append(label)\\n self._vertex_count += 1\\n return idx\\n\\n def get_label(self, v: int):\\n \\\"\\\"\\\"Get the label corresponding to the given index.\\\"\\\"\\\"\\n assert 0 <= v < self._vertex_count\\n return self.i2l[v]\\n\\n def vertex_count(self) -> int:\\n \\\"\\\"\\\"Get the number of vertices in the map.\\\"\\\"\\\"\\n return self._vertex_count\\n\\n\\n# ----------------------------------------------------------------------------\\n# Breath-First Search (BFS)\\n# ----------------------------------------------------------------------------\\n\\nimport collections\\nimport enum\\nimport math\\n\\n\\nclass BFS:\\n \\\"\\\"\\\"Breath-First Search (BFS)\\\"\\\"\\\"\\n\\n class Observer:\\n\\n def init(self, traversal):\\n self.traversal = traversal\\n self.graph = traversal.graph\\n\\n def start_traversal(self, sources: list[int]):\\n ...\\n\\n def finish_traversal(self):\\n ...\\n\\n def stop_traversal(self):\\n ...\\n\\n def enter_vertex(self, u: int, cost_u):\\n ...\\n\\n def exit_vertex(self, u: int):\\n ...\\n\\n def traverse_tree_edge(self, edge: Edge, target_cost):\\n ...\\n\\n def visit_edge(self, edge: Edge, target_cost):\\n ...\\n\\n\\n class StopTraversal(Exception):\\n ...\\n\\n class SkipVertex(Exception):\\n ...\\n\\n class VStatus(enum.Enum):\\n UNDISCOVERED = 1\\n ENQUEUED = 2\\n EXITED = 3\\n\\n def __init__(self, graph, observer=None, get_cost=None, make_queue=None):\\n # Traversal state:\\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\\n self.costs = [math.inf] * graph.vertex_count()\\n self.queue = None\\n self.stopped = False\\n # Traversal parameters:\\n self.graph = graph\\n self.observer = observer if observer is not None else self.Observer()\\n self.get_cost = get_cost if get_cost is not None else self.cost\\n self.make_queue = make_queue if make_queue is not None else self.Queue\\n self.observer.init(self)\\n\\n # -- Cost & Queue Definitions ----------------------------------------------\\n\\n @staticmethod\\n def cost(cost_u, attrs_uv):\\n return cost_u + 1\\n\\n class Queue:\\n\\n def __init__(self):\\n self._queue = collections.deque()\\n\\n def put(self, edge: Edge, target_cost):\\n self._queue.append((edge, target_cost))\\n\\n def pop(self):\\n # assert len(self._queue) > 0\\n return self._queue.popleft()\\n\\n def __len__(self):\\n return len(self._queue)\\n\\n # -- Traversal Configuration -----------------------------------------------\\n\\n # If you are getting TLE, consider inlining the config methods, especially\\n # `_visit_edge` and `_enqueue`.\\n\\n def _enter_vertex(self, u: int, cost_u):\\n # assert self.statuses[v] == self.VStatus.ENQUEUED\\n self.costs[u] = cost_u\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\\n self._enqueue(edge, target_cost)\\n\\n def _enqueue(self, edge: Edge, target_cost):\\n # UNDISCOVERED -> ENQUEUED\\n self.statuses[edge.target] = self.VStatus.ENQUEUED\\n self.queue.put(edge, target_cost)\\n\\n def _exit_vertex(self, u: int):\\n # ENQUEUED -> EXITED\\n self.statuses[u] = self.VStatus.EXITED\\n\\n # -- Traversal -------------------------------------------------------------\\n\\n def run(self, sources: list[int], source_cost=0):\\n if isinstance(sources, int):\\n sources = [sources]\\n self.queue = self.make_queue()\\n self.stopped = False\\n for u in sources:\\n self._visit_edge(Edge(source=-1, target=u), source_cost)\\n if not self.queue:\\n return\\n try:\\n self.observer.start_traversal(sources)\\n while self.queue:\\n try:\\n in_edge, cost_u = self.queue.pop()\\n u = in_edge.target\\n if in_edge.source >= 0:\\n self.observer.traverse_tree_edge(in_edge, cost_u)\\n self._enter_vertex(u, cost_u)\\n self.observer.enter_vertex(u, cost_u)\\n for out_edge in self.graph.out_edges(u):\\n cost_v = self.get_cost(cost_u, out_edge.attrs)\\n self.observer.visit_edge(out_edge, cost_v)\\n self._visit_edge(out_edge, cost_v)\\n self.observer.exit_vertex(u)\\n self._exit_vertex(u)\\n except self.SkipVertex:\\n ...\\n except self.StopTraversal:\\n self.observer.stop_traversal()\\n self.stopped = True\\n else:\\n self.observer.finish_traversal()\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS Variants\\n# ----------------------------------------------------------------------------\\n\\n\\nclass TopologicalBFS(BFS):\\n\\n def __init__(self, graph, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.in_degs = graph.in_degrees()\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n self.in_degs[edge.target] -= 1\\n if self.in_degs[edge.target] <= 0:\\n self._enqueue(edge, target_cost)\\n\\n def run(self):\\n super().run([u for u in self.graph.vertices() if self.in_degs[u] == 0])\\n\\n\\nclass RestrictedBFS(BFS):\\n\\n class VStatus(enum.Enum):\\n UNDISCOVERED = 1\\n DISCOVERED = 2\\n ENQUEUED = 3\\n EXITED = 4\\n\\n def __init__(self, graph, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.open = [True] * graph.vertex_count()\\n self.in_edges = [None] * graph.vertex_count()\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\\n if self.open[edge.target]:\\n # UNDISCOVERED -> ENQUEUED\\n self._enqueue(edge, target_cost)\\n else:\\n # UNDISCOVERED -> DISCOVERED\\n self.statuses[edge.target] = self.VStatus.DISCOVERED\\n if self.statuses[edge.target] == self.VStatus.DISCOVERED:\\n # assert not self.open[edge.target]\\n self.in_edges[edge.target] = edge \\n self.costs[edge.target] = target_cost\\n\\n def unlock(self, u: int):\\n self.open[u] = True\\n if self.statuses[u] == self.VStatus.DISCOVERED:\\n # DISCOVERED -> ENQUEUED\\n self._enqueue(self.in_edges[u], self.costs[u])\\n\\n\\nclass MultiEntryBFS(BFS):\\n\\n def __init__(self, graph, max_entry_count=1, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.max_entry_count = max_entry_count\\n self.entry_counts = [0] * graph.vertex_count()\\n\\n def _enter_vertex(self, u: int, cost_u):\\n # assert self.costs[u] <= cost_u\\n # TODO: multiple entries with the same cost -> add a config param\\n if self.statuses[u] == self.VStatus.EXITED or self.costs[u] == cost_u:\\n raise self.SkipVertex\\n self.costs[u] = cost_u\\n self.entry_counts[u] += 1\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] != self.VStatus.EXITED:\\n self._enqueue(edge, target_cost)\\n\\n def _exit_vertex(self, u: int):\\n if self.entry_counts[u] >= self.max_entry_count:\\n self.statuses[u] = self.VStatus.EXITED\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS Observers\\n# ----------------------------------------------------------------------------\\n\\n\\nclass ToTarget(BFS.Observer):\\n\\n def __init__(self, target: int):\\n self.target = target\\n\\n def init(self, traversal):\\n super().init(traversal)\\n if self.target < 0:\\n self.target += self.graph.vertex_count()\\n assert 0 <= self.target < self.graph.vertex_count()\\n\\n def enter_vertex(self, u: int, cost_u):\\n if u == self.target:\\n raise self.traversal.StopTraversal\\n\\n\\nclass ToCost(BFS.Observer):\\n\\n def __init__(self, target_cost):\\n self.target_cost = target_cost\\n\\n def enter_vertex(self, u: int, cost_u):\\n if cost_u > self.target_cost:\\n raise self.traversal.SkipVertex\\n\\n\\nclass InEdges(BFS.Observer):\\n\\n def init(self, traversal):\\n super().init(traversal)\\n self.in_edges = [None] * self.graph.vertex_count()\\n\\n def traverse_tree_edge(self, edge: Edge, target_cost):\\n self.in_edges[edge.target] = edge\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n\\ndef find_cc(graph):\\n\\n class ConnectedComponents(BFS.Observer):\\n\\n def __init__(self):\\n self.count = 0\\n self.vertex2comp = [-1] * graph.vertex_count()\\n self.comp2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, sources):\\n self.count += 1\\n\\n def enter_vertex(self, u, cost_u):\\n self.vertex2comp[u] = self.count - 1\\n self.comp2vertices[self.count - 1].append(u)\\n\\n cc = ConnectedComponents()\\n bfs = BFS(graph, cc)\\n for v in graph.vertices():\\n bfs.run(v)\\n return cc\\n\\n\\ndef find_layers(graph):\\n\\n class Layers(BFS.Observer):\\n\\n def __init__(self):\\n self.vertex2layer = [-1] * graph.vertex_count()\\n self.layer2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, sources):\\n for u in sources:\\n self.vertex2layer[u] = 0\\n\\n def enter_vertex(self, u, cost_u):\\n self.layer2vertices[self.vertex2layer[u]].append(u)\\n\\n def visit_edge(self, edge: Edge, target_cost):\\n self.vertex2layer[edge.target] = max(self.vertex2layer[edge.target],\\n self.vertex2layer[edge.source] + 1)\\n\\n layers = Layers()\\n TopologicalBFS(graph, layers).run()\\n return layers\\n\\n\\ndef sort_topologically(graph, bfs_cls=TopologicalBFS):\\n\\n class Order(BFS.Observer):\\n\\n def __init__(self):\\n self.vertices = []\\n\\n def enter_vertex(self, u, cost_u):\\n self.vertices.append(u)\\n\\n obs = Order()\\n bfs_cls(graph, obs).run()\\n return obs.vertices\\n\\n\\n# ----------------------------------------------------------------------------\\n# MinCost-First Search (MCFS)\\n# ----------------------------------------------------------------------------\\n\\nimport sortedcontainers\\n\\n\\nclass MCFS(BFS):\\n \\\"\\\"\\\"MinCost-First Search (MCFS)\\\"\\\"\\\"\\n\\n @staticmethod\\n def cost(cost_u, attr_uv):\\n return cost_u + attr_uv\\n\\n class Queue:\\n\\n def __init__(self):\\n self._items = sortedcontainers.SortedSet()\\n\\n def put(self, edge, target_cost):\\n self._items.add(self._Item(target_cost, edge))\\n\\n def pop(self):\\n # assert len(self._items) > 1\\n item = self._items.pop(0)\\n return item.edge, item.target_cost\\n\\n def __len__(self):\\n return len(self._items)\\n\\n @dataclass\\n class _Item:\\n target_cost: Any\\n edge: Any\\n\\n def __lt__(self, other):\\n return self.target_cost < other.target_cost\\n\\n def __hash__(self):\\n return hash(self.target_cost)\\n\\n def _enter_vertex(self, u: int, cost_u):\\n if self.statuses[u] == self.VStatus.EXITED:\\n raise self.SkipVertex\\n self.costs[u] = cost_u\\n\\n def _visit_edge(self, edge, target_cost):\\n if self.costs[edge.target] > target_cost:\\n self.costs[edge.target] = target_cost\\n self._enqueue(edge, target_cost)\\n\\n\\n# ----------------------------------------------------------------------------\\n# MCFS Variants\\n# ----------------------------------------------------------------------------\\n\\n\\nclass BinaryMCFS(MCFS):\\n \\\"\\\"\\\"Works for graphs where each edge's cost is either 0 or 1.\\\"\\\"\\\"\\n\\n class Queue(BFS.Queue):\\n\\n def put(self, edge, target_cost):\\n if self._queue and self._queue[-1][1] <= target_cost:\\n self._queue.append((edge, target_cost))\\n else:\\n self._queue.appendleft((edge, target_cost))\\n\\n\\nclass BoundedMCFS(MCFS):\\n \\\"\\\"\\\"Works for graphs where max vertex's cost is ~ O(graph.edge_count()).\\\"\\\"\\\"\\n\\n class Queue:\\n\\n def __init__(self):\\n self._queue = []\\n self._size = 0\\n self._cost = 0\\n\\n def put(self, edge: Edge, target_cost):\\n # assert target_cost >= self._cost\\n queue_len = len(self._queue)\\n if target_cost >= queue_len:\\n self._queue.extend([[] for _ in range(target_cost - queue_len + 1)])\\n self._queue[target_cost].append(edge)\\n self._size += 1\\n\\n def pop(self):\\n # assert self._size > 0\\n while not self._queue[self._cost]:\\n self._cost += 1\\n edge = self._queue[self._cost].pop()\\n self._size -= 1\\n return edge, self._cost\\n\\n def __len__(self):\\n return self._size\\n\\n\\nclass MultiEntryMCFS(MultiEntryBFS):\\n\\n cost = MCFS.cost\\n\\n Queue = MCFS.Queue\\n\\n\\n# ----------------------------------------------------------------------------\\n# MCFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n# TODO: implement\\n\\n\\n# ----------------------------------------------------------------------------\\n# Depth-First Search\\n# ----------------------------------------------------------------------------\\n\\nimport enum\\n\\n\\nclass DFS:\\n \\\"\\\"\\\"Depth-first Search (DFS)\\\"\\\"\\\"\\n\\n class Observer:\\n\\n def init(self, traversal):\\n self.traversal = traversal\\n self.graph = traversal.graph\\n\\n # -- Event Handlers ------------------------------------------------------\\n\\n def start_traversal(self, source: int):\\n ...\\n\\n def finish_traversal(self):\\n ...\\n\\n def stop_traversal(self):\\n ...\\n\\n def enter_vertex(self, u: int):\\n ...\\n\\n def exit_vertex(self, u: int):\\n ...\\n\\n def traverse_tree_edge(self, edge: Edge):\\n ...\\n\\n def retrace_tree_edge(self, edge: Edge):\\n ...\\n\\n def visit_backward_edge(self, edge: Edge):\\n # Hint: Check if edge.target == self.traversal.parents[edge.source].\\n ...\\n\\n def visit_forward_edge(self, edge: Edge):\\n ...\\n\\n def visit_cross_edge(self, edge: Edge):\\n ...\\n\\n class StopTraversal(Exception):\\n ...\\n\\n class VStatus(enum.Enum):\\n UNDISCOVERED = 1\\n ENTERED = 2\\n EXITED = 3\\n\\n def __init__(self, graph, observer=None):\\n # Traversal state:\\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\\n self.entry_times = [0] * graph.vertex_count()\\n self.parents = [-1] * graph.vertex_count()\\n self.time = 0\\n self.stack = None\\n self.stopped = False\\n self._out_edges = [graph.out_edges(v) for v in graph.vertices()]\\n # Traversal parameters:\\n self.graph = graph\\n self.observer = observer if observer is not None else self.Observer()\\n self.observer.init(self)\\n\\n # -- Traversal Configuration -----------------------------------------------\\n\\n def _enter_vertex(self, v: int):\\n # UNDISCOVERED -> ENTERED\\n self.statuses[v] = self.VStatus.ENTERED\\n self.time += 1\\n self.entry_times[v] = self.time\\n\\n def _exit_vertex(self, v: int):\\n # ENTERED -> EXITED\\n self.statuses[v] = self.VStatus.EXITED\\n\\n # -- Traversal -------------------------------------------------------------\\n\\n def run(self, source: int):\\n if self.statuses[source] != self.VStatus.UNDISCOVERED:\\n return\\n stack = [Edge(source=-1, target=source)]\\n self.stopped = False\\n try:\\n self.observer.start_traversal(source)\\n while stack:\\n edge = stack[-1]\\n p = edge.source # previous vertex\\n u = edge.target\\n match self.statuses[u]:\\n case self.VStatus.UNDISCOVERED:\\n self.parents[u] = p\\n if p >= 0:\\n self.observer.traverse_tree_edge(edge)\\n self._enter_vertex(u)\\n self.observer.enter_vertex(u)\\n case self.VStatus.EXITED:\\n stack.pop()\\n if self.entry_times[u] > self.entry_times[p]:\\n self.observer.visit_forward_edge(edge)\\n else:\\n self.observer.visit_cross_edge(edge)\\n case self.VStatus.ENTERED:\\n if p >= 0 and self.entry_times[u] < self.entry_times[p]:\\n stack.pop()\\n self.observer.visit_backward_edge(edge)\\n else:\\n try:\\n stack.append(next(self._out_edges[u]))\\n except StopIteration:\\n self.observer.exit_vertex(u)\\n self._exit_vertex(u)\\n stack.pop()\\n if p >= 0:\\n self.observer.retrace_tree_edge(edge)\\n except self.StopTraversal:\\n self.stopped = True\\n self.observer.stop_traversal()\\n else:\\n self.observer.finish_traversal()\\n\\n\\n# ----------------------------------------------------------------------------\\n# DFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n\\ndef find_scc(graph):\\n\\n class Pass1(DFS.Observer):\\n\\n def __init__(self):\\n self.order = []\\n\\n def exit_vertex(self, u):\\n self.order.append(u)\\n\\n pass1 = Pass1()\\n dfs1 = DFS(graph, pass1)\\n for v in graph.vertices():\\n dfs1.run(v)\\n\\n class StronglyConnectedComponents(DFS.Observer):\\n\\n def __init__(self):\\n self.count = 0\\n self.vertex2comp = [-1] * graph.vertex_count()\\n self.comp2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, source):\\n self.count += 1\\n\\n def enter_vertex(self, u):\\n self.vertex2comp[u] = self.count - 1\\n self.comp2vertices[self.count - 1].append(u)\\n\\n scc = StronglyConnectedComponents()\\n dfs2 = DFS(transposed(graph), scc)\\n for v in reversed(pass1.order):\\n dfs2.run(v)\\n return scc\\n\\n\\ndef build_condensation_graph(graph, scc=None):\\n if scc is None:\\n scc = find_scc(graph)\\n edges = set()\\n for c in range(scc.count):\\n for u in scc.comp2vertices[c]:\\n for v, _ in graph.out_edges(u):\\n if scc.vertex2comp[v] == c: continue\\n edges.add((c, scc.vertex2comp[v]))\\n cond_graph = AdjacencyLists(scc.count)\\n cond_graph.add_edges(edges)\\n return cond_graph\\n\\n\\ndef find_bridges_and_cutpoints(graph):\\n\\n class Finder(DFS.Observer):\\n\\n def __init__(self):\\n self.low = [graph.vertex_count() + 1] * graph.vertex_count()\\n self.bridges = []\\n self.is_cutpoint = [False] * graph.vertex_count()\\n\\n def start_traversal(self, source):\\n self.root = source\\n\\n def finish_traversal(self):\\n if self.traversal.parents.count(self.root) > 1:\\n self.is_cutpoint[self.root] = True\\n\\n def enter_vertex(self, u):\\n self.low[u] = self.traversal.entry_times[u]\\n\\n def visit_backward_edge(self, edge: Edge):\\n u, v, _, _ = astuple(edge)\\n if v == self.traversal.parents[u]: return\\n self.low[u] = min(self.low[u], self.traversal.entry_times[v]) \\n\\n def retrace_tree_edge(self, edge: Edge):\\n u, v, _, _ = astuple(edge)\\n self.low[u] = min(self.low[u], self.low[v])\\n if self.low[v] >= self.traversal.entry_times[v]:\\n self.bridges.append(edge)\\n if self.low[v] >= self.traversal.entry_times[u] and u != self.root:\\n self.is_cutpoint[u] = True\\n\\n finder = Finder()\\n dfs = DFS(graph, finder)\\n for v in graph.vertices():\\n dfs.run(v)\\n\\n return finder.bridges, finder.is_cutpoint\",\n \"memory\": \"54900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1:\\n return -1\\n\\n kRows = len(grid)\\n kCols = len(grid[0])\\n\\n graph = Grid(kRows, kCols)\\n\\n mcfs = BoundedMCFS(graph, ToTarget(graph.vertex_count() - 1))\\n\\n def get_attrs(r1, c1, r2, c2):\\n edge_len = max(grid[r2][c2] - mcfs.costs[graph.coor2idx(r1, c1)], 0)\\n if edge_len % 2 == 0:\\n edge_len += 1\\n return edge_len\\n\\n graph.get_attrs = get_attrs\\n\\n mcfs.run(0)\\n\\n return mcfs.costs[-1]\\n\\n\\nfrom dataclasses import dataclass, astuple\\nfrom typing import Any\\n\\n\\n@dataclass\\nclass Edge:\\n source: int\\n target: int\\n attrs: Any = ()\\n handle: Any = None\\n\\n\\nclass Graph:\\n \\\"\\\"\\\"Graph ABC.\\n\\n This class assumes that vertices are indexed 0, 1, 2, ..., vertex_count-1.\\n \\\"\\\"\\\"\\n\\n def __init__(self, vertex_count):\\n \\\"\\\"\\\"Initialize the graph with the given number of vertices.\\\"\\\"\\\"\\n assert vertex_count > 0\\n self._vertex_count = vertex_count\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add a directed edge from source to target with given attributes.\\n\\n Returns: edge handle that can be used in `get` and 'remove' operations.\\n \\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def add_undirected_edge(self, u: int, v: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add an undirected edge between u and v with the given attributes.\\n\\n Returns: edge handles that can be used in `get` and 'remove' operations.\\n \\\"\\\"\\\"\\n handle_uv = self.add_edge(u, v, attrs, **kwargs)\\n handle_vu = self.add_edge(v, u, attrs, **kwargs)\\n return handle_uv, handle_vu\\n\\n def get_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Retrieve a directed edge from source to target.\\n\\n Returns: Edge object.\\n \\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def remove_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Remove a directed edge from source to target.\\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n for edge in self.edges():\\n if edge.target == target:\\n yield edge\\n\\n def edges(self):\\n \\\"\\\"\\\"Generate all edges in the graph.\\\"\\\"\\\"\\n for source in self.vertices():\\n yield from self.out_edges(source)\\n\\n def vertices(self):\\n \\\"\\\"\\\"Generate all vertices in the graph.\\\"\\\"\\\"\\n return range(self._vertex_count)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n return len(list(self.out_edges(source)))\\n\\n def out_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of out-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self.out_degree(source) for source in self.vertices()]\\n\\n def in_degree(self, target: int) -> int:\\n \\\"\\\"\\\"Get the in-degree of a given target vertex.\\\"\\\"\\\"\\n return len(list(self.in_edges(target)))\\n\\n def in_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of in-degrees of all vertices in the graph.\\\"\\\"\\\"\\n in_degs = [0] * self.vertex_count()\\n for edge in self.edges():\\n in_degs[edge.target] += 1\\n return in_degs\\n\\n # --------------------------------------------------------------------------\\n\\n def edge_count(self) -> int:\\n \\\"\\\"\\\"Get the number of edges in the graph.\\\"\\\"\\\"\\n return sum(self.out_degrees())\\n\\n def vertex_count(self) -> int:\\n \\\"\\\"\\\"Get the number of vertices in the graph.\\\"\\\"\\\"\\n return self._vertex_count\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edges(self, edges):\\n \\\"\\\"\\\"Add directed edges with optional attributes.\\\"\\\"\\\"\\n for edge in edges:\\n source, target, *attrs = edge\\n self.add_edge(source, target, self._seq2attrs(attrs))\\n\\n def add_undirected_edges(self, edges):\\n \\\"\\\"\\\"Add undirected edges with optional attributes.\\\"\\\"\\\"\\n for edge in edges:\\n source, target, *attrs = edge\\n self.add_undirected_edge(source, target, self._seq2attrs(attrs))\\n\\n def _seq2attrs(self, attrs):\\n match len(attrs):\\n case 0: return Edge.attrs # default empty tuple\\n case 1: return attrs[0]\\n case _: return attrs\\n\\n # --------------------------------------------------------------------------\\n\\n def _get_attrs(self, attrs, kwargs):\\n \\\"\\\"\\\"Build edge attrs object from `add_[undirected_]edge` method args.\\\"\\\"\\\"\\n if attrs is None:\\n if kwargs:\\n # TODO: Convert to a named tuple?\\n attrs = kwargs\\n else:\\n attrs = Edge.attrs\\n return attrs\\n\\n\\ndef transposed(graph):\\n \\\"\\\"\\\"Transpose (reverse the direction of all edges in) the given graph.\\\"\\\"\\\"\\n transposed = type(graph)(graph.vertex_count())\\n for source, target, attrs, _ in graph.edges():\\n transposed.add_edge(target, source, attrs)\\n return transposed\\n\\n\\n# ----------------------------------------------------------------------------\\n# Concrete Graph Classes\\n# ----------------------------------------------------------------------------\\n\\n\\nclass AdjacencyList():\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize an empty adjacency list.\\\"\\\"\\\"\\n self._out_edges = []\\n self._size = 0\\n\\n def add(self, target: int, attrs) -> int:\\n \\\"\\\"\\\"Add a new edge to the end of the adjacency list.\\n\\n Returns: index of the added edge.\\n \\\"\\\"\\\"\\n if len(self._out_edges) == self._size:\\n self._out_edges.append((target, attrs))\\n else:\\n # assert len(self._out_edges) > self._size\\n assert self._out_edges[self._size] is None\\n self._out_edges[self._size] = (target, attrs)\\n self._size += 1\\n return self._size - 1\\n\\n def get(self, source: int, target: int, idx: int = None):\\n \\\"\\\"\\\"Retrieve an / the edge pointing at vertex `target`.\\\"\\\"\\\"\\n idx = self._index(target, idx)\\n return Edge(source, target, self._out_edges[idx][1], idx)\\n\\n def remove(self, target: int, idx: int = None):\\n \\\"\\\"\\\"Remove an / the edge pointing at vertex `target`.\\\"\\\"\\\"\\n idx = self._index(target, idx)\\n self._size -= 1\\n self._out_edges[idx] = self._out_edges[self._size]\\n self._out_edges[self._size] = idx\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges.\\\"\\\"\\\"\\n for idx, (target, attrs) in enumerate(self._out_edges[:self._size]):\\n yield Edge(source, target, attrs, idx)\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the number of edges in this adjacency list.\\\"\\\"\\\"\\n return self._size\\n\\n def _index(self, target: int, idx: int = None):\\n \\\"\\\"\\\"Return index of an / the edge pointing at vertex `target`.\\n\\n Raise a ValueError if there is no such edge.\\n\\n If `idx` is None, return index of the first edge pointing at `target`.\\n Otherwise, return current index of the edge that originally sat at `idx`.\\n \\\"\\\"\\\"\\n if idx is None:\\n for idx in range(self._size):\\n if self._out_edges[idx][0] == target:\\n return idx\\n else:\\n assert 0 <= idx < len(self._out_edges)\\n while idx >= self._size:\\n idx, self._out_edges[idx] = self._out_edges[idx], None\\n if target is None or self._out_edges[idx][0] == target:\\n return idx\\n raise ValueError('vertex {} is not in adjacency list'.format(target))\\n\\n\\nclass AdjacencyLists(Graph):\\n\\n def __init__(self, vertex_count, make_list=None):\\n \\\"\\\"\\\"Initialize the graph with the given number of vertices.\\\"\\\"\\\"\\n super().__init__(vertex_count)\\n self._make_list = make_list if make_list is not None else AdjacencyList\\n self._adj_lists = [self._make_list() for _ in range(vertex_count)]\\n\\n # --------------------------------------------------------------------------\\n\\n def add_edge(self, source: int, target: int, attrs=None, **kwargs):\\n \\\"\\\"\\\"Add a directed edge from source to target with given attributes.\\n\\n Returns: edge handle that can be used in `remove` and 'get' methods.\\n \\\"\\\"\\\"\\n attrs = self._get_attrs(attrs, kwargs)\\n return self._adj_lists[source].add(target, attrs)\\n\\n def get_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Retrieve a directed edge from source to target.\\n\\n Returns: tuple[edge attrs, edge handle]\\n \\\"\\\"\\\"\\n return self._adj_lists[source].get(source, target, handle)\\n\\n def remove_edge(self, source: int, target: int, handle=None):\\n \\\"\\\"\\\"Remove a directed edge from source to target.\\\"\\\"\\\"\\n self._adj_lists[source].remove(target, handle)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n yield from self._adj_lists[source].out_edges(source)\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n return len(self._adj_lists[source])\\n\\n\\nclass Clique(Graph):\\n\\n def __init__(self, vertex_count, get_attrs=None):\\n \\\"\\\"\\\"Initialize the clique with the given number of rows and columns.\\\"\\\"\\\"\\n super().__init__(vertex_count)\\n # Returns attributes of the edge between vertices u and v.\\n self.get_attrs = (get_attrs if get_attrs is not None else\\n lambda u, v: Edge.attrs)\\n\\n # --------------------------------------------------------------------------\\n\\n # TODO get_edge()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n for target in self.vertices():\\n if source != target:\\n yield Edge(source, target, self.get_attrs(source, target))\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n for source in self.vertices():\\n if source != target:\\n yield Edge(source, target, self.get_attrs(source, target))\\n\\n # --------------------------------------------------------------------------\\n\\n def out_degree(self, source: int) -> int:\\n \\\"\\\"\\\"Get the out-degree of a given source vertex.\\\"\\\"\\\"\\n return self._vertex_count - 1\\n\\n def out_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of out-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self._vertex_count - 1 for source in self.vertices()]\\n\\n def in_degree(self, target: int) -> int:\\n \\\"\\\"\\\"Get the in-degree of a given target vertex.\\\"\\\"\\\"\\n return self._vertex_count - 1\\n\\n def in_degrees(self) -> list[int]:\\n \\\"\\\"\\\"Get the list of in-degrees of all vertices in the graph.\\\"\\\"\\\"\\n return [self._vertex_count - 1 for source in self.vertices()]\\n\\n # --------------------------------------------------------------------------\\n\\n def edge_count(self) -> int:\\n \\\"\\\"\\\"Get the number of edges in the graph.\\\"\\\"\\\"\\n raise self._vertex_count * (self._vertex_count - 1)\\n\\n\\nclass Grid(Graph):\\n\\n class Type:\\n k4Way = 1 # default\\n k8Way = 2\\n\\n def __init__(self, rows=0, cols=0, grid_type=None, get_attrs=None):\\n \\\"\\\"\\\"Initialize the grid with the given number of rows and columns.\\\"\\\"\\\"\\n super().__init__(rows * cols)\\n self.rows = rows\\n self.cols = cols\\n # Returns attributes of the edge between cells (r1,c1) and (r2,c2):\\n self.get_attrs = (get_attrs if get_attrs is not None else\\n lambda r1, c1, r2, c2: Edge.attrs)\\n # Implementation details:\\n self._neighborhood = [(1, 0), (0, 1), (-1, 0), (0, -1)]\\n if grid_type == self.Type.k8Way:\\n self._neighborhood += [(1, 1), (1, -1), (-1, 1), (-1, -1)]\\n\\n # --------------------------------------------------------------------------\\n\\n # TODO get_edge()\\n\\n # --------------------------------------------------------------------------\\n\\n def out_edges(self, source: int):\\n \\\"\\\"\\\"Generate all outgoing edges from a given source vertex.\\\"\\\"\\\"\\n # assert 0 <= source < self.vertex_count()\\n sr, sc = self.idx2coor(source)\\n for tr, tc in self._get_neighbor_cells(sr, sc):\\n attrs = self.get_attrs(sr, sc, tr, tc)\\n if attrs is not None:\\n yield Edge(source, self.coor2idx(tr, tc), attrs)\\n\\n def in_edges(self, target: int):\\n \\\"\\\"\\\"Generate all incoming edges to a given target vertex.\\\"\\\"\\\"\\n # assert 0 <= target < self.vertex_count()\\n tr, tc = self.idx2coor(target)\\n for sr, sc in self._get_neighbor_cells(tr, tc):\\n attrs = self.get_attrs(sr, sc, tr, tc)\\n if attrs is not None:\\n yield Edge(self.coor2idx(sr, sc), target, attrs)\\n\\n def _get_neighbor_cells(self, r1: int, c1: int) -> list[tuple[int, int]]:\\n \\\"\\\"\\\"Generate the valid neighboring cells for a given grid cell.\\\"\\\"\\\"\\n for dr, dc in self._neighborhood:\\n r2, c2 = r1 + dr, c1 + dc\\n if (0 <= r2 < self.rows) and (0 <= c2 < self.cols):\\n yield r2, c2\\n\\n # --------------------------------------------------------------------------\\n\\n def coor2idx(self, r: int, c: int) -> int:\\n \\\"\\\"\\\"Convert a pair of grid coordinates to a linear index.\\\"\\\"\\\"\\n return r * self.cols + c\\n\\n def idx2coor(self, idx: int) -> tuple[int, int]:\\n \\\"\\\"\\\"Convert a linear index to a pair of grid coordinates.\\\"\\\"\\\"\\n return (idx // self.cols, idx % self.cols)\\n\\n\\nclass VertexMap:\\n \\\"\\\"\\\"A utility class to map vertex labels to int indices and vice versa.\\\"\\\"\\\"\\n\\n def __init__(self):\\n self.l2i = {} # label to index map\\n self.i2l = [] # index to label map\\n self._vertex_count = 0\\n\\n def add_vertex(self, label):\\n \\\"\\\"\\\"\\n Add a vertex with the given label to the map.\\n If label already exists, return its index.\\n \\\"\\\"\\\"\\n return self.get_index(label)\\n\\n def get_index(self, label) -> int:\\n \\\"\\\"\\\"\\n Get the index corresponding to the given label.\\n If label doesn't exist, create an entry for it.\\n \\\"\\\"\\\"\\n idx = self.l2i.setdefault(label, self.vertex_count())\\n if idx == self._vertex_count:\\n self.i2l.append(label)\\n self._vertex_count += 1\\n return idx\\n\\n def get_label(self, v: int):\\n \\\"\\\"\\\"Get the label corresponding to the given index.\\\"\\\"\\\"\\n assert 0 <= v < self._vertex_count\\n return self.i2l[v]\\n\\n def vertex_count(self) -> int:\\n \\\"\\\"\\\"Get the number of vertices in the map.\\\"\\\"\\\"\\n return self._vertex_count\\n\\n\\n# ----------------------------------------------------------------------------\\n# Breath-First Search (BFS)\\n# ----------------------------------------------------------------------------\\n\\nimport collections\\nimport math\\n\\n\\nclass BFS:\\n \\\"\\\"\\\"Breath-First Search (BFS)\\\"\\\"\\\"\\n\\n class Observer:\\n\\n def init(self, traversal):\\n self.traversal = traversal\\n self.graph = traversal.graph\\n\\n def start_traversal(self, sources: list[int]):\\n ...\\n\\n def finish_traversal(self):\\n ...\\n\\n def stop_traversal(self):\\n ...\\n\\n def enter_vertex(self, u: int, cost_u):\\n ...\\n\\n def exit_vertex(self, u: int):\\n ...\\n\\n def traverse_tree_edge(self, edge: Edge, target_cost):\\n ...\\n\\n def visit_edge(self, edge: Edge, target_cost):\\n ...\\n\\n\\n class StopTraversal(Exception):\\n ...\\n\\n class SkipVertex(Exception):\\n ...\\n\\n class VStatus:\\n UNDISCOVERED = 1\\n ENQUEUED = 2\\n EXITED = 3\\n\\n def __init__(self, graph, observer=None, get_cost=None, make_queue=None):\\n # Traversal state:\\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\\n self.costs = [math.inf] * graph.vertex_count()\\n self.queue = None\\n self.stopped = False\\n # Traversal parameters:\\n self.graph = graph\\n self.observer = observer if observer is not None else self.Observer()\\n self.get_cost = get_cost if get_cost is not None else self.cost\\n self.make_queue = make_queue if make_queue is not None else self.Queue\\n self.observer.init(self)\\n\\n # -- Cost & Queue Definitions ----------------------------------------------\\n\\n @staticmethod\\n def cost(cost_u, attrs_uv):\\n return cost_u + 1\\n\\n class Queue:\\n\\n def __init__(self):\\n self._queue = collections.deque()\\n\\n def put(self, edge: Edge, target_cost):\\n self._queue.append((edge, target_cost))\\n\\n def pop(self):\\n # assert len(self._queue) > 0\\n return self._queue.popleft()\\n\\n def __len__(self):\\n return len(self._queue)\\n\\n # -- Traversal Configuration -----------------------------------------------\\n\\n # If you are getting TLE, consider inlining the config methods, especially\\n # `_visit_edge` and `_enqueue`.\\n\\n def _enter_vertex(self, u: int, cost_u):\\n # assert self.statuses[v] == self.VStatus.ENQUEUED\\n self.costs[u] = cost_u\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\\n self._enqueue(edge, target_cost)\\n\\n def _enqueue(self, edge: Edge, target_cost):\\n # UNDISCOVERED -> ENQUEUED\\n self.statuses[edge.target] = self.VStatus.ENQUEUED\\n self.queue.put(edge, target_cost)\\n\\n def _exit_vertex(self, u: int):\\n # ENQUEUED -> EXITED\\n self.statuses[u] = self.VStatus.EXITED\\n\\n # -- Traversal -------------------------------------------------------------\\n\\n def run(self, sources: list[int], source_cost=0):\\n if isinstance(sources, int):\\n sources = [sources]\\n self.queue = self.make_queue()\\n self.stopped = False\\n for u in sources:\\n self._visit_edge(Edge(source=-1, target=u), source_cost)\\n if not self.queue:\\n return\\n try:\\n self.observer.start_traversal(sources)\\n while self.queue:\\n try:\\n in_edge, cost_u = self.queue.pop()\\n u = in_edge.target\\n if in_edge.source >= 0:\\n self.observer.traverse_tree_edge(in_edge, cost_u)\\n self._enter_vertex(u, cost_u)\\n self.observer.enter_vertex(u, cost_u)\\n for out_edge in self.graph.out_edges(u):\\n cost_v = self.get_cost(cost_u, out_edge.attrs)\\n self.observer.visit_edge(out_edge, cost_v)\\n self._visit_edge(out_edge, cost_v)\\n self.observer.exit_vertex(u)\\n self._exit_vertex(u)\\n except self.SkipVertex:\\n ...\\n except self.StopTraversal:\\n self.observer.stop_traversal()\\n self.stopped = True\\n else:\\n self.observer.finish_traversal()\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS Variants\\n# ----------------------------------------------------------------------------\\n\\n\\nclass TopologicalBFS(BFS):\\n\\n def __init__(self, graph, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.in_degs = graph.in_degrees()\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n self.in_degs[edge.target] -= 1\\n if self.in_degs[edge.target] <= 0:\\n self._enqueue(edge, target_cost)\\n\\n def run(self):\\n super().run([u for u in self.graph.vertices() if self.in_degs[u] == 0])\\n\\n\\nclass RestrictedBFS(BFS):\\n\\n class VStatus:\\n UNDISCOVERED = 1\\n DISCOVERED = 2\\n ENQUEUED = 3\\n EXITED = 4\\n\\n def __init__(self, graph, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.open = [True] * graph.vertex_count()\\n self.in_edges = [None] * graph.vertex_count()\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] == self.VStatus.UNDISCOVERED:\\n if self.open[edge.target]:\\n # UNDISCOVERED -> ENQUEUED\\n self._enqueue(edge, target_cost)\\n else:\\n # UNDISCOVERED -> DISCOVERED\\n self.statuses[edge.target] = self.VStatus.DISCOVERED\\n if self.statuses[edge.target] == self.VStatus.DISCOVERED:\\n # assert not self.open[edge.target]\\n self.in_edges[edge.target] = edge \\n self.costs[edge.target] = target_cost\\n\\n def unlock(self, u: int):\\n self.open[u] = True\\n if self.statuses[u] == self.VStatus.DISCOVERED:\\n # DISCOVERED -> ENQUEUED\\n self._enqueue(self.in_edges[u], self.costs[u])\\n\\n\\nclass MultiEntryBFS(BFS):\\n\\n def __init__(self, graph, max_entry_count=1, *args, **kwargs):\\n super().__init__(graph, *args, **kwargs)\\n self.max_entry_count = max_entry_count\\n self.entry_counts = [0] * graph.vertex_count()\\n\\n def _enter_vertex(self, u: int, cost_u):\\n # assert self.costs[u] <= cost_u\\n # TODO: multiple entries with the same cost -> add a config param\\n if self.statuses[u] == self.VStatus.EXITED or self.costs[u] == cost_u:\\n raise self.SkipVertex\\n self.costs[u] = cost_u\\n self.entry_counts[u] += 1\\n\\n def _visit_edge(self, edge: Edge, target_cost):\\n if self.statuses[edge.target] != self.VStatus.EXITED:\\n self._enqueue(edge, target_cost)\\n\\n def _exit_vertex(self, u: int):\\n if self.entry_counts[u] >= self.max_entry_count:\\n self.statuses[u] = self.VStatus.EXITED\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS Observers\\n# ----------------------------------------------------------------------------\\n\\n\\nclass ToTarget(BFS.Observer):\\n\\n def __init__(self, target: int):\\n self.target = target\\n\\n def init(self, traversal):\\n super().init(traversal)\\n if self.target < 0:\\n self.target += self.graph.vertex_count()\\n assert 0 <= self.target < self.graph.vertex_count()\\n\\n def enter_vertex(self, u: int, cost_u):\\n if u == self.target:\\n raise self.traversal.StopTraversal\\n\\n\\nclass ToCost(BFS.Observer):\\n\\n def __init__(self, target_cost):\\n self.target_cost = target_cost\\n\\n def enter_vertex(self, u: int, cost_u):\\n if cost_u > self.target_cost:\\n raise self.traversal.SkipVertex\\n\\n\\nclass InEdges(BFS.Observer):\\n\\n def init(self, traversal):\\n super().init(traversal)\\n self.in_edges = [None] * self.graph.vertex_count()\\n\\n def traverse_tree_edge(self, edge: Edge, target_cost):\\n self.in_edges[edge.target] = edge\\n\\n\\n# ----------------------------------------------------------------------------\\n# BFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n\\ndef find_cc(graph):\\n\\n class ConnectedComponents(BFS.Observer):\\n\\n def __init__(self):\\n self.count = 0\\n self.vertex2comp = [-1] * graph.vertex_count()\\n self.comp2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, sources):\\n self.count += 1\\n\\n def enter_vertex(self, u, cost_u):\\n self.vertex2comp[u] = self.count - 1\\n self.comp2vertices[self.count - 1].append(u)\\n\\n cc = ConnectedComponents()\\n bfs = BFS(graph, cc)\\n for v in graph.vertices():\\n bfs.run(v)\\n return cc\\n\\n\\ndef find_layers(graph):\\n\\n class Layers(BFS.Observer):\\n\\n def __init__(self):\\n self.vertex2layer = [-1] * graph.vertex_count()\\n self.layer2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, sources):\\n for u in sources:\\n self.vertex2layer[u] = 0\\n\\n def enter_vertex(self, u, cost_u):\\n self.layer2vertices[self.vertex2layer[u]].append(u)\\n\\n def visit_edge(self, edge: Edge, target_cost):\\n self.vertex2layer[edge.target] = max(self.vertex2layer[edge.target],\\n self.vertex2layer[edge.source] + 1)\\n\\n layers = Layers()\\n TopologicalBFS(graph, layers).run()\\n return layers\\n\\n\\ndef sort_topologically(graph, bfs_cls=TopologicalBFS):\\n\\n class Order(BFS.Observer):\\n\\n def __init__(self):\\n self.vertices = []\\n\\n def enter_vertex(self, u, cost_u):\\n self.vertices.append(u)\\n\\n obs = Order()\\n bfs_cls(graph, obs).run()\\n return obs.vertices\\n\\n\\n# ----------------------------------------------------------------------------\\n# MinCost-First Search (MCFS)\\n# ----------------------------------------------------------------------------\\n\\nimport sortedcontainers\\n\\n\\nclass MCFS(BFS):\\n \\\"\\\"\\\"MinCost-First Search (MCFS)\\\"\\\"\\\"\\n\\n @staticmethod\\n def cost(cost_u, attr_uv):\\n return cost_u + attr_uv\\n\\n class Queue:\\n\\n def __init__(self):\\n self._items = sortedcontainers.SortedSet()\\n\\n def put(self, edge, target_cost):\\n self._items.add(self._Item(target_cost, edge))\\n\\n def pop(self):\\n # assert len(self._items) > 1\\n item = self._items.pop(0)\\n return item.edge, item.target_cost\\n\\n def __len__(self):\\n return len(self._items)\\n\\n @dataclass\\n class _Item:\\n target_cost: Any\\n edge: Any\\n\\n def __lt__(self, other):\\n return self.target_cost < other.target_cost\\n\\n def __hash__(self):\\n return hash(self.target_cost)\\n\\n def _enter_vertex(self, u: int, cost_u):\\n if self.statuses[u] == self.VStatus.EXITED:\\n raise self.SkipVertex\\n self.costs[u] = cost_u\\n\\n def _visit_edge(self, edge, target_cost):\\n if self.costs[edge.target] > target_cost:\\n self.costs[edge.target] = target_cost\\n self._enqueue(edge, target_cost)\\n\\n\\n# ----------------------------------------------------------------------------\\n# MCFS Variants\\n# ----------------------------------------------------------------------------\\n\\n\\nclass BinaryMCFS(MCFS):\\n \\\"\\\"\\\"Works for graphs where each edge's cost is either 0 or 1.\\\"\\\"\\\"\\n\\n class Queue(BFS.Queue):\\n\\n def put(self, edge, target_cost):\\n if self._queue and self._queue[-1][1] <= target_cost:\\n self._queue.append((edge, target_cost))\\n else:\\n self._queue.appendleft((edge, target_cost))\\n\\n\\nclass BoundedMCFS(MCFS):\\n \\\"\\\"\\\"Works for graphs where max vertex's cost is ~ O(graph.edge_count()).\\\"\\\"\\\"\\n\\n class Queue:\\n\\n def __init__(self):\\n self._queue = []\\n self._size = 0\\n self._cost = 0\\n\\n def put(self, edge: Edge, target_cost):\\n # assert target_cost >= self._cost\\n queue_len = len(self._queue)\\n if target_cost >= queue_len:\\n self._queue.extend([[] for _ in range(target_cost - queue_len + 1)])\\n self._queue[target_cost].append(edge)\\n self._size += 1\\n\\n def pop(self):\\n # assert self._size > 0\\n while not self._queue[self._cost]:\\n self._cost += 1\\n edge = self._queue[self._cost].pop()\\n self._size -= 1\\n return edge, self._cost\\n\\n def __len__(self):\\n return self._size\\n\\n\\nclass MultiEntryMCFS(MultiEntryBFS):\\n\\n cost = MCFS.cost\\n\\n Queue = MCFS.Queue\\n\\n\\n# ----------------------------------------------------------------------------\\n# MCFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n# TODO: implement\\n\\n\\n# ----------------------------------------------------------------------------\\n# Depth-First Search\\n# ----------------------------------------------------------------------------\\n\\nimport enum\\n\\n\\nclass DFS:\\n \\\"\\\"\\\"Depth-first Search (DFS)\\\"\\\"\\\"\\n\\n class Observer:\\n\\n def init(self, traversal):\\n self.traversal = traversal\\n self.graph = traversal.graph\\n\\n # -- Event Handlers ------------------------------------------------------\\n\\n def start_traversal(self, source: int):\\n ...\\n\\n def finish_traversal(self):\\n ...\\n\\n def stop_traversal(self):\\n ...\\n\\n def enter_vertex(self, u: int):\\n ...\\n\\n def exit_vertex(self, u: int):\\n ...\\n\\n def traverse_tree_edge(self, edge: Edge):\\n ...\\n\\n def retrace_tree_edge(self, edge: Edge):\\n ...\\n\\n def visit_backward_edge(self, edge: Edge):\\n # Hint: Check if edge.target == self.traversal.parents[edge.source].\\n ...\\n\\n def visit_forward_edge(self, edge: Edge):\\n ...\\n\\n def visit_cross_edge(self, edge: Edge):\\n ...\\n\\n class StopTraversal(Exception):\\n ...\\n\\n class VStatus(enum.Enum):\\n UNDISCOVERED = 1\\n ENTERED = 2\\n EXITED = 3\\n\\n def __init__(self, graph, observer=None):\\n # Traversal state:\\n self.statuses = [self.VStatus.UNDISCOVERED] * graph.vertex_count()\\n self.entry_times = [0] * graph.vertex_count()\\n self.parents = [-1] * graph.vertex_count()\\n self.time = 0\\n self.stack = None\\n self.stopped = False\\n self._out_edges = [graph.out_edges(v) for v in graph.vertices()]\\n # Traversal parameters:\\n self.graph = graph\\n self.observer = observer if observer is not None else self.Observer()\\n self.observer.init(self)\\n\\n # -- Traversal Configuration -----------------------------------------------\\n\\n def _enter_vertex(self, v: int):\\n # UNDISCOVERED -> ENTERED\\n self.statuses[v] = self.VStatus.ENTERED\\n self.time += 1\\n self.entry_times[v] = self.time\\n\\n def _exit_vertex(self, v: int):\\n # ENTERED -> EXITED\\n self.statuses[v] = self.VStatus.EXITED\\n\\n # -- Traversal -------------------------------------------------------------\\n\\n def run(self, source: int):\\n if self.statuses[source] != self.VStatus.UNDISCOVERED:\\n return\\n stack = [Edge(source=-1, target=source)]\\n self.stopped = False\\n try:\\n self.observer.start_traversal(source)\\n while stack:\\n edge = stack[-1]\\n p = edge.source # previous vertex\\n u = edge.target\\n match self.statuses[u]:\\n case self.VStatus.UNDISCOVERED:\\n self.parents[u] = p\\n if p >= 0:\\n self.observer.traverse_tree_edge(edge)\\n self._enter_vertex(u)\\n self.observer.enter_vertex(u)\\n case self.VStatus.EXITED:\\n stack.pop()\\n if self.entry_times[u] > self.entry_times[p]:\\n self.observer.visit_forward_edge(edge)\\n else:\\n self.observer.visit_cross_edge(edge)\\n case self.VStatus.ENTERED:\\n if p >= 0 and self.entry_times[u] < self.entry_times[p]:\\n stack.pop()\\n self.observer.visit_backward_edge(edge)\\n else:\\n try:\\n stack.append(next(self._out_edges[u]))\\n except StopIteration:\\n self.observer.exit_vertex(u)\\n self._exit_vertex(u)\\n stack.pop()\\n if p >= 0:\\n self.observer.retrace_tree_edge(edge)\\n except self.StopTraversal:\\n self.stopped = True\\n self.observer.stop_traversal()\\n else:\\n self.observer.finish_traversal()\\n\\n\\n# ----------------------------------------------------------------------------\\n# DFS-based Algorithms\\n# ----------------------------------------------------------------------------\\n\\n\\ndef find_scc(graph):\\n\\n class Pass1(DFS.Observer):\\n\\n def __init__(self):\\n self.order = []\\n\\n def exit_vertex(self, u):\\n self.order.append(u)\\n\\n pass1 = Pass1()\\n dfs1 = DFS(graph, pass1)\\n for v in graph.vertices():\\n dfs1.run(v)\\n\\n class StronglyConnectedComponents(DFS.Observer):\\n\\n def __init__(self):\\n self.count = 0\\n self.vertex2comp = [-1] * graph.vertex_count()\\n self.comp2vertices = collections.defaultdict(list)\\n\\n def start_traversal(self, source):\\n self.count += 1\\n\\n def enter_vertex(self, u):\\n self.vertex2comp[u] = self.count - 1\\n self.comp2vertices[self.count - 1].append(u)\\n\\n scc = StronglyConnectedComponents()\\n dfs2 = DFS(transposed(graph), scc)\\n for v in reversed(pass1.order):\\n dfs2.run(v)\\n return scc\\n\\n\\ndef build_condensation_graph(graph, scc=None):\\n if scc is None:\\n scc = find_scc(graph)\\n edges = set()\\n for c in range(scc.count):\\n for u in scc.comp2vertices[c]:\\n for v, _ in graph.out_edges(u):\\n if scc.vertex2comp[v] == c: continue\\n edges.add((c, scc.vertex2comp[v]))\\n cond_graph = AdjacencyLists(scc.count)\\n cond_graph.add_edges(edges)\\n return cond_graph\\n\\n\\ndef find_bridges_and_cutpoints(graph):\\n\\n class Finder(DFS.Observer):\\n\\n def __init__(self):\\n self.low = [graph.vertex_count() + 1] * graph.vertex_count()\\n self.bridges = []\\n self.is_cutpoint = [False] * graph.vertex_count()\\n\\n def start_traversal(self, source):\\n self.root = source\\n\\n def finish_traversal(self):\\n if self.traversal.parents.count(self.root) > 1:\\n self.is_cutpoint[self.root] = True\\n\\n def enter_vertex(self, u):\\n self.low[u] = self.traversal.entry_times[u]\\n\\n def visit_backward_edge(self, edge: Edge):\\n u, v, _, _ = astuple(edge)\\n if v == self.traversal.parents[u]: return\\n self.low[u] = min(self.low[u], self.traversal.entry_times[v]) \\n\\n def retrace_tree_edge(self, edge: Edge):\\n u, v, _, _ = astuple(edge)\\n self.low[u] = min(self.low[u], self.low[v])\\n if self.low[v] >= self.traversal.entry_times[v]:\\n self.bridges.append(edge)\\n if self.low[v] >= self.traversal.entry_times[u] and u != self.root:\\n self.is_cutpoint[u] = True\\n\\n finder = Finder()\\n dfs = DFS(graph, finder)\\n for v in graph.vertices():\\n dfs.run(v)\\n\\n return finder.bridges, finder.is_cutpoint\",\n \"memory\": \"55300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[1][0] > 1 and grid[0][1] > 1: \\n return -1\\n import heapq\\n from collections import defaultdict\\n m, n = len(grid), len(grid[0])\\n dis = defaultdict(lambda: float('inf'))\\n dis[(0, 0)] = 0\\n queue = [[0, (0, 0)]]\\n heapq.heapify(queue)\\n seen = set()\\n directions = [\\n [-1, 0], \\n [1, 0], \\n [0, -1], \\n [0, 1]\\n ]\\n while queue: \\n dis_curr, (x, y) = heapq.heappop(queue)\\n seen.add((x, y))\\n if x == m - 1 and y == n - 1: \\n return dis_curr\\n for dx, dy in directions: \\n xx = x + dx\\n yy = y + dy\\n if 0 <= xx < m and 0 <= yy < n: \\n if dis_curr + 1 >= grid[xx][yy]: \\n if dis_curr + 1 < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1\\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\\n else: \\n diff = grid[xx][yy] - (dis_curr + 1)\\n if diff % 2 == 1: \\n diff += 1\\n if dis_curr + 1 + diff < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1 + diff\\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\\n \\n print(dis)\\n return -1 \\n \\n \\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n ## adjusted Dijkstra's algo\\n if grid[1][0] > 1 and grid[0][1] > 1: \\n return -1\\n import heapq\\n from collections import defaultdict\\n m, n = len(grid), len(grid[0])\\n dis = defaultdict(lambda: float('inf'))\\n dis[(0, 0)] = 0\\n queue = [[0, (0, 0)]]\\n heapq.heapify(queue)\\n seen = set()\\n directions = [\\n [-1, 0], \\n [1, 0], \\n [0, -1], \\n [0, 1]\\n ]\\n while queue: \\n dis_curr, (x, y) = heapq.heappop(queue)\\n seen.add((x, y))\\n if x == m - 1 and y == n - 1: \\n return dis_curr\\n for dx, dy in directions: \\n xx = x + dx\\n yy = y + dy\\n if 0 <= xx < m and 0 <= yy < n: \\n if dis_curr + 1 >= grid[xx][yy]: \\n if dis_curr + 1 < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1\\n heapq.heappush(queue, [dis_curr + 1, (xx, yy)])\\n else: \\n diff = grid[xx][yy] - (dis_curr + 1)\\n if diff % 2 == 1: \\n diff += 1\\n if dis_curr + 1 + diff < dis[(xx, yy)]: \\n dis[(xx, yy)] = dis_curr + 1 + diff\\n heapq.heappush(queue, [dis_curr + 1 + diff, (xx, yy)])\\n \\n return -1 \\n \\n \\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n m, n = len(grid), len(grid[0])\\n visited = set()\\n pq = [(grid[0][0], 0, 0)]\\n \\n while pq:\\n time, row, col = heappop(pq)\\n if row == m-1 and col == n-1: return time\\n if (row, col) in visited: continue\\n visited.add((row, col))\\n for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\\n r, c = row + dr, col + dc\\n if 0 <= r < m and 0 <= c < n and (r, c) not in visited:\\n wait = 1 if ((grid[r][c] - time) % 2 == 0) else 0\\n heappush(pq, (max(time + 1, grid[r][c] + wait), r, c))\\n return -1\\n def minimumTime(self, grid: List[List[int]]) -> int:\\n m, n = len(grid), len(grid[0])\\n\\n tgt = (m-1, n-1)\\n src = (0, 0)\\n\\n que = [(0, src)]\\n seen = defaultdict(int)\\n seen[src] = 0\\n\\n if grid[0][0] > 0: return -1\\n if grid[0][1] > 1 and grid[1][0] > 1: return -1\\n\\n while que:\\n cur_time, (x,y) = heappop(que) \\n if (x, y) == tgt: return cur_time\\n for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:\\n xx, yy = dx + x, dy + y\\n\\n if 0<= xx < m and 0 <= yy < n and ((xx, yy) not in seen or seen[(xx, yy)] > cur_time + 1):\\n #update the modified origin if there is one\\n tmp = cur_time\\n modified_origin = False\\n if tmp + 1 < grid[xx][yy]:\\n tmp = (grid[xx][yy] - 1) if (grid[xx][yy] - 1 - tmp) %2 == 0 else grid[xx][yy]\\n modified_origin = True\\n\\n if tmp + 1 >= grid[xx][yy] and ((xx, yy) not in seen or seen[(xx, yy)] > tmp +1):\\n seen[(xx, yy)] = tmp + 1\\n heappush(que, (tmp + 1, (xx, yy)))\\n\\n if modified_origin:\\n heappush(que, (tmp, (x, y)))\\n return -1\\n\\n\",\n \"memory\": \"61000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":70,"string":"70"}}},{"rowIdx":2455,"cells":{"question_id":{"kind":"number","value":2135,"string":"2,135"},"name":{"kind":"string","value":"maximum-number-of-ways-to-partition-an-array"},"content":{"kind":"string","value":"<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code>. The number of ways to <strong>partition</strong> <code>nums</code> is the number of <code>pivot</code> indices that satisfy both conditions:</p>\n\n<ul>\n\t<li><code>1 <= pivot < n</code></li>\n\t<li><code>nums[0] + nums[1] + ... + nums[pivot - 1] == nums[pivot] + nums[pivot + 1] + ... + nums[n - 1]</code></li>\n</ul>\n\n<p>You are also given an integer <code>k</code>. You can choose to change the value of <strong>one</strong> element of <code>nums</code> to <code>k</code>, or to leave the array <strong>unchanged</strong>.</p>\n\n<p>Return <em>the <strong>maximum</strong> possible number of ways to <strong>partition</strong> </em><code>nums</code><em> to satisfy both conditions after changing <strong>at most</strong> one element</em>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [2,-1,2], k = 3\n<strong>Output:</strong> 1\n<strong>Explanation:</strong> One optimal approach is to change nums[0] to k. The array becomes [<strong><u>3</u></strong>,-1,2].\nThere is one way to partition the array:\n- For pivot = 2, we have the partition [3,-1 | 2]: 3 + -1 == 2.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [0,0,0], k = 1\n<strong>Output:</strong> 2\n<strong>Explanation:</strong> The optimal approach is to leave the array unchanged.\nThere are two ways to partition the array:\n- For pivot = 1, we have the partition [0 | 0,0]: 0 == 0 + 0.\n- For pivot = 2, we have the partition [0,0 | 0]: 0 + 0 == 0.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14], k = -33\n<strong>Output:</strong> 4\n<strong>Explanation:</strong> One optimal approach is to change nums[2] to k. The array becomes [22,4,<u><strong>-33</strong></u>,-20,-15,15,-16,7,19,-10,0,-13,-14].\nThere are four ways to partition the array.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>n == nums.length</code></li>\n\t<li><code>2 <= n <= 10<sup>5</sup></code></li>\n\t<li><code>-10<sup>5</sup> <= k, nums[i] <= 10<sup>5</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":34.52540747842761,"string":"34.525407"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","counting","enumeration","prefix-sum"],"string":"[\n \"array\",\n \"hash-table\",\n \"counting\",\n \"enumeration\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1614\", 0.8955], [\"1676\", 0.2985], [\"1738\", 1.791], [\"1800\", 4.178999999999999], [\"1862\", 11.940000000000003], [\"1925\", 10.745999999999999], [\"1987\", 16.119], [\"2049\", 7.462499999999998], [\"2111\", 15.223500000000003], [\"2173\", 11.044500000000001], [\"2236\", 2.9849999999999994], [\"2298\", 3.283499999999999], [\"2360\", 2.0895], [\"2422\", 2.9849999999999994], [\"2484\", 1.791], [\"2547\", 0.2985], [\"2609\", 0.2985], [\"2671\", 0.2985], [\"2733\", 0.2985], [\"2795\", 0.2985], [\"2858\", 0.2985], [\"2920\", 0.2985]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"30838\", 6.2685], [\"31314\", 0.2985], [\"31790\", 0.2985], [\"32266\", 0.2985], [\"32743\", 0.2985], [\"33219\", 0.8955], [\"33695\", 0.597], [\"34171\", 0.8955], [\"34648\", 0.2985], [\"35124\", 0.597], [\"35600\", 0.2985], [\"36076\", 0.2985], [\"36553\", 0.8955], [\"37029\", 7.1642], [\"37505\", 4.7761], [\"37981\", 0.2985], [\"38458\", 0.2985], [\"38934\", 1.194], [\"39410\", 0.597], [\"39886\", 0.2985], [\"40363\", 0.597], [\"40839\", 2.3881], [\"41315\", 4.1791], [\"41791\", 2.9851], [\"42268\", 7.4627], [\"42744\", 1.791], [\"43220\", 3.582], [\"43696\", 2.388], [\"44173\", 1.194], [\"44649\", 1.4925], [\"45125\", 2.6864999999999997], [\"45601\", 0.8955], [\"46078\", 0.597], [\"46554\", 0.597], [\"47030\", 1.4925], [\"47506\", 1.4925], [\"47983\", 1.4925], [\"48459\", 4.1791], [\"48935\", 0.597], [\"49411\", 4.4775], [\"49888\", 4.776], [\"50364\", 1.791], [\"50840\", 0.597], [\"51316\", 2.388], [\"51793\", 2.6864999999999997], [\"52269\", 1.791], [\"52745\", 0.2985], [\"53221\", 0.2985], [\"53698\", 0.597], [\"54174\", 0.2985], [\"54650\", 0.2985], [\"55126\", 1.791], [\"55603\", 0.597], [\"56079\", 0.8955], [\"56555\", 0.2985], [\"57031\", 0.2985], [\"57508\", 0.597], [\"57984\", 0.2985], [\"58460\", 0.2985], [\"58936\", 0.2985], [\"59413\", 0.2985]]}"},"rt_list":{"kind":"list like","value":[{"code":"import bisect\nimport collections\nfrom typing import List, Tuple, Mapping\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n diffsIfReplacedWithK = [k - num for num in nums]\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\n for i in range(len(diffsIfReplacedWithK)):\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\n\n leftHalf = 0\n rightHalf = sum(nums)\n pivot = 0\n diffsToPivots = collections.defaultdict[int, list[int]](list)\n for num in nums[:-1]:\n pivot += 1\n leftHalf += num\n rightHalf -= num\n diffsToPivots[leftHalf - rightHalf].append(pivot)\n\n\n outerWays = len(diffsToPivots[0]) # this is no replacement\n\n for diff, replacedIndices in diffsToReplaceIndices.items():\n if diff == 0:\n continue\n pivots1 = diffsToPivots.get(diff)\n pivots2 = diffsToPivots.get(-diff)\n if (not pivots1 and not pivots2):\n continue\n\n # Let's say diff is > 0\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\n # We want to find a number to be replaced whose location is after the pivot,\n # i.e. pivot1 <= replacedIndex.\n # Or, we can find one whose location is before the pivots2 (but with -diff),\n # i.e. pivot2 > replaceIndex.\n\n for replacedIndex in replacedIndices:\n ways = 0\n if pivots1:\n loc = bisect.bisect_right(pivots1, replacedIndex)\n ways += loc\n if pivots2:\n loc = bisect.bisect_right(pivots2, replacedIndex)\n ways += len(pivots2) - loc\n outerWays = max(outerWays, ways)\n\n return outerWays","runtime":"1614"},{"code":"'''class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n before = {k:0}; after = {}; counter = Counter(nums)\n p = list(accumulate(nums))\n n = len(nums)\n for i, num in enumerate(nums[:n-1]):\n before[num] = max(before.get(num, 0), after.get(num, 0))\n counter[nums[i]] -= 1\n if counter[nums[i]] == 0: del counter[nums[i]]\n \n diff = 2 * p[i] - p[-1]\n if (k + diff) in before: before[k + diff] += 1\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\n return max(max([0] + list(before.values())), max([0] + list(after.values())))'''\n\nimport bisect\nimport collections\nfrom typing import List, Tuple, Mapping\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n diffsIfReplacedWithK = [k - num for num in nums]\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\n for i in range(len(diffsIfReplacedWithK)):\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\n\n leftHalf = 0\n rightHalf = sum(nums)\n pivot = 0\n diffsToPivots = collections.defaultdict[int, list[int]](list)\n for num in nums[:-1]:\n pivot += 1\n leftHalf += num\n rightHalf -= num\n diffsToPivots[leftHalf - rightHalf].append(pivot)\n\n\n outerWays = len(diffsToPivots[0]) # this is no replacement\n\n for diff, replacedIndices in diffsToReplaceIndices.items():\n if diff == 0:\n continue\n pivots1 = diffsToPivots.get(diff)\n pivots2 = diffsToPivots.get(-diff)\n if (not pivots1 and not pivots2):\n continue\n\n # Let's say diff is > 0\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\n # We want to find a number to be replaced whose location is after the pivot,\n # i.e. pivot1 <= replacedIndex.\n # Or, we can find one whose location is before the pivots2 (but with -diff),\n # i.e. pivot2 > replaceIndex.\n\n for replacedIndex in replacedIndices:\n ways = 0\n if pivots1:\n loc = bisect.bisect_right(pivots1, replacedIndex)\n ways += loc\n if pivots2:\n loc = bisect.bisect_right(pivots2, replacedIndex)\n ways += len(pivots2) - loc\n outerWays = max(outerWays, ways)\n\n return outerWays","runtime":"1614"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n sz = len(nums)\n ps = list(accumulate(nums))\n m = defaultdict(list)\n for i in range(sz):\n m[ps[i]].append(i)\n \n ans = 0\n # no change\n if ps[-1] % 2 == 0:\n target = ps[-1] // 2\n if target in m:\n ans = len(m[target])\n if ps[-1] == target:\n ans -= 1\n \n # change #i\n for i in range(sz):\n if (ps[-1] - nums[i] + k) % 2 == 0:\n new_sum = ps[-1] - nums[i] + k \n diff = -nums[i] + k\n target = new_sum // 2\n le, ri = target, target - diff\n cur = 0\n if le in m:\n l = m[le]\n idx = bisect.bisect_left(l, i)\n cur += idx\n if ri in m:\n l = m[ri]\n cur += len(l) - bisect.bisect_left(l, i)\n if l[-1] == sz - 1:\n cur -= 1\n ans = max(ans, cur)\n return ans\n\n\n","runtime":"1676"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left, right = 0, sum(nums)\n d = defaultdict(list)\n prev = nums[0]\n n = len(nums)\n ans = 0\n\n for i in range(1, n):\n left += prev\n right -= prev\n \n if left == right:\n ans+=1\n\n d[right - left].append(i)\n prev = nums[i]\n\n for i in range(n):\n diff = k-nums[i]\n l = r = 0\n if diff in d:\n r = len(d[diff]) - bisect_left(d[diff], i+1)\n\n if d[-diff] and d[-diff][0] <= i:\n l = bisect_right(d[-diff], i)\n\n ans = max(ans, l+r)\n\n return ans ","runtime":"1738"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n res = 0\n\n curSum = 0\n prefix = []\n for num in nums:\n prefix.append(curSum + num)\n curSum = prefix[-1]\n \n # first check if not change k\n counts = Counter(prefix)\n if prefix[-1]%2 == 0:\n res = counts[prefix[-1]//2]\n if prefix[-1] == 0:\n res -= 1\n\n # check change every k\n cur = defaultdict(int)\n for i,num in enumerate(nums):\n diff = k-num\n last = prefix[-1]+diff\n if last%2 == 0:\n leftTarget, rightTarget = last//2, last//2-diff\n curWays = cur[leftTarget] + (counts[rightTarget]-cur[rightTarget])\n if last == 0:\n curWays -= 1\n res = max(res, curWays)\n cur[prefix[i]] += 1\n\n return res\n","runtime":"1738"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefixes = []\n res = 0\n tot_sum = 0\n for n in nums:\n tot_sum += n\n prefixes.append(tot_sum)\n \n preds = defaultdict(int)\n posts = defaultdict(int)\n\n for p in prefixes:\n posts[p] += 1\n posts[tot_sum] -= 1\n\n if tot_sum % 2 == 0:\n target = tot_sum // 2\n for p in posts:\n if p == target:\n res += posts[target]\n\n for i in range(len(nums)):\n change = k - nums[i]\n new_sum = tot_sum + change\n if k != nums[i] and new_sum % 2 == 0:\n cur = 0\n new_target = new_sum // 2\n if i >= 1:\n cur += preds[new_target]\n \n if i <= len(nums)-2:\n cur += posts[new_target - change]\n res = max(res, cur)\n preds[prefixes[i]] += 1\n posts[prefixes[i]] -= 1\n return res\n\n\n\n \n","runtime":"1800"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n s = [nums[0]] * n\n right = defaultdict(int)\n for i in range(1, n):\n s[i] = s[i - 1] + nums[i]\n right[s[i - 1]] += 1\n\n ans = 0\n if s[-1] % 2 == 0:\n ans = right[s[-1] // 2]\n\n left = defaultdict(int)\n for v, x in zip(s, nums):\n d = k - x\n if (s[-1] + d) % 2 == 0:\n t = left[(s[-1] + d) // 2] + right[(s[-1] - d) // 2]\n if ans < t:\n ans = t\n left[v] += 1\n right[v] -= 1\n return ans","runtime":"1800"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n targ = sum(nums)\n noneans = 0\n ans = [0]*len(nums)\n lsums,rsums = {nums[0]*2-targ:1},{nums[-1]*2-targ:1}\n prefix = [nums[0]]\n for i in range(1,len(nums)):\n if prefix[-1]*2==targ: noneans += 1\n prefix.append(prefix[-1]+nums[i])\n for i in range(1,len(nums)):\n if k-nums[i] in lsums: ans[i] += lsums[k-nums[i]]\n lsums[prefix[i]*2-targ] = lsums.get(prefix[i]*2-targ,0)+1\n for i in range(len(prefix)-2,-1,-1):\n if k-nums[i] in rsums: ans[i] += rsums[k-nums[i]]\n rsums[targ-prefix[i-1]*2] = rsums.get(targ-prefix[i-1]*2,0)+1\n return max(max(ans),noneans)","runtime":"1862"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n l,r = 0, sum(nums)\n ans = 0\n diff = defaultdict(list)\n n = len(nums)\n prev = nums[0]\n for i in range(1,n):\n l+= prev\n r-=prev\n if l==r:\n ans+=1\n diff[r-l].append(i)\n prev = nums[i]\n print(diff)\n for i in range(n):\n c =nums[i]\n delta = k-nums[i]\n if delta == 0:\n continue\n left = right = 0\n if delta in diff:\n right = len(diff[delta])- bisect_left(diff[delta], i+1)\n if diff[-delta] and diff[-delta][0] <= i:\n left = bisect_right(diff[-delta],i)\n ans = max(ans, left+right)\n return ans\n\n","runtime":"1862"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n s = sum(nums)\n r_diffs = defaultdict(int)\n l_diffs = defaultdict(int)\n left = 0\n for i in range(len(nums) - 1):\n x = nums[i]\n left += x\n right = s - left\n r_diffs[left - right] += 1\n \n ans = r_diffs[0]\n left = 0\n for x in nums:\n left += x\n right = s - left\n d = k - x\n ans = max(ans, l_diffs[d] + r_diffs[-d])\n l_diffs[left - right] += 1\n r_diffs[left - right] -= 1\n return ans\n","runtime":"1925"},{"code":"from collections import defaultdict\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n pre_sums = []\n curr_sum = 0\n for num in nums:\n curr_sum += num\n pre_sums.append(curr_sum)\n\n dict_left = defaultdict(int)\n dict_right = defaultdict(int)\n\n for s in pre_sums[:-1]:\n dict_right[s] += 1\n\n nums_sum = sum(nums)\n half = sum(nums) / 2\n ans = dict_right.get(half, 0)\n\n for i in range(len(nums)):\n new_sum = (nums_sum + k - nums[i])\n if new_sum % 2 == 0:\n new_half = new_sum / 2\n new_ans = dict_left.get(new_half, 0) + dict_right.get(new_sum/2+nums[i]-k, 0)\n ans = max(ans, new_ans)\n\n dict_left[pre_sums[i]] += 1\n dict_right[pre_sums[i]] -= 1\n\n return ans\n ","runtime":"1925"},{"code":"class Solution:\n def waysToPartition(self, A: List[int], k: int) -> int:\n n = len(A) \n pre, s = list(itertools.accumulate(A)), sum(A)\n \n # pred contains all the presum BEFORE i-th number.\n # sufd contains all the presum AFTER and WITH i-th number.\n pred = collections.defaultdict(int)\n sufd = collections.Counter(pre)\n \n # The last prefix sum is NEVER used. \n sufd[sum(A)] -= 1\n \n # The number of ways if we do not change any number.\n ans = 0\n if s % 2 == 0:\n ans = sufd[s // 2]\n\n # The number of ways if we split i-th number to k.\n for i in range(n):\n cur = 0\n \n # We only count number of ways when A[i] != k (otherwise change makes no difference)\n # and when the SUM after the change is dividable by 2.\n if A[i] != k:\n news = s + k - A[i]\n if news % 2 == 0:\n \n # If i == 0, only count suffix part.\n if i > 0:\n cur += pred[news // 2]\n \n # If i == n - 1, only count prefix part.\n if i < n - 1:\n cur += sufd[news // 2 + A[i] - k]\n ans = max(ans, cur)\n \n # Don't forget to change the values in the two counters.\n sufd[pre[i]] -= 1\n pred[pre[i]] += 1\n \n return ans ","runtime":"1987"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = list(itertools.accumulate(nums))\n nums_sum = sum(nums)\n pre = defaultdict(int)\n post = collections.Counter(prefix_sum)\n\n post[nums_sum] -= 1\n\n output = 0\n if nums_sum % 2 == 0:\n output = post[nums_sum//2]\n \n for i, num in enumerate(nums):\n curr = 0\n if num != k:\n new_sum = nums_sum + k - num\n if new_sum % 2 == 0:\n if i>0:\n curr += pre[new_sum//2]\n if i<n-1:\n curr += post[new_sum//2+num-k] # prefix_sum + k-num == new_sum//2\n output = max(output, curr)\n pre[prefix_sum[i]] += 1\n post[prefix_sum[i]] -= 1\n return output","runtime":"1987"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n if len(nums) == 0:\n return 0\n\n prefix_sum = nums[0]\n prefix_sum_counts = defaultdict(int)\n prefix_sum_counts[prefix_sum] += 1\n\n max_ways_to_partition = 0\n arr_sum = sum(nums)\n\n for num in nums[1:]:\n if prefix_sum == arr_sum - prefix_sum:\n max_ways_to_partition += 1\n\n prefix_sum += num\n prefix_sum_counts[prefix_sum] += 1\n\n # to handle the condition that pivot can at most be n - 1.\n prefix_sum_counts[prefix_sum] -= 1\n\n prefix_sum = nums[0]\n left_ps = defaultdict(int)\n\n right_ps = prefix_sum_counts\n\n if (arr_sum - k + nums[0]) % 2 == 0:\n max_ways_to_partition = max(\n max_ways_to_partition, right_ps[(arr_sum - k + nums[0]) // 2]\n )\n\n left_ps[prefix_sum] += 1\n right_ps[prefix_sum] -= 1\n\n for idx, num in enumerate(nums[1:], 1):\n ways_to_partition = 0\n if (arr_sum + k - num) % 2 == 0:\n ways_to_partition += left_ps[(arr_sum + k - num) // 2]\n\n if (arr_sum - k + num) % 2 == 0:\n ways_to_partition += right_ps[(arr_sum - k + num) // 2]\n\n prefix_sum += num\n left_ps[prefix_sum] += 1\n right_ps[prefix_sum] -= 1\n\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\n\n return max_ways_to_partition\n","runtime":"2049"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left, right = defaultdict(int), defaultdict(int)\n n = len(nums)\n prefixSum, suffixSum = [0] * n, [0] * n\n prefixSum[0] = nums[0]\n suffixSum[-1] = nums[-1]\n for i in range(1,n):\n prefixSum[i] = nums[i] + prefixSum[i-1]\n for i in range(n-2, -1, -1):\n suffixSum[i] = nums[i] + suffixSum[i+1]\n for i in range(n-1):\n right[prefixSum[i] - suffixSum[i+1]] += 1\n ans = right[0]\n for i in range(n):\n # change the element at i to k\n diff = k - nums[i]\n cur = left[diff] + right[-diff]\n ans = max(cur, ans)\n if i < n - 1:\n curdiff = prefixSum[i] - suffixSum[i+1]\n left[curdiff] += 1\n right[curdiff] -= 1\n return ans\n","runtime":"2049"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n def add_num(db, num):\n if num in db:\n db[num] += 1\n else:\n db[num] = 1\n\n def remove_num(db, num):\n db[num] -= 1\n if db[num]==0:\n del db[num]\n \n n = len(nums)\n pr_sum = [0]*n\n tmp = 0\n for i in range(n):\n tmp += nums[i]\n pr_sum[i] = tmp\n\n sf_sum = [0]*n\n tmp = 0 \n for i in range(n-1, -1, -1):\n tmp += nums[i]\n sf_sum[i] = tmp\n\n pr_db = {}\n sf_db = {}\n for i in range(n-1):\n add_num(pr_db, pr_sum[i])\n ret = 0\n total = sum(nums)\n mid = total//2\n if total%2==0 and mid in pr_db:\n ret = pr_db[mid]\n for i in range(n):\n new_total = total+nums[i]-k\n mid = new_total//2\n if new_total%2==0:\n cnt = 0\n if mid in pr_db:\n cnt += pr_db[mid]\n if mid in sf_db:\n cnt += sf_db[mid]\n ret = max(ret, cnt)\n if i!=n-1:\n remove_num(pr_db, pr_sum[i])\n add_num(sf_db, sf_sum[i+1])\n \n return ret \n\n \n\n\n \n ","runtime":"2111"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # Prefix and suffix sum\n # Move i from left to right, attempt to change this number to k\n # Left diff: the diff from prefix[i] to suffix[i + 1] that is on the left of current index\n # Right diff: the diff from prefix[i] to suffix[i + 1] that is on the right of current index\n # change diff: change = k - nums[i], this will cause the left diffs to go down by `change`, which may result in 0 diff between left and right.\n # and right diffs to go up by `change`\n # Count left_diff[change] + right_diff[-change], and the current count of diff[0]\n\n n = len(nums)\n prefix = [0] * n\n prefix[0] = nums[0]\n suffix = [0] * n\n suffix[-1] = nums[-1]\n for i in range(1, n):\n prefix[i] = prefix[i - 1] + nums[i]\n suffix[n - 1 - i] = suffix[n - i] + nums[n - 1 - i]\n\n right_diff = defaultdict(int)\n for i in range(n - 1):\n diff = prefix[i] - suffix[i + 1]\n right_diff[diff] += 1\n \n max_count = right_diff[0]\n left_diff = defaultdict(int)\n for i in range(n):\n if i > 0:\n diff = prefix[i - 1] - suffix[i]\n right_diff[diff] -= 1\n left_diff[diff] += 1\n change = k - nums[i]\n max_count = max(max_count, left_diff[change] + right_diff[-change])\n\n return max_count","runtime":"2111"},{"code":"#from itertools import accumulate # Correct import for accumulate\nfrom bisect import bisect\nfrom collections import defaultdict\n\nclass Solution:\n def waysToPartition(self, nums, k):\n n = len(nums)\n \n # Calculate prefix sums\n acc1 = list(accumulate(nums))\n d1 = defaultdict(list)\n for idx, num in enumerate(acc1):\n d1[num].append(idx)\n \n # Calculate suffix sums\n acc2 = list(accumulate(nums[::-1]))\n d2 = defaultdict(list)\n for idx, num in enumerate(acc2):\n d2[num].append(idx)\n \n ans, ans2 = 0, 0\n \n # Count original valid partitions (ans2)\n for i in range(n - 1):\n if acc1[-1] == 2 * acc1[i]: \n ans2 += 1\n \n # Evaluate maximum partitions possible after modifying one element\n for i in range(0, n):\n cand = (acc1[-1] - nums[i] + k) / 2\n \n # Using bisect to find number of valid partition points\n lft = bisect(d1[cand], i - 1)\n rgh = bisect(d2[cand], n - i - 2)\n \n # Update the maximum number of valid partitions\n ans = max(ans, lft + rgh)\n \n return max(ans, ans2)\n","runtime":"2173"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = list(accumulate(nums))\n total_sum = prefix_sums[-1]\n best = 0\n if total_sum % 2 == 0:\n best = prefix_sums[:-1].count(total_sum // 2) # If no change\n\n after_counts = Counter(\n [total_sum - (2 * prefix_sum) for prefix_sum in prefix_sums[:-1]]\n )\n before_counts = Counter()\n\n best = max(best, after_counts[k - nums[0]]) # If we change first num\n\n for prefix, x in zip(prefix_sums, nums[1:]):\n gap = total_sum - 2 * prefix\n after_counts[gap] -= 1\n before_counts[gap] += 1\n\n best = max(best, after_counts[k - x] + before_counts[x - k])\n\n return best","runtime":"2173"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sl, sr = 0, sum(nums)\n for i in range(N - 1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n diffs.append(math.inf) # to prevent error in the counter arithemtic\n \n cl, cr = Counter(), Counter(diffs)\n res = cl[0] + cr[0]\n for i in range(N):\n d = k - nums[i]\n res = max(res, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n return res","runtime":"2236"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \"\"\"This is a good problem. It's not difficult, but is quite complex.\n\n The idea is that once we change a position at i, for all the pivots at\n 1...i, the sum of the left half stay the same whereas the sum of\n the right half changes by delta = k - nums[i]. Similarly, for all the\n pivots at i + 1...n - 1, the left half changes by delta, whereas the\n right half stay the same.\n\n We can pre-compute all the differences at each pivot position and make\n that into a diffs = [d1, d2, .... , dn-1]\n\n Then after a change at i, if we want the pivots at 1...i to form a good\n partition, we must have left - (right + delta) = 0 => delta = left - right\n In other words, the number of good partitions is the count of d1, d2, ...\n di that are equal to delta. Similarly, if we want the pivots at i + 1...\n n - 1 to form a good partition, we must have left + delta - right = 0\n => left - right = -delta. In other words, the number of good partitions\n is the count of di+1, ...., dn-1 that are equal to -delta.\n\n Based on this, we progressively build a left sum and right sum to\n compute the diffs array. And then progressively build a left counter\n and right counter to compute the number of matches to delta and -delta.\n\n The difficulty is in the implementation, especially with the indices.\n\n O(N), 7339 ms, faster than 32.20%\n \"\"\"\n N = len(nums)\n diffs = []\n sl, sr = 0, sum(nums)\n for i in range(N - 1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n diffs.append(math.inf) # to prevent error in the counter arithemtic\n \n cl, cr = Counter(), Counter(diffs)\n print(cr)\n res = cl[0] + cr[0]\n for i in range(N):\n d = k - nums[i]\n res = max(res, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n return res\n\n \n # n = len(nums)\n # pre, s = list(itertools.accumulate(nums)), sum(nums)\n \n # # pred contains all the presum BEFORE i-th number.\n # # sufd contains all the presum AFTER and WITH i-th number.\n # pred = collections.defaultdict(int)\n # sufd = collections.Counter(pre)\n \n # # The last prefix sum is NEVER used. \n # sufd[sum(nums)] -= 1\n \n # # The number of ways if we do not change any number.\n # ans = 0\n # if s % 2 == 0:\n # ans = sufd[s // 2]\n\n # # The number of ways if we split i-th number to k.\n # for i in range(n):\n # cur = 0\n \n # # We only count number of ways when A[i] != k (otherwise change makes no difference)\n # # and when the SUM after the change is dividable by 2.\n # if nums[i] != k:\n # news = s + k - nums[i]\n # if news % 2 == 0:\n \n # # If i == 0, only count suffix part.\n # if i > 0:\n # cur += pred[news // 2]\n \n # # If i == n - 1, only count prefix part.\n # if i < n - 1:\n # cur += sufd[news // 2 + nums[i] - k]\n # ans = max(ans, cur)\n \n # # Don't forget to change the values in the two counters.\n # sufd[pre[i]] -= 1\n # pred[pre[i]] += 1\n \n # return ans\n\n \n \n # def summarize(nums):\n # s = [nums[0]]\n # for num in nums[1:]:\n # s.append(s[-1]+num)\n # return s\n\n # prefix = summarize(nums)\n # suffix = summarize(nums[::-1])[::-1]\n # print(prefix)\n # print(suffix)\n \n # n = len(nums)\n # dic = collections.defaultdict(list)\n # for i in range(1, n):\n # dic[suffix[i]-prefix[i-1]].append(i)\n # sort = sorted(list(dic.items()), key=lambda x: len(x[1]), reverse=True)\n # print(sort)\n # res = len(dic[0])\n \n # num_diff = {}\n # for i, num in enumerate(nums):\n # if k-num not in num_diff:\n # num_diff[k-num] = i\n # print(num_diff)\n \n # for diff, idices in sort:\n # if len(idices) <= res:\n # break\n # if diff not in num_diff:\n # continue\n # idx = bisect.bisect_left(idices, num_diff[diff])\n # res = max(res, len(idices)-idx)\n # return res","runtime":"2236"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left_sum = list(accumulate(nums))\n right_sum = list(accumulate(nums[::-1]))[::-1]\n possible_left_deltas = defaultdict(lambda: 0)\n possible_right_deltas = defaultdict(lambda: 0)\n pivot_count_per_left_delta = defaultdict(lambda: 0)\n pivot_count_per_right_delta = defaultdict(lambda: 0)\n # can only change one SINGLE element\n counts = 0\n for i, n in enumerate(nums):\n possible_right_deltas[n - k] += 1\n if i > 0 and left_sum[i-1] == right_sum[i]:\n counts += 1\n for i, n in enumerate(nums):\n if i > 0 and possible_left_deltas[left_sum[i-1] - right_sum[i]] > 0:\n pivot_count_per_left_delta[left_sum[i-1] - right_sum[i]] += 1\n if i > 0 and possible_right_deltas[right_sum[i] - left_sum[i-1]] > 0:\n pivot_count_per_right_delta[right_sum[i] - left_sum[i-1]] += 1\n pivot_count_per_left_delta[n - k] = max(pivot_count_per_left_delta[n - k], pivot_count_per_right_delta[n - k])\n possible_left_deltas[n - k] += 1\n possible_right_deltas[n - k] -= 1\n return max([counts] + list(pivot_count_per_left_delta.values()) + list(pivot_count_per_right_delta.values()))","runtime":"2298"},{"code":"class Solution:\n def waysToPartition(self, nums: list[int], k: int) -> int:\n n = len(nums)\n summ = sum(nums)\n prefix = 0\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [0..i)\n l = collections.Counter()\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [i..n)\n r = collections.Counter()\n\n for pivot in range(1, n):\n prefix += nums[pivot - 1]\n suffix = summ - prefix\n r[prefix - suffix] += 1\n\n ans = r[0]\n prefix = 0\n\n for num in nums:\n ans = max(ans, l[k - num] + r[num - k])\n prefix += num\n suffix = summ - prefix\n diff = prefix - suffix\n r[diff] -= 1\n l[diff] += 1\n\n return ans","runtime":"2298"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n preSum = [0] * (n + 1)\n for i in range(n):\n preSum[i + 1] = preSum[i] + nums[i]\n totalSum = preSum[n]\n\n balances = []\n for pivot in range(1, n):\n bal = 2 * preSum[pivot] - totalSum\n balances.append(bal)\n\n from collections import Counter\n counts_bal = Counter(balances)\n\n left_counts = Counter()\n right_counts = counts_bal.copy()\n max_counts = counts_bal[0] # counts of valid pivots in original array\n\n for i in range(n):\n diff = k - nums[i]\n counts_left = left_counts.get(diff, 0)\n counts_right = right_counts.get(-diff, 0)\n total_counts = counts_left + counts_right\n max_counts = max(max_counts, total_counts)\n if i < n - 1:\n bal = balances[i]\n left_counts[bal] += 1\n right_counts[bal] -= 1\n if right_counts[bal] == 0:\n del right_counts[bal]\n return max_counts\n","runtime":"2360"},{"code":"from itertools import accumulate\nfrom collections import Counter\nfrom typing import List\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # Step 1: Compute prefix sums\n prefix_sums = list(accumulate(nums))\n print(prefix_sums)\n prefix_sums = [0] * (len(nums) + 1)\n\n for i in range(len(nums)):\n prefix_sums[i + 1] = prefix_sums[i] + nums[i] \n\n print(prefix_sums)\n \n # Step 2: Initialize counters\n left_counter = Counter()\n right_counter = Counter(prefix_sums[1:][:-1])\n # print(prefix_sums)\n # print(f\"{prefix_sums[:-1]=}\")\n # print(right_counter)\n \n # Step 3: Calculate initial valid partitions\n total_sum = prefix_sums[-1]\n max_partitions = right_counter[total_sum / 2]\n \n # Step 4: Iterate through the array to consider each possible change\n for i, current_prefix_sum in enumerate(prefix_sums[1:]):\n change = k - nums[i]\n \n # Check potential partitions if nums[i] is changed to k\n target_left = (total_sum + change) / 2\n target_right = (total_sum - change) / 2\n \n # Calculate the number of valid partitions with this change\n current_partitions = left_counter[target_left] + right_counter[target_right]\n max_partitions = max(max_partitions, current_partitions)\n \n # Update counters for the next iteration\n left_counter[current_prefix_sum] += 1\n right_counter[current_prefix_sum] -= 1\n \n return max_partitions\n","runtime":"2360"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefixSum = list(accumulate(nums))\n leftCount = Counter()\n rightCount = Counter()\n\n ans = 0\n\n n = len(nums)\n for i in range(1, n):\n diff = prefixSum[i-1] - (prefixSum[-1] - prefixSum[i-1])\n rightCount[diff] += 1\n\n ans = rightCount[0]\n for i in range(n):\n d = k - nums[i]\n ans = max(ans, leftCount[d] + rightCount[-d])\n if i < n - 1:\n origDiff = prefixSum[i] - (prefixSum[-1] - prefixSum[i])\n leftCount[origDiff] += 1\n rightCount[origDiff] -= 1\n\n return ans\n \n\n","runtime":"2422"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n pass\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sum_all = sum(nums)\n\n # calculate prefix sum\n prefix_sum = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sum.append(accum)\n \n prefix_counter = collections.defaultdict(int)\n suffix_counter = collections.Counter(prefix_sum)\n suffix_counter[sum_all] -= 1\n\n # count answers without changing k\n ans = 0\n if sum_all % 2 == 0:\n ans = suffix_counter[sum_all//2]\n \n # replace ith num to k\n for i in range(n):\n curr = 0\n\n if nums[i] != k:\n sum_all_new = sum_all + k - nums[i]\n if sum_all_new % 2 == 0:\n if i > 0:\n curr += prefix_counter[sum_all_new // 2]\n \n if i < n-1:\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\n\n ans = max(ans, curr)\n\n suffix_counter[prefix_sum[i]] -= 1\n prefix_counter[prefix_sum[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n counter_left = collections.defaultdict(int)\n \n # without chaning k\n ans = 0\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # change k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n \n counter_left = collections.defaultdict(int)\n counter_right = collections.Counter(prefix_sums)\n counter_right[accum] -= 1\n\n ans = 0\n\n # without replacing k\n if accum % 2 == 0:\n ans += counter_right[accum//2]\n \n # with replacing k\n for i in range(len(nums)):\n # replace nums[i] --> k\n new_sums = accum - nums[i] + k\n curr = 0\n if new_sums % 2 == 0:\n if i > 0:\n curr += counter_left[new_sums//2]\n if i < len(nums)-1:\n curr += counter_right[new_sums//2 - k + nums[i]]\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n ans = max(ans, curr)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.defaultdict(int)\n counter_right[total_sum] -= 1\n\n ans = 0\n\n # case 1. No switch to k\n if total_sum % 2 == 0:\n ans += counter_right[total_sum // 2]\n \n # case 2. Switch to k\n for i in range(len(nums)):\n curr = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\n ans = max(ans, curr)\n\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n return ans\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.Counter()\n counter_right[total_sum] -= 1\n\n cnt = 0\n # without changing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n\n # change nums[i] --> k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_left = collections.Counter()\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n\n cnt = 0\n\n # without replacing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # replace k\n for i in range(len(nums)):\n curr_cnt = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr_cnt += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\n cnt = max(cnt, curr_cnt)\n counter_right[prefix_sums[i]] -= 1\n counter_right[prefix_sums[i]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n prefix_sums = []\n for n in nums:\n accum += n\n prefix_sums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(prefix_sums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n # no switch\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # switch nums[i] --> k\n for i in range(len(nums)):\n total_sums_new = total_sum + k - nums[i]\n cnt_curr = 0\n if total_sums_new % 2 == 0:\n if i > 0:\n cnt_curr += left_counter[total_sums_new//2]\n if i < len(nums)-1:\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\n cnt = max(cnt, cnt_curr)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n counter_right[accum] += 1\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right[total_sum] -= 1\n\n\n ans = 0\n # No replace\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # replace\n for i, num in enumerate(nums):\n total_new = total_sum - num + k\n curr = 0\n if total_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_new // 2 - (k - num)]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans","runtime":"2422"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sl, sr = 0, sum(nums)\n for i in range(N-1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n diffs.append(math.inf)\n\n cl, cr = Counter(), Counter(diffs)\n ans = cr[0]\n\n for i in range(N):\n d = k - nums[i]\n ans = max(ans, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n \n return ans\n\n # sum[i] = sum of 0 to i's number. total = sum[-1]\n # diff[i] = total - 2*sum[i]\n # k_num[i] = k - nums[i]. have that in a set k_n_set\n # collect diff[i] in a hashmap with (diff, count)\n # for elements in k_n_set, check if it's in the hashmap and return max count\n # [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14]\n # sum: [22, 26, 1, -19, -34, -19, -35, -28, -9, -19, -19, -32, -46]\n # [-55, -37, -8, -12, ...]\n # diff: [-8x, -big, -44, -8, xx, -8, xx, xx, -8, -8..]\n #. map[-8] = 4, max. return 4\n\n # def helper(nums, k):\n # sum_i, _sum, k_num = [], 0, set()\n # k_num.add(0)\n # for n in nums:\n # _sum += n\n # sum_i.append(_sum)\n # k_num.add(k - n)\n \n # diff_count = defaultdict(int)\n # for s in sum_i[:-1]:\n # diff = sum_i[-1] - 2 * s\n # diff_count[diff] += 1\n \n # ans = 0\n # for n in k_num:\n # ans = max(diff_count[n] + diff_count[-n], ans)\n \n # print(nums)\n # print(sum_i)\n # print(diff_count)\n # print(k_num)\n \n # return ans\n\n # return helper(nums, k)","runtime":"2484"},{"code":"import collections\nimport itertools\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n cumSum = list(accumulate(nums)) #cumulative sum of the nums array\n rightCnt = Counter() \n leftCnt = Counter()\n\n\n\n for i in range(1,len(nums)):\n left = cumSum[i-1] #exclude the pivot index from the left portion\n right = cumSum[-1] - cumSum[i-1]\n difference = right - left\n\n #use the difference to populate the right count\n rightCnt[difference] += 1\n \n #initialize our answer to be the number of valid partition without changing any values\n totalValid = rightCnt[0]\n\n #update totalValid to account for changing numbers\n for i in range(len(nums)):\n difference = k - nums[i] #change between original value and k\n\n #right - left\n #if k is included in the left, sum of the partitions will decrease by difference\n #if k is included in the right, sum of the partitions will increase by difference\n\n totalValid = max(totalValid, leftCnt[-difference] + rightCnt[difference])\n \n #adjust counters for each side of the partition\n left = cumSum[i] #exclude the pivot index from the left portion\n right = cumSum[-1] - cumSum[i]\n originalDifference = right - left\n \n leftCnt[originalDifference] += 1\n rightCnt[originalDifference] -= 1\n \n return totalValid\n\n\n\n\n\n","runtime":"2484"},{"code":"import itertools\nfrom collections import defaultdict, Counter\nimport math\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = list(itertools.accumulate(nums))\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\n\n def get_max_pivots_v1():\n max_pivots = 0\n for i in range(n):\n pivots = 0\n delta = k - nums[i]\n for j in range(1, n):\n diff = prefix_sum[j - 1] - suffix_sum[j]\n if diff == 0:\n pivots += 1\n continue\n if j <= i:\n if diff == delta:\n pivots += 1\n else:\n if diff == -delta:\n pivots += 1\n max_pivots = max(pivots, max_pivots)\n return max_pivots\n\n def get_max_pivots_v2():\n diffs = []\n for i in range(1, n):\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\n diffs_rev = list(reversed(diffs))\n pre_diffs = Counter()\n post_diffs = Counter(diffs)\n max_pivots = post_diffs[0]\n for i in range(n):\n delta = k - nums[i]\n if diffs_rev and i != 0:\n diff = diffs_rev.pop()\n pre_diffs.update([diff])\n post_diffs.subtract([diff])\n max_pivots = max(max_pivots, pre_diffs[delta] + post_diffs[-delta])\n return max_pivots\n\n return get_max_pivots_v2()\n","runtime":"2547"},{"code":"import itertools\nfrom collections import defaultdict, Counter\nimport math\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = list(itertools.accumulate(nums))\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\n\n def get_max_pivots_v1():\n max_pivots = 0\n for i in range(n):\n pivots = 0\n delta = k - nums[i]\n for j in range(1, n):\n diff = prefix_sum[j - 1] - suffix_sum[j]\n if diff == 0:\n pivots += 1\n continue\n if j <= i:\n if diff == delta:\n pivots += 1\n else:\n if diff == -delta:\n pivots += 1\n max_pivots = max(pivots, max_pivots)\n return max_pivots\n\n def get_max_pivots_v2():\n diffs = []\n for i in range(1, n):\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\n print(diffs)\n diffs_rev = list(reversed(diffs))\n pre_diffs = Counter()\n post_diffs = Counter(diffs)\n max_pivots = post_diffs[0]\n for i in range(n):\n delta = k - nums[i]\n if diffs_rev and i != 0:\n diff = diffs_rev.pop()\n pre_diffs.update([diff])\n post_diffs.subtract([diff])\n max_pivots = max(max_pivots, pre_diffs[delta] + post_diffs[-delta])\n return max_pivots\n\n return get_max_pivots_v2()\n","runtime":"2609"},{"code":"import itertools\nfrom collections import defaultdict, Counter\nimport math\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = list(itertools.accumulate(nums))\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\n\n def get_max_pivots_v1():\n max_pivots = 0\n for i in range(n):\n pivots = 0\n delta = k - nums[i]\n for j in range(1, n):\n diff = prefix_sum[j - 1] - suffix_sum[j]\n if diff == 0:\n pivots += 1\n continue\n if j <= i:\n if diff == delta:\n pivots += 1\n else:\n if diff == -delta:\n pivots += 1\n max_pivots = max(pivots, max_pivots)\n return max_pivots\n\n def get_max_pivots_v2():\n diffs = []\n for i in range(1, n):\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\n print(diffs)\n diffs_rev = list(reversed(diffs))\n pre_diffs = Counter()\n post_diffs = Counter(diffs)\n max_pivots = post_diffs[0]\n for i in range(n):\n delta = k - nums[i]\n if diffs_rev and i != 0:\n diff = diffs_rev.pop()\n pre_diffs.update([diff])\n post_diffs.subtract([diff])\n max_pivots = max(max_pivots, max(pre_diffs[delta], 0) + max(post_diffs[-delta], 0))\n return max_pivots\n\n return get_max_pivots_v2()\n","runtime":"2671"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n total = 0\n aggsum_index_dict = defaultdict(list)\n for i, num in enumerate(nums):\n total += num\n if i < len(nums) - 1:\n aggsum_index_dict[total].append(i)\n\n max_ways = 0\n if total % 2 == 0 and aggsum_index_dict[total // 2]:\n max_ways = len(aggsum_index_dict[total // 2])\n\n for i, num in enumerate(nums):\n changed_total = total + k - num\n if changed_total % 2 == 0:\n valid_left_of_k = len([index for index in aggsum_index_dict[changed_total // 2] if index < i])\n valid_right_of_k = len([index for index in aggsum_index_dict[changed_total // 2 - k + num] if index >= i])\n max_ways = max(max_ways, valid_left_of_k + valid_right_of_k)\n\n return max_ways\n ","runtime":"2733"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n diff_k_num = [k-nums[i] for i in range(n)]\n diff_2_partition_idx = {}\n prefix, suffix = 0, sum(nums)\n max_ways = 0\n\n for i in range(n-1):\n prefix += nums[i]\n suffix -= nums[i]\n diff = prefix - suffix\n max_ways = max_ways + 1 if prefix == suffix else max_ways\n if diff not in diff_2_partition_idx:\n diff_2_partition_idx[diff] = [i+1]\n else:\n diff_2_partition_idx[diff].append(i+1)\n \n for i in range(n):\n diff_k_num_i = diff_k_num[i]\n count = 0\n if -1*diff_k_num_i in diff_2_partition_idx:\n partitions = diff_2_partition_idx[-diff_k_num_i]\n for partition in partitions:\n if i < partition:\n count += 1\n if diff_k_num_i in diff_2_partition_idx:\n partitions = diff_2_partition_idx[diff_k_num_i]\n for partition in partitions:\n if i >= partition:\n count += 1\n max_ways = max(max_ways, count)\n \n return max_ways\n","runtime":"2795"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n leftSum = [0] * len(nums)\n rightSum = [0] * len(nums)\n\n for i in range(1, len(nums)):\n leftSum[i] = leftSum[i-1] + nums[i-1]\n\n rightSum[-1] = nums[-1]\n for i in range(len(nums)-2, -1, -1):\n rightSum[i] = rightSum[i+1] + nums[i]\n\n diffs = defaultdict(list)\n valDict = defaultdict(set)\n for i in range(len(nums)):\n valDict[nums[i]].add(i)\n\n res = 0\n for i in range(1,len(nums)):\n if leftSum[i] == rightSum[i]:\n res += 1\n diffs[rightSum[i]-leftSum[i]].append(i)\n #print(diffs)\n #print(valDict)\n for i in range(len(nums)):\n tmp = 0\n newDiff = k - nums[i]\n #print(newDiff)\n\n for ind in diffs[newDiff]:\n if ind > i:\n tmp += 1\n for ind in diffs[-newDiff]:\n if ind <= i:\n tmp += 1\n res = max(res, tmp)\n\n return res\n \n","runtime":"2858"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # there are n-1 possible pivot points\n n = len(nums)\n\n # given each pivot, there will be a left sum and right sum\n # - we also have the option to change one element in left or right sum to k\n # - suppose we have left_sum[i], right_sum[i]. and diff[i] = k - nums[i],\n # then diff[i] is the delta we need to add to left_sum or right_sum if we were to\n # swap nums[i] with k.\n # - for each k swap, we should count the total number of pivots that satisfy it.\n\n diffs = []\n diff_to_k = defaultdict(list) # we want to look up diff value -> set(index) as well for faster lookup\n for i, num in enumerate(nums):\n diffs.append(k - num)\n diff_to_k[k-num].append(i)\n\n # sort indices\n for diff, ks in diff_to_k.items():\n diff_to_k[diff] = SortedList(ks)\n\n # diff_count_per_diff\n\n def get_prefix_sum(nums):\n left_sums = []\n for i, num in enumerate(nums):\n if len(left_sums) == 0:\n left_sums.append(num)\n else:\n left_sums.append(num + left_sums[-1])\n return left_sums\n\n left_sum = get_prefix_sum(nums)\n right_sum = get_prefix_sum(nums[::-1])[::-1]\n\n # # iterate through each possible pivot point\n # partitions_per_k = defaultdict(lambda: 0) # reserve 0 as the key for when we don't make changes in nums\n\n # num_zero_diffs = 0\n # for diff in diffs:\n # if diff == 0:\n # num_zero_diffs += 1\n\n # # O(n ^ 2) -> this can be made faster?\n # for pivot in range(1, n):\n # if left_sum[pivot-1] == right_sum[pivot]:\n # partitions_per_k[0] += 1\n\n # # check if there is diffs == 0 -- but we can only add this once\n # # partitions_per_k[0] += num_zero_diffs\n # else:\n # diff = left_sum[pivot-1] - right_sum[pivot]\n\n # # left sum\n # candidates_k = diff_to_k[-diff]\n # if len(candidates_k) > 0:\n # # left_end = candidates_k.bisect_right(pivot-1)\n # # for k in range(candidates_k[candidates_k.bisect_right(pivot-1)]):\n # for k in candidates_k: # this is sorted\n # if k <= pivot-1:\n # partitions_per_k[k] += 1\n # else:\n # break # we are done\n\n # # right sum\n # candidates_k = diff_to_k[diff]\n # if len(candidates_k) > 0:\n # # iterate from right to left and break when we are \n # for k in list(range(1, len(nums)))[::-1]:\n # if k >= pivot:\n # partitions_per_k[k] += 1\n # else: # we are done\n # break \n\n # might be faster: iterate through k itself - ie what happens if we swap nums[k]?\n # if nums[i] is swapped, the new total sum is target = (sum(nums) - (k - nums[i])))/2.\n # - suppose with swap nums[i] for k, then we have a new target\n # - in lookup table, we can check which left_nums and right_nums indices == target.\n # these indices should be sorted.\n # - given the indices, and i, we can then deduce how many possible pivots there are\n # that are valid partitions.\n left_table = defaultdict(list)\n right_table = defaultdict(list)\n\n for i, left_s in enumerate(left_sum):\n left_table[left_s].append(i)\n for key, vals in left_table.items():\n left_table[key] = sorted(vals)\n \n for i, right_s in enumerate(right_sum):\n right_table[right_s].append(i)\n for key, vals in right_table.items():\n right_table[key] = sorted(vals)\n\n # let us change nums[i] -> k\n tot_sum = sum(nums)\n\n max_matches = 0\n for i, num in enumerate(nums):\n num_matches = 0\n\n target = (tot_sum - num + k) / 2\n\n # suppose nums[i] -> k is changed, we can count left_sums that are == target\n # - in this case left_index < i\n if target in left_table.keys():\n left_indices = left_table[target]\n for index in left_indices:\n if index < i:\n num_matches +=1\n else:\n break # we are done\n \n # similarly, let's count the right_sums that are == target\n # - in this case right_index > i\n if target in right_table.keys():\n right_indices = right_table[target]\n for index in right_indices:\n if index > i:\n num_matches += 1\n\n max_matches = max(max_matches, num_matches)\n\n # now assume we don't change any number to k\n target = tot_sum / 2\n matches = left_table[target] # can include all excpet last element\n if len(matches) > 0 and matches[-1] == len(nums)-1:\n num_matches = len(matches)-1\n else:\n num_matches = len(matches)\n max_matches = max(max_matches, num_matches)\n\n return max_matches\n","runtime":"2920"}],"string":"[\n {\n \"code\": \"import bisect\\nimport collections\\nfrom typing import List, Tuple, Mapping\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n diffsIfReplacedWithK = [k - num for num in nums]\\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\\n for i in range(len(diffsIfReplacedWithK)):\\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\\n\\n leftHalf = 0\\n rightHalf = sum(nums)\\n pivot = 0\\n diffsToPivots = collections.defaultdict[int, list[int]](list)\\n for num in nums[:-1]:\\n pivot += 1\\n leftHalf += num\\n rightHalf -= num\\n diffsToPivots[leftHalf - rightHalf].append(pivot)\\n\\n\\n outerWays = len(diffsToPivots[0]) # this is no replacement\\n\\n for diff, replacedIndices in diffsToReplaceIndices.items():\\n if diff == 0:\\n continue\\n pivots1 = diffsToPivots.get(diff)\\n pivots2 = diffsToPivots.get(-diff)\\n if (not pivots1 and not pivots2):\\n continue\\n\\n # Let's say diff is > 0\\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\\n # We want to find a number to be replaced whose location is after the pivot,\\n # i.e. pivot1 <= replacedIndex.\\n # Or, we can find one whose location is before the pivots2 (but with -diff),\\n # i.e. pivot2 > replaceIndex.\\n\\n for replacedIndex in replacedIndices:\\n ways = 0\\n if pivots1:\\n loc = bisect.bisect_right(pivots1, replacedIndex)\\n ways += loc\\n if pivots2:\\n loc = bisect.bisect_right(pivots2, replacedIndex)\\n ways += len(pivots2) - loc\\n outerWays = max(outerWays, ways)\\n\\n return outerWays\",\n \"runtime\": \"1614\"\n },\n {\n \"code\": \"'''class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n before = {k:0}; after = {}; counter = Counter(nums)\\n p = list(accumulate(nums))\\n n = len(nums)\\n for i, num in enumerate(nums[:n-1]):\\n before[num] = max(before.get(num, 0), after.get(num, 0))\\n counter[nums[i]] -= 1\\n if counter[nums[i]] == 0: del counter[nums[i]]\\n \\n diff = 2 * p[i] - p[-1]\\n if (k + diff) in before: before[k + diff] += 1\\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\\n return max(max([0] + list(before.values())), max([0] + list(after.values())))'''\\n\\nimport bisect\\nimport collections\\nfrom typing import List, Tuple, Mapping\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n diffsIfReplacedWithK = [k - num for num in nums]\\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\\n for i in range(len(diffsIfReplacedWithK)):\\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\\n\\n leftHalf = 0\\n rightHalf = sum(nums)\\n pivot = 0\\n diffsToPivots = collections.defaultdict[int, list[int]](list)\\n for num in nums[:-1]:\\n pivot += 1\\n leftHalf += num\\n rightHalf -= num\\n diffsToPivots[leftHalf - rightHalf].append(pivot)\\n\\n\\n outerWays = len(diffsToPivots[0]) # this is no replacement\\n\\n for diff, replacedIndices in diffsToReplaceIndices.items():\\n if diff == 0:\\n continue\\n pivots1 = diffsToPivots.get(diff)\\n pivots2 = diffsToPivots.get(-diff)\\n if (not pivots1 and not pivots2):\\n continue\\n\\n # Let's say diff is > 0\\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\\n # We want to find a number to be replaced whose location is after the pivot,\\n # i.e. pivot1 <= replacedIndex.\\n # Or, we can find one whose location is before the pivots2 (but with -diff),\\n # i.e. pivot2 > replaceIndex.\\n\\n for replacedIndex in replacedIndices:\\n ways = 0\\n if pivots1:\\n loc = bisect.bisect_right(pivots1, replacedIndex)\\n ways += loc\\n if pivots2:\\n loc = bisect.bisect_right(pivots2, replacedIndex)\\n ways += len(pivots2) - loc\\n outerWays = max(outerWays, ways)\\n\\n return outerWays\",\n \"runtime\": \"1614\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n sz = len(nums)\\n ps = list(accumulate(nums))\\n m = defaultdict(list)\\n for i in range(sz):\\n m[ps[i]].append(i)\\n \\n ans = 0\\n # no change\\n if ps[-1] % 2 == 0:\\n target = ps[-1] // 2\\n if target in m:\\n ans = len(m[target])\\n if ps[-1] == target:\\n ans -= 1\\n \\n # change #i\\n for i in range(sz):\\n if (ps[-1] - nums[i] + k) % 2 == 0:\\n new_sum = ps[-1] - nums[i] + k \\n diff = -nums[i] + k\\n target = new_sum // 2\\n le, ri = target, target - diff\\n cur = 0\\n if le in m:\\n l = m[le]\\n idx = bisect.bisect_left(l, i)\\n cur += idx\\n if ri in m:\\n l = m[ri]\\n cur += len(l) - bisect.bisect_left(l, i)\\n if l[-1] == sz - 1:\\n cur -= 1\\n ans = max(ans, cur)\\n return ans\\n\\n\\n\",\n \"runtime\": \"1676\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left, right = 0, sum(nums)\\n d = defaultdict(list)\\n prev = nums[0]\\n n = len(nums)\\n ans = 0\\n\\n for i in range(1, n):\\n left += prev\\n right -= prev\\n \\n if left == right:\\n ans+=1\\n\\n d[right - left].append(i)\\n prev = nums[i]\\n\\n for i in range(n):\\n diff = k-nums[i]\\n l = r = 0\\n if diff in d:\\n r = len(d[diff]) - bisect_left(d[diff], i+1)\\n\\n if d[-diff] and d[-diff][0] <= i:\\n l = bisect_right(d[-diff], i)\\n\\n ans = max(ans, l+r)\\n\\n return ans \",\n \"runtime\": \"1738\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n res = 0\\n\\n curSum = 0\\n prefix = []\\n for num in nums:\\n prefix.append(curSum + num)\\n curSum = prefix[-1]\\n \\n # first check if not change k\\n counts = Counter(prefix)\\n if prefix[-1]%2 == 0:\\n res = counts[prefix[-1]//2]\\n if prefix[-1] == 0:\\n res -= 1\\n\\n # check change every k\\n cur = defaultdict(int)\\n for i,num in enumerate(nums):\\n diff = k-num\\n last = prefix[-1]+diff\\n if last%2 == 0:\\n leftTarget, rightTarget = last//2, last//2-diff\\n curWays = cur[leftTarget] + (counts[rightTarget]-cur[rightTarget])\\n if last == 0:\\n curWays -= 1\\n res = max(res, curWays)\\n cur[prefix[i]] += 1\\n\\n return res\\n\",\n \"runtime\": \"1738\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefixes = []\\n res = 0\\n tot_sum = 0\\n for n in nums:\\n tot_sum += n\\n prefixes.append(tot_sum)\\n \\n preds = defaultdict(int)\\n posts = defaultdict(int)\\n\\n for p in prefixes:\\n posts[p] += 1\\n posts[tot_sum] -= 1\\n\\n if tot_sum % 2 == 0:\\n target = tot_sum // 2\\n for p in posts:\\n if p == target:\\n res += posts[target]\\n\\n for i in range(len(nums)):\\n change = k - nums[i]\\n new_sum = tot_sum + change\\n if k != nums[i] and new_sum % 2 == 0:\\n cur = 0\\n new_target = new_sum // 2\\n if i >= 1:\\n cur += preds[new_target]\\n \\n if i <= len(nums)-2:\\n cur += posts[new_target - change]\\n res = max(res, cur)\\n preds[prefixes[i]] += 1\\n posts[prefixes[i]] -= 1\\n return res\\n\\n\\n\\n \\n\",\n \"runtime\": \"1800\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n s = [nums[0]] * n\\n right = defaultdict(int)\\n for i in range(1, n):\\n s[i] = s[i - 1] + nums[i]\\n right[s[i - 1]] += 1\\n\\n ans = 0\\n if s[-1] % 2 == 0:\\n ans = right[s[-1] // 2]\\n\\n left = defaultdict(int)\\n for v, x in zip(s, nums):\\n d = k - x\\n if (s[-1] + d) % 2 == 0:\\n t = left[(s[-1] + d) // 2] + right[(s[-1] - d) // 2]\\n if ans < t:\\n ans = t\\n left[v] += 1\\n right[v] -= 1\\n return ans\",\n \"runtime\": \"1800\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n targ = sum(nums)\\n noneans = 0\\n ans = [0]*len(nums)\\n lsums,rsums = {nums[0]*2-targ:1},{nums[-1]*2-targ:1}\\n prefix = [nums[0]]\\n for i in range(1,len(nums)):\\n if prefix[-1]*2==targ: noneans += 1\\n prefix.append(prefix[-1]+nums[i])\\n for i in range(1,len(nums)):\\n if k-nums[i] in lsums: ans[i] += lsums[k-nums[i]]\\n lsums[prefix[i]*2-targ] = lsums.get(prefix[i]*2-targ,0)+1\\n for i in range(len(prefix)-2,-1,-1):\\n if k-nums[i] in rsums: ans[i] += rsums[k-nums[i]]\\n rsums[targ-prefix[i-1]*2] = rsums.get(targ-prefix[i-1]*2,0)+1\\n return max(max(ans),noneans)\",\n \"runtime\": \"1862\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n l,r = 0, sum(nums)\\n ans = 0\\n diff = defaultdict(list)\\n n = len(nums)\\n prev = nums[0]\\n for i in range(1,n):\\n l+= prev\\n r-=prev\\n if l==r:\\n ans+=1\\n diff[r-l].append(i)\\n prev = nums[i]\\n print(diff)\\n for i in range(n):\\n c =nums[i]\\n delta = k-nums[i]\\n if delta == 0:\\n continue\\n left = right = 0\\n if delta in diff:\\n right = len(diff[delta])- bisect_left(diff[delta], i+1)\\n if diff[-delta] and diff[-delta][0] <= i:\\n left = bisect_right(diff[-delta],i)\\n ans = max(ans, left+right)\\n return ans\\n\\n\",\n \"runtime\": \"1862\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n s = sum(nums)\\n r_diffs = defaultdict(int)\\n l_diffs = defaultdict(int)\\n left = 0\\n for i in range(len(nums) - 1):\\n x = nums[i]\\n left += x\\n right = s - left\\n r_diffs[left - right] += 1\\n \\n ans = r_diffs[0]\\n left = 0\\n for x in nums:\\n left += x\\n right = s - left\\n d = k - x\\n ans = max(ans, l_diffs[d] + r_diffs[-d])\\n l_diffs[left - right] += 1\\n r_diffs[left - right] -= 1\\n return ans\\n\",\n \"runtime\": \"1925\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n pre_sums = []\\n curr_sum = 0\\n for num in nums:\\n curr_sum += num\\n pre_sums.append(curr_sum)\\n\\n dict_left = defaultdict(int)\\n dict_right = defaultdict(int)\\n\\n for s in pre_sums[:-1]:\\n dict_right[s] += 1\\n\\n nums_sum = sum(nums)\\n half = sum(nums) / 2\\n ans = dict_right.get(half, 0)\\n\\n for i in range(len(nums)):\\n new_sum = (nums_sum + k - nums[i])\\n if new_sum % 2 == 0:\\n new_half = new_sum / 2\\n new_ans = dict_left.get(new_half, 0) + dict_right.get(new_sum/2+nums[i]-k, 0)\\n ans = max(ans, new_ans)\\n\\n dict_left[pre_sums[i]] += 1\\n dict_right[pre_sums[i]] -= 1\\n\\n return ans\\n \",\n \"runtime\": \"1925\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, A: List[int], k: int) -> int:\\n n = len(A) \\n pre, s = list(itertools.accumulate(A)), sum(A)\\n \\n # pred contains all the presum BEFORE i-th number.\\n # sufd contains all the presum AFTER and WITH i-th number.\\n pred = collections.defaultdict(int)\\n sufd = collections.Counter(pre)\\n \\n # The last prefix sum is NEVER used. \\n sufd[sum(A)] -= 1\\n \\n # The number of ways if we do not change any number.\\n ans = 0\\n if s % 2 == 0:\\n ans = sufd[s // 2]\\n\\n # The number of ways if we split i-th number to k.\\n for i in range(n):\\n cur = 0\\n \\n # We only count number of ways when A[i] != k (otherwise change makes no difference)\\n # and when the SUM after the change is dividable by 2.\\n if A[i] != k:\\n news = s + k - A[i]\\n if news % 2 == 0:\\n \\n # If i == 0, only count suffix part.\\n if i > 0:\\n cur += pred[news // 2]\\n \\n # If i == n - 1, only count prefix part.\\n if i < n - 1:\\n cur += sufd[news // 2 + A[i] - k]\\n ans = max(ans, cur)\\n \\n # Don't forget to change the values in the two counters.\\n sufd[pre[i]] -= 1\\n pred[pre[i]] += 1\\n \\n return ans \",\n \"runtime\": \"1987\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = list(itertools.accumulate(nums))\\n nums_sum = sum(nums)\\n pre = defaultdict(int)\\n post = collections.Counter(prefix_sum)\\n\\n post[nums_sum] -= 1\\n\\n output = 0\\n if nums_sum % 2 == 0:\\n output = post[nums_sum//2]\\n \\n for i, num in enumerate(nums):\\n curr = 0\\n if num != k:\\n new_sum = nums_sum + k - num\\n if new_sum % 2 == 0:\\n if i>0:\\n curr += pre[new_sum//2]\\n if i<n-1:\\n curr += post[new_sum//2+num-k] # prefix_sum + k-num == new_sum//2\\n output = max(output, curr)\\n pre[prefix_sum[i]] += 1\\n post[prefix_sum[i]] -= 1\\n return output\",\n \"runtime\": \"1987\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n if len(nums) == 0:\\n return 0\\n\\n prefix_sum = nums[0]\\n prefix_sum_counts = defaultdict(int)\\n prefix_sum_counts[prefix_sum] += 1\\n\\n max_ways_to_partition = 0\\n arr_sum = sum(nums)\\n\\n for num in nums[1:]:\\n if prefix_sum == arr_sum - prefix_sum:\\n max_ways_to_partition += 1\\n\\n prefix_sum += num\\n prefix_sum_counts[prefix_sum] += 1\\n\\n # to handle the condition that pivot can at most be n - 1.\\n prefix_sum_counts[prefix_sum] -= 1\\n\\n prefix_sum = nums[0]\\n left_ps = defaultdict(int)\\n\\n right_ps = prefix_sum_counts\\n\\n if (arr_sum - k + nums[0]) % 2 == 0:\\n max_ways_to_partition = max(\\n max_ways_to_partition, right_ps[(arr_sum - k + nums[0]) // 2]\\n )\\n\\n left_ps[prefix_sum] += 1\\n right_ps[prefix_sum] -= 1\\n\\n for idx, num in enumerate(nums[1:], 1):\\n ways_to_partition = 0\\n if (arr_sum + k - num) % 2 == 0:\\n ways_to_partition += left_ps[(arr_sum + k - num) // 2]\\n\\n if (arr_sum - k + num) % 2 == 0:\\n ways_to_partition += right_ps[(arr_sum - k + num) // 2]\\n\\n prefix_sum += num\\n left_ps[prefix_sum] += 1\\n right_ps[prefix_sum] -= 1\\n\\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\\n\\n return max_ways_to_partition\\n\",\n \"runtime\": \"2049\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left, right = defaultdict(int), defaultdict(int)\\n n = len(nums)\\n prefixSum, suffixSum = [0] * n, [0] * n\\n prefixSum[0] = nums[0]\\n suffixSum[-1] = nums[-1]\\n for i in range(1,n):\\n prefixSum[i] = nums[i] + prefixSum[i-1]\\n for i in range(n-2, -1, -1):\\n suffixSum[i] = nums[i] + suffixSum[i+1]\\n for i in range(n-1):\\n right[prefixSum[i] - suffixSum[i+1]] += 1\\n ans = right[0]\\n for i in range(n):\\n # change the element at i to k\\n diff = k - nums[i]\\n cur = left[diff] + right[-diff]\\n ans = max(cur, ans)\\n if i < n - 1:\\n curdiff = prefixSum[i] - suffixSum[i+1]\\n left[curdiff] += 1\\n right[curdiff] -= 1\\n return ans\\n\",\n \"runtime\": \"2049\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n def add_num(db, num):\\n if num in db:\\n db[num] += 1\\n else:\\n db[num] = 1\\n\\n def remove_num(db, num):\\n db[num] -= 1\\n if db[num]==0:\\n del db[num]\\n \\n n = len(nums)\\n pr_sum = [0]*n\\n tmp = 0\\n for i in range(n):\\n tmp += nums[i]\\n pr_sum[i] = tmp\\n\\n sf_sum = [0]*n\\n tmp = 0 \\n for i in range(n-1, -1, -1):\\n tmp += nums[i]\\n sf_sum[i] = tmp\\n\\n pr_db = {}\\n sf_db = {}\\n for i in range(n-1):\\n add_num(pr_db, pr_sum[i])\\n ret = 0\\n total = sum(nums)\\n mid = total//2\\n if total%2==0 and mid in pr_db:\\n ret = pr_db[mid]\\n for i in range(n):\\n new_total = total+nums[i]-k\\n mid = new_total//2\\n if new_total%2==0:\\n cnt = 0\\n if mid in pr_db:\\n cnt += pr_db[mid]\\n if mid in sf_db:\\n cnt += sf_db[mid]\\n ret = max(ret, cnt)\\n if i!=n-1:\\n remove_num(pr_db, pr_sum[i])\\n add_num(sf_db, sf_sum[i+1])\\n \\n return ret \\n\\n \\n\\n\\n \\n \",\n \"runtime\": \"2111\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # Prefix and suffix sum\\n # Move i from left to right, attempt to change this number to k\\n # Left diff: the diff from prefix[i] to suffix[i + 1] that is on the left of current index\\n # Right diff: the diff from prefix[i] to suffix[i + 1] that is on the right of current index\\n # change diff: change = k - nums[i], this will cause the left diffs to go down by `change`, which may result in 0 diff between left and right.\\n # and right diffs to go up by `change`\\n # Count left_diff[change] + right_diff[-change], and the current count of diff[0]\\n\\n n = len(nums)\\n prefix = [0] * n\\n prefix[0] = nums[0]\\n suffix = [0] * n\\n suffix[-1] = nums[-1]\\n for i in range(1, n):\\n prefix[i] = prefix[i - 1] + nums[i]\\n suffix[n - 1 - i] = suffix[n - i] + nums[n - 1 - i]\\n\\n right_diff = defaultdict(int)\\n for i in range(n - 1):\\n diff = prefix[i] - suffix[i + 1]\\n right_diff[diff] += 1\\n \\n max_count = right_diff[0]\\n left_diff = defaultdict(int)\\n for i in range(n):\\n if i > 0:\\n diff = prefix[i - 1] - suffix[i]\\n right_diff[diff] -= 1\\n left_diff[diff] += 1\\n change = k - nums[i]\\n max_count = max(max_count, left_diff[change] + right_diff[-change])\\n\\n return max_count\",\n \"runtime\": \"2111\"\n },\n {\n \"code\": \"#from itertools import accumulate # Correct import for accumulate\\nfrom bisect import bisect\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def waysToPartition(self, nums, k):\\n n = len(nums)\\n \\n # Calculate prefix sums\\n acc1 = list(accumulate(nums))\\n d1 = defaultdict(list)\\n for idx, num in enumerate(acc1):\\n d1[num].append(idx)\\n \\n # Calculate suffix sums\\n acc2 = list(accumulate(nums[::-1]))\\n d2 = defaultdict(list)\\n for idx, num in enumerate(acc2):\\n d2[num].append(idx)\\n \\n ans, ans2 = 0, 0\\n \\n # Count original valid partitions (ans2)\\n for i in range(n - 1):\\n if acc1[-1] == 2 * acc1[i]: \\n ans2 += 1\\n \\n # Evaluate maximum partitions possible after modifying one element\\n for i in range(0, n):\\n cand = (acc1[-1] - nums[i] + k) / 2\\n \\n # Using bisect to find number of valid partition points\\n lft = bisect(d1[cand], i - 1)\\n rgh = bisect(d2[cand], n - i - 2)\\n \\n # Update the maximum number of valid partitions\\n ans = max(ans, lft + rgh)\\n \\n return max(ans, ans2)\\n\",\n \"runtime\": \"2173\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = list(accumulate(nums))\\n total_sum = prefix_sums[-1]\\n best = 0\\n if total_sum % 2 == 0:\\n best = prefix_sums[:-1].count(total_sum // 2) # If no change\\n\\n after_counts = Counter(\\n [total_sum - (2 * prefix_sum) for prefix_sum in prefix_sums[:-1]]\\n )\\n before_counts = Counter()\\n\\n best = max(best, after_counts[k - nums[0]]) # If we change first num\\n\\n for prefix, x in zip(prefix_sums, nums[1:]):\\n gap = total_sum - 2 * prefix\\n after_counts[gap] -= 1\\n before_counts[gap] += 1\\n\\n best = max(best, after_counts[k - x] + before_counts[x - k])\\n\\n return best\",\n \"runtime\": \"2173\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sl, sr = 0, sum(nums)\\n for i in range(N - 1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n diffs.append(math.inf) # to prevent error in the counter arithemtic\\n \\n cl, cr = Counter(), Counter(diffs)\\n res = cl[0] + cr[0]\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n return res\",\n \"runtime\": \"2236\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"This is a good problem. It's not difficult, but is quite complex.\\n\\n The idea is that once we change a position at i, for all the pivots at\\n 1...i, the sum of the left half stay the same whereas the sum of\\n the right half changes by delta = k - nums[i]. Similarly, for all the\\n pivots at i + 1...n - 1, the left half changes by delta, whereas the\\n right half stay the same.\\n\\n We can pre-compute all the differences at each pivot position and make\\n that into a diffs = [d1, d2, .... , dn-1]\\n\\n Then after a change at i, if we want the pivots at 1...i to form a good\\n partition, we must have left - (right + delta) = 0 => delta = left - right\\n In other words, the number of good partitions is the count of d1, d2, ...\\n di that are equal to delta. Similarly, if we want the pivots at i + 1...\\n n - 1 to form a good partition, we must have left + delta - right = 0\\n => left - right = -delta. In other words, the number of good partitions\\n is the count of di+1, ...., dn-1 that are equal to -delta.\\n\\n Based on this, we progressively build a left sum and right sum to\\n compute the diffs array. And then progressively build a left counter\\n and right counter to compute the number of matches to delta and -delta.\\n\\n The difficulty is in the implementation, especially with the indices.\\n\\n O(N), 7339 ms, faster than 32.20%\\n \\\"\\\"\\\"\\n N = len(nums)\\n diffs = []\\n sl, sr = 0, sum(nums)\\n for i in range(N - 1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n diffs.append(math.inf) # to prevent error in the counter arithemtic\\n \\n cl, cr = Counter(), Counter(diffs)\\n print(cr)\\n res = cl[0] + cr[0]\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n return res\\n\\n \\n # n = len(nums)\\n # pre, s = list(itertools.accumulate(nums)), sum(nums)\\n \\n # # pred contains all the presum BEFORE i-th number.\\n # # sufd contains all the presum AFTER and WITH i-th number.\\n # pred = collections.defaultdict(int)\\n # sufd = collections.Counter(pre)\\n \\n # # The last prefix sum is NEVER used. \\n # sufd[sum(nums)] -= 1\\n \\n # # The number of ways if we do not change any number.\\n # ans = 0\\n # if s % 2 == 0:\\n # ans = sufd[s // 2]\\n\\n # # The number of ways if we split i-th number to k.\\n # for i in range(n):\\n # cur = 0\\n \\n # # We only count number of ways when A[i] != k (otherwise change makes no difference)\\n # # and when the SUM after the change is dividable by 2.\\n # if nums[i] != k:\\n # news = s + k - nums[i]\\n # if news % 2 == 0:\\n \\n # # If i == 0, only count suffix part.\\n # if i > 0:\\n # cur += pred[news // 2]\\n \\n # # If i == n - 1, only count prefix part.\\n # if i < n - 1:\\n # cur += sufd[news // 2 + nums[i] - k]\\n # ans = max(ans, cur)\\n \\n # # Don't forget to change the values in the two counters.\\n # sufd[pre[i]] -= 1\\n # pred[pre[i]] += 1\\n \\n # return ans\\n\\n \\n \\n # def summarize(nums):\\n # s = [nums[0]]\\n # for num in nums[1:]:\\n # s.append(s[-1]+num)\\n # return s\\n\\n # prefix = summarize(nums)\\n # suffix = summarize(nums[::-1])[::-1]\\n # print(prefix)\\n # print(suffix)\\n \\n # n = len(nums)\\n # dic = collections.defaultdict(list)\\n # for i in range(1, n):\\n # dic[suffix[i]-prefix[i-1]].append(i)\\n # sort = sorted(list(dic.items()), key=lambda x: len(x[1]), reverse=True)\\n # print(sort)\\n # res = len(dic[0])\\n \\n # num_diff = {}\\n # for i, num in enumerate(nums):\\n # if k-num not in num_diff:\\n # num_diff[k-num] = i\\n # print(num_diff)\\n \\n # for diff, idices in sort:\\n # if len(idices) <= res:\\n # break\\n # if diff not in num_diff:\\n # continue\\n # idx = bisect.bisect_left(idices, num_diff[diff])\\n # res = max(res, len(idices)-idx)\\n # return res\",\n \"runtime\": \"2236\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left_sum = list(accumulate(nums))\\n right_sum = list(accumulate(nums[::-1]))[::-1]\\n possible_left_deltas = defaultdict(lambda: 0)\\n possible_right_deltas = defaultdict(lambda: 0)\\n pivot_count_per_left_delta = defaultdict(lambda: 0)\\n pivot_count_per_right_delta = defaultdict(lambda: 0)\\n # can only change one SINGLE element\\n counts = 0\\n for i, n in enumerate(nums):\\n possible_right_deltas[n - k] += 1\\n if i > 0 and left_sum[i-1] == right_sum[i]:\\n counts += 1\\n for i, n in enumerate(nums):\\n if i > 0 and possible_left_deltas[left_sum[i-1] - right_sum[i]] > 0:\\n pivot_count_per_left_delta[left_sum[i-1] - right_sum[i]] += 1\\n if i > 0 and possible_right_deltas[right_sum[i] - left_sum[i-1]] > 0:\\n pivot_count_per_right_delta[right_sum[i] - left_sum[i-1]] += 1\\n pivot_count_per_left_delta[n - k] = max(pivot_count_per_left_delta[n - k], pivot_count_per_right_delta[n - k])\\n possible_left_deltas[n - k] += 1\\n possible_right_deltas[n - k] -= 1\\n return max([counts] + list(pivot_count_per_left_delta.values()) + list(pivot_count_per_right_delta.values()))\",\n \"runtime\": \"2298\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: list[int], k: int) -> int:\\n n = len(nums)\\n summ = sum(nums)\\n prefix = 0\\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [0..i)\\n l = collections.Counter()\\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [i..n)\\n r = collections.Counter()\\n\\n for pivot in range(1, n):\\n prefix += nums[pivot - 1]\\n suffix = summ - prefix\\n r[prefix - suffix] += 1\\n\\n ans = r[0]\\n prefix = 0\\n\\n for num in nums:\\n ans = max(ans, l[k - num] + r[num - k])\\n prefix += num\\n suffix = summ - prefix\\n diff = prefix - suffix\\n r[diff] -= 1\\n l[diff] += 1\\n\\n return ans\",\n \"runtime\": \"2298\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n preSum = [0] * (n + 1)\\n for i in range(n):\\n preSum[i + 1] = preSum[i] + nums[i]\\n totalSum = preSum[n]\\n\\n balances = []\\n for pivot in range(1, n):\\n bal = 2 * preSum[pivot] - totalSum\\n balances.append(bal)\\n\\n from collections import Counter\\n counts_bal = Counter(balances)\\n\\n left_counts = Counter()\\n right_counts = counts_bal.copy()\\n max_counts = counts_bal[0] # counts of valid pivots in original array\\n\\n for i in range(n):\\n diff = k - nums[i]\\n counts_left = left_counts.get(diff, 0)\\n counts_right = right_counts.get(-diff, 0)\\n total_counts = counts_left + counts_right\\n max_counts = max(max_counts, total_counts)\\n if i < n - 1:\\n bal = balances[i]\\n left_counts[bal] += 1\\n right_counts[bal] -= 1\\n if right_counts[bal] == 0:\\n del right_counts[bal]\\n return max_counts\\n\",\n \"runtime\": \"2360\"\n },\n {\n \"code\": \"from itertools import accumulate\\nfrom collections import Counter\\nfrom typing import List\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # Step 1: Compute prefix sums\\n prefix_sums = list(accumulate(nums))\\n print(prefix_sums)\\n prefix_sums = [0] * (len(nums) + 1)\\n\\n for i in range(len(nums)):\\n prefix_sums[i + 1] = prefix_sums[i] + nums[i] \\n\\n print(prefix_sums)\\n \\n # Step 2: Initialize counters\\n left_counter = Counter()\\n right_counter = Counter(prefix_sums[1:][:-1])\\n # print(prefix_sums)\\n # print(f\\\"{prefix_sums[:-1]=}\\\")\\n # print(right_counter)\\n \\n # Step 3: Calculate initial valid partitions\\n total_sum = prefix_sums[-1]\\n max_partitions = right_counter[total_sum / 2]\\n \\n # Step 4: Iterate through the array to consider each possible change\\n for i, current_prefix_sum in enumerate(prefix_sums[1:]):\\n change = k - nums[i]\\n \\n # Check potential partitions if nums[i] is changed to k\\n target_left = (total_sum + change) / 2\\n target_right = (total_sum - change) / 2\\n \\n # Calculate the number of valid partitions with this change\\n current_partitions = left_counter[target_left] + right_counter[target_right]\\n max_partitions = max(max_partitions, current_partitions)\\n \\n # Update counters for the next iteration\\n left_counter[current_prefix_sum] += 1\\n right_counter[current_prefix_sum] -= 1\\n \\n return max_partitions\\n\",\n \"runtime\": \"2360\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefixSum = list(accumulate(nums))\\n leftCount = Counter()\\n rightCount = Counter()\\n\\n ans = 0\\n\\n n = len(nums)\\n for i in range(1, n):\\n diff = prefixSum[i-1] - (prefixSum[-1] - prefixSum[i-1])\\n rightCount[diff] += 1\\n\\n ans = rightCount[0]\\n for i in range(n):\\n d = k - nums[i]\\n ans = max(ans, leftCount[d] + rightCount[-d])\\n if i < n - 1:\\n origDiff = prefixSum[i] - (prefixSum[-1] - prefixSum[i])\\n leftCount[origDiff] += 1\\n rightCount[origDiff] -= 1\\n\\n return ans\\n \\n\\n\",\n \"runtime\": \"2422\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n pass\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sum_all = sum(nums)\\n\\n # calculate prefix sum\\n prefix_sum = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sum.append(accum)\\n \\n prefix_counter = collections.defaultdict(int)\\n suffix_counter = collections.Counter(prefix_sum)\\n suffix_counter[sum_all] -= 1\\n\\n # count answers without changing k\\n ans = 0\\n if sum_all % 2 == 0:\\n ans = suffix_counter[sum_all//2]\\n \\n # replace ith num to k\\n for i in range(n):\\n curr = 0\\n\\n if nums[i] != k:\\n sum_all_new = sum_all + k - nums[i]\\n if sum_all_new % 2 == 0:\\n if i > 0:\\n curr += prefix_counter[sum_all_new // 2]\\n \\n if i < n-1:\\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\\n\\n ans = max(ans, curr)\\n\\n suffix_counter[prefix_sum[i]] -= 1\\n prefix_counter[prefix_sum[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.defaultdict(int)\\n \\n # without chaning k\\n ans = 0\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # change k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n \\n counter_left = collections.defaultdict(int)\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[accum] -= 1\\n\\n ans = 0\\n\\n # without replacing k\\n if accum % 2 == 0:\\n ans += counter_right[accum//2]\\n \\n # with replacing k\\n for i in range(len(nums)):\\n # replace nums[i] --> k\\n new_sums = accum - nums[i] + k\\n curr = 0\\n if new_sums % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_sums//2]\\n if i < len(nums)-1:\\n curr += counter_right[new_sums//2 - k + nums[i]]\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n ans = max(ans, curr)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.defaultdict(int)\\n counter_right[total_sum] -= 1\\n\\n ans = 0\\n\\n # case 1. No switch to k\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum // 2]\\n \\n # case 2. Switch to k\\n for i in range(len(nums)):\\n curr = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\\n ans = max(ans, curr)\\n\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n return ans\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.Counter()\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n # without changing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n\\n # change nums[i] --> k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_left = collections.Counter()\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n\\n # without replacing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # replace k\\n for i in range(len(nums)):\\n curr_cnt = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr_cnt += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\\n cnt = max(cnt, curr_cnt)\\n counter_right[prefix_sums[i]] -= 1\\n counter_right[prefix_sums[i]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n prefix_sums = []\\n for n in nums:\\n accum += n\\n prefix_sums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(prefix_sums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n # no switch\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # switch nums[i] --> k\\n for i in range(len(nums)):\\n total_sums_new = total_sum + k - nums[i]\\n cnt_curr = 0\\n if total_sums_new % 2 == 0:\\n if i > 0:\\n cnt_curr += left_counter[total_sums_new//2]\\n if i < len(nums)-1:\\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\\n cnt = max(cnt, cnt_curr)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n counter_right[accum] += 1\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right[total_sum] -= 1\\n\\n\\n ans = 0\\n # No replace\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # replace\\n for i, num in enumerate(nums):\\n total_new = total_sum - num + k\\n curr = 0\\n if total_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_new // 2 - (k - num)]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\",\n \"runtime\": \"2422\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sl, sr = 0, sum(nums)\\n for i in range(N-1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n diffs.append(math.inf)\\n\\n cl, cr = Counter(), Counter(diffs)\\n ans = cr[0]\\n\\n for i in range(N):\\n d = k - nums[i]\\n ans = max(ans, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n \\n return ans\\n\\n # sum[i] = sum of 0 to i's number. total = sum[-1]\\n # diff[i] = total - 2*sum[i]\\n # k_num[i] = k - nums[i]. have that in a set k_n_set\\n # collect diff[i] in a hashmap with (diff, count)\\n # for elements in k_n_set, check if it's in the hashmap and return max count\\n # [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14]\\n # sum: [22, 26, 1, -19, -34, -19, -35, -28, -9, -19, -19, -32, -46]\\n # [-55, -37, -8, -12, ...]\\n # diff: [-8x, -big, -44, -8, xx, -8, xx, xx, -8, -8..]\\n #. map[-8] = 4, max. return 4\\n\\n # def helper(nums, k):\\n # sum_i, _sum, k_num = [], 0, set()\\n # k_num.add(0)\\n # for n in nums:\\n # _sum += n\\n # sum_i.append(_sum)\\n # k_num.add(k - n)\\n \\n # diff_count = defaultdict(int)\\n # for s in sum_i[:-1]:\\n # diff = sum_i[-1] - 2 * s\\n # diff_count[diff] += 1\\n \\n # ans = 0\\n # for n in k_num:\\n # ans = max(diff_count[n] + diff_count[-n], ans)\\n \\n # print(nums)\\n # print(sum_i)\\n # print(diff_count)\\n # print(k_num)\\n \\n # return ans\\n\\n # return helper(nums, k)\",\n \"runtime\": \"2484\"\n },\n {\n \"code\": \"import collections\\nimport itertools\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n cumSum = list(accumulate(nums)) #cumulative sum of the nums array\\n rightCnt = Counter() \\n leftCnt = Counter()\\n\\n\\n\\n for i in range(1,len(nums)):\\n left = cumSum[i-1] #exclude the pivot index from the left portion\\n right = cumSum[-1] - cumSum[i-1]\\n difference = right - left\\n\\n #use the difference to populate the right count\\n rightCnt[difference] += 1\\n \\n #initialize our answer to be the number of valid partition without changing any values\\n totalValid = rightCnt[0]\\n\\n #update totalValid to account for changing numbers\\n for i in range(len(nums)):\\n difference = k - nums[i] #change between original value and k\\n\\n #right - left\\n #if k is included in the left, sum of the partitions will decrease by difference\\n #if k is included in the right, sum of the partitions will increase by difference\\n\\n totalValid = max(totalValid, leftCnt[-difference] + rightCnt[difference])\\n \\n #adjust counters for each side of the partition\\n left = cumSum[i] #exclude the pivot index from the left portion\\n right = cumSum[-1] - cumSum[i]\\n originalDifference = right - left\\n \\n leftCnt[originalDifference] += 1\\n rightCnt[originalDifference] -= 1\\n \\n return totalValid\\n\\n\\n\\n\\n\\n\",\n \"runtime\": \"2484\"\n },\n {\n \"code\": \"import itertools\\nfrom collections import defaultdict, Counter\\nimport math\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = list(itertools.accumulate(nums))\\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\\n\\n def get_max_pivots_v1():\\n max_pivots = 0\\n for i in range(n):\\n pivots = 0\\n delta = k - nums[i]\\n for j in range(1, n):\\n diff = prefix_sum[j - 1] - suffix_sum[j]\\n if diff == 0:\\n pivots += 1\\n continue\\n if j <= i:\\n if diff == delta:\\n pivots += 1\\n else:\\n if diff == -delta:\\n pivots += 1\\n max_pivots = max(pivots, max_pivots)\\n return max_pivots\\n\\n def get_max_pivots_v2():\\n diffs = []\\n for i in range(1, n):\\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\\n diffs_rev = list(reversed(diffs))\\n pre_diffs = Counter()\\n post_diffs = Counter(diffs)\\n max_pivots = post_diffs[0]\\n for i in range(n):\\n delta = k - nums[i]\\n if diffs_rev and i != 0:\\n diff = diffs_rev.pop()\\n pre_diffs.update([diff])\\n post_diffs.subtract([diff])\\n max_pivots = max(max_pivots, pre_diffs[delta] + post_diffs[-delta])\\n return max_pivots\\n\\n return get_max_pivots_v2()\\n\",\n \"runtime\": \"2547\"\n },\n {\n \"code\": \"import itertools\\nfrom collections import defaultdict, Counter\\nimport math\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = list(itertools.accumulate(nums))\\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\\n\\n def get_max_pivots_v1():\\n max_pivots = 0\\n for i in range(n):\\n pivots = 0\\n delta = k - nums[i]\\n for j in range(1, n):\\n diff = prefix_sum[j - 1] - suffix_sum[j]\\n if diff == 0:\\n pivots += 1\\n continue\\n if j <= i:\\n if diff == delta:\\n pivots += 1\\n else:\\n if diff == -delta:\\n pivots += 1\\n max_pivots = max(pivots, max_pivots)\\n return max_pivots\\n\\n def get_max_pivots_v2():\\n diffs = []\\n for i in range(1, n):\\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\\n print(diffs)\\n diffs_rev = list(reversed(diffs))\\n pre_diffs = Counter()\\n post_diffs = Counter(diffs)\\n max_pivots = post_diffs[0]\\n for i in range(n):\\n delta = k - nums[i]\\n if diffs_rev and i != 0:\\n diff = diffs_rev.pop()\\n pre_diffs.update([diff])\\n post_diffs.subtract([diff])\\n max_pivots = max(max_pivots, pre_diffs[delta] + post_diffs[-delta])\\n return max_pivots\\n\\n return get_max_pivots_v2()\\n\",\n \"runtime\": \"2609\"\n },\n {\n \"code\": \"import itertools\\nfrom collections import defaultdict, Counter\\nimport math\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = list(itertools.accumulate(nums))\\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\\n\\n def get_max_pivots_v1():\\n max_pivots = 0\\n for i in range(n):\\n pivots = 0\\n delta = k - nums[i]\\n for j in range(1, n):\\n diff = prefix_sum[j - 1] - suffix_sum[j]\\n if diff == 0:\\n pivots += 1\\n continue\\n if j <= i:\\n if diff == delta:\\n pivots += 1\\n else:\\n if diff == -delta:\\n pivots += 1\\n max_pivots = max(pivots, max_pivots)\\n return max_pivots\\n\\n def get_max_pivots_v2():\\n diffs = []\\n for i in range(1, n):\\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\\n print(diffs)\\n diffs_rev = list(reversed(diffs))\\n pre_diffs = Counter()\\n post_diffs = Counter(diffs)\\n max_pivots = post_diffs[0]\\n for i in range(n):\\n delta = k - nums[i]\\n if diffs_rev and i != 0:\\n diff = diffs_rev.pop()\\n pre_diffs.update([diff])\\n post_diffs.subtract([diff])\\n max_pivots = max(max_pivots, max(pre_diffs[delta], 0) + max(post_diffs[-delta], 0))\\n return max_pivots\\n\\n return get_max_pivots_v2()\\n\",\n \"runtime\": \"2671\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n total = 0\\n aggsum_index_dict = defaultdict(list)\\n for i, num in enumerate(nums):\\n total += num\\n if i < len(nums) - 1:\\n aggsum_index_dict[total].append(i)\\n\\n max_ways = 0\\n if total % 2 == 0 and aggsum_index_dict[total // 2]:\\n max_ways = len(aggsum_index_dict[total // 2])\\n\\n for i, num in enumerate(nums):\\n changed_total = total + k - num\\n if changed_total % 2 == 0:\\n valid_left_of_k = len([index for index in aggsum_index_dict[changed_total // 2] if index < i])\\n valid_right_of_k = len([index for index in aggsum_index_dict[changed_total // 2 - k + num] if index >= i])\\n max_ways = max(max_ways, valid_left_of_k + valid_right_of_k)\\n\\n return max_ways\\n \",\n \"runtime\": \"2733\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n diff_k_num = [k-nums[i] for i in range(n)]\\n diff_2_partition_idx = {}\\n prefix, suffix = 0, sum(nums)\\n max_ways = 0\\n\\n for i in range(n-1):\\n prefix += nums[i]\\n suffix -= nums[i]\\n diff = prefix - suffix\\n max_ways = max_ways + 1 if prefix == suffix else max_ways\\n if diff not in diff_2_partition_idx:\\n diff_2_partition_idx[diff] = [i+1]\\n else:\\n diff_2_partition_idx[diff].append(i+1)\\n \\n for i in range(n):\\n diff_k_num_i = diff_k_num[i]\\n count = 0\\n if -1*diff_k_num_i in diff_2_partition_idx:\\n partitions = diff_2_partition_idx[-diff_k_num_i]\\n for partition in partitions:\\n if i < partition:\\n count += 1\\n if diff_k_num_i in diff_2_partition_idx:\\n partitions = diff_2_partition_idx[diff_k_num_i]\\n for partition in partitions:\\n if i >= partition:\\n count += 1\\n max_ways = max(max_ways, count)\\n \\n return max_ways\\n\",\n \"runtime\": \"2795\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n leftSum = [0] * len(nums)\\n rightSum = [0] * len(nums)\\n\\n for i in range(1, len(nums)):\\n leftSum[i] = leftSum[i-1] + nums[i-1]\\n\\n rightSum[-1] = nums[-1]\\n for i in range(len(nums)-2, -1, -1):\\n rightSum[i] = rightSum[i+1] + nums[i]\\n\\n diffs = defaultdict(list)\\n valDict = defaultdict(set)\\n for i in range(len(nums)):\\n valDict[nums[i]].add(i)\\n\\n res = 0\\n for i in range(1,len(nums)):\\n if leftSum[i] == rightSum[i]:\\n res += 1\\n diffs[rightSum[i]-leftSum[i]].append(i)\\n #print(diffs)\\n #print(valDict)\\n for i in range(len(nums)):\\n tmp = 0\\n newDiff = k - nums[i]\\n #print(newDiff)\\n\\n for ind in diffs[newDiff]:\\n if ind > i:\\n tmp += 1\\n for ind in diffs[-newDiff]:\\n if ind <= i:\\n tmp += 1\\n res = max(res, tmp)\\n\\n return res\\n \\n\",\n \"runtime\": \"2858\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # there are n-1 possible pivot points\\n n = len(nums)\\n\\n # given each pivot, there will be a left sum and right sum\\n # - we also have the option to change one element in left or right sum to k\\n # - suppose we have left_sum[i], right_sum[i]. and diff[i] = k - nums[i],\\n # then diff[i] is the delta we need to add to left_sum or right_sum if we were to\\n # swap nums[i] with k.\\n # - for each k swap, we should count the total number of pivots that satisfy it.\\n\\n diffs = []\\n diff_to_k = defaultdict(list) # we want to look up diff value -> set(index) as well for faster lookup\\n for i, num in enumerate(nums):\\n diffs.append(k - num)\\n diff_to_k[k-num].append(i)\\n\\n # sort indices\\n for diff, ks in diff_to_k.items():\\n diff_to_k[diff] = SortedList(ks)\\n\\n # diff_count_per_diff\\n\\n def get_prefix_sum(nums):\\n left_sums = []\\n for i, num in enumerate(nums):\\n if len(left_sums) == 0:\\n left_sums.append(num)\\n else:\\n left_sums.append(num + left_sums[-1])\\n return left_sums\\n\\n left_sum = get_prefix_sum(nums)\\n right_sum = get_prefix_sum(nums[::-1])[::-1]\\n\\n # # iterate through each possible pivot point\\n # partitions_per_k = defaultdict(lambda: 0) # reserve 0 as the key for when we don't make changes in nums\\n\\n # num_zero_diffs = 0\\n # for diff in diffs:\\n # if diff == 0:\\n # num_zero_diffs += 1\\n\\n # # O(n ^ 2) -> this can be made faster?\\n # for pivot in range(1, n):\\n # if left_sum[pivot-1] == right_sum[pivot]:\\n # partitions_per_k[0] += 1\\n\\n # # check if there is diffs == 0 -- but we can only add this once\\n # # partitions_per_k[0] += num_zero_diffs\\n # else:\\n # diff = left_sum[pivot-1] - right_sum[pivot]\\n\\n # # left sum\\n # candidates_k = diff_to_k[-diff]\\n # if len(candidates_k) > 0:\\n # # left_end = candidates_k.bisect_right(pivot-1)\\n # # for k in range(candidates_k[candidates_k.bisect_right(pivot-1)]):\\n # for k in candidates_k: # this is sorted\\n # if k <= pivot-1:\\n # partitions_per_k[k] += 1\\n # else:\\n # break # we are done\\n\\n # # right sum\\n # candidates_k = diff_to_k[diff]\\n # if len(candidates_k) > 0:\\n # # iterate from right to left and break when we are \\n # for k in list(range(1, len(nums)))[::-1]:\\n # if k >= pivot:\\n # partitions_per_k[k] += 1\\n # else: # we are done\\n # break \\n\\n # might be faster: iterate through k itself - ie what happens if we swap nums[k]?\\n # if nums[i] is swapped, the new total sum is target = (sum(nums) - (k - nums[i])))/2.\\n # - suppose with swap nums[i] for k, then we have a new target\\n # - in lookup table, we can check which left_nums and right_nums indices == target.\\n # these indices should be sorted.\\n # - given the indices, and i, we can then deduce how many possible pivots there are\\n # that are valid partitions.\\n left_table = defaultdict(list)\\n right_table = defaultdict(list)\\n\\n for i, left_s in enumerate(left_sum):\\n left_table[left_s].append(i)\\n for key, vals in left_table.items():\\n left_table[key] = sorted(vals)\\n \\n for i, right_s in enumerate(right_sum):\\n right_table[right_s].append(i)\\n for key, vals in right_table.items():\\n right_table[key] = sorted(vals)\\n\\n # let us change nums[i] -> k\\n tot_sum = sum(nums)\\n\\n max_matches = 0\\n for i, num in enumerate(nums):\\n num_matches = 0\\n\\n target = (tot_sum - num + k) / 2\\n\\n # suppose nums[i] -> k is changed, we can count left_sums that are == target\\n # - in this case left_index < i\\n if target in left_table.keys():\\n left_indices = left_table[target]\\n for index in left_indices:\\n if index < i:\\n num_matches +=1\\n else:\\n break # we are done\\n \\n # similarly, let's count the right_sums that are == target\\n # - in this case right_index > i\\n if target in right_table.keys():\\n right_indices = right_table[target]\\n for index in right_indices:\\n if index > i:\\n num_matches += 1\\n\\n max_matches = max(max_matches, num_matches)\\n\\n # now assume we don't change any number to k\\n target = tot_sum / 2\\n matches = left_table[target] # can include all excpet last element\\n if len(matches) > 0 and matches[-1] == len(nums)-1:\\n num_matches = len(matches)-1\\n else:\\n num_matches = len(matches)\\n max_matches = max(max_matches, num_matches)\\n\\n return max_matches\\n\",\n \"runtime\": \"2920\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":36,"string":"36"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n before = {k:0}; after = {}; counter = Counter(nums)\n p = list(accumulate(nums))\n n = len(nums)\n for i, num in enumerate(nums[:n-1]):\n before[num] = max(before.get(num, 0), after.get(num, 0))\n counter[nums[i]] -= 1\n if counter[nums[i]] == 0: del counter[nums[i]]\n \n diff = 2 * p[i] - p[-1]\n if (k + diff) in before: before[k + diff] += 1\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\n return max(max([0] + list(before.values())), max([0] + list(after.values())))\n ","memory":"30838"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n before = {k:0}\n after = {}\n counter = Counter(nums)\n p = list(accumulate(nums))\n n = len(nums)\n for i, num in enumerate(nums[:n-1]):\n before[num] = max(before.get(num, 0), after.get(num, 0))\n counter[nums[i]] -= 1\n if counter[nums[i]] == 0: del counter[nums[i]]\n \n diff = 2 * p[i] - p[-1]\n if (k + diff) in before: before[k + diff] += 1\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\n \n return max(max([0] + list(before.values())), max([0] + list(after.values())))\n ","memory":"30838"},{"code":"from collections import defaultdict\n\n# misconception change at MOST one element NO MATTER THE PIVOT\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n leftSum = nums[0]\n rightSum = 0\n \n leftDiffMap = defaultdict(list)\n leftDiffMap[k-nums[0]].append(0)\n \n rightDiffMap = defaultdict(list)\n \n for i in range(1, len(nums)):\n rightDiffMap[k-nums[i]].append(i)\n rightSum += nums[i]\n \n changeCount = [0 for _ in range(len(nums))]\n noChangeCount = 0\n \n partitionIdx = 1\n \n while True:\n rightMinusLeft = rightSum - leftSum\n if rightMinusLeft == 0:\n noChangeCount += 1\n\n if (-1 * rightMinusLeft) in rightDiffMap:\n # print('leftSum', leftSum, 'rightSum', rightSum, 'rml', rightMinusLeft, 'partIdx', partitionIdx, '||||')\n for x in rightDiffMap[-1 * rightMinusLeft]:\n # print('partitionIdx', partitionIdx, 'x', x)\n changeCount[x] += 1\n\n elif rightMinusLeft in leftDiffMap:\n # print('leftSum', leftSum, 'rightSum', rightSum, 'rml', rightMinusLeft, 'partIdx', partitionIdx)\n for x in leftDiffMap[rightMinusLeft]:\n # print('partitionIdx', partitionIdx, 'x', x)\n changeCount[x] += 1\n \n \n partitionIdx += 1\n \n if (partitionIdx == len(nums)):\n break\n \n past = nums[partitionIdx-1]\n diff = k - past \n rightDiffMap[diff].remove(partitionIdx-1)\n leftDiffMap[diff].append(partitionIdx-1)\n rightSum -= past\n leftSum += past\n \n # print(changeCount)\n return max(noChangeCount, max(changeCount))\n \n ","memory":"31314"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n ns = set(nums)\n res = [0]*(n+1)\n pre = [i for i in nums]\n for i in range(1,n):\n pre[i] += pre[i-1]\n s = pre[-1]\n idx = defaultdict(list)\n # preset = [set() for _ in range(n)]\n # postset = [set() for _ in range(n)]\n for i in range(n):\n idx[nums[i]].append(i)\n # ans = 0\n for p in range(1,n):\n l = pre[p-1]\n r = s-l\n if l == r:\n res[n] += 1\n # if res[n] > ans:\n # ans = res[n]\n t = l-r+k\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i):\n res[idx[t][j]] += 1\n # if res[idx[t][j]] > ans:\n # ans = res[idx[t][j]]\n t = r+k-l\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i,len(idx[t])):\n res[idx[t][j]] += 1\n # if res[idx[t][j]] > ans:\n # ans = res[idx[t][j]]\n return max(res)\n\n\n\n ","memory":"31790"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n ns = set(nums)\n res = [0]*(n+1)\n pre = [i for i in nums]\n for i in range(1,n):\n pre[i] += pre[i-1]\n s = pre[-1]\n idx = defaultdict(list)\n # preset = [set() for _ in range(n)]\n # postset = [set() for _ in range(n)]\n for i in range(n):\n idx[nums[i]].append(i)\n\n for p in range(1,n):\n l = pre[p-1]\n r = s-l\n if l == r:\n res[n] += 1\n t = l-r+k\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i):\n res[idx[t][j]] += 1\n t = r+k-l\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i,len(idx[t])):\n res[idx[t][j]] += 1\n return max(res)\n\n\n\n ","memory":"32266"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n ns = set()\n res = [0]*(n+1)\n pre = [nums[0]]\n ns.add(nums[0])\n for i in range(1,n):\n ns.add(nums[i])\n pre.append(pre[i-1]+nums[i])\n # pre[i] += pre[i-1]\n s = pre[-1]\n idx = defaultdict(list)\n # preset = [set() for _ in range(n)]\n # postset = [set() for _ in range(n)]\n for i in range(n):\n idx[nums[i]].append(i)\n # ans = 0\n for p in range(1,n):\n l = pre[p-1]\n r = s-l\n if l == r:\n res[n] += 1\n # if res[n] > ans:\n # ans = res[n]\n t = l-r+k\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i):\n res[idx[t][j]] += 1\n # if res[idx[t][j]] > ans:\n # ans = res[idx[t][j]]\n t = r+k-l\n \n if t in ns:\n i = bisect_left(idx[t], p)\n for j in range(i,len(idx[t])):\n res[idx[t][j]] += 1\n # if res[idx[t][j]] > ans:\n # ans = res[idx[t][j]]\n return max(res)\n\n\n\n ","memory":"32743"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # for nums[i], count how many ps before it such that ps == (S-ps) + (k-nums[i])\n cnt, n, ls = Counter(), len(nums), 0\n l, s, ans = [0] * n, sum(nums), 0\n for i in range(n):\n l[i] = (0 if i == 0 else cnt[k-nums[i]])\n ls += nums[i]\n cnt[ls-(s-ls)] += 1\n if ls == s - ls and i < n-1: ans += 1\n\n rs, cnt, r = 0, Counter(), 0\n for i in range(n-1, -1, -1):\n r = (0 if i == n-1 else cnt[k-nums[i]])\n ans = max(ans, l[i] + r)\n rs += nums[i]\n cnt[rs-(s-rs)] += 1\n return ans\n","memory":"33219"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n '''\n aaa | x | bbb\n use a hashmap to save the prev total before x\n if prev total == (total + k - x) // 2, then it is the candidates if we change x\n '''\n\n # no change\n prefix = 0\n total = sum(nums)\n ans = 0\n for num in nums[:-1]:\n prefix += num \n if prefix == total / 2:\n ans += 1\n\n # change number in the right side\n hash = defaultdict(int)\n res = [0] * len(nums)\n\n left = 0\n for i in range(len(nums) - 1):\n left += nums[i]\n hash[left] += 1\n new_total = total + k - nums[i+1]\n res[i+1] = hash[new_total / 2]\n\n right = 0\n hash = defaultdict(int)\n for i in range(len(nums)-1, 0, -1):\n right += nums[i]\n hash[right] += 1\n new_total = total + k - nums[i-1]\n res[i-1] += hash[new_total / 2]\n\n for x in res:\n ans = max(ans, x)\n\n return ans","memory":"33695"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n num_sum = sum(nums)\n \n # if no change\n no_change_partition = 0\n temp_sum = 0\n for i in range(len(nums)):\n if i != 0:\n if temp_sum == num_sum / 2:\n no_change_partition+=1\n\n temp_sum += nums[i]\n\n \n # if change\n p_left = [0 for _ in range(len(nums))]\n p_right = [0 for _ in range(len(nums))]\n \n \n \n prefix_sum = {}\n temp_sum = 0\n for i in range(len(nums)):\n\n if i != 0:\n \n sub_sum = (num_sum - nums[i] + k) / 2\n\n if sub_sum in prefix_sum.keys():\n p_left[i] = prefix_sum[sub_sum]\n \n \n temp_sum += nums[i]\n if temp_sum in prefix_sum.keys():\n prefix_sum[temp_sum]+=1\n else:\n prefix_sum[temp_sum]=1\n \n prefix_sum = {}\n temp_sum = 0\n for i in reversed(range(len(nums))):\n \n if i != len(nums) - 1:\n \n sub_sum = (num_sum - nums[i] + k) / 2\n\n if sub_sum in prefix_sum.keys():\n p_right[i] = prefix_sum[sub_sum]\n \n temp_sum += nums[i]\n if temp_sum in prefix_sum.keys():\n prefix_sum[temp_sum]+=1\n else:\n prefix_sum[temp_sum]=1\n \n partition = [x + y for x, y in zip(p_left, p_right)]\n \n return max(max(partition), no_change_partition)\n \n \n \n \n \n \n \n \n \n# # no cut\n# partition_no_cut\n \n# # cut\n# nums_sum = sum(nums)\n# # nums_sum = -46\n \n# subarray_sum = (k-element+nums_sum) / 2\n \n# prefix_sum = {22:1,\n# 26:1,\n# 1:1,\n# -19:1}\n \n# partition_left = [0,1,0,2,0.....]\n \n# partition_right = [0,1,0,2,0.....]\n \n# partition = [e+f for e, f in (partition_left, partitioin_right)]\n \n# return max(max(partitioin), partition_no_cut)\n\n\n\n ","memory":"34171"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n print(reversed([22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14]))\n \n num_sum = sum(nums)\n \n # if no change\n no_change_partition = 0\n temp_sum = 0\n for i in range(len(nums)):\n if i != 0:\n if temp_sum == num_sum / 2:\n no_change_partition+=1\n\n temp_sum += nums[i]\n \n \n # if change\n p_left = [0 for _ in range(len(nums))]\n p_right = [0 for _ in range(len(nums))]\n \n # left to right\n prefix_sum = {}\n temp_sum = 0\n for i in range(len(nums)):\n if i != 0:\n sub_sum = (num_sum - nums[i] + k) / 2\n\n if sub_sum in prefix_sum.keys():\n p_left[i] = prefix_sum[sub_sum]\n \n temp_sum += nums[i]\n if temp_sum in prefix_sum.keys():\n prefix_sum[temp_sum]+=1\n else:\n prefix_sum[temp_sum]=1\n \n # right to left\n prefix_sum = {}\n temp_sum = 0\n for i in reversed(range(len(nums))):\n \n if i != len(nums) - 1:\n \n sub_sum = (num_sum - nums[i] + k) / 2\n\n if sub_sum in prefix_sum.keys():\n p_right[i] = prefix_sum[sub_sum]\n \n temp_sum += nums[i]\n if temp_sum in prefix_sum.keys():\n prefix_sum[temp_sum]+=1\n else:\n prefix_sum[temp_sum]=1\n \n partition = [x + y for x, y in zip(p_left, p_right)]\n \n return max(max(partition), no_change_partition)\n \n \n \n \n \n \n \n \n \n# # no cut\n# partition_no_cut\n \n# # cut\n# nums_sum = sum(nums)\n# # nums_sum = -46\n \n# subarray_sum = (k-element+nums_sum) / 2\n \n# prefix_sum = {22:1,\n# 26:1,\n# 1:1,\n# -19:1}\n \n# partition_left = [0,1,0,2,0.....]\n \n# partition_right = [0,1,0,2,0.....]\n \n# partition = [e+f for e, f in (partition_left, partitioin_right)]\n \n# return max(max(partitioin), partition_no_cut)\n\n\n\n ","memory":"34648"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n counts = [0] * (len(nums) + 1)\n\n def lower(array, num):\n for a in array:\n if a > num:\n break\n else:\n counts[a] += 1\n return\n\n\n def upper(array, num):\n for a in array[::-1]:\n if a < num:\n break\n else:\n counts[a] += 1\n return\n\n total_fwd = 0\n cum_fwd = [total_fwd := total_fwd + v for v in nums]\n total_bwd = 0\n cum_bwd = [total_bwd := total_bwd + v for v in nums[::-1]][::-1]\n \n diff_map = defaultdict(list)\n for i, v in enumerate(nums):\n diff_map[k - v].append(i)\n\n for i in range(1, len(nums)):\n diff = cum_fwd[i - 1] - cum_bwd[i]\n if diff == 0:\n counts[len(nums)] += 1\n else:\n if -diff in diff_map.keys():\n lower(diff_map[-diff], i - 1)\n if diff in diff_map.keys():\n upper(diff_map[diff], i)\n\n return max(counts)\n","memory":"35124"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n counts = [0] * (len(nums) + 1)\n\n def lower(array, num):\n for a in array:\n if a > num:\n break\n else:\n counts[a] += 1\n return\n\n\n def upper(array, num):\n for a in array[::-1]:\n if a < num:\n break\n else:\n counts[a] += 1\n return\n\n total_fwd = 0\n cum_fwd = [total_fwd := total_fwd + v for v in nums]\n total_bwd = 0\n cum_bwd = [total_bwd := total_bwd + v for v in nums[::-1]][::-1]\n \n diff_map = defaultdict(list)\n for i, v in enumerate(nums):\n diff_map[k - v].append(i)\n\n for i in range(1, len(nums)):\n diff = cum_fwd[i - 1] - cum_bwd[i]\n if diff == 0:\n counts[len(nums)] += 1\n else:\n if -diff in diff_map.keys():\n lower(diff_map[-diff], i - 1)\n if diff in diff_map.keys():\n upper(diff_map[diff], i)\n\n return max(counts)\n","memory":"35124"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n d = defaultdict(list)\n lacc = 0\n l = [0]\n racc = 0\n r = [0]\n for i in range(len(nums)):\n if k - nums[i] == 0:\n pass\n d[k - nums[i]].append(i)\n\n lacc += nums[i]\n l.append(lacc)\n racc += nums[-i - 1]\n r.append(racc)\n r.reverse()\n # print(l)\n # print(r)\n # print(d)\n\n t = defaultdict(int)\n raw = 0\n for i in range(1, len(nums)):\n diff = r[i] - l[i]\n if diff == 0:\n raw += 1\n # need to find + diff left of i\n if diff in d:\n for j in d[diff]:\n if j < i:\n # print(diff, j, i, \"1\")\n t[j] += 1\n else:\n break\n\n # or - diff right of i\n diff = l[i] - r[i]\n if diff in d:\n for j in reversed(d[diff]):\n if j >= i:\n # print(diff, j, i, \"-1\")\n t[j] += 1\n else:\n break\n # print(t)\n # print(raw)\n for i in t.keys():\n raw = max(raw, t[i])\n\n return raw\n","memory":"35600"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sumLeft = 0\n sumRight = sum(nums)\n for i in range(N - 1):\n sumLeft += nums[i]\n sumRight -= nums[i]\n diffs.append(sumLeft - sumRight)\n counterLeft = defaultdict(int)\n counterRight = defaultdict(int)\n for i in range(N-1):\n counterRight[diffs[i]] += 1\n res = counterRight[0]\n for i in range(N):\n d = k - nums[i]\n res = max(res, counterLeft[d] + counterRight[-d])\n if i < N-1:\n counterLeft[diffs[i]] += 1\n counterRight[diffs[i]] -= 1\n return res\n\n ","memory":"36076"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n l, r = 0, sum(nums)\n diffs = [float(\"inf\")] * len(nums)\n\n for i in range(len(nums) - 1):\n l += nums[i]\n r -= nums[i]\n diffs[i] = l - r\n\n l_count = collections.Counter()\n r_count = collections.Counter(diffs)\n\n total = r_count[0] # Before any changes\n\n for i in range(len(nums)):\n # Simulate changing nums[i] to k\n diff = k - nums[i]\n curr = l_count[diff] + r_count[-diff]\n total = max(total, curr)\n \n l_count[diffs[i]] += 1\n r_count[diffs[i]] -= 1\n \n return total\n\n# T: O(N)\n# S: O(N)\n\n\n ","memory":"36553"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n '''prepare google\n https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/?envType=company&envId=google&favoriteSlug=google-three-months&role=all\n '''\n n = len(nums)\n sl, sr = 0, sum(nums)\n diffs = []\n for i in range(n-1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n diffs.append(float('inf'))\n #print(diffs)\n cl, cr = Counter(), Counter(diffs)\n res = cl[0] + cr[0]\n for i in range(n):\n d = k - nums[i]\n res = max(res, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n return res","memory":"37029"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sl, sr = 0, sum(nums)\n for i in range(N - 1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n diffs.append(math.inf) # to prevent error in the counter arithemtic\n \n cl, cr = Counter(), Counter(diffs)\n res = cl[0] + cr[0]\n for i in range(N):\n d = k - nums[i]\n res = max(res, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n return res","memory":"37505"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n diffs = []\n sum_left, sum_right = 0, sum(nums)\n for i in range(n - 1):\n sum_left += nums[i]\n sum_right -= nums[i]\n diffs.append(sum_right - sum_left)\n diffs.append(inf)\n # print(diffs)\n\n counter_left, counter_right = Counter(), Counter(diffs)\n res = counter_left[0] + counter_right[0]\n for i in range(n): # change at all i\n change = k - nums[i]\n local_res = counter_left[-change] + counter_right[change]\n res = max(res, local_res)\n counter_left[diffs[i]] += 1\n counter_right[diffs[i]] -= 1\n return res","memory":"37981"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sumLeft = 0\n sumRight = sum(nums)\n for i in range(N - 1):\n sumLeft += nums[i]\n sumRight -= nums[i]\n diffs.append(sumLeft - sumRight)\n counterLeft = defaultdict(int)\n counterRight = defaultdict(int)\n for i in range(N-1):\n counterRight[diffs[i]] += 1\n res = counterRight[0]\n for i in range(N):\n d = k - nums[i]\n res = max(res, counterLeft[d] + counterRight[-d])\n if i < N-1:\n counterLeft[diffs[i]] += 1\n counterRight[diffs[i]] -= 1\n return res\n\n ","memory":"38458"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n '''\n a a a a | k b b b \n '''\n\n prefix = [nums[0]]\n\n for i in range(1, len(nums)):\n prefix.append(prefix[-1] + nums[i])\n\n # do not change\n total = prefix[-1]\n ans = 0\n for p in prefix[:-1]:\n if p == total / 2:\n ans += 1\n\n # from left to right\n visited = defaultdict(int)\n res = [0] * len(nums)\n for i in range(len(nums)):\n new_total = total + k - nums[i]\n res[i] += visited[new_total/2]\n visited[prefix[i]] += 1\n\n visited = defaultdict(int)\n for i in range(len(nums)-1, -1, -1):\n new_total = total + k - nums[i]\n res[i] += visited[new_total/2]\n prev = prefix[i-1] \n visited[total - prev] += 1\n\n for x in res:\n ans = max(ans, x)\n\n return ans\n \n \n\n\n\n\n ","memory":"38934"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n left=defaultdict(int)\n right=defaultdict(int)\n\n a=0\n s=sum(nums)\n\n for i in nums[:-1]:\n a+=i\n s-=i\n right[a-s]+=1\n \n a=0\n s=sum(nums)\n ans=0\n ans=right[0]\n for i in nums:\n a+=i\n s-=i\n dif=a-s\n diff=k-i\n ans=max(ans,left[diff]+right[-diff])\n\n \n left[dif]+=1\n right[dif]-=1\n if right[dif]==0:\n del right[dif]\n return ans\n","memory":"39410"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n '''\n a a a a | k b b b \n '''\n\n prefix = [nums[0]]\n\n for i in range(1, len(nums)):\n prefix.append(prefix[-1] + nums[i])\n\n # do not change\n total = prefix[-1]\n ans = 0\n for p in prefix[:-1]:\n if p == total / 2:\n ans += 1\n\n # from left to right\n visited = defaultdict(int)\n res = [0] * len(nums)\n for i in range(len(nums)):\n new_total = total + k - nums[i]\n res[i] += visited[new_total/2]\n visited[prefix[i]] += 1\n\n visited = defaultdict(int)\n for i in range(len(nums)-1, -1, -1):\n new_total = total + k - nums[i]\n res[i] += visited[new_total/2]\n prev = prefix[i-1] if i != 0 else 0\n visited[total - prev] += 1\n\n for x in res:\n ans = max(ans, x)\n\n return ans\n \n \n\n\n\n\n ","memory":"39886"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n s = [nums[0]] * n\n right = defaultdict(int)\n for i in range(1, n):\n s[i] = s[i - 1] + nums[i]\n right[s[i - 1]] += 1\n\n ans = 0\n if s[-1] % 2 == 0:\n ans = right[s[-1] // 2]\n\n left = defaultdict(int)\n for v, x in zip(s, nums):\n d = k - x\n if (s[-1] + d) % 2 == 0:\n t = left[(s[-1] + d) // 2] + right[(s[-1] - d) // 2]\n if ans < t:\n ans = t\n left[v] += 1\n right[v] -= 1\n return ans","memory":"40363"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = [0] * n\n prefix_sum[0] = nums[0]\n \n for i in range(1, n):\n prefix_sum[i] = prefix_sum[i-1] + nums[i]\n \n total_sum = prefix_sum[-1]\n \n left = defaultdict(int)\n right = defaultdict(int)\n \n # Initialize the right hashmap with the prefix sums\n for i in range(n-1):\n right[prefix_sum[i]] += 1\n \n # Start with the number of valid partitions in the original array\n max_ways = right[total_sum // 2] if total_sum % 2 == 0 else 0\n \n for i in range(n):\n # Calculate the difference diff = k - nums[i]\n diff = k - nums[i]\n new_total_sum = total_sum + diff\n \n if i > 0:\n left[prefix_sum[i-1]] += 1\n right[prefix_sum[i-1]] -= 1\n \n # Check if the new total sum allows valid partitions\n if new_total_sum % 2 == 0:\n left_sum = new_total_sum // 2\n new_ways = 0\n \n if left_sum in left:\n new_ways += left[left_sum]\n if left_sum - diff in right:\n new_ways += right[left_sum - diff]\n \n max_ways = max(max_ways, new_ways)\n \n return max_ways","memory":"40839"},{"code":"from typing import List\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n total_sum = sum(nums)\n\n prefix_sum = [0] * (n + 1)\n \n for i in range(1, n + 1):\n prefix_sum[i] = prefix_sum[i - 1] + nums[i - 1]\n\n original_partitions = 0\n left_count = {}\n right_count = {}\n\n # Count initial valid partitions\n for i in range(1, n):\n left_sum = prefix_sum[i]\n right_sum = total_sum - left_sum\n right_count[left_sum] = right_count.get(left_sum, 0) + 1\n \n # Calculate original partitions from right_count\n original_partitions = right_count.get(total_sum // 2, 0)\n max_partitions = original_partitions\n \n # Try changing each nums[i] to k\n current_count = left_count.copy()\n\n for i in range(n):\n # If we're moving the pivot from i -> i+1, adjust the counts\n if i > 0:\n left_sum = prefix_sum[i]\n right_sum = total_sum - left_sum\n current_count[left_sum] = current_count.get(left_sum, 0) + 1\n right_count[left_sum] -= 1\n \n # Consider changing nums[i] to k\n diff = k - nums[i]\n potential_total = total_sum + diff\n\n if potential_total % 2 == 0:\n half_needed = potential_total // 2\n\n left_way = current_count.get(half_needed, 0)\n right_way = right_count.get(half_needed - diff, 0)\n\n max_partitions = max(max_partitions, left_way + right_way)\n\n return max_partitions","memory":"41315"},{"code":"class Solution:\n def waysToPartition(self, A: List[int], k: int) -> int:\n n = len(A) \n pre, s = list(itertools.accumulate(A)), sum(A)\n \n # pred contains all the presum BEFORE i-th number.\n # sufd contains all the presum AFTER and WITH i-th number.\n pred = collections.defaultdict(int)\n sufd = collections.Counter(pre)\n \n # The last prefix sum is NEVER used. \n sufd[sum(A)] -= 1\n \n # The number of ways if we do not change any number.\n ans = 0\n if s % 2 == 0:\n ans = sufd[s // 2]\n\n # The number of ways if we split i-th number to k.\n for i in range(n):\n cur = 0\n \n # We only count number of ways when A[i] != k (otherwise change makes no difference)\n # and when the SUM after the change is dividable by 2.\n if A[i] != k:\n news = s + k - A[i]\n if news % 2 == 0:\n \n # If i == 0, only count suffix part.\n if i > 0:\n cur += pred[news // 2]\n \n # If i == n - 1, only count prefix part.\n if i < n - 1:\n cur += sufd[news // 2 + A[i] - k]\n ans = max(ans, cur)\n \n # Don't forget to change the values in the two counters.\n sufd[pre[i]] -= 1\n pred[pre[i]] += 1\n \n return ans","memory":"41791"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n num_elements = len(nums)\n prefix_sums = [nums[0]] * num_elements\n\n right_partition_counts = defaultdict(int)\n\n for i in range(1, num_elements):\n prefix_sums[i] = prefix_sums[i-1] + nums[i]\n right_partition_counts[prefix_sums[i-1]] += 1\n \n max_ways = 0\n if prefix_sums[-1] % 2 == 0:\n max_ways = right_partition_counts[prefix_sums[-1] // 2]\n \n left_partition_counts = defaultdict(int)\n for prefix_sum, num in zip(prefix_sums, nums):\n diff = k - num\n if (prefix_sums[-1] + diff) % 2 == 0:\n total_ways = left_partition_counts[(prefix_sums[-1]+diff) // 2] + right_partition_counts[(prefix_sums[-1]-diff) // 2]\n max_ways = max(max_ways, total_ways)\n left_partition_counts[prefix_sum] += 1\n right_partition_counts[prefix_sum] -= 1\n\n return max_ways ","memory":"42268"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix = []\n left = defaultdict(int)\n total = 0\n for i in range(len(nums)):\n total += nums[i]\n prefix.append(total)\n if i > 0:\n left[prefix[i - 1]] += 1\n \n right = defaultdict(int)\n\n maxWays = 0\n \n if prefix[-1] % 2 == 0:\n maxWays = left[prefix[-1] // 2]\n \n for i in range(len(nums)):\n currWays = 0\n if nums[i] != k:\n newSum = prefix[-1] + k - nums[i]\n if newSum % 2 == 0:\n if i > 0:\n currWays += right[newSum // 2]\n if i < len(nums) - 1:\n currWays += left[newSum // 2 + nums[i] - k]\n maxWays = max(maxWays, currWays)\n\n left[prefix[i]] -= 1\n right[prefix[i]] += 1\n \n return maxWays","memory":"42268"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n pass\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sum_all = sum(nums)\n\n # calculate prefix sum\n prefix_sum = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sum.append(accum)\n \n prefix_counter = collections.defaultdict(int)\n suffix_counter = collections.Counter(prefix_sum)\n suffix_counter[sum_all] -= 1\n\n # count answers without changing k\n ans = 0\n if sum_all % 2 == 0:\n ans = suffix_counter[sum_all//2]\n \n # replace ith num to k\n for i in range(n):\n curr = 0\n\n if nums[i] != k:\n sum_all_new = sum_all + k - nums[i]\n if sum_all_new % 2 == 0:\n if i > 0:\n curr += prefix_counter[sum_all_new // 2]\n \n if i < n-1:\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\n\n ans = max(ans, curr)\n\n suffix_counter[prefix_sum[i]] -= 1\n prefix_counter[prefix_sum[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n counter_left = collections.defaultdict(int)\n \n # without chaning k\n ans = 0\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # change k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n \n counter_left = collections.defaultdict(int)\n counter_right = collections.Counter(prefix_sums)\n counter_right[accum] -= 1\n\n ans = 0\n\n # without replacing k\n if accum % 2 == 0:\n ans += counter_right[accum//2]\n \n # with replacing k\n for i in range(len(nums)):\n # replace nums[i] --> k\n new_sums = accum - nums[i] + k\n curr = 0\n if new_sums % 2 == 0:\n if i > 0:\n curr += counter_left[new_sums//2]\n if i < len(nums)-1:\n curr += counter_right[new_sums//2 - k + nums[i]]\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n ans = max(ans, curr)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.defaultdict(int)\n counter_right[total_sum] -= 1\n\n ans = 0\n\n # case 1. No switch to k\n if total_sum % 2 == 0:\n ans += counter_right[total_sum // 2]\n \n # case 2. Switch to k\n for i in range(len(nums)):\n curr = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\n ans = max(ans, curr)\n\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n return ans\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.Counter()\n counter_right[total_sum] -= 1\n\n cnt = 0\n # without changing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n\n # change nums[i] --> k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_left = collections.Counter()\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n\n cnt = 0\n\n # without replacing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # replace k\n for i in range(len(nums)):\n curr_cnt = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr_cnt += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\n cnt = max(cnt, curr_cnt)\n counter_right[prefix_sums[i]] -= 1\n counter_right[prefix_sums[i]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n prefix_sums = []\n for n in nums:\n accum += n\n prefix_sums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(prefix_sums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n # no switch\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # switch nums[i] --> k\n for i in range(len(nums)):\n total_sums_new = total_sum + k - nums[i]\n cnt_curr = 0\n if total_sums_new % 2 == 0:\n if i > 0:\n cnt_curr += left_counter[total_sums_new//2]\n if i < len(nums)-1:\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\n cnt = max(cnt, cnt_curr)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n counter_right[accum] += 1\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right[total_sum] -= 1\n\n\n ans = 0\n # No replace\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # replace\n for i, num in enumerate(nums):\n total_new = total_sum - num + k\n curr = 0\n if total_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_new // 2 - (k - num)]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans","memory":"42744"},{"code":"from collections import defaultdict as ddict\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n S = sum(nums)\n\n pres = [0] * N\n sufs = [0] * N\n\n pres[0] = nums[0]\n for i in range(N): \n pres[i] = pres[i-1] + nums[i]\n \n sufs[-1] = nums[-1]\n for i in range(N-2, -1, -1): \n sufs[i] = sufs[i+1] + nums[i]\n\n rsts = [0] * N\n cnt = ddict(int)\n for i in range(N): \n cur_sum = S - nums[i] + k\n if cur_sum % 2 == 0: \n rsts[i] += cnt[cur_sum // 2]\n cnt[pres[i]] += 1\n\n cnt.clear()\n for i in range(N-1, -1, -1): \n cur_sum = S - nums[i] + k\n if cur_sum % 2 == 0: \n rsts[i] += cnt[cur_sum // 2]\n cnt[sufs[i]] += 1\n \n rtn = max(rsts)\n \n alt = 0 \n for i in range(N-1): \n if pres[i] == S // 2: \n alt += 1\n\n return max(rtn, alt)\n ","memory":"42744"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n pass\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sum_all = sum(nums)\n\n # calculate prefix sum\n prefix_sum = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sum.append(accum)\n \n prefix_counter = collections.defaultdict(int)\n suffix_counter = collections.Counter(prefix_sum)\n suffix_counter[sum_all] -= 1\n\n # count answers without changing k\n ans = 0\n if sum_all % 2 == 0:\n ans = suffix_counter[sum_all//2]\n \n # replace ith num to k\n for i in range(n):\n curr = 0\n\n if nums[i] != k:\n sum_all_new = sum_all + k - nums[i]\n if sum_all_new % 2 == 0:\n if i > 0:\n curr += prefix_counter[sum_all_new // 2]\n \n if i < n-1:\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\n\n ans = max(ans, curr)\n\n suffix_counter[prefix_sum[i]] -= 1\n prefix_counter[prefix_sum[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n counter_left = collections.defaultdict(int)\n \n # without chaning k\n ans = 0\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # change k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n \n counter_left = collections.defaultdict(int)\n counter_right = collections.Counter(prefix_sums)\n counter_right[accum] -= 1\n\n ans = 0\n\n # without replacing k\n if accum % 2 == 0:\n ans += counter_right[accum//2]\n \n # with replacing k\n for i in range(len(nums)):\n # replace nums[i] --> k\n new_sums = accum - nums[i] + k\n curr = 0\n if new_sums % 2 == 0:\n if i > 0:\n curr += counter_left[new_sums//2]\n if i < len(nums)-1:\n curr += counter_right[new_sums//2 - k + nums[i]]\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n ans = max(ans, curr)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.defaultdict(int)\n counter_right[total_sum] -= 1\n\n ans = 0\n\n # case 1. No switch to k\n if total_sum % 2 == 0:\n ans += counter_right[total_sum // 2]\n \n # case 2. Switch to k\n for i in range(len(nums)):\n curr = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\n ans = max(ans, curr)\n\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n return ans\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.Counter()\n counter_right[total_sum] -= 1\n\n cnt = 0\n # without changing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n\n # change nums[i] --> k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_left = collections.Counter()\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n\n cnt = 0\n\n # without replacing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # replace k\n for i in range(len(nums)):\n curr_cnt = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr_cnt += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\n cnt = max(cnt, curr_cnt)\n counter_right[prefix_sums[i]] -= 1\n counter_right[prefix_sums[i]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n prefix_sums = []\n for n in nums:\n accum += n\n prefix_sums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(prefix_sums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n # no switch\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # switch nums[i] --> k\n for i in range(len(nums)):\n total_sums_new = total_sum + k - nums[i]\n cnt_curr = 0\n if total_sums_new % 2 == 0:\n if i > 0:\n cnt_curr += left_counter[total_sums_new//2]\n if i < len(nums)-1:\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\n cnt = max(cnt, cnt_curr)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n counter_right[accum] += 1\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right[total_sum] -= 1\n\n\n ans = 0\n # No replace\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # replace\n for i, num in enumerate(nums):\n total_new = total_sum - num + k\n curr = 0\n if total_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_new // 2 - (k - num)]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n counter_right[accum] += 1\n counter_right[accum] -= 1\n total_sum = accum\n\n cnt = 0\n # no replacement\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # with replacement\n for idx, num in enumerate(nums):\n # replace num --> k\n curr = 0\n total_sum_new = total_sum - num + k\n if total_sum_new % 2 == 0:\n if idx > 0:\n curr += counter_left[total_sum_new//2]\n if idx < len(nums)-1:\n curr += counter_right[total_sum_new//2 - (k - num)]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[idx]] -= 1\n counter_left[prefix_sums[idx]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n counter_right = collections.Counter()\n counter_left = collections.Counter()\n prefix_sums = []\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n counter_right[accum] += 1\n counter_right[accum] -= 1\n total_sum = accum\n\n ans = 0\n # case 1. no swap\n if total_sum % 2 == 0:\n ans = counter_right[total_sum//2]\n \n # case 2. swap\n for idx, num in enumerate(nums):\n # swap num --> k\n total_sum_new = total_sum - num + k\n cnt = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt += counter_right[total_sum_new // 2 + num - k]\n counter_left[prefix_sums[idx]] += 1\n counter_right[prefix_sums[idx]] -= 1\n ans = max(ans, cnt)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'''\nnums: 1, 2, 2+1, 4, 7, 3\naccu: 1, 3, 5+1, 9+1, 16+1, 19+1\ncounter_left\ncounter_right\n'''\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n accums = []\n counter_left = collections.Counter()\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n counter_right = collections.Counter(accums)\n counter_right[total_sum] -= 1\n\n # no swap\n cnt = 0\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # swap one num --> k\n for idx, num in enumerate(nums):\n total_sum_new = total_sum - num + k\n cnt_temp = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_temp += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_temp += counter_right[total_sum_new // 2 - k + num]\n counter_right[accums[idx]] -= 1\n counter_left[accums[idx]] += 1\n cnt = max(cnt_temp, cnt)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'''\n1, 3, 6, 10 ||. 9, 11\n1, 4, 10,20 29, 40\ntotal_sum = 40 \nfind idx of 20 // 2\n\ncase 1. no switch\ncase 2. switch\n\n1, 3, 6, 10-->11 ||. 9, 11\n1, 4, 10,20+1 29+1, 40+1\nleft_counter\nright_counter\n'''\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n accums = []\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(accums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n\n # case 1. no swap\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # case 2. swap\n for idx, num in enumerate(nums):\n # num --> k\n total_sum_new = total_sum - num + k\n cnt_tmp = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_tmp += left_counter[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_tmp += right_counter[total_sum_new // 2 - k + num]\n right_counter[accums[idx]] -= 1\n left_counter[accums[idx]] += 1\n cnt = max(cnt, cnt_tmp)\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accums = []\n accum = 0\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(accums)\n counter_right[total_sum] -= 1\n counter_left = collections.Counter()\n\n cnt = 0\n # without switching\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n # with switching\n for idx, num in enumerate(nums):\n # num --> k\n cnt_tmp = 0\n total_sum_new = total_sum - num + k\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_tmp += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_tmp += counter_right[total_sum_new // 2 - k + num]\n counter_right[accums[idx]] -= 1\n counter_left[accums[idx]] += 1\n cnt = max(cnt, cnt_tmp)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accums = []\n accum = 0\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n right_counter = collections.Counter(accums)\n right_counter[total_sum] -= 1\n left_counter = collections.Counter()\n\n cnt_all = 0\n\n # 1. no switch\n if total_sum % 2 == 0:\n cnt_all += right_counter[total_sum // 2]\n \n # 2. switch\n for idx in range(len(nums)):\n cnt = 0\n num = nums[idx]\n total_sum_new = total_sum - num + k\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt += left_counter[total_sum_new // 2]\n if idx < len(nums):\n cnt += right_counter[total_sum_new // 2 - k + num]\n right_counter[accums[idx]] -= 1\n left_counter[accums[idx]] += 1\n cnt_all = max(cnt_all, cnt)\n return cnt_all\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accums = []\n accum = 0\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(accums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n\n # case 1. no swap\n if total_sum % 2 == 0:\n cnt = right_counter[total_sum // 2]\n \n # case 2. swap once\n for i in range(len(nums)):\n cnt_tmp = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n cnt_tmp += left_counter[total_sum_new//2]\n if i < len(nums)-1:\n cnt_tmp += right_counter[total_sum_new//2 - k + nums[i]]\n right_counter[accums[i]] -= 1\n left_counter[accums[i]] += 1\n cnt = max(cnt, cnt_tmp)\n return cnt","memory":"43220"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n pass\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sum_all = sum(nums)\n\n # calculate prefix sum\n prefix_sum = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sum.append(accum)\n \n prefix_counter = collections.defaultdict(int)\n suffix_counter = collections.Counter(prefix_sum)\n suffix_counter[sum_all] -= 1\n\n # count answers without changing k\n ans = 0\n if sum_all % 2 == 0:\n ans = suffix_counter[sum_all//2]\n \n # replace ith num to k\n for i in range(n):\n curr = 0\n\n if nums[i] != k:\n sum_all_new = sum_all + k - nums[i]\n if sum_all_new % 2 == 0:\n if i > 0:\n curr += prefix_counter[sum_all_new // 2]\n \n if i < n-1:\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\n\n ans = max(ans, curr)\n\n suffix_counter[prefix_sum[i]] -= 1\n prefix_counter[prefix_sum[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n counter_left = collections.defaultdict(int)\n \n # without chaning k\n ans = 0\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # change k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n \n counter_left = collections.defaultdict(int)\n counter_right = collections.Counter(prefix_sums)\n counter_right[accum] -= 1\n\n ans = 0\n\n # without replacing k\n if accum % 2 == 0:\n ans += counter_right[accum//2]\n \n # with replacing k\n for i in range(len(nums)):\n # replace nums[i] --> k\n new_sums = accum - nums[i] + k\n curr = 0\n if new_sums % 2 == 0:\n if i > 0:\n curr += counter_left[new_sums//2]\n if i < len(nums)-1:\n curr += counter_right[new_sums//2 - k + nums[i]]\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n ans = max(ans, curr)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.defaultdict(int)\n counter_right[total_sum] -= 1\n\n ans = 0\n\n # case 1. No switch to k\n if total_sum % 2 == 0:\n ans += counter_right[total_sum // 2]\n \n # case 2. Switch to k\n for i in range(len(nums)):\n curr = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\n ans = max(ans, curr)\n\n counter_left[prefix_sums[i]] += 1\n counter_right[prefix_sums[i]] -= 1\n return ans\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(prefix_sums)\n counter_left = collections.Counter()\n counter_right[total_sum] -= 1\n\n cnt = 0\n # without changing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n\n # change nums[i] --> k\n for i in range(len(nums)):\n new_total_sum = total_sum - nums[i] + k\n curr = 0\n if new_total_sum % 2 == 0:\n if i > 0:\n curr += counter_left[new_total_sum // 2]\n if i < len(nums)-1:\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_left = collections.Counter()\n counter_right = collections.Counter(prefix_sums)\n counter_right[total_sum] -= 1\n\n cnt = 0\n\n # without replacing k\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # replace k\n for i in range(len(nums)):\n curr_cnt = 0\n total_sum_new = total_sum - nums[i] + k\n if total_sum_new % 2 == 0:\n if i > 0:\n curr_cnt += counter_left[total_sum_new // 2]\n if i < len(nums)-1:\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\n cnt = max(cnt, curr_cnt)\n counter_right[prefix_sums[i]] -= 1\n counter_right[prefix_sums[i]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n prefix_sums = []\n for n in nums:\n accum += n\n prefix_sums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(prefix_sums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n # no switch\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # switch nums[i] --> k\n for i in range(len(nums)):\n total_sums_new = total_sum + k - nums[i]\n cnt_curr = 0\n if total_sums_new % 2 == 0:\n if i > 0:\n cnt_curr += left_counter[total_sums_new//2]\n if i < len(nums)-1:\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\n cnt = max(cnt, cnt_curr)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n counter_right[accum] += 1\n prefix_sums.append(accum)\n total_sum = accum\n\n counter_right[total_sum] -= 1\n\n\n ans = 0\n # No replace\n if total_sum % 2 == 0:\n ans += counter_right[total_sum//2]\n\n # replace\n for i, num in enumerate(nums):\n total_new = total_sum - num + k\n curr = 0\n if total_new % 2 == 0:\n if i > 0:\n curr += counter_left[total_new // 2]\n if i < len(nums)-1:\n curr += counter_right[total_new // 2 - (k - num)]\n ans = max(ans, curr)\n counter_right[prefix_sums[i]] -= 1\n counter_left[prefix_sums[i]] += 1\n return ans\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = []\n counter_left = collections.Counter()\n counter_right = collections.Counter()\n accum = 0\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n counter_right[accum] += 1\n counter_right[accum] -= 1\n total_sum = accum\n\n cnt = 0\n # no replacement\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # with replacement\n for idx, num in enumerate(nums):\n # replace num --> k\n curr = 0\n total_sum_new = total_sum - num + k\n if total_sum_new % 2 == 0:\n if idx > 0:\n curr += counter_left[total_sum_new//2]\n if idx < len(nums)-1:\n curr += counter_right[total_sum_new//2 - (k - num)]\n cnt = max(cnt, curr)\n counter_right[prefix_sums[idx]] -= 1\n counter_left[prefix_sums[idx]] += 1\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n counter_right = collections.Counter()\n counter_left = collections.Counter()\n prefix_sums = []\n for num in nums:\n accum += num\n prefix_sums.append(accum)\n counter_right[accum] += 1\n counter_right[accum] -= 1\n total_sum = accum\n\n ans = 0\n # case 1. no swap\n if total_sum % 2 == 0:\n ans = counter_right[total_sum//2]\n \n # case 2. swap\n for idx, num in enumerate(nums):\n # swap num --> k\n total_sum_new = total_sum - num + k\n cnt = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt += counter_right[total_sum_new // 2 + num - k]\n counter_left[prefix_sums[idx]] += 1\n counter_right[prefix_sums[idx]] -= 1\n ans = max(ans, cnt)\n return ans\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'''\nnums: 1, 2, 2+1, 4, 7, 3\naccu: 1, 3, 5+1, 9+1, 16+1, 19+1\ncounter_left\ncounter_right\n'''\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n accums = []\n counter_left = collections.Counter()\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n counter_right = collections.Counter(accums)\n counter_right[total_sum] -= 1\n\n # no swap\n cnt = 0\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n \n # swap one num --> k\n for idx, num in enumerate(nums):\n total_sum_new = total_sum - num + k\n cnt_temp = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_temp += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_temp += counter_right[total_sum_new // 2 - k + num]\n counter_right[accums[idx]] -= 1\n counter_left[accums[idx]] += 1\n cnt = max(cnt_temp, cnt)\n return cnt\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'''\n1, 3, 6, 10 ||. 9, 11\n1, 4, 10,20 29, 40\ntotal_sum = 40 \nfind idx of 20 // 2\n\ncase 1. no switch\ncase 2. switch\n\n1, 3, 6, 10-->11 ||. 9, 11\n1, 4, 10,20+1 29+1, 40+1\nleft_counter\nright_counter\n'''\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accum = 0\n accums = []\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n left_counter = collections.Counter()\n right_counter = collections.Counter(accums)\n right_counter[total_sum] -= 1\n\n cnt = 0\n\n # case 1. no swap\n if total_sum % 2 == 0:\n cnt += right_counter[total_sum // 2]\n \n # case 2. swap\n for idx, num in enumerate(nums):\n # num --> k\n total_sum_new = total_sum - num + k\n cnt_tmp = 0\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_tmp += left_counter[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_tmp += right_counter[total_sum_new // 2 - k + num]\n right_counter[accums[idx]] -= 1\n left_counter[accums[idx]] += 1\n cnt = max(cnt, cnt_tmp)\n return cnt\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n accums = []\n accum = 0\n for num in nums:\n accum += num\n accums.append(accum)\n total_sum = accum\n\n counter_right = collections.Counter(accums)\n counter_right[total_sum] -= 1\n counter_left = collections.Counter()\n\n cnt = 0\n # without switching\n if total_sum % 2 == 0:\n cnt += counter_right[total_sum // 2]\n # with switching\n for idx, num in enumerate(nums):\n # num --> k\n cnt_tmp = 0\n total_sum_new = total_sum - num + k\n if total_sum_new % 2 == 0:\n if idx > 0:\n cnt_tmp += counter_left[total_sum_new // 2]\n if idx < len(nums)-1:\n cnt_tmp += counter_right[total_sum_new // 2 - k + num]\n counter_right[accums[idx]] -= 1\n counter_left[accums[idx]] += 1\n cnt = max(cnt, cnt_tmp)\n return cnt","memory":"43220"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n total = sum(nums)\n left, right = collections.Counter(), collections.Counter()\n lsum = 0\n for i in range(len(nums)-1):\n lsum += nums[i]\n right[total - 2 * lsum] += 1\n res = right[0]\n lsum = 0\n for num in nums:\n res = max(res, left[num - k] + right[-num + k])\n lsum += num\n left[total - 2 * lsum] += 1\n right[total - 2 * lsum] -= 1\n return res\n","memory":"43696"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n total = sum(nums)\n left, right = collections.Counter(), collections.Counter()\n lsum = 0\n for i in range(len(nums)-1):\n lsum += nums[i]\n rsum = total - lsum\n right[lsum - rsum] += 1\n res = right[0] # if we don't do any replacement, the answer is the number of 0\n lsum = 0\n for num in nums:\n res = max(res, left[k - num] + right[num - k]) # if we replace nums[i] with k, we will get left[d] + right[-d] pivot, where d = nums[i] - k\n lsum += num\n rsum = total - lsum\n right[lsum - rsum] -= 1 # transfer the frequency from 'right' to 'left'\n left[lsum - rsum] += 1\n return res\n","memory":"43696"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n counter = Counter()\n tot = sum(nums)\n curr = nums[0]\n\n for num in nums[1:]:\n counter[2*curr - tot]+=1\n curr+=num \n \n res = counter[0]\n left_counter = Counter()\n right_counter = counter\n curr = 0\n\n for i, num in enumerate(nums):\n res = max(res, left_counter[k-num] + right_counter[num - k])\n curr+=num \n right_counter[2*curr - tot]-=1\n left_counter[2*curr - tot]+=1\n \n return res\n\n\n\n\n ","memory":"44173"},{"code":"class Solution:\n def waysToPartition(self, nums: list[int], k: int) -> int:\n n = len(nums)\n summ = sum(nums)\n prefix = 0\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [0..i)\n l = collections.Counter()\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [i..n)\n r = collections.Counter()\n\n for pivot in range(1, n):\n prefix += nums[pivot - 1]\n suffix = summ - prefix\n r[prefix - suffix] += 1\n\n ans = r[0]\n prefix = 0\n\n for num in nums:\n ans = max(ans, l[k - num] + r[num - k])\n prefix += num\n suffix = summ - prefix\n diff = prefix - suffix\n r[diff] -= 1\n l[diff] += 1\n\n return ans\n ","memory":"44173"},{"code":"import collections\nimport itertools\nfrom typing import List\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n total = sum(nums)\n left = 0\n change_val_on_left_diff_table = collections.defaultdict(int)\n for a in nums[:-1]:\n left += a\n right = total - left\n change_val_on_left_diff_table[left - right] += 1\n\n change_val_on_right_diff_table = collections.defaultdict(int)\n left = 0\n res = change_val_on_left_diff_table[0]\n for a in nums:\n left += a\n right = total - left\n d = k - a\n res = max(\n res, change_val_on_right_diff_table[d] +\n change_val_on_left_diff_table[-d])\n change_val_on_right_diff_table[left - right] += 1\n change_val_on_left_diff_table[left - right] -= 1\n return res","memory":"44649"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n remain = sum(nums)\n s = 0\n diffs = []\n minus_diff = defaultdict(int)\n for i in range(len(nums) - 1):\n remain -= nums[i]\n s += nums[i]\n diffs.append(s - remain)\n minus_diff[s - remain] += 1\n\n res = minus_diff[0]\n add_diff = defaultdict(int)\n for i in range(len(nums)):\n res = max(res, add_diff[k - nums[i]] + minus_diff[nums[i] - k])\n if i < len(nums) - 1:\n add_diff[diffs[i]] += 1\n minus_diff[diffs[i]] -= 1\n return res\n","memory":"44649"},{"code":"class Solution:\n def waysToPartition(self, A, k):\n N = len(A)\n total_sum = sum(A)\n after_update_freq_sum_diff, initial_freq_sum_diff = defaultdict(int), defaultdict(int)\n \n left_sum = 0\n for i in range(N - 1):\n left_sum += A[i]\n right_sum = total_sum - left_sum\n initial_freq_sum_diff[left_sum - right_sum] += 1\n \n ans = initial_freq_sum_diff[0] # If no replacement is done, answer is the number of `0`s in the frequency map\n \n left_sum = 0\n for i in range(N):\n left_sum += A[i]\n right_sum = total_sum - left_sum\n d = k - A[i] # Difference if we replace A[i] with k\n ans = max(ans, after_update_freq_sum_diff[d] + initial_freq_sum_diff[-d]) # Get max of current result or new pivot count after replacement\n initial_freq_sum_diff[left_sum - right_sum] -= 1 # Transfer frequency from initial_freq_sum_diff to after_update_freq_sum_diff\n after_update_freq_sum_diff[left_sum - right_sum] += 1\n \n return ans\n","memory":"45125"},{"code":"class Solution:\n def waysToPartition(self, A, k):\n N = len(A)\n total_sum = sum(A)\n initial_freq_sum_diff = defaultdict(int)\n \n left_sum = 0\n for i in range(N - 1):\n left_sum += A[i]\n right_sum = total_sum - left_sum\n initial_freq_sum_diff[left_sum - right_sum] += 1\n\n after_update_freq_sum_diff = defaultdict(int)\n ans = initial_freq_sum_diff[0] # If no replacement is done, answer is the number of `0`s in the frequency map\n \n left_sum = 0\n for i in range(N):\n left_sum += A[i]\n right_sum = total_sum - left_sum\n d = k - A[i] # Difference if we replace A[i] with k\n ans = max(ans, after_update_freq_sum_diff[d] + initial_freq_sum_diff[-d]) # Get max of current result or new pivot count after replacement\n initial_freq_sum_diff[left_sum - right_sum] -= 1 # Transfer frequency from initial_freq_sum_diff(prefix) to after_update_freq_sum_diff(suffix) \n after_update_freq_sum_diff[left_sum - right_sum] += 1\n \n return ans\n","memory":"45125"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sum_array = [0] * n\n sum_array[0] = nums[0]\n left_freq_sums = defaultdict(int)\n right_freq_sums = defaultdict(int)\n right_freq_sums[sum_array[0]] += 1\n for i in range(1, n):\n sum_array[i] = sum_array[i-1] + nums[i]\n if i != n-1:\n right_freq_sums[sum_array[i]] += 1\n total_sum = sum_array[-1]\n\n left_sum = [sum_array[0]]\n partitions = [0] * (n+1)\n\n for pivot in range(1, n):\n if sum_array[pivot-1] == total_sum / 2:\n partitions[-1] += 1\n \n for change in range(n):\n diff = k - nums[change]\n new_total = total_sum + diff\n partitions[change] += left_freq_sums[new_total / 2]\n partitions[change] += right_freq_sums[(new_total / 2) - diff]\n \n if change != n-1:\n left_freq_sums[sum_array[change]] += 1\n right_freq_sums[sum_array[change]] -= 1\n \n return max(partitions)","memory":"45601"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n diffs = []\n sl, sr = 0, sum(nums)\n \n # Calculate prefix differences\n for i in range(N - 1):\n sl += nums[i]\n sr -= nums[i]\n diffs.append(sl - sr)\n \n # Add infinity to prevent error in the counter arithmetic\n diffs.append(float('inf'))\n print(diffs)\n\n c = Counter(diffs)\n \n # Counters for differences\n cl, cr = Counter(), Counter(diffs)\n \n # Result if k does not affect the array\n # what do we need to get 0 if we substract\n res = cr[0] # count the zeroes, thats the first result\n for i in range(N):\n d = k - nums[i]\n res = max(res, cl[d] + cr[-d])\n cl[diffs[i]] += 1\n cr[diffs[i]] -= 1\n \n\n \n return res\n","memory":"45601"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n right = Counter(itertools.accumulate(reversed(nums), operator.add))\n left = Counter()\n total = sum(nums)\n ans = self.count(right, total)\n if not total:\n ans -= 1\n left_sum, right_sum = 0, total\n for i, num in enumerate(nums):\n curr = self.count(left, total + k - num)\n left_sum += num\n left[left_sum] += 1\n right[right_sum] -= 1\n right_sum -= num\n curr += self.count(right, total + k - num)\n ans = max(ans, curr)\n\n return ans\n\n\n def count(self, cntr, sm):\n return (cntr[sm >> 1]) if not (sm & 1) else 0","memory":"46078"},{"code":"from collections import Counter\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n total = sum(nums)\n\n prefix_sum_counter = Counter()\n postfix_sum_counter = Counter()\n\n right_sum = 0\n for num in reversed(nums):\n right_sum += num\n postfix_sum_counter[right_sum] += 1\n\n if total % 2 == 0:\n out = postfix_sum_counter[total // 2]\n if total == 0:\n out -= 1\n else:\n out = 0\n\n left_sum = 0\n right_sum = total\n\n # [2,-1,2]\n #postfix_sum_counter = {2: 1, 1: 1, 3 : 1}\n # total = right_sum = 3\n \n for num in nums:\n left_sum += num #2\n \n postfix_sum_counter[right_sum] -= 1 #{2: 1, 1: 1}\n right_sum -= num #1\n\n # change num to k\n new_total = total + k - num # 4\n if new_total % 2 == 0:\n next_out = prefix_sum_counter[new_total // 2] + postfix_sum_counter[new_total // 2]\n out = max(out, next_out)\n\n prefix_sum_counter[left_sum] += 1 #{2: 1}\n \n return out\n","memory":"46078"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n sum_map = defaultdict(int)\n sum_map_reverse = defaultdict(int)\n total_sum = sum(nums)\n cur_sum = 0\n for i in reversed(range(len(nums))):\n cur_sum += nums[i]\n sum_map_reverse[cur_sum] += 1 \n res = []\n cur_sum = 0\n for i in range(len(nums)):\n offset = k - nums[i]\n cur_half = (total_sum+offset)/2\n left_count = sum_map[cur_half]\n sum_map_reverse[total_sum-cur_sum] -= 1\n cur_sum += nums[i]\n sum_map[cur_sum] += 1\n right_count = sum_map_reverse[cur_half]\n res.append(left_count+right_count)\n no_change_res = 0\n cur_sum = 0\n for i in range(len(nums)-1): \n cur_sum += nums[i]\n if cur_sum == total_sum/2:\n no_change_res += 1\n res.append(no_change_res)\n return max(res)\n\n\n\n\n ","memory":"46554"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n total_sum = sum(nums)\n prefix_sum = 0\n left_count = defaultdict(int)\n right_count = defaultdict(int)\n \n for i in range(1, n):\n prefix_sum += nums[i - 1]\n right_count[prefix_sum] += 1\n \n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\n \n prefix_sum = 0\n for i in range(n):\n if i > 0:\n prefix_sum += nums[i - 1]\n right_count[prefix_sum] -= 1\n left_count[prefix_sum] += 1\n \n diff = k - nums[i]\n if (total_sum + diff) % 2 == 0:\n target = (total_sum + diff) // 2\n max_ways = max(max_ways, left_count[target] + right_count[target - diff])\n \n return max_ways","memory":"47030"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n total_sum = sum(nums)\n prefix_sum = 0\n left_count = defaultdict(int)\n right_count = defaultdict(int)\n \n for i in range(1, n):\n prefix_sum += nums[i - 1]\n right_count[prefix_sum] += 1\n \n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\n \n prefix_sum = 0\n for i in range(n):\n if i > 0:\n prefix_sum += nums[i - 1]\n right_count[prefix_sum] -= 1\n left_count[prefix_sum] += 1\n \n diff = k - nums[i]\n if (total_sum + diff) % 2 == 0:\n target = (total_sum + diff) // 2\n max_ways = max(max_ways, left_count[target] + right_count[target - diff])\n \n return max_ways","memory":"47030"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n total_sum = sum(nums)\n prefix_sum = 0\n \n # Calculate initial valid pivots without any change\n left_count = defaultdict(int)\n right_count = defaultdict(int)\n \n # Fill right_count with initial pivot possibilities\n for i in range(n - 1):\n prefix_sum += nums[i]\n right_count[prefix_sum] += 1\n \n prefix_sum = 0\n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\n \n # Check the effect of changing each element to k\n for i in range(n):\n current = nums[i]\n diff = k - current\n \n # Calculate the number of ways if we change nums[i] to k\n if i > 0:\n prefix_sum += nums[i - 1]\n left_count[prefix_sum] += 1\n right_count[prefix_sum] -= 1\n \n if (total_sum + diff) % 2 == 0:\n target = (total_sum + diff) // 2\n current_ways = left_count[target] + right_count[target - diff]\n max_ways = max(max_ways, current_ways)\n \n return max_ways\n\n# Example usage:\n# solution = Solution()\n# print(solution.waysToPartition([2, -1, 2], 3)) # Output: 1\n# print(solution.waysToPartition([0, 0, 0], 1)) # Output: 2\n# print(solution.waysToPartition([22, 4, -25, -20, -15, 15, -16, 7, 19, -10, 0, -13, -14], -33)) # Output: 4","memory":"47506"},{"code":"class Solution:\n # Time: O()\n # Space: O(), where n = len(nums)\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n total_sum = sum(nums)\n counts_pref_sums = defaultdict(int)\n curr_sum = 0\n \n # Calculate prefix sums and count occurrences\n for idx in range(len(nums) - 1):\n curr_sum += nums[idx]\n counts_pref_sums[curr_sum] += 1\n \n # Case 1: When no element is changed, calculate the number of ways to partition\n res = 0\n if total_sum % 2 == 0:\n # Each left and right should have this sum half_sum\n half_sum = total_sum // 2\n res = counts_pref_sums[half_sum]\n\n temp_counts = defaultdict(int)\n curr_sum = 0\n n = len(nums)\n \n for idx in range(n):\n # possible = curr_sum + k\n half_sum = total_sum + k - nums[idx]\n \n if half_sum % 2 == 1:\n # If new half_sum is not an integer, skip this element\n curr_sum += nums[idx]\n temp_counts[curr_sum] += 1\n else:\n half_sum //= 2\n curr_sum += nums[idx]\n \n # Calculate valid partitions if the pivot happens later or before\n total_halves_later = counts_pref_sums[half_sum - k + nums[idx]] - temp_counts[half_sum - k + nums[idx]]\n total_halves_before = temp_counts[half_sum]\n \n temp_counts[curr_sum] += 1\n res = max(res, total_halves_later + total_halves_before)\n \n return res\n\n","memory":"47506"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sum = 0\n prefix_sum_counts = defaultdict(int)\n # prefix_sum_counts[prefix_sum] += 1\n\n max_ways_to_partition = 0\n arr_sum = sum(nums)\n\n for num in nums[:-1]:\n prefix_sum += num\n if prefix_sum == arr_sum - prefix_sum:\n max_ways_to_partition += 1\n\n prefix_sum_counts[prefix_sum] += 1\n\n # # to handle the condition that pivot can at most be n - 1.\n # prefix_sum_counts[prefix_sum] -= 1\n\n prefix_sum = 0\n left_ps = defaultdict(int)\n\n for num in nums:\n ways_to_partition = (\n left_ps[(arr_sum + k - num) / 2]\n + prefix_sum_counts[(arr_sum - k + num) / 2]\n )\n\n prefix_sum += num\n left_ps[prefix_sum] += 1\n prefix_sum_counts[prefix_sum] -= 1\n\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\n\n return max_ways_to_partition\n","memory":"47983"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sum = 0\n prefix_sum_counts = defaultdict(int)\n\n max_ways_to_partition = 0\n arr_sum = sum(nums)\n\n for num in nums[:-1]:\n prefix_sum += num\n if prefix_sum == arr_sum - prefix_sum:\n max_ways_to_partition += 1\n\n prefix_sum_counts[prefix_sum] += 1\n\n prefix_sum = 0\n left_ps = defaultdict(int)\n\n for num in nums:\n ways_to_partition = (\n left_ps[(arr_sum + k - num) / 2]\n + prefix_sum_counts[(arr_sum - k + num) / 2]\n )\n\n prefix_sum += num\n left_ps[prefix_sum] += 1\n prefix_sum_counts[prefix_sum] -= 1\n\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\n\n return max_ways_to_partition\n","memory":"47983"},{"code":"class Solution:\n def waysToPartition(self, A: List[int], k: int) -> int:\n presum = list(accumulate(A))\n\n leftCnt = Counter()\n rightCnt = Counter()\n\n n = len(A)\n\n for i in range(1, n):\n diff = presum[i-1] - (presum[-1] - presum[i-1])\n rightCnt[diff] += 1\n\n ans = rightCnt[0]\n\n for i, a in enumerate(A):\n diff = k - a\n ans = max(ans, leftCnt[diff] + rightCnt[-diff])\n # Why rightCnt[-diff]?\n # Since only prefix (left) is in creased by diff and the suffix is not influenced\n # the original diff will become new_diff = (prefix + diff) - suffix\n # To make new_diff also zero, we have to offset by -diff... so we query rightCnt[-diff]\n\n # Why leftCnt[diff]\n # Because.. new_diff = prefix - (suffix + diff)\n # To make new_diff also zero, we have to offset by +diff... so we query leftCnt[diff]\n \n # simply copy right to left...\n oriDiff = presum[i] - (presum[-1] - presum[i])\n leftCnt[oriDiff] += 1\n rightCnt[oriDiff] -= 1\n\n\n return ans ","memory":"48459"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n diff_counter = collections.Counter()\n n = len(nums)\n P = [0] + list(accumulate(nums))\n\n for p in range(n-1):\n left = P[p + 1] - P[0]\n right = P[n] - P[p + 1]\n diff_counter[right - left] += 1\n\n ans = diff_counter[0]\n counter = Counter()\n\n for i in range(n):\n diff = k - nums[i]\n ans = max(ans, diff_counter[diff] + counter[-diff])\n\n left = P[i+1] - P[0]\n right = P[n] - P[i+1]\n counter[right - left] += 1\n diff_counter[right - left] -= 1\n\n return ans","memory":"48459"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n, nSum = len(nums), sum(nums)\n pref = [nums[0]]\n for l in range(1,n):\n pref.append(nums[l]+pref[l-1])\n diffAfter=collections.defaultdict(int)\n for i in range(n-1):\n diffAfter[nSum - 2 * pref[i]]+=1\n diffBefore = collections.defaultdict(int)\n ans = diffAfter[0]\n ans = max(ans, diffAfter[k - nums[0]]) # If we change first num\n # right side = sum - prefix[i]-k left side = prefix[i] +k\n print(diffAfter,nums[0],k)\n for j in range(1,n):\n diff = nSum - 2 * pref[j-1]\n diffAfter[diff]-=1\n diffBefore[diff]+=1\n ans = max(ans, diffAfter[k - nums[j]] + diffBefore[nums[j] - k])\n\n return ans \n\n\n ","memory":"48935"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n prefix_sums = [0] * n\n prefix_sums[0] = nums[0]\n for i in range(1, n):\n prefix_sums[i] = prefix_sums[i-1] + nums[i]\n \n whole_sum = prefix_sums[-1]\n\n before_diffs = defaultdict(int)\n after_diffs = defaultdict(int)\n\n for i in range(n - 1):\n after_diffs[whole_sum - 2 * prefix_sums[i]] += 1\n \n res = after_diffs[0]\n\n for i in range(n):\n d = k - nums[i]\n res = max(res, after_diffs[d] + before_diffs[-d])\n\n after_diffs[whole_sum - 2 * prefix_sums[i]] -= 1\n before_diffs[whole_sum - 2 * prefix_sums[i]] += 1\n \n return res\n","memory":"48935"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = [0]*n\n prefix_sum[0] = nums[0]\n for i in range(1,n):\n prefix_sum[i] = prefix_sum[i-1]+nums[i]\n \n total_sum = prefix_sum[-1]\n diff_map_right = defaultdict(int)\n diff_map_left = defaultdict(int)\n\n for i in range(1,n):\n cur_diff = 2*prefix_sum[i-1] - total_sum\n diff_map_right[cur_diff]+=1\n\n max_partition = diff_map_right[0]\n\n for j in range(n):\n change_diff = k - nums[j]\n \n max_partition = max(max_partition, diff_map_left[change_diff]+diff_map_right[-change_diff])\n \n diff = 2 * prefix_sum[j] - total_sum\n diff_map_left[diff]+=1\n diff_map_right[diff]-=1\n \n return max_partition","memory":"49411"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sums = list(accumulate(nums))\n total_sum = prefix_sums[-1]\n best = 0\n if total_sum % 2 == 0:\n best = prefix_sums[:-1].count(total_sum // 2) # If no change\n\n after_counts = Counter(total_sum - 2 * prefix_sum\n for prefix_sum in prefix_sums[:-1])\n before_counts = Counter()\n\n best = max(best, after_counts[k - nums[0]]) # If we change first num\n\n for prefix, x in zip(prefix_sums, nums[1:]):\n gap = total_sum - 2 * prefix\n after_counts[gap] -= 1\n before_counts[gap] += 1\n\n best = max(best, after_counts[k - x] + before_counts[x - k])\n\n return best","memory":"49411"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n targ = sum(nums)\n noneans = 0\n ans = [0]*len(nums)\n lsums,rsums = {nums[0]*2-targ:1},{nums[-1]*2-targ:1}\n prefix = [nums[0]]\n for i in range(1,len(nums)):\n if prefix[-1]*2==targ: noneans += 1\n prefix.append(prefix[-1]+nums[i])\n for i in range(1,len(nums)):\n if k-nums[i] in lsums: ans[i] += lsums[k-nums[i]]\n lsums[prefix[i]*2-targ] = lsums.get(prefix[i]*2-targ,0)+1\n for i in range(len(prefix)-2,-1,-1):\n if k-nums[i] in rsums: ans[i] += rsums[k-nums[i]]\n rsums[targ-prefix[i-1]*2] = rsums.get(targ-prefix[i-1]*2,0)+1\n return max(max(ans),noneans)","memory":"49888"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n, nSum = len(nums), sum(nums)\n pref = list(accumulate(nums))\n diffAfter = Counter(nSum - 2 * prefix\n for prefix in pref[:-1])\n # for i in range(n-1):\n # diffAfter[nSum - 2 * pref[i]]+=1\n diffBefore = collections.defaultdict(int)\n ans = diffAfter[0]\n ans = max(ans, diffAfter[k - nums[0]]) # If we change first num\n # right side = sum - prefix[i]-k left side = prefix[i] +k\n for j in range(1,n):\n diff = nSum - 2 * pref[j-1]\n diffAfter[diff]-=1\n diffBefore[diff]+=1\n ans = max(ans, diffAfter[k - nums[j]] + diffBefore[nums[j] - k])\n\n return ans \n\n\n ","memory":"49888"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix_sum = nums[0]\n prefix_sum_counts = defaultdict(int)\n prefix_sum_counts[prefix_sum] += 1\n\n max_ways_to_partition = 0\n arr_sum = sum(nums)\n\n for num in nums[1:]:\n if prefix_sum == arr_sum - prefix_sum:\n max_ways_to_partition += 1\n\n prefix_sum += num\n prefix_sum_counts[prefix_sum] += 1\n\n # to handle the condition that pivot can at most be n - 1.\n prefix_sum_counts[prefix_sum] -= 1\n\n prefix_sum = nums[0]\n left_ps = defaultdict(int)\n\n right_ps = prefix_sum_counts\n\n if (arr_sum - k + nums[0]) % 2 == 0:\n max_ways_to_partition = max(\n max_ways_to_partition, right_ps[(arr_sum - k + nums[0]) // 2]\n )\n\n left_ps[prefix_sum] += 1\n right_ps[prefix_sum] -= 1\n\n for idx, num in enumerate(nums[1:], 1):\n ways_to_partition = 0\n ways_to_partition += left_ps[(arr_sum + k - num) / 2]\n ways_to_partition += right_ps[(arr_sum - k + num) / 2]\n\n prefix_sum += num\n left_ps[prefix_sum] += 1\n right_ps[prefix_sum] -= 1\n\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\n\n return max_ways_to_partition\n","memory":"50364"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n\n left_sum = [nums[0]]\n for num in nums[1:]:\n left_sum.append(left_sum[-1] + num)\n\n right_sum = [nums[-1]]\n for num in nums[::-1][1:]:\n right_sum.append(right_sum[-1] + num)\n right_sum = right_sum[::-1]\n\n diffs = []\n\n for pivot in range(1, len(nums)):\n diffs.append(left_sum[pivot-1]-right_sum[pivot])\n diffs.append(math.inf) # to prevent error in the counter arithemtic\n \n counter_left, counter_right = Counter(), Counter(diffs)\n output = counter_right[0]\n for i in range(len(nums)):\n d = k - nums[i]\n output = max(output, counter_left[d] + counter_right[-d])\n counter_left[diffs[i]] += 1\n counter_right[diffs[i]] -= 1\n \n print(diffs)\n return output","memory":"50364"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix = [0]\n for x in nums: prefix.append(prefix[-1] + x)\n \n ans = 0\n n = len(nums)\n loc = defaultdict(list)\n for i in range(1, n):\n if prefix[i] * 2 == prefix[-1]: ans += 1\n loc[prefix[i]].append(i)\n \n total = prefix[-1]\n if total % 2 == 0: ans = max(ans, len(loc[total//2]))\n \n for i, x in enumerate(nums):\n cnt = 0\n diff = k - x\n if diff:\n r = total + diff\n if r % 2 == 0:\n r //= 2\n cnt += bisect_left(loc[r], i+1)\n if r-diff in loc:\n cnt += len(loc[r-diff]) - bisect_left(loc[r-diff], i+1)\n ans = max(ans, cnt)\n return ans","memory":"50840"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left_sum = [nums[0]]\n for num in nums[1:]:\n left_sum.append(left_sum[-1] + num)\n\n right_sum = [nums[-1]]\n for num in nums[::-1][1:]:\n right_sum.append(right_sum[-1] + num)\n right_sum = right_sum[::-1]\n\n diffs = []\n for pivot in range(1, len(nums)):\n diffs.append(left_sum[pivot-1]-right_sum[pivot])\n diffs.append(math.inf) # to prevent error in the counter arithemtic\n \n counter_left, counter_right = Counter(), Counter(diffs)\n output = counter_right[0]\n for i in range(len(nums)):\n d = k - nums[i]\n output = max(output, counter_left[d] + counter_right[-d])\n counter_left[diffs[i]] += 1\n counter_right[diffs[i]] -= 1\n \n return output","memory":"50840"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n preSum = [0] * (n + 1)\n for i in range(n):\n preSum[i + 1] = preSum[i] + nums[i]\n totalSum = preSum[n]\n\n balances = []\n for pivot in range(1, n):\n bal = 2 * preSum[pivot] - totalSum\n balances.append(bal)\n\n from collections import Counter\n counts_bal = Counter(balances)\n\n left_counts = Counter()\n right_counts = counts_bal.copy()\n max_counts = counts_bal[0] # counts of valid pivots in original array\n\n for i in range(n):\n diff = k - nums[i]\n counts_left = left_counts.get(diff, 0)\n counts_right = right_counts.get(-diff, 0)\n total_counts = counts_left + counts_right\n max_counts = max(max_counts, total_counts)\n if i < n - 1:\n bal = balances[i]\n left_counts[bal] += 1\n right_counts[bal] -= 1\n if right_counts[bal] == 0:\n del right_counts[bal]\n return max_counts\n","memory":"51316"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \n \n def get_prefix(nums):\n prefix = [0]*(len(nums))\n prefix[0] = nums[0]\n for idx in range(1,len(nums)):\n prefix[idx] = prefix[idx-1] + nums[idx]\n \n return prefix\n \n original = get_prefix(nums)\n \n dic_nums = defaultdict(list)\n \n for idx,prefix in enumerate(original[:-1]):\n dic_nums[prefix].append(idx)\n \n \n real_total = original[-1]\n \n def count_partition(arr):\n left_sum = arr[0]\n total = sum(arr)\n cnt = 0\n for idx in range(1,len(arr)):\n right_sum = total - left_sum\n \n if left_sum == right_sum:\n cnt +=1\n \n left_sum += arr[idx]\n \n return cnt\n ans = count_partition(nums)\n print(ans)\n \n for idx in range(len(nums)):\n diff = nums[idx] - k\n pure_target = real_total - diff\n if pure_target % 2 == 1:\n continue\n \n target_left = pure_target//2\n target_right = target_left + diff\n \n \n left_contribution = 0\n \n if target_left in dic_nums:\n left_contribution = bisect_left(dic_nums[target_left],idx)\n \n right_contribution = 0\n if target_right in dic_nums:\n right_contribution = len(dic_nums[target_right]) - bisect_left(dic_nums[target_right],idx)\n \n \n cur_ans = left_contribution + right_contribution\n \n \n if idx == 18:\n print(left_contribution,right_contribution,target_left,target_right)\n print(dic_nums[target_left],len(dic_nums[target_left]))\n print(dic_nums[target_right],len(dic_nums[target_right]))\n \n \n ans = max(ans,cur_ans)\n \n \n \n \n \n \n \n return ans\n \n \n \n \n \n \n ","memory":"51316"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix = [0]\n loc = defaultdict(list)\n for i, x in enumerate(nums): \n prefix.append(prefix[-1] + x)\n if i < len(nums)-1: loc[prefix[-1]].append(i)\n \n ans = 0 \n if prefix[-1] % 2 == 0: ans = len(loc[prefix[-1]//2]) # unchanged \n \n total = prefix[-1]\n for i, x in enumerate(nums): \n cnt = 0 \n diff = k - x\n target = total + diff \n if target % 2 == 0: \n target //= 2\n cnt += bisect_left(loc[target], i)\n cnt += len(loc[target-diff]) - bisect_left(loc[target-diff], i)\n ans = max(ans, cnt)\n return ans ","memory":"51793"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix = [0]\n loc = defaultdict(list)\n for i, x in enumerate(nums): \n prefix.append(prefix[-1] + x)\n if i < len(nums)-1: loc[prefix[-1]].append(i)\n \n ans = 0 \n if prefix[-1] % 2 == 0: ans = len(loc[prefix[-1]//2]) # unchanged \n \n total = prefix[-1]\n for i, x in enumerate(nums): \n cnt = 0 \n diff = k - x\n target = total + diff \n if target % 2 == 0: \n target //= 2\n cnt += bisect_left(loc[target], i)\n cnt += len(loc[target-diff]) - bisect_left(loc[target-diff], i)\n ans = max(ans, cnt)\n return ans ","memory":"51793"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n N = len(nums)\n prefix_sum = [0 for _ in range(N)]\n postfix_sum = [0 for _ in range(N)]\n prefix_sum[0] = nums[0]\n postfix_sum[-1] = nums[-1]\n\n for i in range(1, N):\n prefix_sum[i] = prefix_sum[i - 1] + nums[i]\n postfix_sum[N - 1 - i] = postfix_sum[N - i] + nums[N - 1 - i]\n \n ways_unchanged = 0\n \n for pivot in range(1, N):\n left = prefix_sum[pivot - 1]\n right = postfix_sum[pivot]\n if left == right:\n ways_unchanged += 1\n \n ways_changed = 0\n\n \"\"\"\n left - something + k == right\n or\n left == right - something + k\n\n We have prefix sums and postfix sums.\n We are considering the case of changing one element here ONLY.\n Does it help to keep track of frequencies (counters) of sums? Maybe.\n\n \"\"\"\n sum_diffs = [l - r for l, r in zip(prefix_sum[:-1], postfix_sum[1:])]\n left = Counter()\n right = Counter(sum_diffs)\n\n for idx in range(N):\n replaced = nums[idx]\n required_diff = k - replaced\n ways = 0\n if idx > 0:\n left[sum_diffs[idx - 1]] += 1\n right[sum_diffs[idx - 1]] -= 1\n ways += left[required_diff] \n ways += right[-required_diff]\n ways_changed = max(ways, ways_changed)\n \n return max(ways_unchanged, ways_changed)\n","memory":"52269"},{"code":"import itertools\nfrom collections import defaultdict, Counter\nimport math\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n prefix_sum = list(itertools.accumulate(nums))\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\n\n def get_max_pivots_v1():\n max_pivots = 0\n for i in range(n):\n pivots = 0\n delta = k - nums[i]\n for j in range(1, n):\n diff = prefix_sum[j - 1] - suffix_sum[j]\n if diff == 0:\n pivots += 1\n continue\n if j <= i:\n if diff == delta:\n pivots += 1\n else:\n if diff == -delta:\n pivots += 1\n max_pivots = max(pivots, max_pivots)\n return max_pivots\n\n def get_max_pivots_v2():\n diffs = []\n for i in range(1, n):\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\n print(diffs)\n diffs_rev = list(reversed(diffs))\n pre_diffs = Counter()\n post_diffs = Counter(diffs)\n max_pivots = post_diffs[0]\n for i in range(n):\n delta = k - nums[i]\n if diffs_rev and i != 0:\n diff = diffs_rev.pop()\n pre_diffs.update([diff])\n post_diffs.subtract([diff])\n max_pivots = max(max_pivots, max(pre_diffs[delta], 0) + max(post_diffs[-delta], 0))\n return max_pivots\n\n return get_max_pivots_v2()\n","memory":"52269"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n sz, ans, left, right = len(nums), 0, defaultdict(int), defaultdict(int)\n prefix, suffix = [0] * sz, [0] * sz\n prefix[0], suffix[-1] = nums[0], nums[-1]\n # store prefix and suffix sum\n for idx in range(1, sz):\n prefix[idx] = prefix[idx - 1] + nums[idx]\n suffix[sz - 1 - idx] = suffix[sz - idx] + nums[sz - 1 - idx]\n # intially store the differences in the hashmap right\n # print(prefix)\n # print(\"*******\")\n # print(suffix)\n for idx in range(sz - 1):\n right[prefix[idx] - suffix[idx + 1]] += 1\n # print(\"*******\")\n # print(right)\n if 0 in right:\n ans = right[0]\n for idx in range(sz):\n # find the number of pivot indexes when nums[i] is changed to k\n curr, diff = 0, k - nums[idx]\n if diff in left: \n curr += left[diff]\n if -diff in right: \n curr += right[-diff]\n # update answer\n ans = max(ans, curr)\n # transfer the current element from right to left\n if idx < sz - 1:\n currentElem = prefix[idx] - suffix[idx + 1]\n left[currentElem] += 1\n right[currentElem] -= 1\n # if right[currentElem] == 0:\n # del right[currentElem]\n # print(\"=======\")\n # print(right)\n # print(left)\n # print(\"__________\")\n return ans\n # res = 0\n # prefix_sum = [nums[0]]*len(nums)\n # prefix_map = defaultdict(int)\n # prefix_map[nums[0]] = 1\n # for i in range(1, len(nums)):\n # prefix_sum[i] = prefix_sum[i-1] + nums[i]\n # if i != len(nums) - 1:\n # prefix_map[prefix_sum[i]] += 1\n # print(prefix_map)\n # if prefix_sum[-1] % 2 == 0:\n # res = max(res, prefix_map[prefix_sum[-1]//2])\n # print(\"Prefix sum half : \", prefix_sum[-1]//2,\" count is : \", res)\n \n \n # for i in range(len(nums)):\n # # count = 0\n # diff = k - nums[i]\n # if (prefix_sum[-1] + diff) % 2 != 0:\n # continue\n # # for j in range(len(nums)-1):\n # # cur_prefix = prefix_sum[j] + diff if j >= i else prefix_sum[j]\n # # if cur_prefix == ((prefix_sum[-1] + diff) // 2):\n # # count += 1\n # # print(\"Prefix sum half : \", ((prefix_sum[-1] + diff) // 2),\" count is : \", count)\n # res = max(res, prefix_map[(prefix_sum[-1] + diff)//2])\n\n # return res\n\n ","memory":"52745"},{"code":"\"\"\"\nnums = [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14], k = -33\n\n[ 22, 4,-25,-20, -15, 15,-16, 7, 19,-10, 0,-13,-14]\n 22 26 1 -19 -34 -19 -35 -28 -9 -19 -19 -32 -46 \n -33 k\n -33\n -33 k\n 22 -11\n -33 k\n 22 26 -7\n -33 k\n 22 26 1 -32\n\n1) 2 eq part: prefix sum = suffix sum\n 3) unchange can calc directly by iter each num as pivot (T:n)\n2) try change each num to k, or unchange\n - calc prefix sum, suffix sum for every nums[i] change (T:n^2)\n3) change k, left contain num[i]->k changes, same to right\n - till j, whether 0~j changes, the same on left\n - every p, if left has k meets, than changes can be 1 of left, |left| poss?\n - but num[i]->k is diff change, not k change\n4) diff of left part and right part matters\n - part_diff = left - right\n - no change: find part_diff = 0\n - change diff = k - nums[i]\n - change on jth, \n - right contain j: left (0, 0)..(0, j-1) right (1, n-1)..(j,n-1)\n -> left = right + change_diff\n -> left - right = change_diff \n -> part_diff = change_diff\n - left contain j: left (0, j)..(0, n-2) right (j+1, n-1)..(n-1,n-1)\n -> left + change_diff = right\n -> left - right = -change_diff\n -> part_diff = -change_diff\n - diffs_left_right_left_inc_k, diffs_left_right_right_inc_k\n\n\"\"\"\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n left_pf_sum = [0 for _ in range(n)]\n right_pf_sum = [0 for _ in range(n)]\n for i in range(n):\n left_pf_sum[i] = (left_pf_sum[i-1] + nums[i]) if i-1 >= 0 else nums[i]\n for i in range(n-1, -1, -1):\n right_pf_sum[i] = (right_pf_sum[i+1] + nums[i]) if i+1 <= n-1 else nums[i]\n # no change\n result = 0\n for i in range(n-1):\n if left_pf_sum[i] == right_pf_sum[i+1]: result += 1\n \n # changes on k\n diffs_left_right_k_in_left = {} # diff:cnt\n for i in range(n-1):\n diff = left_pf_sum[i]-right_pf_sum[i+1]\n diffs_left_right_k_in_left[diff] = diffs_left_right_k_in_left.get(diff, 0) + 1\n diffs_left_right_k_in_right = {} # diff:cnt\n for i in range(n):\n change = k-nums[i]\n # print(f\"nums[i]:{nums[i]}, change:{change}, diffs_left:{diffs_left_right_k_in_left}, diffs_right:{diffs_left_right_k_in_right}\")\n result_cur = 0\n result_cur += diffs_left_right_k_in_left.get(-change, 0)\n result_cur += diffs_left_right_k_in_right.get(change, 0)\n result = max(result, result_cur)\n if i+1 > n-1: break\n diff_cur = (left_pf_sum[i]-right_pf_sum[i+1])\n diffs_left_right_k_in_left[diff_cur] -= 1\n diffs_left_right_k_in_right[diff_cur] = diffs_left_right_k_in_right.get(diff_cur, 0) + 1\n\n return result","memory":"53221"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n \"\"\"\n 1. How can we find the count of pivots if we don't change any value\n - count all indexes where prefix[i] = suffix[i + 1]\n 2. If we change jth element to k and get d = k - nums[j]\n - Values from prefix[j] to prefix[n - 1] will increase by d\n - values from suffix[j] to suffix[0] will be increased by d\n - If we have counts of all indexies i, such that\n - if i < j, where prefix[i] - suffix[i] = d in the original array\n - if i >= j, where prefix[i]- suffix[i] = -d in the original array\n \"\"\"\n # calculate prefix and suffix\n n = len(nums)\n prefix, suffix = [0] * n, [0] * n\n prefix[0], suffix[n - 1] = nums[0], nums[n - 1]\n for i in range(1, n):\n prefix[i] = prefix[i - 1] + nums[i]\n suffix[n - 1 - i] = suffix[n - i] + nums[n - 1 - i]\n\n # create a map to count the frequency of different d (prefix[i] - suffix[i])\n # we rotate items from right to left later to comply with the change of the elements\n left, right = defaultdict(int), defaultdict(int)\n for i in range(n - 1):\n right[prefix[i] - suffix[i + 1]] += 1\n\n # this is the number of ways of partitions without changing any element\n res = right[0]\n\n # try to change each element\n for i in range(n):\n d = k - nums[i]\n # here the left dictionary is formed in the previous loop\n cur = left[d] + right[-d]\n res = max(res, cur)\n\n # rotate the d that is calculated with ith element from right to left for next loop\n if i < n - 1:\n dd = prefix[i] - suffix[i + 1]\n right[dd] -= 1\n left[dd] += 1\n\n return res","memory":"53698"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix = []\n rightDiff = defaultdict(int)\n for num in nums:\n if prefix:\n prefix.append(prefix[-1] + num)\n else:\n prefix.append(num)\n n = len(nums)\n diffArr = []\n for i in range(1,n):\n left = prefix[i-1]\n right = prefix[-1] - left\n diffArr.append(right-left)\n rightDiff[right-left] += 1\n sol = rightDiff[0]\n ans = [0]*n + [sol]\n leftDiff = defaultdict(int)\n for i in range(n):\n change = k - nums[i]\n ans[i] += rightDiff[change] + leftDiff[change]\n switched = diffArr[i] if i < n-1 else 0\n rightDiff[switched] -= 1\n leftDiff[-switched] += 1\n return max(ans)\n\n\n \n\n \n \n\n \n ","memory":"54174"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left, right = defaultdict(int), defaultdict(int)\n n = len(nums)\n prefixSum, suffixSum = [0] * n, [0] * n\n prefixSum[0] = nums[0]\n suffixSum[-1] = nums[-1]\n for i in range(1,n):\n prefixSum[i] = nums[i] + prefixSum[i-1]\n for i in range(n-2, -1, -1):\n suffixSum[i] = nums[i] + suffixSum[i+1]\n for i in range(n-1):\n right[prefixSum[i] - suffixSum[i+1]] += 1\n ans = right[0]\n for i in range(n):\n # change the element at i to k\n diff = k - nums[i]\n cur = left[diff] + right[-diff]\n ans = max(cur, ans)\n if i < n - 1:\n curdiff = prefixSum[i] - suffixSum[i+1]\n left[curdiff] += 1\n right[curdiff] -= 1\n return ans\n","memory":"54650"},{"code":"from collections import defaultdict\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n left, right = defaultdict(int), defaultdict(int)\n n = len(nums)\n prefixSum, suffixSum = [0] * n, [0] * n\n prefixSum[0] = nums[0]\n suffixSum[-1] = nums[-1]\n for i in range(1,n):\n prefixSum[i] = nums[i] + prefixSum[i-1]\n for i in range(n-2, -1, -1):\n suffixSum[i] = nums[i] + suffixSum[i+1]\n for i in range(n-1):\n right[prefixSum[i] - suffixSum[i+1]] += 1\n ans = right[0]\n for i in range(n):\n # change the element at i to k\n diff = k - nums[i]\n cur = left[diff] + right[-diff]\n ans = max(cur, ans)\n if i < n - 1:\n curdiff = prefixSum[i] - suffixSum[i+1]\n left[curdiff] += 1\n right[curdiff] -= 1\n return ans\n","memory":"55126"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # Approach #1: calculate the trailing and \n # leading sums of nums at each position.\n # Then, at each position, calculate the difference between\n # the trailing and leading sums.\n # That should give the number of paritions without changing any elements.\n # Then, at each position, check whether swapping with k would lead to a higher number of partitions.\n # This is done by looking up a map of number of positions by trailing - leading difference.\n # Time complexity: O(4 * n)\n # Space complexity: O(n ^ 2)\n\n # Approach #2: improved version of Approach #1, but instead of\n # storing maps of differences at each position, iterate once and\n # increment / decrement the difference maps and check whether swapping with k\n # would lead to higher numbers of partitions.\n # The trailing map would be from trailing_diff - leading_diff to number of indexes at index i < pivot\n # The leading map would be from trailing_diff - leading_diff to number of indexes at index i >= pivot\n # At each position pivot, the number of positions would then be:\n # partitions_i = partitions_0 + trailing[nums[pivot] - k] + leading[nums[pivot] - k]\n # partitions_0 being the number of partitions without any changes\n # The final number of partitions would be the max(partitions_i)\n # Time complexity: O(4 * n)\n # Space complexity: O(2 * n)\n\n leading, trailing = [0], [0]\n ldiffs, tdiffs = defaultdict(int), defaultdict(int)\n n = len(nums)\n for i in range(n):\n trailing.append(nums[i] + trailing[-1])\n leading.append(nums[-i-1] + leading[-1])\n leading, trailing = leading[:0:-1], trailing[:-1]\n\n # print('nums', nums)\n\n # print('trailing', trailing)\n # print('leading', leading)\n\n for i in range(1, n):\n tdiffs[trailing[i] - leading[i]] += 1\n\n partitions_0 = tdiffs[0]\n partitions = partitions_0\n\n # print('tdiffs', tdiffs)\n # print('ldiffs', ldiffs)\n\n for i in range(n-1,-1,-1):\n delta = k - nums[i]\n partitions_i = (\n partitions_0 + \n tdiffs[delta] + \n ldiffs[-delta] -\n tdiffs[0] - \n ldiffs[0]\n )\n partitions = max(partitions, partitions_i)\n if i > 0:\n tdiffs[trailing[i] - leading[i]] -= 1\n ldiffs[trailing[i] - leading[i]] += 1\n \n # print('i, partitions, partitions_i', i, partitions, partitions_i)\n\n return partitions\n","memory":"55126"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n prefix=[]\n suffix=[]\n n=len(nums)\n s1=0\n s2=0\n for i in range(n):\n s1+=nums[i]\n s2+=nums[n-1-i]\n prefix.append(s1)\n suffix.append(s2)\n suffix=suffix[::-1]\n #suffix sum and prefix sum\n left_diff={}\n right_diff={}\n #made two dictionaries(hash map) to store the diffrent b/w right and left sub arrays suffix[i+1]-prefix[i] for every i.\n diff_arr=[]\n for i in range(n-1):\n diff=suffix[i+1]-prefix[i]\n if diff in right_diff:\n right_diff[diff]+=1\n else:\n right_diff[diff]=1\n diff_arr.append(diff)\n ans=0\n if 0 in right_diff:\n ans=right_diff[0]\n arr_diff=[]\n arr_diff.append([right_diff.copy(),{}])\n \n for i in range(n):\n if i==0:\n diff=k-nums[i]\n if diff in right_diff:\n ans=max(ans,right_diff[diff])\n else:\n ct=0\n a=diff_arr[i-1]\n if right_diff[a]>0:\n right_diff[a]-=1\n if a in left_diff:\n left_diff[a]+=1\n else:\n left_diff[a]=1\n diff=k-nums[i]\n if diff in right_diff:\n ct+=right_diff[diff]\n if -diff in left_diff:\n ct+=left_diff[-diff]\n \n ans=max(ans,ct)\n \n return ans ","memory":"55603"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n\n\n prefix=[]\n suffix=[]\n n=len(nums)\n s1=0\n s2=0\n for i in range(n):\n s1+=nums[i]\n s2+=nums[n-1-i]\n prefix.append(s1)\n suffix.append(s2)\n suffix=suffix[::-1]\n #suffix sum and prefix sum\n left_diff={}\n right_diff={}\n #made two dictionaries(hash map) to store the diffrent b/w right and left sub arrays suffix[i+1]-prefix[i] for every i.\n diff_arr=[]\n for i in range(n-1):\n diff=suffix[i+1]-prefix[i]\n if diff in right_diff:\n right_diff[diff]+=1\n else:\n right_diff[diff]=1\n diff_arr.append(diff)\n ans=0\n if 0 in right_diff:\n ans=right_diff[0]\n arr_diff=[]\n arr_diff.append([right_diff.copy(),{}])\n \n for i in range(n):\n if i==0:\n diff=k-nums[i]\n if diff in right_diff:\n ans=max(ans,right_diff[diff])\n else:\n ct=0\n a=diff_arr[i-1]\n if right_diff[a]>0:\n right_diff[a]-=1\n if a in left_diff:\n left_diff[a]+=1\n else:\n left_diff[a]=1\n diff=k-nums[i]\n if diff in right_diff:\n ct+=right_diff[diff]\n if -diff in left_diff:\n ct+=left_diff[-diff]\n \n ans=max(ans,ct)\n \n return ans","memory":"55603"},{"code":"'''class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n before = {k:0}; after = {}; counter = Counter(nums)\n p = list(accumulate(nums))\n n = len(nums)\n for i, num in enumerate(nums[:n-1]):\n before[num] = max(before.get(num, 0), after.get(num, 0))\n counter[nums[i]] -= 1\n if counter[nums[i]] == 0: del counter[nums[i]]\n \n diff = 2 * p[i] - p[-1]\n if (k + diff) in before: before[k + diff] += 1\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\n return max(max([0] + list(before.values())), max([0] + list(after.values())))'''\n\nimport bisect\nimport collections\nfrom typing import List, Tuple, Mapping\n\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n diffsIfReplacedWithK = [k - num for num in nums]\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\n for i in range(len(diffsIfReplacedWithK)):\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\n\n leftHalf = 0\n rightHalf = sum(nums)\n pivot = 0\n diffsToPivots = collections.defaultdict[int, list[int]](list)\n for num in nums[:-1]:\n pivot += 1\n leftHalf += num\n rightHalf -= num\n diffsToPivots[leftHalf - rightHalf].append(pivot)\n\n\n outerWays = len(diffsToPivots[0]) # this is no replacement\n\n for diff, replacedIndices in diffsToReplaceIndices.items():\n if diff == 0:\n continue\n pivots1 = diffsToPivots.get(diff)\n pivots2 = diffsToPivots.get(-diff)\n if (not pivots1 and not pivots2):\n continue\n\n # Let's say diff is > 0\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\n # We want to find a number to be replaced whose location is after the pivot,\n # i.e. pivot1 <= replacedIndex.\n # Or, we can find one whose location is before the pivots2 (but with -diff),\n # i.e. pivot2 > replaceIndex.\n\n for replacedIndex in replacedIndices:\n ways = 0\n if pivots1:\n loc = bisect.bisect_right(pivots1, replacedIndex)\n ways += loc\n if pivots2:\n loc = bisect.bisect_right(pivots2, replacedIndex)\n ways += len(pivots2) - loc\n outerWays = max(outerWays, ways)\n\n return outerWays","memory":"57508"},{"code":"from bisect import bisect_right\n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n '''\n n = len(nums)\n nums = [1,2,3,4]\n part1 = [0:pivot], part2 = [pivot:n]\n sum(part1) == sum(part2)\n\n at least one element in each partition\n '''\n\n n = len(nums)\n\n pref = list(itertools.accumulate(nums)) # pref[i] = sum(nums[:i+1])\n suff = [pref[n-1]]+[pref[n-1]-pref[i] for i in range(n-1)] # suff[i]: sum(nums[i:])\n\n diff_to_idx = {}\n for i in range(1,n):\n diff_to_idx.setdefault(pref[i-1]-suff[i],[]).append(i)\n\n print(diff_to_idx)\n\n ans = 0\n for i in range(-1,n):\n delta = k - nums[i] if i != -1 else 0\n idx_left = diff_to_idx.get(delta,[])\n nbr_left = bisect_right(idx_left, i)\n idx_right = diff_to_idx.get(-delta,[])\n nbr_right = len(diff_to_idx.get(-delta,[])) - bisect_right(idx_right, i)\n ans = max(ans, nbr_left+nbr_right)\n\n return ans\n\n\n\n \n\n return ans\n\n # nums = [1,0,-1], k = 2\n # pref = [0,1,1,0]\n","memory":"57984"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n size = len(nums)\n if size <= 0:\n return 0\n \n prefix_sum = []\n sum = 0\n for index in range(0, size):\n sum += nums[index]\n prefix_sum.append(sum)\n \n suffix_sum = []\n sum = 0 \n for index in range(size - 1, -1, -1):\n sum += nums[index]\n suffix_sum.append(sum)\n suffix_sum.reverse()\n\n def prefix(start, end):\n if start == 0:\n return prefix_sum[end]\n else:\n return prefix_sum[end] - prefix_sum[start - 1]\n \n\n \n valid_pivot = set()\n diff_map = {}\n count = 0\n\n for pivot in range(1, size):\n left_sum = prefix(0, pivot - 1)\n right_sum = prefix(pivot, size - 1)\n\n \n if left_sum == right_sum:\n count += 1\n print(\"here - \", pivot)\n valid_pivot.add(pivot)\n else:\n # store the diff in some DS\n diff = (left_sum - right_sum)\n if diff not in diff_map:\n diff_map[diff] = []\n diff_map[diff].append(pivot)\n \n print(diff_map)\n changed = False\n max_count = count\n for index in range(size):\n count = 0\n change = k - nums[index]\n if change == 0:\n continue\n \n change = -1 * change\n if change in diff_map:\n pivots = diff_map[change]\n for pivot in pivots:\n if index < pivot:\n count += 1\n changed = True\n \n change = change * -1\n if change in diff_map:\n pivots = diff_map[change]\n for pivot in pivots:\n if index >= pivot:\n count += 1\n changed = True\n max_count = max(max_count, count)\n \n return max_count\n\n\n\n\n \"\"\"\n for index in range(size):\n change = k - nums[index]\n if index < pivot:\n if left_sum + change == right_sum:\n count += 1\n print(\"here 2 - \", pivot, index)\n break\n else:\n if left_sum == right_sum + change:\n count += 1\n print(\"here 3- \", pivot, index)\n break\n \"\"\"\n\n\n\n ","memory":"58460"},{"code":"import bisect \n\nclass Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n diff = defaultdict(list)\n pref = [0]\n for num in nums:\n pref.append(pref[-1]+num)\n suff = [0]\n for num in reversed(nums):\n suff.append(suff[-1]+num)\n suff = suff[::-1]\n \n for pivot in range(1, len(nums)):\n left = pref[pivot]\n right = suff[pivot]\n diff[left-right].append(pivot)\n\n res = len(diff[0])\n for i in range(len(nums)):\n res = max(res, bisect.bisect_left(diff[k-nums[i]], i+1)+(len(diff[nums[i]-k])-bisect.bisect_left(diff[nums[i]-k], i+1)))\n return res","memory":"58936"},{"code":"class Solution:\n def waysToPartition(self, nums: List[int], k: int) -> int:\n # [22,4,-25,-20,-15,15] k = 10\n\n # keep track of every thing after current pivot ninclusive (pivot must be on left side)\n # keep track of the +/- diff needed to make it equal on the LEFT\n # sortedlist of differences. also a prefix array so we can delete\n #\n bests = defaultdict(int)\n def countWays(nums, rev):\n counts = defaultdict(int) # diff -> count\n diffs = defaultdict(int) # index - > diff (meaning you put a pivot inbetween this element and previous)\n pref = list(itertools.accumulate(nums))\n suff = list(itertools.accumulate(nums[::-1]))[::-1]\n\n for i in range(1, len(nums)):\n lside = pref[i-1]\n rside = suff[i]\n\n diffs[i] = rside - lside\n counts[diffs[i]] += 1\n \n \n bests[0] = counts[0]\n for i in range(1, len(nums)):\n change = k - nums[i - 1] # we have chanvged the left side sum to +change\n\n if rev:\n bests[len(nums) - i + 1] += counts[change]\n else:\n bests[i] += counts[change]\n counts[diffs[i]] -= 1\n \n return 0\n \n w1 = countWays(nums, False)\n w2 = countWays(nums[::-1], True)\n return max(bests.values())\n\n\n\n\n\n","memory":"59413"}],"string":"[\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n before = {k:0}; after = {}; counter = Counter(nums)\\n p = list(accumulate(nums))\\n n = len(nums)\\n for i, num in enumerate(nums[:n-1]):\\n before[num] = max(before.get(num, 0), after.get(num, 0))\\n counter[nums[i]] -= 1\\n if counter[nums[i]] == 0: del counter[nums[i]]\\n \\n diff = 2 * p[i] - p[-1]\\n if (k + diff) in before: before[k + diff] += 1\\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\\n return max(max([0] + list(before.values())), max([0] + list(after.values())))\\n \",\n \"memory\": \"30838\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n before = {k:0}\\n after = {}\\n counter = Counter(nums)\\n p = list(accumulate(nums))\\n n = len(nums)\\n for i, num in enumerate(nums[:n-1]):\\n before[num] = max(before.get(num, 0), after.get(num, 0))\\n counter[nums[i]] -= 1\\n if counter[nums[i]] == 0: del counter[nums[i]]\\n \\n diff = 2 * p[i] - p[-1]\\n if (k + diff) in before: before[k + diff] += 1\\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\\n \\n return max(max([0] + list(before.values())), max([0] + list(after.values())))\\n \",\n \"memory\": \"30838\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n# misconception change at MOST one element NO MATTER THE PIVOT\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n leftSum = nums[0]\\n rightSum = 0\\n \\n leftDiffMap = defaultdict(list)\\n leftDiffMap[k-nums[0]].append(0)\\n \\n rightDiffMap = defaultdict(list)\\n \\n for i in range(1, len(nums)):\\n rightDiffMap[k-nums[i]].append(i)\\n rightSum += nums[i]\\n \\n changeCount = [0 for _ in range(len(nums))]\\n noChangeCount = 0\\n \\n partitionIdx = 1\\n \\n while True:\\n rightMinusLeft = rightSum - leftSum\\n if rightMinusLeft == 0:\\n noChangeCount += 1\\n\\n if (-1 * rightMinusLeft) in rightDiffMap:\\n # print('leftSum', leftSum, 'rightSum', rightSum, 'rml', rightMinusLeft, 'partIdx', partitionIdx, '||||')\\n for x in rightDiffMap[-1 * rightMinusLeft]:\\n # print('partitionIdx', partitionIdx, 'x', x)\\n changeCount[x] += 1\\n\\n elif rightMinusLeft in leftDiffMap:\\n # print('leftSum', leftSum, 'rightSum', rightSum, 'rml', rightMinusLeft, 'partIdx', partitionIdx)\\n for x in leftDiffMap[rightMinusLeft]:\\n # print('partitionIdx', partitionIdx, 'x', x)\\n changeCount[x] += 1\\n \\n \\n partitionIdx += 1\\n \\n if (partitionIdx == len(nums)):\\n break\\n \\n past = nums[partitionIdx-1]\\n diff = k - past \\n rightDiffMap[diff].remove(partitionIdx-1)\\n leftDiffMap[diff].append(partitionIdx-1)\\n rightSum -= past\\n leftSum += past\\n \\n # print(changeCount)\\n return max(noChangeCount, max(changeCount))\\n \\n \",\n \"memory\": \"31314\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n ns = set(nums)\\n res = [0]*(n+1)\\n pre = [i for i in nums]\\n for i in range(1,n):\\n pre[i] += pre[i-1]\\n s = pre[-1]\\n idx = defaultdict(list)\\n # preset = [set() for _ in range(n)]\\n # postset = [set() for _ in range(n)]\\n for i in range(n):\\n idx[nums[i]].append(i)\\n # ans = 0\\n for p in range(1,n):\\n l = pre[p-1]\\n r = s-l\\n if l == r:\\n res[n] += 1\\n # if res[n] > ans:\\n # ans = res[n]\\n t = l-r+k\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i):\\n res[idx[t][j]] += 1\\n # if res[idx[t][j]] > ans:\\n # ans = res[idx[t][j]]\\n t = r+k-l\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i,len(idx[t])):\\n res[idx[t][j]] += 1\\n # if res[idx[t][j]] > ans:\\n # ans = res[idx[t][j]]\\n return max(res)\\n\\n\\n\\n \",\n \"memory\": \"31790\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n ns = set(nums)\\n res = [0]*(n+1)\\n pre = [i for i in nums]\\n for i in range(1,n):\\n pre[i] += pre[i-1]\\n s = pre[-1]\\n idx = defaultdict(list)\\n # preset = [set() for _ in range(n)]\\n # postset = [set() for _ in range(n)]\\n for i in range(n):\\n idx[nums[i]].append(i)\\n\\n for p in range(1,n):\\n l = pre[p-1]\\n r = s-l\\n if l == r:\\n res[n] += 1\\n t = l-r+k\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i):\\n res[idx[t][j]] += 1\\n t = r+k-l\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i,len(idx[t])):\\n res[idx[t][j]] += 1\\n return max(res)\\n\\n\\n\\n \",\n \"memory\": \"32266\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n ns = set()\\n res = [0]*(n+1)\\n pre = [nums[0]]\\n ns.add(nums[0])\\n for i in range(1,n):\\n ns.add(nums[i])\\n pre.append(pre[i-1]+nums[i])\\n # pre[i] += pre[i-1]\\n s = pre[-1]\\n idx = defaultdict(list)\\n # preset = [set() for _ in range(n)]\\n # postset = [set() for _ in range(n)]\\n for i in range(n):\\n idx[nums[i]].append(i)\\n # ans = 0\\n for p in range(1,n):\\n l = pre[p-1]\\n r = s-l\\n if l == r:\\n res[n] += 1\\n # if res[n] > ans:\\n # ans = res[n]\\n t = l-r+k\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i):\\n res[idx[t][j]] += 1\\n # if res[idx[t][j]] > ans:\\n # ans = res[idx[t][j]]\\n t = r+k-l\\n \\n if t in ns:\\n i = bisect_left(idx[t], p)\\n for j in range(i,len(idx[t])):\\n res[idx[t][j]] += 1\\n # if res[idx[t][j]] > ans:\\n # ans = res[idx[t][j]]\\n return max(res)\\n\\n\\n\\n \",\n \"memory\": \"32743\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # for nums[i], count how many ps before it such that ps == (S-ps) + (k-nums[i])\\n cnt, n, ls = Counter(), len(nums), 0\\n l, s, ans = [0] * n, sum(nums), 0\\n for i in range(n):\\n l[i] = (0 if i == 0 else cnt[k-nums[i]])\\n ls += nums[i]\\n cnt[ls-(s-ls)] += 1\\n if ls == s - ls and i < n-1: ans += 1\\n\\n rs, cnt, r = 0, Counter(), 0\\n for i in range(n-1, -1, -1):\\n r = (0 if i == n-1 else cnt[k-nums[i]])\\n ans = max(ans, l[i] + r)\\n rs += nums[i]\\n cnt[rs-(s-rs)] += 1\\n return ans\\n\",\n \"memory\": \"33219\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n '''\\n aaa | x | bbb\\n use a hashmap to save the prev total before x\\n if prev total == (total + k - x) // 2, then it is the candidates if we change x\\n '''\\n\\n # no change\\n prefix = 0\\n total = sum(nums)\\n ans = 0\\n for num in nums[:-1]:\\n prefix += num \\n if prefix == total / 2:\\n ans += 1\\n\\n # change number in the right side\\n hash = defaultdict(int)\\n res = [0] * len(nums)\\n\\n left = 0\\n for i in range(len(nums) - 1):\\n left += nums[i]\\n hash[left] += 1\\n new_total = total + k - nums[i+1]\\n res[i+1] = hash[new_total / 2]\\n\\n right = 0\\n hash = defaultdict(int)\\n for i in range(len(nums)-1, 0, -1):\\n right += nums[i]\\n hash[right] += 1\\n new_total = total + k - nums[i-1]\\n res[i-1] += hash[new_total / 2]\\n\\n for x in res:\\n ans = max(ans, x)\\n\\n return ans\",\n \"memory\": \"33695\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n num_sum = sum(nums)\\n \\n # if no change\\n no_change_partition = 0\\n temp_sum = 0\\n for i in range(len(nums)):\\n if i != 0:\\n if temp_sum == num_sum / 2:\\n no_change_partition+=1\\n\\n temp_sum += nums[i]\\n\\n \\n # if change\\n p_left = [0 for _ in range(len(nums))]\\n p_right = [0 for _ in range(len(nums))]\\n \\n \\n \\n prefix_sum = {}\\n temp_sum = 0\\n for i in range(len(nums)):\\n\\n if i != 0:\\n \\n sub_sum = (num_sum - nums[i] + k) / 2\\n\\n if sub_sum in prefix_sum.keys():\\n p_left[i] = prefix_sum[sub_sum]\\n \\n \\n temp_sum += nums[i]\\n if temp_sum in prefix_sum.keys():\\n prefix_sum[temp_sum]+=1\\n else:\\n prefix_sum[temp_sum]=1\\n \\n prefix_sum = {}\\n temp_sum = 0\\n for i in reversed(range(len(nums))):\\n \\n if i != len(nums) - 1:\\n \\n sub_sum = (num_sum - nums[i] + k) / 2\\n\\n if sub_sum in prefix_sum.keys():\\n p_right[i] = prefix_sum[sub_sum]\\n \\n temp_sum += nums[i]\\n if temp_sum in prefix_sum.keys():\\n prefix_sum[temp_sum]+=1\\n else:\\n prefix_sum[temp_sum]=1\\n \\n partition = [x + y for x, y in zip(p_left, p_right)]\\n \\n return max(max(partition), no_change_partition)\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# # no cut\\n# partition_no_cut\\n \\n# # cut\\n# nums_sum = sum(nums)\\n# # nums_sum = -46\\n \\n# subarray_sum = (k-element+nums_sum) / 2\\n \\n# prefix_sum = {22:1,\\n# 26:1,\\n# 1:1,\\n# -19:1}\\n \\n# partition_left = [0,1,0,2,0.....]\\n \\n# partition_right = [0,1,0,2,0.....]\\n \\n# partition = [e+f for e, f in (partition_left, partitioin_right)]\\n \\n# return max(max(partitioin), partition_no_cut)\\n\\n\\n\\n \",\n \"memory\": \"34171\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n print(reversed([22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14]))\\n \\n num_sum = sum(nums)\\n \\n # if no change\\n no_change_partition = 0\\n temp_sum = 0\\n for i in range(len(nums)):\\n if i != 0:\\n if temp_sum == num_sum / 2:\\n no_change_partition+=1\\n\\n temp_sum += nums[i]\\n \\n \\n # if change\\n p_left = [0 for _ in range(len(nums))]\\n p_right = [0 for _ in range(len(nums))]\\n \\n # left to right\\n prefix_sum = {}\\n temp_sum = 0\\n for i in range(len(nums)):\\n if i != 0:\\n sub_sum = (num_sum - nums[i] + k) / 2\\n\\n if sub_sum in prefix_sum.keys():\\n p_left[i] = prefix_sum[sub_sum]\\n \\n temp_sum += nums[i]\\n if temp_sum in prefix_sum.keys():\\n prefix_sum[temp_sum]+=1\\n else:\\n prefix_sum[temp_sum]=1\\n \\n # right to left\\n prefix_sum = {}\\n temp_sum = 0\\n for i in reversed(range(len(nums))):\\n \\n if i != len(nums) - 1:\\n \\n sub_sum = (num_sum - nums[i] + k) / 2\\n\\n if sub_sum in prefix_sum.keys():\\n p_right[i] = prefix_sum[sub_sum]\\n \\n temp_sum += nums[i]\\n if temp_sum in prefix_sum.keys():\\n prefix_sum[temp_sum]+=1\\n else:\\n prefix_sum[temp_sum]=1\\n \\n partition = [x + y for x, y in zip(p_left, p_right)]\\n \\n return max(max(partition), no_change_partition)\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# # no cut\\n# partition_no_cut\\n \\n# # cut\\n# nums_sum = sum(nums)\\n# # nums_sum = -46\\n \\n# subarray_sum = (k-element+nums_sum) / 2\\n \\n# prefix_sum = {22:1,\\n# 26:1,\\n# 1:1,\\n# -19:1}\\n \\n# partition_left = [0,1,0,2,0.....]\\n \\n# partition_right = [0,1,0,2,0.....]\\n \\n# partition = [e+f for e, f in (partition_left, partitioin_right)]\\n \\n# return max(max(partitioin), partition_no_cut)\\n\\n\\n\\n \",\n \"memory\": \"34648\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n counts = [0] * (len(nums) + 1)\\n\\n def lower(array, num):\\n for a in array:\\n if a > num:\\n break\\n else:\\n counts[a] += 1\\n return\\n\\n\\n def upper(array, num):\\n for a in array[::-1]:\\n if a < num:\\n break\\n else:\\n counts[a] += 1\\n return\\n\\n total_fwd = 0\\n cum_fwd = [total_fwd := total_fwd + v for v in nums]\\n total_bwd = 0\\n cum_bwd = [total_bwd := total_bwd + v for v in nums[::-1]][::-1]\\n \\n diff_map = defaultdict(list)\\n for i, v in enumerate(nums):\\n diff_map[k - v].append(i)\\n\\n for i in range(1, len(nums)):\\n diff = cum_fwd[i - 1] - cum_bwd[i]\\n if diff == 0:\\n counts[len(nums)] += 1\\n else:\\n if -diff in diff_map.keys():\\n lower(diff_map[-diff], i - 1)\\n if diff in diff_map.keys():\\n upper(diff_map[diff], i)\\n\\n return max(counts)\\n\",\n \"memory\": \"35124\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n counts = [0] * (len(nums) + 1)\\n\\n def lower(array, num):\\n for a in array:\\n if a > num:\\n break\\n else:\\n counts[a] += 1\\n return\\n\\n\\n def upper(array, num):\\n for a in array[::-1]:\\n if a < num:\\n break\\n else:\\n counts[a] += 1\\n return\\n\\n total_fwd = 0\\n cum_fwd = [total_fwd := total_fwd + v for v in nums]\\n total_bwd = 0\\n cum_bwd = [total_bwd := total_bwd + v for v in nums[::-1]][::-1]\\n \\n diff_map = defaultdict(list)\\n for i, v in enumerate(nums):\\n diff_map[k - v].append(i)\\n\\n for i in range(1, len(nums)):\\n diff = cum_fwd[i - 1] - cum_bwd[i]\\n if diff == 0:\\n counts[len(nums)] += 1\\n else:\\n if -diff in diff_map.keys():\\n lower(diff_map[-diff], i - 1)\\n if diff in diff_map.keys():\\n upper(diff_map[diff], i)\\n\\n return max(counts)\\n\",\n \"memory\": \"35124\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n d = defaultdict(list)\\n lacc = 0\\n l = [0]\\n racc = 0\\n r = [0]\\n for i in range(len(nums)):\\n if k - nums[i] == 0:\\n pass\\n d[k - nums[i]].append(i)\\n\\n lacc += nums[i]\\n l.append(lacc)\\n racc += nums[-i - 1]\\n r.append(racc)\\n r.reverse()\\n # print(l)\\n # print(r)\\n # print(d)\\n\\n t = defaultdict(int)\\n raw = 0\\n for i in range(1, len(nums)):\\n diff = r[i] - l[i]\\n if diff == 0:\\n raw += 1\\n # need to find + diff left of i\\n if diff in d:\\n for j in d[diff]:\\n if j < i:\\n # print(diff, j, i, \\\"1\\\")\\n t[j] += 1\\n else:\\n break\\n\\n # or - diff right of i\\n diff = l[i] - r[i]\\n if diff in d:\\n for j in reversed(d[diff]):\\n if j >= i:\\n # print(diff, j, i, \\\"-1\\\")\\n t[j] += 1\\n else:\\n break\\n # print(t)\\n # print(raw)\\n for i in t.keys():\\n raw = max(raw, t[i])\\n\\n return raw\\n\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sumLeft = 0\\n sumRight = sum(nums)\\n for i in range(N - 1):\\n sumLeft += nums[i]\\n sumRight -= nums[i]\\n diffs.append(sumLeft - sumRight)\\n counterLeft = defaultdict(int)\\n counterRight = defaultdict(int)\\n for i in range(N-1):\\n counterRight[diffs[i]] += 1\\n res = counterRight[0]\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, counterLeft[d] + counterRight[-d])\\n if i < N-1:\\n counterLeft[diffs[i]] += 1\\n counterRight[diffs[i]] -= 1\\n return res\\n\\n \",\n \"memory\": \"36076\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n l, r = 0, sum(nums)\\n diffs = [float(\\\"inf\\\")] * len(nums)\\n\\n for i in range(len(nums) - 1):\\n l += nums[i]\\n r -= nums[i]\\n diffs[i] = l - r\\n\\n l_count = collections.Counter()\\n r_count = collections.Counter(diffs)\\n\\n total = r_count[0] # Before any changes\\n\\n for i in range(len(nums)):\\n # Simulate changing nums[i] to k\\n diff = k - nums[i]\\n curr = l_count[diff] + r_count[-diff]\\n total = max(total, curr)\\n \\n l_count[diffs[i]] += 1\\n r_count[diffs[i]] -= 1\\n \\n return total\\n\\n# T: O(N)\\n# S: O(N)\\n\\n\\n \",\n \"memory\": \"36553\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n '''prepare google\\n https://leetcode.com/problems/maximum-number-of-ways-to-partition-an-array/?envType=company&envId=google&favoriteSlug=google-three-months&role=all\\n '''\\n n = len(nums)\\n sl, sr = 0, sum(nums)\\n diffs = []\\n for i in range(n-1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n diffs.append(float('inf'))\\n #print(diffs)\\n cl, cr = Counter(), Counter(diffs)\\n res = cl[0] + cr[0]\\n for i in range(n):\\n d = k - nums[i]\\n res = max(res, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n return res\",\n \"memory\": \"37029\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sl, sr = 0, sum(nums)\\n for i in range(N - 1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n diffs.append(math.inf) # to prevent error in the counter arithemtic\\n \\n cl, cr = Counter(), Counter(diffs)\\n res = cl[0] + cr[0]\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n return res\",\n \"memory\": \"37505\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n diffs = []\\n sum_left, sum_right = 0, sum(nums)\\n for i in range(n - 1):\\n sum_left += nums[i]\\n sum_right -= nums[i]\\n diffs.append(sum_right - sum_left)\\n diffs.append(inf)\\n # print(diffs)\\n\\n counter_left, counter_right = Counter(), Counter(diffs)\\n res = counter_left[0] + counter_right[0]\\n for i in range(n): # change at all i\\n change = k - nums[i]\\n local_res = counter_left[-change] + counter_right[change]\\n res = max(res, local_res)\\n counter_left[diffs[i]] += 1\\n counter_right[diffs[i]] -= 1\\n return res\",\n \"memory\": \"37981\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sumLeft = 0\\n sumRight = sum(nums)\\n for i in range(N - 1):\\n sumLeft += nums[i]\\n sumRight -= nums[i]\\n diffs.append(sumLeft - sumRight)\\n counterLeft = defaultdict(int)\\n counterRight = defaultdict(int)\\n for i in range(N-1):\\n counterRight[diffs[i]] += 1\\n res = counterRight[0]\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, counterLeft[d] + counterRight[-d])\\n if i < N-1:\\n counterLeft[diffs[i]] += 1\\n counterRight[diffs[i]] -= 1\\n return res\\n\\n \",\n \"memory\": \"38458\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n '''\\n a a a a | k b b b \\n '''\\n\\n prefix = [nums[0]]\\n\\n for i in range(1, len(nums)):\\n prefix.append(prefix[-1] + nums[i])\\n\\n # do not change\\n total = prefix[-1]\\n ans = 0\\n for p in prefix[:-1]:\\n if p == total / 2:\\n ans += 1\\n\\n # from left to right\\n visited = defaultdict(int)\\n res = [0] * len(nums)\\n for i in range(len(nums)):\\n new_total = total + k - nums[i]\\n res[i] += visited[new_total/2]\\n visited[prefix[i]] += 1\\n\\n visited = defaultdict(int)\\n for i in range(len(nums)-1, -1, -1):\\n new_total = total + k - nums[i]\\n res[i] += visited[new_total/2]\\n prev = prefix[i-1] \\n visited[total - prev] += 1\\n\\n for x in res:\\n ans = max(ans, x)\\n\\n return ans\\n \\n \\n\\n\\n\\n\\n \",\n \"memory\": \"38934\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n left=defaultdict(int)\\n right=defaultdict(int)\\n\\n a=0\\n s=sum(nums)\\n\\n for i in nums[:-1]:\\n a+=i\\n s-=i\\n right[a-s]+=1\\n \\n a=0\\n s=sum(nums)\\n ans=0\\n ans=right[0]\\n for i in nums:\\n a+=i\\n s-=i\\n dif=a-s\\n diff=k-i\\n ans=max(ans,left[diff]+right[-diff])\\n\\n \\n left[dif]+=1\\n right[dif]-=1\\n if right[dif]==0:\\n del right[dif]\\n return ans\\n\",\n \"memory\": \"39410\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n '''\\n a a a a | k b b b \\n '''\\n\\n prefix = [nums[0]]\\n\\n for i in range(1, len(nums)):\\n prefix.append(prefix[-1] + nums[i])\\n\\n # do not change\\n total = prefix[-1]\\n ans = 0\\n for p in prefix[:-1]:\\n if p == total / 2:\\n ans += 1\\n\\n # from left to right\\n visited = defaultdict(int)\\n res = [0] * len(nums)\\n for i in range(len(nums)):\\n new_total = total + k - nums[i]\\n res[i] += visited[new_total/2]\\n visited[prefix[i]] += 1\\n\\n visited = defaultdict(int)\\n for i in range(len(nums)-1, -1, -1):\\n new_total = total + k - nums[i]\\n res[i] += visited[new_total/2]\\n prev = prefix[i-1] if i != 0 else 0\\n visited[total - prev] += 1\\n\\n for x in res:\\n ans = max(ans, x)\\n\\n return ans\\n \\n \\n\\n\\n\\n\\n \",\n \"memory\": \"39886\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n s = [nums[0]] * n\\n right = defaultdict(int)\\n for i in range(1, n):\\n s[i] = s[i - 1] + nums[i]\\n right[s[i - 1]] += 1\\n\\n ans = 0\\n if s[-1] % 2 == 0:\\n ans = right[s[-1] // 2]\\n\\n left = defaultdict(int)\\n for v, x in zip(s, nums):\\n d = k - x\\n if (s[-1] + d) % 2 == 0:\\n t = left[(s[-1] + d) // 2] + right[(s[-1] - d) // 2]\\n if ans < t:\\n ans = t\\n left[v] += 1\\n right[v] -= 1\\n return ans\",\n \"memory\": \"40363\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = [0] * n\\n prefix_sum[0] = nums[0]\\n \\n for i in range(1, n):\\n prefix_sum[i] = prefix_sum[i-1] + nums[i]\\n \\n total_sum = prefix_sum[-1]\\n \\n left = defaultdict(int)\\n right = defaultdict(int)\\n \\n # Initialize the right hashmap with the prefix sums\\n for i in range(n-1):\\n right[prefix_sum[i]] += 1\\n \\n # Start with the number of valid partitions in the original array\\n max_ways = right[total_sum // 2] if total_sum % 2 == 0 else 0\\n \\n for i in range(n):\\n # Calculate the difference diff = k - nums[i]\\n diff = k - nums[i]\\n new_total_sum = total_sum + diff\\n \\n if i > 0:\\n left[prefix_sum[i-1]] += 1\\n right[prefix_sum[i-1]] -= 1\\n \\n # Check if the new total sum allows valid partitions\\n if new_total_sum % 2 == 0:\\n left_sum = new_total_sum // 2\\n new_ways = 0\\n \\n if left_sum in left:\\n new_ways += left[left_sum]\\n if left_sum - diff in right:\\n new_ways += right[left_sum - diff]\\n \\n max_ways = max(max_ways, new_ways)\\n \\n return max_ways\",\n \"memory\": \"40839\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n total_sum = sum(nums)\\n\\n prefix_sum = [0] * (n + 1)\\n \\n for i in range(1, n + 1):\\n prefix_sum[i] = prefix_sum[i - 1] + nums[i - 1]\\n\\n original_partitions = 0\\n left_count = {}\\n right_count = {}\\n\\n # Count initial valid partitions\\n for i in range(1, n):\\n left_sum = prefix_sum[i]\\n right_sum = total_sum - left_sum\\n right_count[left_sum] = right_count.get(left_sum, 0) + 1\\n \\n # Calculate original partitions from right_count\\n original_partitions = right_count.get(total_sum // 2, 0)\\n max_partitions = original_partitions\\n \\n # Try changing each nums[i] to k\\n current_count = left_count.copy()\\n\\n for i in range(n):\\n # If we're moving the pivot from i -> i+1, adjust the counts\\n if i > 0:\\n left_sum = prefix_sum[i]\\n right_sum = total_sum - left_sum\\n current_count[left_sum] = current_count.get(left_sum, 0) + 1\\n right_count[left_sum] -= 1\\n \\n # Consider changing nums[i] to k\\n diff = k - nums[i]\\n potential_total = total_sum + diff\\n\\n if potential_total % 2 == 0:\\n half_needed = potential_total // 2\\n\\n left_way = current_count.get(half_needed, 0)\\n right_way = right_count.get(half_needed - diff, 0)\\n\\n max_partitions = max(max_partitions, left_way + right_way)\\n\\n return max_partitions\",\n \"memory\": \"41315\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, A: List[int], k: int) -> int:\\n n = len(A) \\n pre, s = list(itertools.accumulate(A)), sum(A)\\n \\n # pred contains all the presum BEFORE i-th number.\\n # sufd contains all the presum AFTER and WITH i-th number.\\n pred = collections.defaultdict(int)\\n sufd = collections.Counter(pre)\\n \\n # The last prefix sum is NEVER used. \\n sufd[sum(A)] -= 1\\n \\n # The number of ways if we do not change any number.\\n ans = 0\\n if s % 2 == 0:\\n ans = sufd[s // 2]\\n\\n # The number of ways if we split i-th number to k.\\n for i in range(n):\\n cur = 0\\n \\n # We only count number of ways when A[i] != k (otherwise change makes no difference)\\n # and when the SUM after the change is dividable by 2.\\n if A[i] != k:\\n news = s + k - A[i]\\n if news % 2 == 0:\\n \\n # If i == 0, only count suffix part.\\n if i > 0:\\n cur += pred[news // 2]\\n \\n # If i == n - 1, only count prefix part.\\n if i < n - 1:\\n cur += sufd[news // 2 + A[i] - k]\\n ans = max(ans, cur)\\n \\n # Don't forget to change the values in the two counters.\\n sufd[pre[i]] -= 1\\n pred[pre[i]] += 1\\n \\n return ans\",\n \"memory\": \"41791\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n num_elements = len(nums)\\n prefix_sums = [nums[0]] * num_elements\\n\\n right_partition_counts = defaultdict(int)\\n\\n for i in range(1, num_elements):\\n prefix_sums[i] = prefix_sums[i-1] + nums[i]\\n right_partition_counts[prefix_sums[i-1]] += 1\\n \\n max_ways = 0\\n if prefix_sums[-1] % 2 == 0:\\n max_ways = right_partition_counts[prefix_sums[-1] // 2]\\n \\n left_partition_counts = defaultdict(int)\\n for prefix_sum, num in zip(prefix_sums, nums):\\n diff = k - num\\n if (prefix_sums[-1] + diff) % 2 == 0:\\n total_ways = left_partition_counts[(prefix_sums[-1]+diff) // 2] + right_partition_counts[(prefix_sums[-1]-diff) // 2]\\n max_ways = max(max_ways, total_ways)\\n left_partition_counts[prefix_sum] += 1\\n right_partition_counts[prefix_sum] -= 1\\n\\n return max_ways \",\n \"memory\": \"42268\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix = []\\n left = defaultdict(int)\\n total = 0\\n for i in range(len(nums)):\\n total += nums[i]\\n prefix.append(total)\\n if i > 0:\\n left[prefix[i - 1]] += 1\\n \\n right = defaultdict(int)\\n\\n maxWays = 0\\n \\n if prefix[-1] % 2 == 0:\\n maxWays = left[prefix[-1] // 2]\\n \\n for i in range(len(nums)):\\n currWays = 0\\n if nums[i] != k:\\n newSum = prefix[-1] + k - nums[i]\\n if newSum % 2 == 0:\\n if i > 0:\\n currWays += right[newSum // 2]\\n if i < len(nums) - 1:\\n currWays += left[newSum // 2 + nums[i] - k]\\n maxWays = max(maxWays, currWays)\\n\\n left[prefix[i]] -= 1\\n right[prefix[i]] += 1\\n \\n return maxWays\",\n \"memory\": \"42268\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n pass\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sum_all = sum(nums)\\n\\n # calculate prefix sum\\n prefix_sum = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sum.append(accum)\\n \\n prefix_counter = collections.defaultdict(int)\\n suffix_counter = collections.Counter(prefix_sum)\\n suffix_counter[sum_all] -= 1\\n\\n # count answers without changing k\\n ans = 0\\n if sum_all % 2 == 0:\\n ans = suffix_counter[sum_all//2]\\n \\n # replace ith num to k\\n for i in range(n):\\n curr = 0\\n\\n if nums[i] != k:\\n sum_all_new = sum_all + k - nums[i]\\n if sum_all_new % 2 == 0:\\n if i > 0:\\n curr += prefix_counter[sum_all_new // 2]\\n \\n if i < n-1:\\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\\n\\n ans = max(ans, curr)\\n\\n suffix_counter[prefix_sum[i]] -= 1\\n prefix_counter[prefix_sum[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.defaultdict(int)\\n \\n # without chaning k\\n ans = 0\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # change k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n \\n counter_left = collections.defaultdict(int)\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[accum] -= 1\\n\\n ans = 0\\n\\n # without replacing k\\n if accum % 2 == 0:\\n ans += counter_right[accum//2]\\n \\n # with replacing k\\n for i in range(len(nums)):\\n # replace nums[i] --> k\\n new_sums = accum - nums[i] + k\\n curr = 0\\n if new_sums % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_sums//2]\\n if i < len(nums)-1:\\n curr += counter_right[new_sums//2 - k + nums[i]]\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n ans = max(ans, curr)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.defaultdict(int)\\n counter_right[total_sum] -= 1\\n\\n ans = 0\\n\\n # case 1. No switch to k\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum // 2]\\n \\n # case 2. Switch to k\\n for i in range(len(nums)):\\n curr = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\\n ans = max(ans, curr)\\n\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n return ans\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.Counter()\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n # without changing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n\\n # change nums[i] --> k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_left = collections.Counter()\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n\\n # without replacing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # replace k\\n for i in range(len(nums)):\\n curr_cnt = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr_cnt += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\\n cnt = max(cnt, curr_cnt)\\n counter_right[prefix_sums[i]] -= 1\\n counter_right[prefix_sums[i]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n prefix_sums = []\\n for n in nums:\\n accum += n\\n prefix_sums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(prefix_sums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n # no switch\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # switch nums[i] --> k\\n for i in range(len(nums)):\\n total_sums_new = total_sum + k - nums[i]\\n cnt_curr = 0\\n if total_sums_new % 2 == 0:\\n if i > 0:\\n cnt_curr += left_counter[total_sums_new//2]\\n if i < len(nums)-1:\\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\\n cnt = max(cnt, cnt_curr)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n counter_right[accum] += 1\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right[total_sum] -= 1\\n\\n\\n ans = 0\\n # No replace\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # replace\\n for i, num in enumerate(nums):\\n total_new = total_sum - num + k\\n curr = 0\\n if total_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_new // 2 - (k - num)]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\",\n \"memory\": \"42744\"\n },\n {\n \"code\": \"from collections import defaultdict as ddict\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n S = sum(nums)\\n\\n pres = [0] * N\\n sufs = [0] * N\\n\\n pres[0] = nums[0]\\n for i in range(N): \\n pres[i] = pres[i-1] + nums[i]\\n \\n sufs[-1] = nums[-1]\\n for i in range(N-2, -1, -1): \\n sufs[i] = sufs[i+1] + nums[i]\\n\\n rsts = [0] * N\\n cnt = ddict(int)\\n for i in range(N): \\n cur_sum = S - nums[i] + k\\n if cur_sum % 2 == 0: \\n rsts[i] += cnt[cur_sum // 2]\\n cnt[pres[i]] += 1\\n\\n cnt.clear()\\n for i in range(N-1, -1, -1): \\n cur_sum = S - nums[i] + k\\n if cur_sum % 2 == 0: \\n rsts[i] += cnt[cur_sum // 2]\\n cnt[sufs[i]] += 1\\n \\n rtn = max(rsts)\\n \\n alt = 0 \\n for i in range(N-1): \\n if pres[i] == S // 2: \\n alt += 1\\n\\n return max(rtn, alt)\\n \",\n \"memory\": \"42744\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n pass\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sum_all = sum(nums)\\n\\n # calculate prefix sum\\n prefix_sum = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sum.append(accum)\\n \\n prefix_counter = collections.defaultdict(int)\\n suffix_counter = collections.Counter(prefix_sum)\\n suffix_counter[sum_all] -= 1\\n\\n # count answers without changing k\\n ans = 0\\n if sum_all % 2 == 0:\\n ans = suffix_counter[sum_all//2]\\n \\n # replace ith num to k\\n for i in range(n):\\n curr = 0\\n\\n if nums[i] != k:\\n sum_all_new = sum_all + k - nums[i]\\n if sum_all_new % 2 == 0:\\n if i > 0:\\n curr += prefix_counter[sum_all_new // 2]\\n \\n if i < n-1:\\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\\n\\n ans = max(ans, curr)\\n\\n suffix_counter[prefix_sum[i]] -= 1\\n prefix_counter[prefix_sum[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.defaultdict(int)\\n \\n # without chaning k\\n ans = 0\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # change k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n \\n counter_left = collections.defaultdict(int)\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[accum] -= 1\\n\\n ans = 0\\n\\n # without replacing k\\n if accum % 2 == 0:\\n ans += counter_right[accum//2]\\n \\n # with replacing k\\n for i in range(len(nums)):\\n # replace nums[i] --> k\\n new_sums = accum - nums[i] + k\\n curr = 0\\n if new_sums % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_sums//2]\\n if i < len(nums)-1:\\n curr += counter_right[new_sums//2 - k + nums[i]]\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n ans = max(ans, curr)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.defaultdict(int)\\n counter_right[total_sum] -= 1\\n\\n ans = 0\\n\\n # case 1. No switch to k\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum // 2]\\n \\n # case 2. Switch to k\\n for i in range(len(nums)):\\n curr = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\\n ans = max(ans, curr)\\n\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n return ans\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.Counter()\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n # without changing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n\\n # change nums[i] --> k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_left = collections.Counter()\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n\\n # without replacing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # replace k\\n for i in range(len(nums)):\\n curr_cnt = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr_cnt += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\\n cnt = max(cnt, curr_cnt)\\n counter_right[prefix_sums[i]] -= 1\\n counter_right[prefix_sums[i]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n prefix_sums = []\\n for n in nums:\\n accum += n\\n prefix_sums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(prefix_sums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n # no switch\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # switch nums[i] --> k\\n for i in range(len(nums)):\\n total_sums_new = total_sum + k - nums[i]\\n cnt_curr = 0\\n if total_sums_new % 2 == 0:\\n if i > 0:\\n cnt_curr += left_counter[total_sums_new//2]\\n if i < len(nums)-1:\\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\\n cnt = max(cnt, cnt_curr)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n counter_right[accum] += 1\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right[total_sum] -= 1\\n\\n\\n ans = 0\\n # No replace\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # replace\\n for i, num in enumerate(nums):\\n total_new = total_sum - num + k\\n curr = 0\\n if total_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_new // 2 - (k - num)]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n counter_right[accum] += 1\\n counter_right[accum] -= 1\\n total_sum = accum\\n\\n cnt = 0\\n # no replacement\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # with replacement\\n for idx, num in enumerate(nums):\\n # replace num --> k\\n curr = 0\\n total_sum_new = total_sum - num + k\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n curr += counter_left[total_sum_new//2]\\n if idx < len(nums)-1:\\n curr += counter_right[total_sum_new//2 - (k - num)]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[idx]] -= 1\\n counter_left[prefix_sums[idx]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n counter_right = collections.Counter()\\n counter_left = collections.Counter()\\n prefix_sums = []\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n counter_right[accum] += 1\\n counter_right[accum] -= 1\\n total_sum = accum\\n\\n ans = 0\\n # case 1. no swap\\n if total_sum % 2 == 0:\\n ans = counter_right[total_sum//2]\\n \\n # case 2. swap\\n for idx, num in enumerate(nums):\\n # swap num --> k\\n total_sum_new = total_sum - num + k\\n cnt = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt += counter_right[total_sum_new // 2 + num - k]\\n counter_left[prefix_sums[idx]] += 1\\n counter_right[prefix_sums[idx]] -= 1\\n ans = max(ans, cnt)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n'''\\nnums: 1, 2, 2+1, 4, 7, 3\\naccu: 1, 3, 5+1, 9+1, 16+1, 19+1\\ncounter_left\\ncounter_right\\n'''\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n accums = []\\n counter_left = collections.Counter()\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n counter_right = collections.Counter(accums)\\n counter_right[total_sum] -= 1\\n\\n # no swap\\n cnt = 0\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # swap one num --> k\\n for idx, num in enumerate(nums):\\n total_sum_new = total_sum - num + k\\n cnt_temp = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_temp += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_temp += counter_right[total_sum_new // 2 - k + num]\\n counter_right[accums[idx]] -= 1\\n counter_left[accums[idx]] += 1\\n cnt = max(cnt_temp, cnt)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n'''\\n1, 3, 6, 10 ||. 9, 11\\n1, 4, 10,20 29, 40\\ntotal_sum = 40 \\nfind idx of 20 // 2\\n\\ncase 1. no switch\\ncase 2. switch\\n\\n1, 3, 6, 10-->11 ||. 9, 11\\n1, 4, 10,20+1 29+1, 40+1\\nleft_counter\\nright_counter\\n'''\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n accums = []\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(accums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n\\n # case 1. no swap\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # case 2. swap\\n for idx, num in enumerate(nums):\\n # num --> k\\n total_sum_new = total_sum - num + k\\n cnt_tmp = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_tmp += left_counter[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_tmp += right_counter[total_sum_new // 2 - k + num]\\n right_counter[accums[idx]] -= 1\\n left_counter[accums[idx]] += 1\\n cnt = max(cnt, cnt_tmp)\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(accums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.Counter()\\n\\n cnt = 0\\n # without switching\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n # with switching\\n for idx, num in enumerate(nums):\\n # num --> k\\n cnt_tmp = 0\\n total_sum_new = total_sum - num + k\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_tmp += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_tmp += counter_right[total_sum_new // 2 - k + num]\\n counter_right[accums[idx]] -= 1\\n counter_left[accums[idx]] += 1\\n cnt = max(cnt, cnt_tmp)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n right_counter = collections.Counter(accums)\\n right_counter[total_sum] -= 1\\n left_counter = collections.Counter()\\n\\n cnt_all = 0\\n\\n # 1. no switch\\n if total_sum % 2 == 0:\\n cnt_all += right_counter[total_sum // 2]\\n \\n # 2. switch\\n for idx in range(len(nums)):\\n cnt = 0\\n num = nums[idx]\\n total_sum_new = total_sum - num + k\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt += left_counter[total_sum_new // 2]\\n if idx < len(nums):\\n cnt += right_counter[total_sum_new // 2 - k + num]\\n right_counter[accums[idx]] -= 1\\n left_counter[accums[idx]] += 1\\n cnt_all = max(cnt_all, cnt)\\n return cnt_all\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(accums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n\\n # case 1. no swap\\n if total_sum % 2 == 0:\\n cnt = right_counter[total_sum // 2]\\n \\n # case 2. swap once\\n for i in range(len(nums)):\\n cnt_tmp = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n cnt_tmp += left_counter[total_sum_new//2]\\n if i < len(nums)-1:\\n cnt_tmp += right_counter[total_sum_new//2 - k + nums[i]]\\n right_counter[accums[i]] -= 1\\n left_counter[accums[i]] += 1\\n cnt = max(cnt, cnt_tmp)\\n return cnt\",\n \"memory\": \"43220\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n pass\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sum_all = sum(nums)\\n\\n # calculate prefix sum\\n prefix_sum = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sum.append(accum)\\n \\n prefix_counter = collections.defaultdict(int)\\n suffix_counter = collections.Counter(prefix_sum)\\n suffix_counter[sum_all] -= 1\\n\\n # count answers without changing k\\n ans = 0\\n if sum_all % 2 == 0:\\n ans = suffix_counter[sum_all//2]\\n \\n # replace ith num to k\\n for i in range(n):\\n curr = 0\\n\\n if nums[i] != k:\\n sum_all_new = sum_all + k - nums[i]\\n if sum_all_new % 2 == 0:\\n if i > 0:\\n curr += prefix_counter[sum_all_new // 2]\\n \\n if i < n-1:\\n curr += suffix_counter[sum_all_new // 2 + nums[i] - k]\\n\\n ans = max(ans, curr)\\n\\n suffix_counter[prefix_sum[i]] -= 1\\n prefix_counter[prefix_sum[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.defaultdict(int)\\n \\n # without chaning k\\n ans = 0\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # change k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[(new_total_sum // 2 - (k - nums[i]))]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n \\n counter_left = collections.defaultdict(int)\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[accum] -= 1\\n\\n ans = 0\\n\\n # without replacing k\\n if accum % 2 == 0:\\n ans += counter_right[accum//2]\\n \\n # with replacing k\\n for i in range(len(nums)):\\n # replace nums[i] --> k\\n new_sums = accum - nums[i] + k\\n curr = 0\\n if new_sums % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_sums//2]\\n if i < len(nums)-1:\\n curr += counter_right[new_sums//2 - k + nums[i]]\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n ans = max(ans, curr)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.defaultdict(int)\\n counter_right[total_sum] -= 1\\n\\n ans = 0\\n\\n # case 1. No switch to k\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum // 2]\\n \\n # case 2. Switch to k\\n for i in range(len(nums)):\\n curr = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_sum_new // 2 - k + nums[i]]\\n ans = max(ans, curr)\\n\\n counter_left[prefix_sums[i]] += 1\\n counter_right[prefix_sums[i]] -= 1\\n return ans\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(prefix_sums)\\n counter_left = collections.Counter()\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n # without changing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n\\n # change nums[i] --> k\\n for i in range(len(nums)):\\n new_total_sum = total_sum - nums[i] + k\\n curr = 0\\n if new_total_sum % 2 == 0:\\n if i > 0:\\n curr += counter_left[new_total_sum // 2]\\n if i < len(nums)-1:\\n curr += counter_right[new_total_sum // 2 - (k - nums[i])]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_left = collections.Counter()\\n counter_right = collections.Counter(prefix_sums)\\n counter_right[total_sum] -= 1\\n\\n cnt = 0\\n\\n # without replacing k\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # replace k\\n for i in range(len(nums)):\\n curr_cnt = 0\\n total_sum_new = total_sum - nums[i] + k\\n if total_sum_new % 2 == 0:\\n if i > 0:\\n curr_cnt += counter_left[total_sum_new // 2]\\n if i < len(nums)-1:\\n curr_cnt += counter_right[total_sum_new // 2 + (nums[i] - k)]\\n cnt = max(cnt, curr_cnt)\\n counter_right[prefix_sums[i]] -= 1\\n counter_right[prefix_sums[i]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n prefix_sums = []\\n for n in nums:\\n accum += n\\n prefix_sums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(prefix_sums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n # no switch\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # switch nums[i] --> k\\n for i in range(len(nums)):\\n total_sums_new = total_sum + k - nums[i]\\n cnt_curr = 0\\n if total_sums_new % 2 == 0:\\n if i > 0:\\n cnt_curr += left_counter[total_sums_new//2]\\n if i < len(nums)-1:\\n cnt_curr += right_counter[total_sums_new//2 - k + nums[i]]\\n cnt = max(cnt, cnt_curr)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n counter_right[accum] += 1\\n prefix_sums.append(accum)\\n total_sum = accum\\n\\n counter_right[total_sum] -= 1\\n\\n\\n ans = 0\\n # No replace\\n if total_sum % 2 == 0:\\n ans += counter_right[total_sum//2]\\n\\n # replace\\n for i, num in enumerate(nums):\\n total_new = total_sum - num + k\\n curr = 0\\n if total_new % 2 == 0:\\n if i > 0:\\n curr += counter_left[total_new // 2]\\n if i < len(nums)-1:\\n curr += counter_right[total_new // 2 - (k - num)]\\n ans = max(ans, curr)\\n counter_right[prefix_sums[i]] -= 1\\n counter_left[prefix_sums[i]] += 1\\n return ans\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = []\\n counter_left = collections.Counter()\\n counter_right = collections.Counter()\\n accum = 0\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n counter_right[accum] += 1\\n counter_right[accum] -= 1\\n total_sum = accum\\n\\n cnt = 0\\n # no replacement\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # with replacement\\n for idx, num in enumerate(nums):\\n # replace num --> k\\n curr = 0\\n total_sum_new = total_sum - num + k\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n curr += counter_left[total_sum_new//2]\\n if idx < len(nums)-1:\\n curr += counter_right[total_sum_new//2 - (k - num)]\\n cnt = max(cnt, curr)\\n counter_right[prefix_sums[idx]] -= 1\\n counter_left[prefix_sums[idx]] += 1\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n counter_right = collections.Counter()\\n counter_left = collections.Counter()\\n prefix_sums = []\\n for num in nums:\\n accum += num\\n prefix_sums.append(accum)\\n counter_right[accum] += 1\\n counter_right[accum] -= 1\\n total_sum = accum\\n\\n ans = 0\\n # case 1. no swap\\n if total_sum % 2 == 0:\\n ans = counter_right[total_sum//2]\\n \\n # case 2. swap\\n for idx, num in enumerate(nums):\\n # swap num --> k\\n total_sum_new = total_sum - num + k\\n cnt = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt += counter_right[total_sum_new // 2 + num - k]\\n counter_left[prefix_sums[idx]] += 1\\n counter_right[prefix_sums[idx]] -= 1\\n ans = max(ans, cnt)\\n return ans\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n'''\\nnums: 1, 2, 2+1, 4, 7, 3\\naccu: 1, 3, 5+1, 9+1, 16+1, 19+1\\ncounter_left\\ncounter_right\\n'''\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n accums = []\\n counter_left = collections.Counter()\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n counter_right = collections.Counter(accums)\\n counter_right[total_sum] -= 1\\n\\n # no swap\\n cnt = 0\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n \\n # swap one num --> k\\n for idx, num in enumerate(nums):\\n total_sum_new = total_sum - num + k\\n cnt_temp = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_temp += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_temp += counter_right[total_sum_new // 2 - k + num]\\n counter_right[accums[idx]] -= 1\\n counter_left[accums[idx]] += 1\\n cnt = max(cnt_temp, cnt)\\n return cnt\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n'''\\n1, 3, 6, 10 ||. 9, 11\\n1, 4, 10,20 29, 40\\ntotal_sum = 40 \\nfind idx of 20 // 2\\n\\ncase 1. no switch\\ncase 2. switch\\n\\n1, 3, 6, 10-->11 ||. 9, 11\\n1, 4, 10,20+1 29+1, 40+1\\nleft_counter\\nright_counter\\n'''\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accum = 0\\n accums = []\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n left_counter = collections.Counter()\\n right_counter = collections.Counter(accums)\\n right_counter[total_sum] -= 1\\n\\n cnt = 0\\n\\n # case 1. no swap\\n if total_sum % 2 == 0:\\n cnt += right_counter[total_sum // 2]\\n \\n # case 2. swap\\n for idx, num in enumerate(nums):\\n # num --> k\\n total_sum_new = total_sum - num + k\\n cnt_tmp = 0\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_tmp += left_counter[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_tmp += right_counter[total_sum_new // 2 - k + num]\\n right_counter[accums[idx]] -= 1\\n left_counter[accums[idx]] += 1\\n cnt = max(cnt, cnt_tmp)\\n return cnt\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n accums = []\\n accum = 0\\n for num in nums:\\n accum += num\\n accums.append(accum)\\n total_sum = accum\\n\\n counter_right = collections.Counter(accums)\\n counter_right[total_sum] -= 1\\n counter_left = collections.Counter()\\n\\n cnt = 0\\n # without switching\\n if total_sum % 2 == 0:\\n cnt += counter_right[total_sum // 2]\\n # with switching\\n for idx, num in enumerate(nums):\\n # num --> k\\n cnt_tmp = 0\\n total_sum_new = total_sum - num + k\\n if total_sum_new % 2 == 0:\\n if idx > 0:\\n cnt_tmp += counter_left[total_sum_new // 2]\\n if idx < len(nums)-1:\\n cnt_tmp += counter_right[total_sum_new // 2 - k + num]\\n counter_right[accums[idx]] -= 1\\n counter_left[accums[idx]] += 1\\n cnt = max(cnt, cnt_tmp)\\n return cnt\",\n \"memory\": \"43220\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n total = sum(nums)\\n left, right = collections.Counter(), collections.Counter()\\n lsum = 0\\n for i in range(len(nums)-1):\\n lsum += nums[i]\\n right[total - 2 * lsum] += 1\\n res = right[0]\\n lsum = 0\\n for num in nums:\\n res = max(res, left[num - k] + right[-num + k])\\n lsum += num\\n left[total - 2 * lsum] += 1\\n right[total - 2 * lsum] -= 1\\n return res\\n\",\n \"memory\": \"43696\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n total = sum(nums)\\n left, right = collections.Counter(), collections.Counter()\\n lsum = 0\\n for i in range(len(nums)-1):\\n lsum += nums[i]\\n rsum = total - lsum\\n right[lsum - rsum] += 1\\n res = right[0] # if we don't do any replacement, the answer is the number of 0\\n lsum = 0\\n for num in nums:\\n res = max(res, left[k - num] + right[num - k]) # if we replace nums[i] with k, we will get left[d] + right[-d] pivot, where d = nums[i] - k\\n lsum += num\\n rsum = total - lsum\\n right[lsum - rsum] -= 1 # transfer the frequency from 'right' to 'left'\\n left[lsum - rsum] += 1\\n return res\\n\",\n \"memory\": \"43696\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n counter = Counter()\\n tot = sum(nums)\\n curr = nums[0]\\n\\n for num in nums[1:]:\\n counter[2*curr - tot]+=1\\n curr+=num \\n \\n res = counter[0]\\n left_counter = Counter()\\n right_counter = counter\\n curr = 0\\n\\n for i, num in enumerate(nums):\\n res = max(res, left_counter[k-num] + right_counter[num - k])\\n curr+=num \\n right_counter[2*curr - tot]-=1\\n left_counter[2*curr - tot]+=1\\n \\n return res\\n\\n\\n\\n\\n \",\n \"memory\": \"44173\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: list[int], k: int) -> int:\\n n = len(nums)\\n summ = sum(nums)\\n prefix = 0\\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [0..i)\\n l = collections.Counter()\\n # Count of sum(A[0..k)) - sum(A[k..n)) for k in [i..n)\\n r = collections.Counter()\\n\\n for pivot in range(1, n):\\n prefix += nums[pivot - 1]\\n suffix = summ - prefix\\n r[prefix - suffix] += 1\\n\\n ans = r[0]\\n prefix = 0\\n\\n for num in nums:\\n ans = max(ans, l[k - num] + r[num - k])\\n prefix += num\\n suffix = summ - prefix\\n diff = prefix - suffix\\n r[diff] -= 1\\n l[diff] += 1\\n\\n return ans\\n \",\n \"memory\": \"44173\"\n },\n {\n \"code\": \"import collections\\nimport itertools\\nfrom typing import List\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n total = sum(nums)\\n left = 0\\n change_val_on_left_diff_table = collections.defaultdict(int)\\n for a in nums[:-1]:\\n left += a\\n right = total - left\\n change_val_on_left_diff_table[left - right] += 1\\n\\n change_val_on_right_diff_table = collections.defaultdict(int)\\n left = 0\\n res = change_val_on_left_diff_table[0]\\n for a in nums:\\n left += a\\n right = total - left\\n d = k - a\\n res = max(\\n res, change_val_on_right_diff_table[d] +\\n change_val_on_left_diff_table[-d])\\n change_val_on_right_diff_table[left - right] += 1\\n change_val_on_left_diff_table[left - right] -= 1\\n return res\",\n \"memory\": \"44649\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n remain = sum(nums)\\n s = 0\\n diffs = []\\n minus_diff = defaultdict(int)\\n for i in range(len(nums) - 1):\\n remain -= nums[i]\\n s += nums[i]\\n diffs.append(s - remain)\\n minus_diff[s - remain] += 1\\n\\n res = minus_diff[0]\\n add_diff = defaultdict(int)\\n for i in range(len(nums)):\\n res = max(res, add_diff[k - nums[i]] + minus_diff[nums[i] - k])\\n if i < len(nums) - 1:\\n add_diff[diffs[i]] += 1\\n minus_diff[diffs[i]] -= 1\\n return res\\n\",\n \"memory\": \"44649\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, A, k):\\n N = len(A)\\n total_sum = sum(A)\\n after_update_freq_sum_diff, initial_freq_sum_diff = defaultdict(int), defaultdict(int)\\n \\n left_sum = 0\\n for i in range(N - 1):\\n left_sum += A[i]\\n right_sum = total_sum - left_sum\\n initial_freq_sum_diff[left_sum - right_sum] += 1\\n \\n ans = initial_freq_sum_diff[0] # If no replacement is done, answer is the number of `0`s in the frequency map\\n \\n left_sum = 0\\n for i in range(N):\\n left_sum += A[i]\\n right_sum = total_sum - left_sum\\n d = k - A[i] # Difference if we replace A[i] with k\\n ans = max(ans, after_update_freq_sum_diff[d] + initial_freq_sum_diff[-d]) # Get max of current result or new pivot count after replacement\\n initial_freq_sum_diff[left_sum - right_sum] -= 1 # Transfer frequency from initial_freq_sum_diff to after_update_freq_sum_diff\\n after_update_freq_sum_diff[left_sum - right_sum] += 1\\n \\n return ans\\n\",\n \"memory\": \"45125\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, A, k):\\n N = len(A)\\n total_sum = sum(A)\\n initial_freq_sum_diff = defaultdict(int)\\n \\n left_sum = 0\\n for i in range(N - 1):\\n left_sum += A[i]\\n right_sum = total_sum - left_sum\\n initial_freq_sum_diff[left_sum - right_sum] += 1\\n\\n after_update_freq_sum_diff = defaultdict(int)\\n ans = initial_freq_sum_diff[0] # If no replacement is done, answer is the number of `0`s in the frequency map\\n \\n left_sum = 0\\n for i in range(N):\\n left_sum += A[i]\\n right_sum = total_sum - left_sum\\n d = k - A[i] # Difference if we replace A[i] with k\\n ans = max(ans, after_update_freq_sum_diff[d] + initial_freq_sum_diff[-d]) # Get max of current result or new pivot count after replacement\\n initial_freq_sum_diff[left_sum - right_sum] -= 1 # Transfer frequency from initial_freq_sum_diff(prefix) to after_update_freq_sum_diff(suffix) \\n after_update_freq_sum_diff[left_sum - right_sum] += 1\\n \\n return ans\\n\",\n \"memory\": \"45125\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sum_array = [0] * n\\n sum_array[0] = nums[0]\\n left_freq_sums = defaultdict(int)\\n right_freq_sums = defaultdict(int)\\n right_freq_sums[sum_array[0]] += 1\\n for i in range(1, n):\\n sum_array[i] = sum_array[i-1] + nums[i]\\n if i != n-1:\\n right_freq_sums[sum_array[i]] += 1\\n total_sum = sum_array[-1]\\n\\n left_sum = [sum_array[0]]\\n partitions = [0] * (n+1)\\n\\n for pivot in range(1, n):\\n if sum_array[pivot-1] == total_sum / 2:\\n partitions[-1] += 1\\n \\n for change in range(n):\\n diff = k - nums[change]\\n new_total = total_sum + diff\\n partitions[change] += left_freq_sums[new_total / 2]\\n partitions[change] += right_freq_sums[(new_total / 2) - diff]\\n \\n if change != n-1:\\n left_freq_sums[sum_array[change]] += 1\\n right_freq_sums[sum_array[change]] -= 1\\n \\n return max(partitions)\",\n \"memory\": \"45601\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n diffs = []\\n sl, sr = 0, sum(nums)\\n \\n # Calculate prefix differences\\n for i in range(N - 1):\\n sl += nums[i]\\n sr -= nums[i]\\n diffs.append(sl - sr)\\n \\n # Add infinity to prevent error in the counter arithmetic\\n diffs.append(float('inf'))\\n print(diffs)\\n\\n c = Counter(diffs)\\n \\n # Counters for differences\\n cl, cr = Counter(), Counter(diffs)\\n \\n # Result if k does not affect the array\\n # what do we need to get 0 if we substract\\n res = cr[0] # count the zeroes, thats the first result\\n for i in range(N):\\n d = k - nums[i]\\n res = max(res, cl[d] + cr[-d])\\n cl[diffs[i]] += 1\\n cr[diffs[i]] -= 1\\n \\n\\n \\n return res\\n\",\n \"memory\": \"45601\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n right = Counter(itertools.accumulate(reversed(nums), operator.add))\\n left = Counter()\\n total = sum(nums)\\n ans = self.count(right, total)\\n if not total:\\n ans -= 1\\n left_sum, right_sum = 0, total\\n for i, num in enumerate(nums):\\n curr = self.count(left, total + k - num)\\n left_sum += num\\n left[left_sum] += 1\\n right[right_sum] -= 1\\n right_sum -= num\\n curr += self.count(right, total + k - num)\\n ans = max(ans, curr)\\n\\n return ans\\n\\n\\n def count(self, cntr, sm):\\n return (cntr[sm >> 1]) if not (sm & 1) else 0\",\n \"memory\": \"46078\"\n },\n {\n \"code\": \"from collections import Counter\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n total = sum(nums)\\n\\n prefix_sum_counter = Counter()\\n postfix_sum_counter = Counter()\\n\\n right_sum = 0\\n for num in reversed(nums):\\n right_sum += num\\n postfix_sum_counter[right_sum] += 1\\n\\n if total % 2 == 0:\\n out = postfix_sum_counter[total // 2]\\n if total == 0:\\n out -= 1\\n else:\\n out = 0\\n\\n left_sum = 0\\n right_sum = total\\n\\n # [2,-1,2]\\n #postfix_sum_counter = {2: 1, 1: 1, 3 : 1}\\n # total = right_sum = 3\\n \\n for num in nums:\\n left_sum += num #2\\n \\n postfix_sum_counter[right_sum] -= 1 #{2: 1, 1: 1}\\n right_sum -= num #1\\n\\n # change num to k\\n new_total = total + k - num # 4\\n if new_total % 2 == 0:\\n next_out = prefix_sum_counter[new_total // 2] + postfix_sum_counter[new_total // 2]\\n out = max(out, next_out)\\n\\n prefix_sum_counter[left_sum] += 1 #{2: 1}\\n \\n return out\\n\",\n \"memory\": \"46078\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n sum_map = defaultdict(int)\\n sum_map_reverse = defaultdict(int)\\n total_sum = sum(nums)\\n cur_sum = 0\\n for i in reversed(range(len(nums))):\\n cur_sum += nums[i]\\n sum_map_reverse[cur_sum] += 1 \\n res = []\\n cur_sum = 0\\n for i in range(len(nums)):\\n offset = k - nums[i]\\n cur_half = (total_sum+offset)/2\\n left_count = sum_map[cur_half]\\n sum_map_reverse[total_sum-cur_sum] -= 1\\n cur_sum += nums[i]\\n sum_map[cur_sum] += 1\\n right_count = sum_map_reverse[cur_half]\\n res.append(left_count+right_count)\\n no_change_res = 0\\n cur_sum = 0\\n for i in range(len(nums)-1): \\n cur_sum += nums[i]\\n if cur_sum == total_sum/2:\\n no_change_res += 1\\n res.append(no_change_res)\\n return max(res)\\n\\n\\n\\n\\n \",\n \"memory\": \"46554\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n total_sum = sum(nums)\\n prefix_sum = 0\\n left_count = defaultdict(int)\\n right_count = defaultdict(int)\\n \\n for i in range(1, n):\\n prefix_sum += nums[i - 1]\\n right_count[prefix_sum] += 1\\n \\n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\\n \\n prefix_sum = 0\\n for i in range(n):\\n if i > 0:\\n prefix_sum += nums[i - 1]\\n right_count[prefix_sum] -= 1\\n left_count[prefix_sum] += 1\\n \\n diff = k - nums[i]\\n if (total_sum + diff) % 2 == 0:\\n target = (total_sum + diff) // 2\\n max_ways = max(max_ways, left_count[target] + right_count[target - diff])\\n \\n return max_ways\",\n \"memory\": \"47030\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n total_sum = sum(nums)\\n prefix_sum = 0\\n left_count = defaultdict(int)\\n right_count = defaultdict(int)\\n \\n for i in range(1, n):\\n prefix_sum += nums[i - 1]\\n right_count[prefix_sum] += 1\\n \\n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\\n \\n prefix_sum = 0\\n for i in range(n):\\n if i > 0:\\n prefix_sum += nums[i - 1]\\n right_count[prefix_sum] -= 1\\n left_count[prefix_sum] += 1\\n \\n diff = k - nums[i]\\n if (total_sum + diff) % 2 == 0:\\n target = (total_sum + diff) // 2\\n max_ways = max(max_ways, left_count[target] + right_count[target - diff])\\n \\n return max_ways\",\n \"memory\": \"47030\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n total_sum = sum(nums)\\n prefix_sum = 0\\n \\n # Calculate initial valid pivots without any change\\n left_count = defaultdict(int)\\n right_count = defaultdict(int)\\n \\n # Fill right_count with initial pivot possibilities\\n for i in range(n - 1):\\n prefix_sum += nums[i]\\n right_count[prefix_sum] += 1\\n \\n prefix_sum = 0\\n max_ways = right_count[total_sum // 2] if total_sum % 2 == 0 else 0\\n \\n # Check the effect of changing each element to k\\n for i in range(n):\\n current = nums[i]\\n diff = k - current\\n \\n # Calculate the number of ways if we change nums[i] to k\\n if i > 0:\\n prefix_sum += nums[i - 1]\\n left_count[prefix_sum] += 1\\n right_count[prefix_sum] -= 1\\n \\n if (total_sum + diff) % 2 == 0:\\n target = (total_sum + diff) // 2\\n current_ways = left_count[target] + right_count[target - diff]\\n max_ways = max(max_ways, current_ways)\\n \\n return max_ways\\n\\n# Example usage:\\n# solution = Solution()\\n# print(solution.waysToPartition([2, -1, 2], 3)) # Output: 1\\n# print(solution.waysToPartition([0, 0, 0], 1)) # Output: 2\\n# print(solution.waysToPartition([22, 4, -25, -20, -15, 15, -16, 7, 19, -10, 0, -13, -14], -33)) # Output: 4\",\n \"memory\": \"47506\"\n },\n {\n \"code\": \"class Solution:\\n # Time: O()\\n # Space: O(), where n = len(nums)\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n total_sum = sum(nums)\\n counts_pref_sums = defaultdict(int)\\n curr_sum = 0\\n \\n # Calculate prefix sums and count occurrences\\n for idx in range(len(nums) - 1):\\n curr_sum += nums[idx]\\n counts_pref_sums[curr_sum] += 1\\n \\n # Case 1: When no element is changed, calculate the number of ways to partition\\n res = 0\\n if total_sum % 2 == 0:\\n # Each left and right should have this sum half_sum\\n half_sum = total_sum // 2\\n res = counts_pref_sums[half_sum]\\n\\n temp_counts = defaultdict(int)\\n curr_sum = 0\\n n = len(nums)\\n \\n for idx in range(n):\\n # possible = curr_sum + k\\n half_sum = total_sum + k - nums[idx]\\n \\n if half_sum % 2 == 1:\\n # If new half_sum is not an integer, skip this element\\n curr_sum += nums[idx]\\n temp_counts[curr_sum] += 1\\n else:\\n half_sum //= 2\\n curr_sum += nums[idx]\\n \\n # Calculate valid partitions if the pivot happens later or before\\n total_halves_later = counts_pref_sums[half_sum - k + nums[idx]] - temp_counts[half_sum - k + nums[idx]]\\n total_halves_before = temp_counts[half_sum]\\n \\n temp_counts[curr_sum] += 1\\n res = max(res, total_halves_later + total_halves_before)\\n \\n return res\\n\\n\",\n \"memory\": \"47506\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sum = 0\\n prefix_sum_counts = defaultdict(int)\\n # prefix_sum_counts[prefix_sum] += 1\\n\\n max_ways_to_partition = 0\\n arr_sum = sum(nums)\\n\\n for num in nums[:-1]:\\n prefix_sum += num\\n if prefix_sum == arr_sum - prefix_sum:\\n max_ways_to_partition += 1\\n\\n prefix_sum_counts[prefix_sum] += 1\\n\\n # # to handle the condition that pivot can at most be n - 1.\\n # prefix_sum_counts[prefix_sum] -= 1\\n\\n prefix_sum = 0\\n left_ps = defaultdict(int)\\n\\n for num in nums:\\n ways_to_partition = (\\n left_ps[(arr_sum + k - num) / 2]\\n + prefix_sum_counts[(arr_sum - k + num) / 2]\\n )\\n\\n prefix_sum += num\\n left_ps[prefix_sum] += 1\\n prefix_sum_counts[prefix_sum] -= 1\\n\\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\\n\\n return max_ways_to_partition\\n\",\n \"memory\": \"47983\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sum = 0\\n prefix_sum_counts = defaultdict(int)\\n\\n max_ways_to_partition = 0\\n arr_sum = sum(nums)\\n\\n for num in nums[:-1]:\\n prefix_sum += num\\n if prefix_sum == arr_sum - prefix_sum:\\n max_ways_to_partition += 1\\n\\n prefix_sum_counts[prefix_sum] += 1\\n\\n prefix_sum = 0\\n left_ps = defaultdict(int)\\n\\n for num in nums:\\n ways_to_partition = (\\n left_ps[(arr_sum + k - num) / 2]\\n + prefix_sum_counts[(arr_sum - k + num) / 2]\\n )\\n\\n prefix_sum += num\\n left_ps[prefix_sum] += 1\\n prefix_sum_counts[prefix_sum] -= 1\\n\\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\\n\\n return max_ways_to_partition\\n\",\n \"memory\": \"47983\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, A: List[int], k: int) -> int:\\n presum = list(accumulate(A))\\n\\n leftCnt = Counter()\\n rightCnt = Counter()\\n\\n n = len(A)\\n\\n for i in range(1, n):\\n diff = presum[i-1] - (presum[-1] - presum[i-1])\\n rightCnt[diff] += 1\\n\\n ans = rightCnt[0]\\n\\n for i, a in enumerate(A):\\n diff = k - a\\n ans = max(ans, leftCnt[diff] + rightCnt[-diff])\\n # Why rightCnt[-diff]?\\n # Since only prefix (left) is in creased by diff and the suffix is not influenced\\n # the original diff will become new_diff = (prefix + diff) - suffix\\n # To make new_diff also zero, we have to offset by -diff... so we query rightCnt[-diff]\\n\\n # Why leftCnt[diff]\\n # Because.. new_diff = prefix - (suffix + diff)\\n # To make new_diff also zero, we have to offset by +diff... so we query leftCnt[diff]\\n \\n # simply copy right to left...\\n oriDiff = presum[i] - (presum[-1] - presum[i])\\n leftCnt[oriDiff] += 1\\n rightCnt[oriDiff] -= 1\\n\\n\\n return ans \",\n \"memory\": \"48459\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n diff_counter = collections.Counter()\\n n = len(nums)\\n P = [0] + list(accumulate(nums))\\n\\n for p in range(n-1):\\n left = P[p + 1] - P[0]\\n right = P[n] - P[p + 1]\\n diff_counter[right - left] += 1\\n\\n ans = diff_counter[0]\\n counter = Counter()\\n\\n for i in range(n):\\n diff = k - nums[i]\\n ans = max(ans, diff_counter[diff] + counter[-diff])\\n\\n left = P[i+1] - P[0]\\n right = P[n] - P[i+1]\\n counter[right - left] += 1\\n diff_counter[right - left] -= 1\\n\\n return ans\",\n \"memory\": \"48459\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n, nSum = len(nums), sum(nums)\\n pref = [nums[0]]\\n for l in range(1,n):\\n pref.append(nums[l]+pref[l-1])\\n diffAfter=collections.defaultdict(int)\\n for i in range(n-1):\\n diffAfter[nSum - 2 * pref[i]]+=1\\n diffBefore = collections.defaultdict(int)\\n ans = diffAfter[0]\\n ans = max(ans, diffAfter[k - nums[0]]) # If we change first num\\n # right side = sum - prefix[i]-k left side = prefix[i] +k\\n print(diffAfter,nums[0],k)\\n for j in range(1,n):\\n diff = nSum - 2 * pref[j-1]\\n diffAfter[diff]-=1\\n diffBefore[diff]+=1\\n ans = max(ans, diffAfter[k - nums[j]] + diffBefore[nums[j] - k])\\n\\n return ans \\n\\n\\n \",\n \"memory\": \"48935\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n prefix_sums = [0] * n\\n prefix_sums[0] = nums[0]\\n for i in range(1, n):\\n prefix_sums[i] = prefix_sums[i-1] + nums[i]\\n \\n whole_sum = prefix_sums[-1]\\n\\n before_diffs = defaultdict(int)\\n after_diffs = defaultdict(int)\\n\\n for i in range(n - 1):\\n after_diffs[whole_sum - 2 * prefix_sums[i]] += 1\\n \\n res = after_diffs[0]\\n\\n for i in range(n):\\n d = k - nums[i]\\n res = max(res, after_diffs[d] + before_diffs[-d])\\n\\n after_diffs[whole_sum - 2 * prefix_sums[i]] -= 1\\n before_diffs[whole_sum - 2 * prefix_sums[i]] += 1\\n \\n return res\\n\",\n \"memory\": \"48935\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = [0]*n\\n prefix_sum[0] = nums[0]\\n for i in range(1,n):\\n prefix_sum[i] = prefix_sum[i-1]+nums[i]\\n \\n total_sum = prefix_sum[-1]\\n diff_map_right = defaultdict(int)\\n diff_map_left = defaultdict(int)\\n\\n for i in range(1,n):\\n cur_diff = 2*prefix_sum[i-1] - total_sum\\n diff_map_right[cur_diff]+=1\\n\\n max_partition = diff_map_right[0]\\n\\n for j in range(n):\\n change_diff = k - nums[j]\\n \\n max_partition = max(max_partition, diff_map_left[change_diff]+diff_map_right[-change_diff])\\n \\n diff = 2 * prefix_sum[j] - total_sum\\n diff_map_left[diff]+=1\\n diff_map_right[diff]-=1\\n \\n return max_partition\",\n \"memory\": \"49411\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sums = list(accumulate(nums))\\n total_sum = prefix_sums[-1]\\n best = 0\\n if total_sum % 2 == 0:\\n best = prefix_sums[:-1].count(total_sum // 2) # If no change\\n\\n after_counts = Counter(total_sum - 2 * prefix_sum\\n for prefix_sum in prefix_sums[:-1])\\n before_counts = Counter()\\n\\n best = max(best, after_counts[k - nums[0]]) # If we change first num\\n\\n for prefix, x in zip(prefix_sums, nums[1:]):\\n gap = total_sum - 2 * prefix\\n after_counts[gap] -= 1\\n before_counts[gap] += 1\\n\\n best = max(best, after_counts[k - x] + before_counts[x - k])\\n\\n return best\",\n \"memory\": \"49411\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n targ = sum(nums)\\n noneans = 0\\n ans = [0]*len(nums)\\n lsums,rsums = {nums[0]*2-targ:1},{nums[-1]*2-targ:1}\\n prefix = [nums[0]]\\n for i in range(1,len(nums)):\\n if prefix[-1]*2==targ: noneans += 1\\n prefix.append(prefix[-1]+nums[i])\\n for i in range(1,len(nums)):\\n if k-nums[i] in lsums: ans[i] += lsums[k-nums[i]]\\n lsums[prefix[i]*2-targ] = lsums.get(prefix[i]*2-targ,0)+1\\n for i in range(len(prefix)-2,-1,-1):\\n if k-nums[i] in rsums: ans[i] += rsums[k-nums[i]]\\n rsums[targ-prefix[i-1]*2] = rsums.get(targ-prefix[i-1]*2,0)+1\\n return max(max(ans),noneans)\",\n \"memory\": \"49888\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n, nSum = len(nums), sum(nums)\\n pref = list(accumulate(nums))\\n diffAfter = Counter(nSum - 2 * prefix\\n for prefix in pref[:-1])\\n # for i in range(n-1):\\n # diffAfter[nSum - 2 * pref[i]]+=1\\n diffBefore = collections.defaultdict(int)\\n ans = diffAfter[0]\\n ans = max(ans, diffAfter[k - nums[0]]) # If we change first num\\n # right side = sum - prefix[i]-k left side = prefix[i] +k\\n for j in range(1,n):\\n diff = nSum - 2 * pref[j-1]\\n diffAfter[diff]-=1\\n diffBefore[diff]+=1\\n ans = max(ans, diffAfter[k - nums[j]] + diffBefore[nums[j] - k])\\n\\n return ans \\n\\n\\n \",\n \"memory\": \"49888\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix_sum = nums[0]\\n prefix_sum_counts = defaultdict(int)\\n prefix_sum_counts[prefix_sum] += 1\\n\\n max_ways_to_partition = 0\\n arr_sum = sum(nums)\\n\\n for num in nums[1:]:\\n if prefix_sum == arr_sum - prefix_sum:\\n max_ways_to_partition += 1\\n\\n prefix_sum += num\\n prefix_sum_counts[prefix_sum] += 1\\n\\n # to handle the condition that pivot can at most be n - 1.\\n prefix_sum_counts[prefix_sum] -= 1\\n\\n prefix_sum = nums[0]\\n left_ps = defaultdict(int)\\n\\n right_ps = prefix_sum_counts\\n\\n if (arr_sum - k + nums[0]) % 2 == 0:\\n max_ways_to_partition = max(\\n max_ways_to_partition, right_ps[(arr_sum - k + nums[0]) // 2]\\n )\\n\\n left_ps[prefix_sum] += 1\\n right_ps[prefix_sum] -= 1\\n\\n for idx, num in enumerate(nums[1:], 1):\\n ways_to_partition = 0\\n ways_to_partition += left_ps[(arr_sum + k - num) / 2]\\n ways_to_partition += right_ps[(arr_sum - k + num) / 2]\\n\\n prefix_sum += num\\n left_ps[prefix_sum] += 1\\n right_ps[prefix_sum] -= 1\\n\\n max_ways_to_partition = max(max_ways_to_partition, ways_to_partition)\\n\\n return max_ways_to_partition\\n\",\n \"memory\": \"50364\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n\\n left_sum = [nums[0]]\\n for num in nums[1:]:\\n left_sum.append(left_sum[-1] + num)\\n\\n right_sum = [nums[-1]]\\n for num in nums[::-1][1:]:\\n right_sum.append(right_sum[-1] + num)\\n right_sum = right_sum[::-1]\\n\\n diffs = []\\n\\n for pivot in range(1, len(nums)):\\n diffs.append(left_sum[pivot-1]-right_sum[pivot])\\n diffs.append(math.inf) # to prevent error in the counter arithemtic\\n \\n counter_left, counter_right = Counter(), Counter(diffs)\\n output = counter_right[0]\\n for i in range(len(nums)):\\n d = k - nums[i]\\n output = max(output, counter_left[d] + counter_right[-d])\\n counter_left[diffs[i]] += 1\\n counter_right[diffs[i]] -= 1\\n \\n print(diffs)\\n return output\",\n \"memory\": \"50364\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix = [0]\\n for x in nums: prefix.append(prefix[-1] + x)\\n \\n ans = 0\\n n = len(nums)\\n loc = defaultdict(list)\\n for i in range(1, n):\\n if prefix[i] * 2 == prefix[-1]: ans += 1\\n loc[prefix[i]].append(i)\\n \\n total = prefix[-1]\\n if total % 2 == 0: ans = max(ans, len(loc[total//2]))\\n \\n for i, x in enumerate(nums):\\n cnt = 0\\n diff = k - x\\n if diff:\\n r = total + diff\\n if r % 2 == 0:\\n r //= 2\\n cnt += bisect_left(loc[r], i+1)\\n if r-diff in loc:\\n cnt += len(loc[r-diff]) - bisect_left(loc[r-diff], i+1)\\n ans = max(ans, cnt)\\n return ans\",\n \"memory\": \"50840\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left_sum = [nums[0]]\\n for num in nums[1:]:\\n left_sum.append(left_sum[-1] + num)\\n\\n right_sum = [nums[-1]]\\n for num in nums[::-1][1:]:\\n right_sum.append(right_sum[-1] + num)\\n right_sum = right_sum[::-1]\\n\\n diffs = []\\n for pivot in range(1, len(nums)):\\n diffs.append(left_sum[pivot-1]-right_sum[pivot])\\n diffs.append(math.inf) # to prevent error in the counter arithemtic\\n \\n counter_left, counter_right = Counter(), Counter(diffs)\\n output = counter_right[0]\\n for i in range(len(nums)):\\n d = k - nums[i]\\n output = max(output, counter_left[d] + counter_right[-d])\\n counter_left[diffs[i]] += 1\\n counter_right[diffs[i]] -= 1\\n \\n return output\",\n \"memory\": \"50840\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n preSum = [0] * (n + 1)\\n for i in range(n):\\n preSum[i + 1] = preSum[i] + nums[i]\\n totalSum = preSum[n]\\n\\n balances = []\\n for pivot in range(1, n):\\n bal = 2 * preSum[pivot] - totalSum\\n balances.append(bal)\\n\\n from collections import Counter\\n counts_bal = Counter(balances)\\n\\n left_counts = Counter()\\n right_counts = counts_bal.copy()\\n max_counts = counts_bal[0] # counts of valid pivots in original array\\n\\n for i in range(n):\\n diff = k - nums[i]\\n counts_left = left_counts.get(diff, 0)\\n counts_right = right_counts.get(-diff, 0)\\n total_counts = counts_left + counts_right\\n max_counts = max(max_counts, total_counts)\\n if i < n - 1:\\n bal = balances[i]\\n left_counts[bal] += 1\\n right_counts[bal] -= 1\\n if right_counts[bal] == 0:\\n del right_counts[bal]\\n return max_counts\\n\",\n \"memory\": \"51316\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\n \\n def get_prefix(nums):\\n prefix = [0]*(len(nums))\\n prefix[0] = nums[0]\\n for idx in range(1,len(nums)):\\n prefix[idx] = prefix[idx-1] + nums[idx]\\n \\n return prefix\\n \\n original = get_prefix(nums)\\n \\n dic_nums = defaultdict(list)\\n \\n for idx,prefix in enumerate(original[:-1]):\\n dic_nums[prefix].append(idx)\\n \\n \\n real_total = original[-1]\\n \\n def count_partition(arr):\\n left_sum = arr[0]\\n total = sum(arr)\\n cnt = 0\\n for idx in range(1,len(arr)):\\n right_sum = total - left_sum\\n \\n if left_sum == right_sum:\\n cnt +=1\\n \\n left_sum += arr[idx]\\n \\n return cnt\\n ans = count_partition(nums)\\n print(ans)\\n \\n for idx in range(len(nums)):\\n diff = nums[idx] - k\\n pure_target = real_total - diff\\n if pure_target % 2 == 1:\\n continue\\n \\n target_left = pure_target//2\\n target_right = target_left + diff\\n \\n \\n left_contribution = 0\\n \\n if target_left in dic_nums:\\n left_contribution = bisect_left(dic_nums[target_left],idx)\\n \\n right_contribution = 0\\n if target_right in dic_nums:\\n right_contribution = len(dic_nums[target_right]) - bisect_left(dic_nums[target_right],idx)\\n \\n \\n cur_ans = left_contribution + right_contribution\\n \\n \\n if idx == 18:\\n print(left_contribution,right_contribution,target_left,target_right)\\n print(dic_nums[target_left],len(dic_nums[target_left]))\\n print(dic_nums[target_right],len(dic_nums[target_right]))\\n \\n \\n ans = max(ans,cur_ans)\\n \\n \\n \\n \\n \\n \\n \\n return ans\\n \\n \\n \\n \\n \\n \\n \",\n \"memory\": \"51316\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix = [0]\\n loc = defaultdict(list)\\n for i, x in enumerate(nums): \\n prefix.append(prefix[-1] + x)\\n if i < len(nums)-1: loc[prefix[-1]].append(i)\\n \\n ans = 0 \\n if prefix[-1] % 2 == 0: ans = len(loc[prefix[-1]//2]) # unchanged \\n \\n total = prefix[-1]\\n for i, x in enumerate(nums): \\n cnt = 0 \\n diff = k - x\\n target = total + diff \\n if target % 2 == 0: \\n target //= 2\\n cnt += bisect_left(loc[target], i)\\n cnt += len(loc[target-diff]) - bisect_left(loc[target-diff], i)\\n ans = max(ans, cnt)\\n return ans \",\n \"memory\": \"51793\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix = [0]\\n loc = defaultdict(list)\\n for i, x in enumerate(nums): \\n prefix.append(prefix[-1] + x)\\n if i < len(nums)-1: loc[prefix[-1]].append(i)\\n \\n ans = 0 \\n if prefix[-1] % 2 == 0: ans = len(loc[prefix[-1]//2]) # unchanged \\n \\n total = prefix[-1]\\n for i, x in enumerate(nums): \\n cnt = 0 \\n diff = k - x\\n target = total + diff \\n if target % 2 == 0: \\n target //= 2\\n cnt += bisect_left(loc[target], i)\\n cnt += len(loc[target-diff]) - bisect_left(loc[target-diff], i)\\n ans = max(ans, cnt)\\n return ans \",\n \"memory\": \"51793\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n prefix_sum = [0 for _ in range(N)]\\n postfix_sum = [0 for _ in range(N)]\\n prefix_sum[0] = nums[0]\\n postfix_sum[-1] = nums[-1]\\n\\n for i in range(1, N):\\n prefix_sum[i] = prefix_sum[i - 1] + nums[i]\\n postfix_sum[N - 1 - i] = postfix_sum[N - i] + nums[N - 1 - i]\\n \\n ways_unchanged = 0\\n \\n for pivot in range(1, N):\\n left = prefix_sum[pivot - 1]\\n right = postfix_sum[pivot]\\n if left == right:\\n ways_unchanged += 1\\n \\n ways_changed = 0\\n\\n \\\"\\\"\\\"\\n left - something + k == right\\n or\\n left == right - something + k\\n\\n We have prefix sums and postfix sums.\\n We are considering the case of changing one element here ONLY.\\n Does it help to keep track of frequencies (counters) of sums? Maybe.\\n\\n \\\"\\\"\\\"\\n sum_diffs = [l - r for l, r in zip(prefix_sum[:-1], postfix_sum[1:])]\\n left = Counter()\\n right = Counter(sum_diffs)\\n\\n for idx in range(N):\\n replaced = nums[idx]\\n required_diff = k - replaced\\n ways = 0\\n if idx > 0:\\n left[sum_diffs[idx - 1]] += 1\\n right[sum_diffs[idx - 1]] -= 1\\n ways += left[required_diff] \\n ways += right[-required_diff]\\n ways_changed = max(ways, ways_changed)\\n \\n return max(ways_unchanged, ways_changed)\\n\",\n \"memory\": \"52269\"\n },\n {\n \"code\": \"import itertools\\nfrom collections import defaultdict, Counter\\nimport math\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n prefix_sum = list(itertools.accumulate(nums))\\n suffix_sum = list(reversed(list(itertools.accumulate(nums[::-1]))))\\n\\n def get_max_pivots_v1():\\n max_pivots = 0\\n for i in range(n):\\n pivots = 0\\n delta = k - nums[i]\\n for j in range(1, n):\\n diff = prefix_sum[j - 1] - suffix_sum[j]\\n if diff == 0:\\n pivots += 1\\n continue\\n if j <= i:\\n if diff == delta:\\n pivots += 1\\n else:\\n if diff == -delta:\\n pivots += 1\\n max_pivots = max(pivots, max_pivots)\\n return max_pivots\\n\\n def get_max_pivots_v2():\\n diffs = []\\n for i in range(1, n):\\n diffs.append(prefix_sum[i - 1] - suffix_sum[i])\\n print(diffs)\\n diffs_rev = list(reversed(diffs))\\n pre_diffs = Counter()\\n post_diffs = Counter(diffs)\\n max_pivots = post_diffs[0]\\n for i in range(n):\\n delta = k - nums[i]\\n if diffs_rev and i != 0:\\n diff = diffs_rev.pop()\\n pre_diffs.update([diff])\\n post_diffs.subtract([diff])\\n max_pivots = max(max_pivots, max(pre_diffs[delta], 0) + max(post_diffs[-delta], 0))\\n return max_pivots\\n\\n return get_max_pivots_v2()\\n\",\n \"memory\": \"52269\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n sz, ans, left, right = len(nums), 0, defaultdict(int), defaultdict(int)\\n prefix, suffix = [0] * sz, [0] * sz\\n prefix[0], suffix[-1] = nums[0], nums[-1]\\n # store prefix and suffix sum\\n for idx in range(1, sz):\\n prefix[idx] = prefix[idx - 1] + nums[idx]\\n suffix[sz - 1 - idx] = suffix[sz - idx] + nums[sz - 1 - idx]\\n # intially store the differences in the hashmap right\\n # print(prefix)\\n # print(\\\"*******\\\")\\n # print(suffix)\\n for idx in range(sz - 1):\\n right[prefix[idx] - suffix[idx + 1]] += 1\\n # print(\\\"*******\\\")\\n # print(right)\\n if 0 in right:\\n ans = right[0]\\n for idx in range(sz):\\n # find the number of pivot indexes when nums[i] is changed to k\\n curr, diff = 0, k - nums[idx]\\n if diff in left: \\n curr += left[diff]\\n if -diff in right: \\n curr += right[-diff]\\n # update answer\\n ans = max(ans, curr)\\n # transfer the current element from right to left\\n if idx < sz - 1:\\n currentElem = prefix[idx] - suffix[idx + 1]\\n left[currentElem] += 1\\n right[currentElem] -= 1\\n # if right[currentElem] == 0:\\n # del right[currentElem]\\n # print(\\\"=======\\\")\\n # print(right)\\n # print(left)\\n # print(\\\"__________\\\")\\n return ans\\n # res = 0\\n # prefix_sum = [nums[0]]*len(nums)\\n # prefix_map = defaultdict(int)\\n # prefix_map[nums[0]] = 1\\n # for i in range(1, len(nums)):\\n # prefix_sum[i] = prefix_sum[i-1] + nums[i]\\n # if i != len(nums) - 1:\\n # prefix_map[prefix_sum[i]] += 1\\n # print(prefix_map)\\n # if prefix_sum[-1] % 2 == 0:\\n # res = max(res, prefix_map[prefix_sum[-1]//2])\\n # print(\\\"Prefix sum half : \\\", prefix_sum[-1]//2,\\\" count is : \\\", res)\\n \\n \\n # for i in range(len(nums)):\\n # # count = 0\\n # diff = k - nums[i]\\n # if (prefix_sum[-1] + diff) % 2 != 0:\\n # continue\\n # # for j in range(len(nums)-1):\\n # # cur_prefix = prefix_sum[j] + diff if j >= i else prefix_sum[j]\\n # # if cur_prefix == ((prefix_sum[-1] + diff) // 2):\\n # # count += 1\\n # # print(\\\"Prefix sum half : \\\", ((prefix_sum[-1] + diff) // 2),\\\" count is : \\\", count)\\n # res = max(res, prefix_map[(prefix_sum[-1] + diff)//2])\\n\\n # return res\\n\\n \",\n \"memory\": \"52745\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nnums = [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14], k = -33\\n\\n[ 22, 4,-25,-20, -15, 15,-16, 7, 19,-10, 0,-13,-14]\\n 22 26 1 -19 -34 -19 -35 -28 -9 -19 -19 -32 -46 \\n -33 k\\n -33\\n -33 k\\n 22 -11\\n -33 k\\n 22 26 -7\\n -33 k\\n 22 26 1 -32\\n\\n1) 2 eq part: prefix sum = suffix sum\\n 3) unchange can calc directly by iter each num as pivot (T:n)\\n2) try change each num to k, or unchange\\n - calc prefix sum, suffix sum for every nums[i] change (T:n^2)\\n3) change k, left contain num[i]->k changes, same to right\\n - till j, whether 0~j changes, the same on left\\n - every p, if left has k meets, than changes can be 1 of left, |left| poss?\\n - but num[i]->k is diff change, not k change\\n4) diff of left part and right part matters\\n - part_diff = left - right\\n - no change: find part_diff = 0\\n - change diff = k - nums[i]\\n - change on jth, \\n - right contain j: left (0, 0)..(0, j-1) right (1, n-1)..(j,n-1)\\n -> left = right + change_diff\\n -> left - right = change_diff \\n -> part_diff = change_diff\\n - left contain j: left (0, j)..(0, n-2) right (j+1, n-1)..(n-1,n-1)\\n -> left + change_diff = right\\n -> left - right = -change_diff\\n -> part_diff = -change_diff\\n - diffs_left_right_left_inc_k, diffs_left_right_right_inc_k\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n left_pf_sum = [0 for _ in range(n)]\\n right_pf_sum = [0 for _ in range(n)]\\n for i in range(n):\\n left_pf_sum[i] = (left_pf_sum[i-1] + nums[i]) if i-1 >= 0 else nums[i]\\n for i in range(n-1, -1, -1):\\n right_pf_sum[i] = (right_pf_sum[i+1] + nums[i]) if i+1 <= n-1 else nums[i]\\n # no change\\n result = 0\\n for i in range(n-1):\\n if left_pf_sum[i] == right_pf_sum[i+1]: result += 1\\n \\n # changes on k\\n diffs_left_right_k_in_left = {} # diff:cnt\\n for i in range(n-1):\\n diff = left_pf_sum[i]-right_pf_sum[i+1]\\n diffs_left_right_k_in_left[diff] = diffs_left_right_k_in_left.get(diff, 0) + 1\\n diffs_left_right_k_in_right = {} # diff:cnt\\n for i in range(n):\\n change = k-nums[i]\\n # print(f\\\"nums[i]:{nums[i]}, change:{change}, diffs_left:{diffs_left_right_k_in_left}, diffs_right:{diffs_left_right_k_in_right}\\\")\\n result_cur = 0\\n result_cur += diffs_left_right_k_in_left.get(-change, 0)\\n result_cur += diffs_left_right_k_in_right.get(change, 0)\\n result = max(result, result_cur)\\n if i+1 > n-1: break\\n diff_cur = (left_pf_sum[i]-right_pf_sum[i+1])\\n diffs_left_right_k_in_left[diff_cur] -= 1\\n diffs_left_right_k_in_right[diff_cur] = diffs_left_right_k_in_right.get(diff_cur, 0) + 1\\n\\n return result\",\n \"memory\": \"53221\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n 1. How can we find the count of pivots if we don't change any value\\n - count all indexes where prefix[i] = suffix[i + 1]\\n 2. If we change jth element to k and get d = k - nums[j]\\n - Values from prefix[j] to prefix[n - 1] will increase by d\\n - values from suffix[j] to suffix[0] will be increased by d\\n - If we have counts of all indexies i, such that\\n - if i < j, where prefix[i] - suffix[i] = d in the original array\\n - if i >= j, where prefix[i]- suffix[i] = -d in the original array\\n \\\"\\\"\\\"\\n # calculate prefix and suffix\\n n = len(nums)\\n prefix, suffix = [0] * n, [0] * n\\n prefix[0], suffix[n - 1] = nums[0], nums[n - 1]\\n for i in range(1, n):\\n prefix[i] = prefix[i - 1] + nums[i]\\n suffix[n - 1 - i] = suffix[n - i] + nums[n - 1 - i]\\n\\n # create a map to count the frequency of different d (prefix[i] - suffix[i])\\n # we rotate items from right to left later to comply with the change of the elements\\n left, right = defaultdict(int), defaultdict(int)\\n for i in range(n - 1):\\n right[prefix[i] - suffix[i + 1]] += 1\\n\\n # this is the number of ways of partitions without changing any element\\n res = right[0]\\n\\n # try to change each element\\n for i in range(n):\\n d = k - nums[i]\\n # here the left dictionary is formed in the previous loop\\n cur = left[d] + right[-d]\\n res = max(res, cur)\\n\\n # rotate the d that is calculated with ith element from right to left for next loop\\n if i < n - 1:\\n dd = prefix[i] - suffix[i + 1]\\n right[dd] -= 1\\n left[dd] += 1\\n\\n return res\",\n \"memory\": \"53698\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix = []\\n rightDiff = defaultdict(int)\\n for num in nums:\\n if prefix:\\n prefix.append(prefix[-1] + num)\\n else:\\n prefix.append(num)\\n n = len(nums)\\n diffArr = []\\n for i in range(1,n):\\n left = prefix[i-1]\\n right = prefix[-1] - left\\n diffArr.append(right-left)\\n rightDiff[right-left] += 1\\n sol = rightDiff[0]\\n ans = [0]*n + [sol]\\n leftDiff = defaultdict(int)\\n for i in range(n):\\n change = k - nums[i]\\n ans[i] += rightDiff[change] + leftDiff[change]\\n switched = diffArr[i] if i < n-1 else 0\\n rightDiff[switched] -= 1\\n leftDiff[-switched] += 1\\n return max(ans)\\n\\n\\n \\n\\n \\n \\n\\n \\n \",\n \"memory\": \"54174\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left, right = defaultdict(int), defaultdict(int)\\n n = len(nums)\\n prefixSum, suffixSum = [0] * n, [0] * n\\n prefixSum[0] = nums[0]\\n suffixSum[-1] = nums[-1]\\n for i in range(1,n):\\n prefixSum[i] = nums[i] + prefixSum[i-1]\\n for i in range(n-2, -1, -1):\\n suffixSum[i] = nums[i] + suffixSum[i+1]\\n for i in range(n-1):\\n right[prefixSum[i] - suffixSum[i+1]] += 1\\n ans = right[0]\\n for i in range(n):\\n # change the element at i to k\\n diff = k - nums[i]\\n cur = left[diff] + right[-diff]\\n ans = max(cur, ans)\\n if i < n - 1:\\n curdiff = prefixSum[i] - suffixSum[i+1]\\n left[curdiff] += 1\\n right[curdiff] -= 1\\n return ans\\n\",\n \"memory\": \"54650\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n left, right = defaultdict(int), defaultdict(int)\\n n = len(nums)\\n prefixSum, suffixSum = [0] * n, [0] * n\\n prefixSum[0] = nums[0]\\n suffixSum[-1] = nums[-1]\\n for i in range(1,n):\\n prefixSum[i] = nums[i] + prefixSum[i-1]\\n for i in range(n-2, -1, -1):\\n suffixSum[i] = nums[i] + suffixSum[i+1]\\n for i in range(n-1):\\n right[prefixSum[i] - suffixSum[i+1]] += 1\\n ans = right[0]\\n for i in range(n):\\n # change the element at i to k\\n diff = k - nums[i]\\n cur = left[diff] + right[-diff]\\n ans = max(cur, ans)\\n if i < n - 1:\\n curdiff = prefixSum[i] - suffixSum[i+1]\\n left[curdiff] += 1\\n right[curdiff] -= 1\\n return ans\\n\",\n \"memory\": \"55126\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # Approach #1: calculate the trailing and \\n # leading sums of nums at each position.\\n # Then, at each position, calculate the difference between\\n # the trailing and leading sums.\\n # That should give the number of paritions without changing any elements.\\n # Then, at each position, check whether swapping with k would lead to a higher number of partitions.\\n # This is done by looking up a map of number of positions by trailing - leading difference.\\n # Time complexity: O(4 * n)\\n # Space complexity: O(n ^ 2)\\n\\n # Approach #2: improved version of Approach #1, but instead of\\n # storing maps of differences at each position, iterate once and\\n # increment / decrement the difference maps and check whether swapping with k\\n # would lead to higher numbers of partitions.\\n # The trailing map would be from trailing_diff - leading_diff to number of indexes at index i < pivot\\n # The leading map would be from trailing_diff - leading_diff to number of indexes at index i >= pivot\\n # At each position pivot, the number of positions would then be:\\n # partitions_i = partitions_0 + trailing[nums[pivot] - k] + leading[nums[pivot] - k]\\n # partitions_0 being the number of partitions without any changes\\n # The final number of partitions would be the max(partitions_i)\\n # Time complexity: O(4 * n)\\n # Space complexity: O(2 * n)\\n\\n leading, trailing = [0], [0]\\n ldiffs, tdiffs = defaultdict(int), defaultdict(int)\\n n = len(nums)\\n for i in range(n):\\n trailing.append(nums[i] + trailing[-1])\\n leading.append(nums[-i-1] + leading[-1])\\n leading, trailing = leading[:0:-1], trailing[:-1]\\n\\n # print('nums', nums)\\n\\n # print('trailing', trailing)\\n # print('leading', leading)\\n\\n for i in range(1, n):\\n tdiffs[trailing[i] - leading[i]] += 1\\n\\n partitions_0 = tdiffs[0]\\n partitions = partitions_0\\n\\n # print('tdiffs', tdiffs)\\n # print('ldiffs', ldiffs)\\n\\n for i in range(n-1,-1,-1):\\n delta = k - nums[i]\\n partitions_i = (\\n partitions_0 + \\n tdiffs[delta] + \\n ldiffs[-delta] -\\n tdiffs[0] - \\n ldiffs[0]\\n )\\n partitions = max(partitions, partitions_i)\\n if i > 0:\\n tdiffs[trailing[i] - leading[i]] -= 1\\n ldiffs[trailing[i] - leading[i]] += 1\\n \\n # print('i, partitions, partitions_i', i, partitions, partitions_i)\\n\\n return partitions\\n\",\n \"memory\": \"55126\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n prefix=[]\\n suffix=[]\\n n=len(nums)\\n s1=0\\n s2=0\\n for i in range(n):\\n s1+=nums[i]\\n s2+=nums[n-1-i]\\n prefix.append(s1)\\n suffix.append(s2)\\n suffix=suffix[::-1]\\n #suffix sum and prefix sum\\n left_diff={}\\n right_diff={}\\n #made two dictionaries(hash map) to store the diffrent b/w right and left sub arrays suffix[i+1]-prefix[i] for every i.\\n diff_arr=[]\\n for i in range(n-1):\\n diff=suffix[i+1]-prefix[i]\\n if diff in right_diff:\\n right_diff[diff]+=1\\n else:\\n right_diff[diff]=1\\n diff_arr.append(diff)\\n ans=0\\n if 0 in right_diff:\\n ans=right_diff[0]\\n arr_diff=[]\\n arr_diff.append([right_diff.copy(),{}])\\n \\n for i in range(n):\\n if i==0:\\n diff=k-nums[i]\\n if diff in right_diff:\\n ans=max(ans,right_diff[diff])\\n else:\\n ct=0\\n a=diff_arr[i-1]\\n if right_diff[a]>0:\\n right_diff[a]-=1\\n if a in left_diff:\\n left_diff[a]+=1\\n else:\\n left_diff[a]=1\\n diff=k-nums[i]\\n if diff in right_diff:\\n ct+=right_diff[diff]\\n if -diff in left_diff:\\n ct+=left_diff[-diff]\\n \\n ans=max(ans,ct)\\n \\n return ans \",\n \"memory\": \"55603\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n\\n\\n prefix=[]\\n suffix=[]\\n n=len(nums)\\n s1=0\\n s2=0\\n for i in range(n):\\n s1+=nums[i]\\n s2+=nums[n-1-i]\\n prefix.append(s1)\\n suffix.append(s2)\\n suffix=suffix[::-1]\\n #suffix sum and prefix sum\\n left_diff={}\\n right_diff={}\\n #made two dictionaries(hash map) to store the diffrent b/w right and left sub arrays suffix[i+1]-prefix[i] for every i.\\n diff_arr=[]\\n for i in range(n-1):\\n diff=suffix[i+1]-prefix[i]\\n if diff in right_diff:\\n right_diff[diff]+=1\\n else:\\n right_diff[diff]=1\\n diff_arr.append(diff)\\n ans=0\\n if 0 in right_diff:\\n ans=right_diff[0]\\n arr_diff=[]\\n arr_diff.append([right_diff.copy(),{}])\\n \\n for i in range(n):\\n if i==0:\\n diff=k-nums[i]\\n if diff in right_diff:\\n ans=max(ans,right_diff[diff])\\n else:\\n ct=0\\n a=diff_arr[i-1]\\n if right_diff[a]>0:\\n right_diff[a]-=1\\n if a in left_diff:\\n left_diff[a]+=1\\n else:\\n left_diff[a]=1\\n diff=k-nums[i]\\n if diff in right_diff:\\n ct+=right_diff[diff]\\n if -diff in left_diff:\\n ct+=left_diff[-diff]\\n \\n ans=max(ans,ct)\\n \\n return ans\",\n \"memory\": \"55603\"\n },\n {\n \"code\": \"'''class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n before = {k:0}; after = {}; counter = Counter(nums)\\n p = list(accumulate(nums))\\n n = len(nums)\\n for i, num in enumerate(nums[:n-1]):\\n before[num] = max(before.get(num, 0), after.get(num, 0))\\n counter[nums[i]] -= 1\\n if counter[nums[i]] == 0: del counter[nums[i]]\\n \\n diff = 2 * p[i] - p[-1]\\n if (k + diff) in before: before[k + diff] += 1\\n if (k - diff) in counter: after[k - diff] = after.get(k - diff, 0) + 1\\n return max(max([0] + list(before.values())), max([0] + list(after.values())))'''\\n\\nimport bisect\\nimport collections\\nfrom typing import List, Tuple, Mapping\\n\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n diffsIfReplacedWithK = [k - num for num in nums]\\n diffsToReplaceIndices = collections.defaultdict[int, list[int]](list)\\n for i in range(len(diffsIfReplacedWithK)):\\n diffsToReplaceIndices[diffsIfReplacedWithK[i]].append(i)\\n\\n leftHalf = 0\\n rightHalf = sum(nums)\\n pivot = 0\\n diffsToPivots = collections.defaultdict[int, list[int]](list)\\n for num in nums[:-1]:\\n pivot += 1\\n leftHalf += num\\n rightHalf -= num\\n diffsToPivots[leftHalf - rightHalf].append(pivot)\\n\\n\\n outerWays = len(diffsToPivots[0]) # this is no replacement\\n\\n for diff, replacedIndices in diffsToReplaceIndices.items():\\n if diff == 0:\\n continue\\n pivots1 = diffsToPivots.get(diff)\\n pivots2 = diffsToPivots.get(-diff)\\n if (not pivots1 and not pivots2):\\n continue\\n\\n # Let's say diff is > 0\\n # Then left half's sum is > right half's sum, if splited by one of the pivots1.\\n # We want to find a number to be replaced whose location is after the pivot,\\n # i.e. pivot1 <= replacedIndex.\\n # Or, we can find one whose location is before the pivots2 (but with -diff),\\n # i.e. pivot2 > replaceIndex.\\n\\n for replacedIndex in replacedIndices:\\n ways = 0\\n if pivots1:\\n loc = bisect.bisect_right(pivots1, replacedIndex)\\n ways += loc\\n if pivots2:\\n loc = bisect.bisect_right(pivots2, replacedIndex)\\n ways += len(pivots2) - loc\\n outerWays = max(outerWays, ways)\\n\\n return outerWays\",\n \"memory\": \"57508\"\n },\n {\n \"code\": \"from bisect import bisect_right\\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n '''\\n n = len(nums)\\n nums = [1,2,3,4]\\n part1 = [0:pivot], part2 = [pivot:n]\\n sum(part1) == sum(part2)\\n\\n at least one element in each partition\\n '''\\n\\n n = len(nums)\\n\\n pref = list(itertools.accumulate(nums)) # pref[i] = sum(nums[:i+1])\\n suff = [pref[n-1]]+[pref[n-1]-pref[i] for i in range(n-1)] # suff[i]: sum(nums[i:])\\n\\n diff_to_idx = {}\\n for i in range(1,n):\\n diff_to_idx.setdefault(pref[i-1]-suff[i],[]).append(i)\\n\\n print(diff_to_idx)\\n\\n ans = 0\\n for i in range(-1,n):\\n delta = k - nums[i] if i != -1 else 0\\n idx_left = diff_to_idx.get(delta,[])\\n nbr_left = bisect_right(idx_left, i)\\n idx_right = diff_to_idx.get(-delta,[])\\n nbr_right = len(diff_to_idx.get(-delta,[])) - bisect_right(idx_right, i)\\n ans = max(ans, nbr_left+nbr_right)\\n\\n return ans\\n\\n\\n\\n \\n\\n return ans\\n\\n # nums = [1,0,-1], k = 2\\n # pref = [0,1,1,0]\\n\",\n \"memory\": \"57984\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n size = len(nums)\\n if size <= 0:\\n return 0\\n \\n prefix_sum = []\\n sum = 0\\n for index in range(0, size):\\n sum += nums[index]\\n prefix_sum.append(sum)\\n \\n suffix_sum = []\\n sum = 0 \\n for index in range(size - 1, -1, -1):\\n sum += nums[index]\\n suffix_sum.append(sum)\\n suffix_sum.reverse()\\n\\n def prefix(start, end):\\n if start == 0:\\n return prefix_sum[end]\\n else:\\n return prefix_sum[end] - prefix_sum[start - 1]\\n \\n\\n \\n valid_pivot = set()\\n diff_map = {}\\n count = 0\\n\\n for pivot in range(1, size):\\n left_sum = prefix(0, pivot - 1)\\n right_sum = prefix(pivot, size - 1)\\n\\n \\n if left_sum == right_sum:\\n count += 1\\n print(\\\"here - \\\", pivot)\\n valid_pivot.add(pivot)\\n else:\\n # store the diff in some DS\\n diff = (left_sum - right_sum)\\n if diff not in diff_map:\\n diff_map[diff] = []\\n diff_map[diff].append(pivot)\\n \\n print(diff_map)\\n changed = False\\n max_count = count\\n for index in range(size):\\n count = 0\\n change = k - nums[index]\\n if change == 0:\\n continue\\n \\n change = -1 * change\\n if change in diff_map:\\n pivots = diff_map[change]\\n for pivot in pivots:\\n if index < pivot:\\n count += 1\\n changed = True\\n \\n change = change * -1\\n if change in diff_map:\\n pivots = diff_map[change]\\n for pivot in pivots:\\n if index >= pivot:\\n count += 1\\n changed = True\\n max_count = max(max_count, count)\\n \\n return max_count\\n\\n\\n\\n\\n \\\"\\\"\\\"\\n for index in range(size):\\n change = k - nums[index]\\n if index < pivot:\\n if left_sum + change == right_sum:\\n count += 1\\n print(\\\"here 2 - \\\", pivot, index)\\n break\\n else:\\n if left_sum == right_sum + change:\\n count += 1\\n print(\\\"here 3- \\\", pivot, index)\\n break\\n \\\"\\\"\\\"\\n\\n\\n\\n \",\n \"memory\": \"58460\"\n },\n {\n \"code\": \"import bisect \\n\\nclass Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n diff = defaultdict(list)\\n pref = [0]\\n for num in nums:\\n pref.append(pref[-1]+num)\\n suff = [0]\\n for num in reversed(nums):\\n suff.append(suff[-1]+num)\\n suff = suff[::-1]\\n \\n for pivot in range(1, len(nums)):\\n left = pref[pivot]\\n right = suff[pivot]\\n diff[left-right].append(pivot)\\n\\n res = len(diff[0])\\n for i in range(len(nums)):\\n res = max(res, bisect.bisect_left(diff[k-nums[i]], i+1)+(len(diff[nums[i]-k])-bisect.bisect_left(diff[nums[i]-k], i+1)))\\n return res\",\n \"memory\": \"58936\"\n },\n {\n \"code\": \"class Solution:\\n def waysToPartition(self, nums: List[int], k: int) -> int:\\n # [22,4,-25,-20,-15,15] k = 10\\n\\n # keep track of every thing after current pivot ninclusive (pivot must be on left side)\\n # keep track of the +/- diff needed to make it equal on the LEFT\\n # sortedlist of differences. also a prefix array so we can delete\\n #\\n bests = defaultdict(int)\\n def countWays(nums, rev):\\n counts = defaultdict(int) # diff -> count\\n diffs = defaultdict(int) # index - > diff (meaning you put a pivot inbetween this element and previous)\\n pref = list(itertools.accumulate(nums))\\n suff = list(itertools.accumulate(nums[::-1]))[::-1]\\n\\n for i in range(1, len(nums)):\\n lside = pref[i-1]\\n rside = suff[i]\\n\\n diffs[i] = rside - lside\\n counts[diffs[i]] += 1\\n \\n \\n bests[0] = counts[0]\\n for i in range(1, len(nums)):\\n change = k - nums[i - 1] # we have chanvged the left side sum to +change\\n\\n if rev:\\n bests[len(nums) - i + 1] += counts[change]\\n else:\\n bests[i] += counts[change]\\n counts[diffs[i]] -= 1\\n \\n return 0\\n \\n w1 = countWays(nums, False)\\n w2 = countWays(nums[::-1], True)\\n return max(bests.values())\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"59413\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":83,"string":"83"}}},{"rowIdx":2456,"cells":{"question_id":{"kind":"number","value":1545,"string":"1,545"},"name":{"kind":"string","value":"form-largest-integer-with-digits-that-add-up-to-target"},"content":{"kind":"string","value":"<p>Given an array of integers <code>cost</code> and an integer <code>target</code>, return <em>the <strong>maximum</strong> integer you can paint under the following rules</em>:</p>\n\n<ul>\n\t<li>The cost of painting a digit <code>(i + 1)</code> is given by <code>cost[i]</code> (<strong>0-indexed</strong>).</li>\n\t<li>The total cost used must be equal to <code>target</code>.</li>\n\t<li>The integer does not have <code>0</code> digits.</li>\n</ul>\n\n<p>Since the answer may be very large, return it as a string. If there is no way to paint any integer given the condition, return <code>"0"</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> cost = [4,3,2,5,6,7,2,5,5], target = 9\n<strong>Output:</strong> "7772"\n<strong>Explanation:</strong> The cost to paint the digit '7' is 2, and the digit '2' is 3. Then cost("7772") = 2*3+ 3*1 = 9. You could also paint "977", but "7772" is the largest number.\n<strong>Digit cost</strong>\n 1 -> 4\n 2 -> 3\n 3 -> 2\n 4 -> 5\n 5 -> 6\n 6 -> 7\n 7 -> 2\n 8 -> 5\n 9 -> 5\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> cost = [7,6,5,5,5,6,8,7,8], target = 12\n<strong>Output:</strong> "85"\n<strong>Explanation:</strong> The cost to paint the digit '8' is 7, and the digit '5' is 5. Then cost("85") = 7 + 5 = 12.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> cost = [2,4,6,2,4,6,4,4,4], target = 5\n<strong>Output:</strong> "0"\n<strong>Explanation:</strong> It is impossible to paint any integer with total cost equal to target.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>cost.length == 9</code></li>\n\t<li><code>1 <= cost[i], target <= 5000</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":48.398431532311456,"string":"48.398432"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"96\", 11.046600000000002], [\"130\", 20.930400000000006], [\"163\", 24.4188], [\"197\", 11.046600000000003], [\"230\", 1.1628], [\"264\", 5.814], [\"297\", 4.6512], [\"331\", 2.3256], [\"364\", 0.5814], [\"398\", 0.5814], [\"431\", 0.5814], [\"465\", 0.5814], [\"498\", 0.5814], [\"532\", 0.5814], [\"565\", 0.5814], [\"599\", 4.0698], [\"632\", 0.5814], [\"666\", 0.5814], [\"699\", 0.5814], [\"733\", 0.5814], [\"766\", 0.5814], [\"799\", 0.5814], [\"833\", 0.5814], [\"866\", 0.5814], [\"900\", 0.5814]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16500\", 0.5814], [\"16600\", 0.5814], [\"16700\", 1.7442], [\"17000\", 4.0698], [\"17100\", 6.9767], [\"17200\", 3.4884], [\"17300\", 0.5814], [\"17700\", 1.7442], [\"18800\", 0.5814], [\"18900\", 0.5814], [\"19000\", 2.3256], [\"19100\", 4.0698], [\"19200\", 2.3256], [\"19900\", 0.5814], [\"20100\", 1.1628], [\"20200\", 2.3256], [\"20300\", 0.5814], [\"22000\", 1.1628], [\"22100\", 0.5814], [\"22200\", 1.7442], [\"22300\", 1.1628], [\"22400\", 1.7442], [\"22600\", 0.5814], [\"24100\", 0.5814], [\"24200\", 0.5814], [\"24800\", 0.5814], [\"25800\", 0.5814], [\"27600\", 0.5814], [\"28400\", 0.5814], [\"28500\", 1.1628], [\"28600\", 1.7442], [\"28700\", 0.5814], [\"28800\", 0.5814], [\"29000\", 0.5814], [\"29100\", 9.8837], [\"29200\", 6.9767], [\"29300\", 0.5814], [\"29400\", 1.1628], [\"29500\", 1.7442], [\"29900\", 0.5814], [\"30000\", 0.5814], [\"30300\", 0.5814], [\"34400\", 0.5814], [\"34700\", 0.5814], [\"35200\", 0.5814], [\"35400\", 0.5814], [\"35500\", 1.1628], [\"35600\", 0.5814], [\"35700\", 0.5814], [\"35900\", 0.5814], [\"36000\", 0.5814], [\"36300\", 0.5814], [\"36400\", 1.7442], [\"36700\", 0.5814], [\"36900\", 0.5814], [\"39000\", 0.5814], [\"39100\", 0.5814], [\"45200\", 0.5814], [\"74600\", 1.1628], [\"79200\", 0.5814], [\"83500\", 0.5814], [\"90500\", 0.5814], [\"94000\", 2.3256], [\"94100\", 4.6512], [\"94200\", 0.5814], [\"94600\", 1.1628], [\"106600\", 0.5814]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\n dp = [-1] * (target + 1)\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\n\n # Iterate through each digit and its cost\n for digit in range(1, 10):\n c = cost[digit - 1] # Cost of the current digit\n for i in range(c, target + 1):\n # If it's possible to form a number with the remaining cost\n if dp[i - c] != -1:\n dp[i] = max(dp[i], dp[i - c] + 1)\n\n # If it's not possible to form any number with the target cost\n if dp[target] == -1:\n return \"0\"\n\n # Construct the largest number by backtracking\n result = []\n curr_target = target\n for digit in reversed(range(1, 10)):\n c = cost[digit - 1]\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\n result.append(str(digit))\n curr_target -= c\n\n return ''.join(result)\n\n# Example usage:\nsolution = Solution()\ncost = [4,3,2,5,6,7,2,5,5]\ntarget = 9\nprint(solution.largestNumber(cost, target)) # Output: \"7772\"","runtime":"96"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\n dp = [-1] * (target + 1)\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\n\n # Iterate through each digit and its cost\n for digit in range(1, 10):\n c = cost[digit - 1] # Cost of the current digit\n for i in range(c, target + 1):\n # If it's possible to form a number with the remaining cost\n if dp[i - c] != -1:\n dp[i] = max(dp[i], dp[i - c] + 1)\n\n # If it's not possible to form any number with the target cost\n if dp[target] == -1:\n return \"0\"\n\n # Construct the largest number by backtracking\n result = []\n curr_target = target\n for digit in reversed(range(1, 10)):\n c = cost[digit - 1]\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\n result.append(str(digit))\n curr_target -= c\n\n return ''.join(result)\n\n# Example usage:\nsolution = Solution()\ncost = [4,3,2,5,6,7,2,5,5]\ntarget = 9\nprint(solution.largestNumber(cost, target)) # Output: \"7772\"","runtime":"96"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Initialize dp array with -1\n dp = [-1] * (target + 1)\n dp[0] = 0 # Base case: cost 0 can form a number of length 0\n\n # Fill the dp array\n for i in range(1, target + 1):\n for j, c in enumerate(cost):\n if i >= c and dp[i - c] != -1:\n dp[i] = max(dp[i], dp[i - c] + 1)\n\n # If no number can be formed, return \"0\"\n if dp[target] == -1:\n return \"0\"\n\n # Construct the maximum number by backtracking\n ans = []\n curr_target = target\n while curr_target > 0:\n for digit in range(8, -1, -1): # Start from the largest digit\n c = cost[digit]\n if curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\n ans.append(str(digit + 1))\n curr_target -= c\n break\n\n return ''.join(ans)\n\n# Example usage:\nsolution = Solution()\ncost = [4, 3, 2, 5, 6, 7, 2, 5, 5]\ntarget = 9\nprint(solution.largestNumber(cost, target)) # Output: \"7772\"","runtime":"130"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n def maxInt(a,b):\n if len(a) == len(b):\n return max(a,b)\n elif len(a) > len(b):\n return a\n return b\n dp = ['#' for _ in range(target + 1)]\n dp[0] = ''\n for i in range(len(cost)):\n num = cost[i]\n for w in range(num, target + 1):\n if dp[w-num] != '#':\n dp[w] = maxInt(dp[w], str(i+1) + dp[w-num])\n if dp[target] == '#':\n return \"0\"\n return dp[target]","runtime":"130"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\n optimization:space\n '''\n # dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n # dp[0] = [0]*(target+1)\n # for i in range(9):\n # for j in range(target+1):\n # dp[i+1][j] = dp[i][j]\n # if j-cost[i]>=0:\n # last = dp[i+1][j-cost[i]]\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\n # return dp[-1][-1]\n\n\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\n dp = [[float(\"-inf\")] * (target + 1) for _ in range(10)]\n # where[i][j]表示从dp[i][j]来的上一步的花费\n where = [[0] * (target + 1) for _ in range(10)]\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n\n # 遍历每一个数字（数字从1到9，索引从0到8）\n for i, c in enumerate(cost):\n for j in range(target + 1):\n if j < c:\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n # 否则，判断是选择不使用数字i+1，还是使用它\n if dp[i][j] > dp[i + 1][j - c] + 1:\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n dp[i + 1][j] = dp[i + 1][j - c] + 1\n where[i + 1][j] = j - c\n \n # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n if dp[9][target] < 0:\n return \"0\"\n \n # 回溯路径，构造答案\n ans = list()\n i, j = 9, target\n while i > 0:\n if j == where[i][j]:\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n else:\n ans.append(str(i)) # 记录使用的数字\n j = where[i][j] # 更新花费\n \n return \"\".join(ans)\n\n\n","runtime":"163"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n the largest number must have max length\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max length of num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\n optimization:space\n '''\n dp = [-float(\"inf\")]*(target+1)\n dp[0]= 0\n for i in range(9):\n for j in range(target+1):\n dp[j] = dp[j]\n if j-cost[i]>=0:\n dp[j] = max(dp[j], (dp[j-cost[i]] + 1))\n length = dp[-1]\n if length < 0:\n return \"0\"\n '''\n loop from the digit 9 to digit 1\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\n '''\n res = []\n j = target\n for i in range(8,-1,-1):\n c = cost[i]\n while j-c>=0 and dp[j] == dp[j-c]+1:\n res.append(str(i+1))\n j -= c\n return \"\".join(res)\n\n\n\n","runtime":"163"},{"code":"class Solution:\n def largestNumber(self, cost, target):\n sys.set_int_max_str_digits(1000000000)\n dp = [0] + [-1] * (target + 5000)\n for t in range(1, target + 1):\n dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\n return str(max(dp[t], 0))","runtime":"197"},{"code":"import sys\nsys.set_int_max_str_digits(0)\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n self.d = {}\n def top_down(t):\n if t == 0: return 0\n if t in self.d: return self.d[t]\n cur = float('-inf')\n for digit in range(1,10):\n if (t-cost[digit-1]) >= 0:\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\n self.d[t] = cur\n return cur\n\n res = top_down(target)\n return str(res) if res != float('-inf') else \"0\"\n\n\n# class Solution(object):\n# def largestNumber(self, cost, target):\n# ans = self.dfs(cost, 1, target)\n# return ans if '0' not in ans else '0'\n \n# def dfs(self, cost, index, remain):\n# \t\t# base cases\n# if remain == 0:\n# return ''\n# elif remain < 0 or index == len(cost)+1:\n# return '0'\n \n# \t\t# decisions \n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \n# skip = self.dfs(cost, index+1, remain) \n\t\t\n# \t\t# memoize and return the max of decisions\n# return self.getBigger(take, skip) \n \n# def getBigger(self, num1, num2):\n# if '0' in num2:\n# return num1\n# elif '0' in num1:\n# return num2\n# elif int(num1)>int(num2):\n# return num1 \n# else:\n# return num2\n\n\n# class Solution:\n# def largestNumber(self, cost, target):\n# dp = [0] + [-1] * (target + 5000)\n# for t in range(1, target + 1):\n# dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\n# return str(max(dp[t], 0))\n\n# # def largestNumber(self, cost: List[int], target: int) -> str:\n# # cost_map = {}\n# # for i, v in enumerate(cost):\n# # cost_map[i+1] = v\n \n# self.ans = 0\n# dp = [''] * (target+1)\n \n# def get_max(a, b):\n# if not a:\n# a = '0'\n# if not b:\n# b = '0'\n# if int(a) > int(b):\n# return a\n# return b\n \n# def get_cost(num, rem):\n# ncost = 0\n# for i in num:\n# ncost += cost[int(i)-1]\n# return ncost == rem\n \n# def helper(rem):\n# num = ''\n# # print(rem, mem)\n# if dp[rem] == '':\n \n# if rem == 0:\n# return ''\n# if rem < 0:\n# return float('-inf')\n\n# for i in range(len(cost)-1, -1, -1):\n# # if cost[i] > rem:\n# # continue\n# val = helper(rem-cost[i])\n# # \n# if val == float('-inf'):\n# continue\n# num = get_max(num, str(i+1)+val)\n# if get_cost(num, rem):\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\n# # else:\n# # mem[rem] = ''\n# return dp[rem]\n \n# # print(helper(cost, target, ''))\n \n# ans = str(helper(target))\n# return ans if ans else '0'","runtime":"197"},{"code":"import sys\nsys.set_int_max_str_digits(5001)\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n n = len(cost)\n cost = cost[::-1]\n dp = [[-1 for i in range(target + 1)] for j in range(n+1)]\n for i in range(n+1):\n dp[i][0] = 0\n for i in range(1, n+1):\n for j in range(1, target + 1):\n dp[i][j] = dp[i-1][j]\n if j-cost[i-1] >= 0 and dp[i][j-cost[i-1]] != -1:\n dp[i][j] = max(dp[i][j], dp[i][j - cost[i-1]]*10 + 9-i + 1)\n return str(max(dp[-1][target], 0))","runtime":"230"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","runtime":"230"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","runtime":"264"},{"code":"from functools import cache\nfrom typing import List\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n \n @cache\n def helper(i, c):\n # Base case: if the target cost is exactly 0, we have a valid number\n if c == 0:\n return 0\n # If we've exhausted all digits or the cost goes negative, return negative infinity\n if i == N or c < 0:\n return -float('inf')\n # Choose the maximum between not using the current digit or using it\n return max(helper(i + 1, c), 1 + helper(i, c - cost[i]))\n \n # Calculate the maximum number of digits we can form with the given target\n e = helper(0, target)\n \n # If it's impossible to form any number, return \"0\"\n if e == -float('inf'):\n return \"0\"\n \n # Construct the largest number by iterating over the number of digits\n for i in range(e):\n # Try to place the largest possible digit at each position\n for j in reversed(range(1, 10)):\n # Check if the current digit can be used and if it leads to a valid solution\n if cost[j - 1] <= target and helper(0, target - cost[j - 1]) == e - i - 1:\n target -= cost[j - 1]\n s += str(j)\n break\n \n return s","runtime":"264"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","runtime":"297"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","runtime":"297"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # i: curr digit, rem: remaining target\n n = len(cost)\n\n def bigger(a, b):\n if len(a) != len(b):\n return len(a) > len(b)\n return a > b\n\n @cache\n def dfs(i, target):\n if target == 0:\n return \"\"\n if target < 0 or i == n + 1:\n return \"#\"\n # take this digit\n take = str(i) + dfs(1, target - cost[i - 1])\n # don't take this digit\n skip = dfs(i + 1, target)\n\n if '#' in take and '#' not in skip:\n return skip\n if '#' not in take and '#' in skip:\n return take\n \n return take if bigger(take, skip) else skip\n\n res = dfs(1, target)\n dfs.cache_clear()\n if '#' in res:\n return '0'\n return res\n","runtime":"331"},{"code":"'''\nThe more digits you have, the better because it's larger\n\nBrute Force is to try every digit and see if it fits into your current costs and DFS from there and try every possible combinations\n\nThis seems like dynamic programming -> what's the maximum integer I can get given I have a target of X\n\ndp[x] represents maximum integer given target of X\n\n\ndp[x + 1] = \"i\" + dp[x + 1 - costs[i]] where i = 0 1 2 3 4 5 6 7 8 9\n\nBut you have to know where to place the i...i don't think that's actually important because you can always rearrange them at the end...\nMaybe an array of size 10 to keep track of the digits and then you can compare like that...\n\nPseudocode\n- Create a dp of size target\n- dp[0] = (True, empty array of size 10), dp[i] = (False, empty array of size 10), represents (possible to do, largest integer at cost i)\n- Iterate from cost of 1 to target\n - iterate through everything in cost - dp[i] = max(dp[i], dp[i - costs[j]]) for j from 1 - 9. The comparison is custom, we will compare the largest integer array which we can do easily, note you must only compare only if it is possible\n- Go through dp[target] and form the string\n\n'''\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [(False, [0] * 9)] * (target + 1)\n dp[0] = (True, [0] * 9)\n \n for cur_target in range(1, target + 1):\n for cur_num in range(9):\n cur_cost = cost[cur_num]\n \n if cur_target >= cur_cost and dp[cur_target - cur_cost][0]:\n cur_biggest = dp[cur_target - cur_cost][1].copy()\n cur_biggest[cur_num] += 1\n \n if self.compare(cur_biggest, dp[cur_target][1]):\n dp[cur_target] = (True, cur_biggest)\n \n possible, biggest_num = dp[-1]\n \n if not possible:\n return \"0\"\n else:\n res = []\n \n for j in range(len(biggest_num) - 1, -1, -1):\n for k in range(biggest_num[j]):\n res.append(str(j + 1))\n return ''.join(res)\n \n def compare(self, a, b):\n if sum(a) > sum(b):\n return True\n elif sum(b) > sum(a):\n return False\n \n for i in range(8, 0, -1):\n if a[i] > b[i]:\n return True\n elif b[i] > a[i]:\n return False\n return True","runtime":"331"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[int], new_combo: list[int]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(digit_idx + 1) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No used digits at all.\n return \"0\"\n return \"\".join(str(digit) for digit in digits_combo[target])\n","runtime":"364"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n if target == 5000:\n return '9'* 5000\n cache = {}\n def bruteforce(index: int,currScore):\n if (index, currScore) in cache:\n return cache[(index, currScore)]\n if (currScore > target or index == len(cost)):\n return '0'\n if currScore == target:\n return ''\n \n s1 = bruteforce(index+1, currScore)\n s2 = bruteforce(0, currScore + cost[index]) + str(index+1)\n s1 = int(s1) if s1[0] != '0' else 0\n s2 = int(s2) if s2[0] != '0' else 0\n \n cache[(index, currScore)] = str(max(s1,s2))\n return cache[(index, currScore)]\n \n result = bruteforce(0, 0)\n return result if '0' not in result else '0'\n \n def getBigger(self, num1, num2):\n if '0' in num2:\n print(\"num2: \", num2)\n return num1\n elif '0' in num1:\n print(\"num1: \", num1)\n return num2\n elif int(num1)>int(num2):\n return num1 \n else:\n return num2","runtime":"398"},{"code":"class Solution:\n @staticmethod\n def _compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self._compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"431"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n # if not digits_combo[target]: # No used digits at all.\n # return \n return max(\"\".join(digits_combo[target]), \"0\")\n","runtime":"465"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No used digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"498"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"532"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"565"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"599"},{"code":"class Solution:\n @staticmethod\n def _compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self._compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","runtime":"599"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n \n cost = cost[::-1]\n visited = set()\n for i in range(len(cost)):\n if cost[i] in visited:\n cost[i] = -1\n visited.add(cost[i])\n\n #print(cost)\n #return '0'\n\n def comp(list1, list2):\n if list2 is None:\n return 1\n \n summ = sum(list1) - sum(list2)\n if summ > 0:\n return 1\n if summ < 0:\n return -1\n for i in range(len(list1)):\n if list1[i] > list2[i]:\n return 1\n if list1[i] < list2[i]:\n return -1\n \n return 0\n\n @cache\n def itero(idx, rem):\n if rem < 0:\n return None\n if cost[idx] == -1:\n if idx < 8:\n return itero(idx+1, rem)\n elif rem == 0:\n return [0 for i in range(9)]\n else:\n return None \n newval = None\n if idx == 8:\n if rem%cost[idx] == 0:\n newval = [0 for i in range(9)]\n newval[idx] = rem//cost[idx]\n #print(idx, rem, newval)\n return newval\n else:\n #print(idx, rem, newval)\n return None\n \n if rem == 0:\n #print(idx, rem, [0 for i in range(9)])\n return [0 for i in range(9)]\n \n \n for i in range((rem//cost[idx])+1):\n result = itero(idx+1, rem - cost[idx]*i)\n if result is not None:\n result = [result[j] + (0 if idx != j else i) for j in range(9)]\n if comp(result, newval) > 0:\n newval = [el for el in result]\n \n #print(idx, rem, newval)\n return newval\n\n\n val = itero(0, target)\n if val is None:\n return '0'\n return ''.join([str(9-idx)*val[idx] for idx in range(9)])","runtime":"632"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n # Use copy to prevent modification on previous storage.\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n\n return self.create_largest_integer(max_digits[target], True)\n","runtime":"666"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n # Use copy to prevent modification on previous storage.\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n\n return self.create_largest_integer(max_digits[target], True)\n","runtime":"699"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1:\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1])\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if max_usage[iterated_target] == -1: # New combo is the 1st found combo.\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n continue\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n\n return self.create_largest_integer(max_digits[target], True)\n","runtime":"733"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = ['' for i in range(target+1)]\n dp[0] = '0'\n for i in range(1, target+1):\n for k in range(1, 10):\n t = i-cost[k-1]\n if t<0 or len(dp[t])==0:\n continue\n v = ''.join(sorted(str(k)+dp[t], reverse=True))\n # if i==target:\n # print(k, v)\n if len(v)>len(dp[i]) or (len(v)==len(dp[i]) and v>dp[i]):\n dp[i]=v\n # print(i, dp)\n if dp[target]=='':\n return '0'\n return dp[target][:len(dp[target])-1]\n \n \n \n \n ","runtime":"766"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp=[\"\"]*(target+1)\n for i in range(0,target+1):\n for j in range(1,10):\n if i+cost[j-1]<=target :\n if dp[i]==\"\" and i!=0:\n continue\n res=\"\".join(sorted(dp[i]+str(j),reverse=True))\n if len(res)>len(dp[i+cost[j-1]]):\n dp[i+cost[j-1]]=res\n elif len(res)==len(dp[i+cost[j-1]]) and res>dp[i+cost[j-1]]:\n dp[i+cost[j-1]]=res\n return [dp[target],\"0\"][dp[target]==\"\"]","runtime":"799"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i, prev_digit in enumerate(max_prev_digit):\n if int(prev_digit) < digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n #print(dp)\n return str(dp[-1])","runtime":"833"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n #dp[cost] = dp[cost - 1]\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i, prev_digit in enumerate(max_prev_digit):\n if int(prev_digit) < digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n #print(dp)\n return str(dp[-1])","runtime":"866"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i in range(n - 1, -1, -1):\n prev_digit = max_prev_digit[i]\n if int(prev_digit) > digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n return str(dp[-1])","runtime":"900"}],"string":"[\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\\n dp = [-1] * (target + 1)\\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\\n\\n # Iterate through each digit and its cost\\n for digit in range(1, 10):\\n c = cost[digit - 1] # Cost of the current digit\\n for i in range(c, target + 1):\\n # If it's possible to form a number with the remaining cost\\n if dp[i - c] != -1:\\n dp[i] = max(dp[i], dp[i - c] + 1)\\n\\n # If it's not possible to form any number with the target cost\\n if dp[target] == -1:\\n return \\\"0\\\"\\n\\n # Construct the largest number by backtracking\\n result = []\\n curr_target = target\\n for digit in reversed(range(1, 10)):\\n c = cost[digit - 1]\\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\\n result.append(str(digit))\\n curr_target -= c\\n\\n return ''.join(result)\\n\\n# Example usage:\\nsolution = Solution()\\ncost = [4,3,2,5,6,7,2,5,5]\\ntarget = 9\\nprint(solution.largestNumber(cost, target)) # Output: \\\"7772\\\"\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\\n dp = [-1] * (target + 1)\\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\\n\\n # Iterate through each digit and its cost\\n for digit in range(1, 10):\\n c = cost[digit - 1] # Cost of the current digit\\n for i in range(c, target + 1):\\n # If it's possible to form a number with the remaining cost\\n if dp[i - c] != -1:\\n dp[i] = max(dp[i], dp[i - c] + 1)\\n\\n # If it's not possible to form any number with the target cost\\n if dp[target] == -1:\\n return \\\"0\\\"\\n\\n # Construct the largest number by backtracking\\n result = []\\n curr_target = target\\n for digit in reversed(range(1, 10)):\\n c = cost[digit - 1]\\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\\n result.append(str(digit))\\n curr_target -= c\\n\\n return ''.join(result)\\n\\n# Example usage:\\nsolution = Solution()\\ncost = [4,3,2,5,6,7,2,5,5]\\ntarget = 9\\nprint(solution.largestNumber(cost, target)) # Output: \\\"7772\\\"\",\n \"runtime\": \"96\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Initialize dp array with -1\\n dp = [-1] * (target + 1)\\n dp[0] = 0 # Base case: cost 0 can form a number of length 0\\n\\n # Fill the dp array\\n for i in range(1, target + 1):\\n for j, c in enumerate(cost):\\n if i >= c and dp[i - c] != -1:\\n dp[i] = max(dp[i], dp[i - c] + 1)\\n\\n # If no number can be formed, return \\\"0\\\"\\n if dp[target] == -1:\\n return \\\"0\\\"\\n\\n # Construct the maximum number by backtracking\\n ans = []\\n curr_target = target\\n while curr_target > 0:\\n for digit in range(8, -1, -1): # Start from the largest digit\\n c = cost[digit]\\n if curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\\n ans.append(str(digit + 1))\\n curr_target -= c\\n break\\n\\n return ''.join(ans)\\n\\n# Example usage:\\nsolution = Solution()\\ncost = [4, 3, 2, 5, 6, 7, 2, 5, 5]\\ntarget = 9\\nprint(solution.largestNumber(cost, target)) # Output: \\\"7772\\\"\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n def maxInt(a,b):\\n if len(a) == len(b):\\n return max(a,b)\\n elif len(a) > len(b):\\n return a\\n return b\\n dp = ['#' for _ in range(target + 1)]\\n dp[0] = ''\\n for i in range(len(cost)):\\n num = cost[i]\\n for w in range(num, target + 1):\\n if dp[w-num] != '#':\\n dp[w] = maxInt(dp[w], str(i+1) + dp[w-num])\\n if dp[target] == '#':\\n return \\\"0\\\"\\n return dp[target]\",\n \"runtime\": \"130\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\\n optimization:space\\n '''\\n # dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n # dp[0] = [0]*(target+1)\\n # for i in range(9):\\n # for j in range(target+1):\\n # dp[i+1][j] = dp[i][j]\\n # if j-cost[i]>=0:\\n # last = dp[i+1][j-cost[i]]\\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\\n # return dp[-1][-1]\\n\\n\\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\\n dp = [[float(\\\"-inf\\\")] * (target + 1) for _ in range(10)]\\n # where[i][j]表示从dp[i][j]来的上一步的花费\\n where = [[0] * (target + 1) for _ in range(10)]\\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n\\n # 遍历每一个数字（数字从1到9，索引从0到8）\\n for i, c in enumerate(cost):\\n for j in range(target + 1):\\n if j < c:\\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n # 否则，判断是选择不使用数字i+1，还是使用它\\n if dp[i][j] > dp[i + 1][j - c] + 1:\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n dp[i + 1][j] = dp[i + 1][j - c] + 1\\n where[i + 1][j] = j - c\\n \\n # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n if dp[9][target] < 0:\\n return \\\"0\\\"\\n \\n # 回溯路径，构造答案\\n ans = list()\\n i, j = 9, target\\n while i > 0:\\n if j == where[i][j]:\\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n else:\\n ans.append(str(i)) # 记录使用的数字\\n j = where[i][j] # 更新花费\\n \\n return \\\"\\\".join(ans)\\n\\n\\n\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n the largest number must have max length\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max length of num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\\n optimization:space\\n '''\\n dp = [-float(\\\"inf\\\")]*(target+1)\\n dp[0]= 0\\n for i in range(9):\\n for j in range(target+1):\\n dp[j] = dp[j]\\n if j-cost[i]>=0:\\n dp[j] = max(dp[j], (dp[j-cost[i]] + 1))\\n length = dp[-1]\\n if length < 0:\\n return \\\"0\\\"\\n '''\\n loop from the digit 9 to digit 1\\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\\n '''\\n res = []\\n j = target\\n for i in range(8,-1,-1):\\n c = cost[i]\\n while j-c>=0 and dp[j] == dp[j-c]+1:\\n res.append(str(i+1))\\n j -= c\\n return \\\"\\\".join(res)\\n\\n\\n\\n\",\n \"runtime\": \"163\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost, target):\\n sys.set_int_max_str_digits(1000000000)\\n dp = [0] + [-1] * (target + 5000)\\n for t in range(1, target + 1):\\n dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\\n return str(max(dp[t], 0))\",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(0)\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n self.d = {}\\n def top_down(t):\\n if t == 0: return 0\\n if t in self.d: return self.d[t]\\n cur = float('-inf')\\n for digit in range(1,10):\\n if (t-cost[digit-1]) >= 0:\\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\\n self.d[t] = cur\\n return cur\\n\\n res = top_down(target)\\n return str(res) if res != float('-inf') else \\\"0\\\"\\n\\n\\n# class Solution(object):\\n# def largestNumber(self, cost, target):\\n# ans = self.dfs(cost, 1, target)\\n# return ans if '0' not in ans else '0'\\n \\n# def dfs(self, cost, index, remain):\\n# \\t\\t# base cases\\n# if remain == 0:\\n# return ''\\n# elif remain < 0 or index == len(cost)+1:\\n# return '0'\\n \\n# \\t\\t# decisions \\n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \\n# skip = self.dfs(cost, index+1, remain) \\n\\t\\t\\n# \\t\\t# memoize and return the max of decisions\\n# return self.getBigger(take, skip) \\n \\n# def getBigger(self, num1, num2):\\n# if '0' in num2:\\n# return num1\\n# elif '0' in num1:\\n# return num2\\n# elif int(num1)>int(num2):\\n# return num1 \\n# else:\\n# return num2\\n\\n\\n# class Solution:\\n# def largestNumber(self, cost, target):\\n# dp = [0] + [-1] * (target + 5000)\\n# for t in range(1, target + 1):\\n# dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\\n# return str(max(dp[t], 0))\\n\\n# # def largestNumber(self, cost: List[int], target: int) -> str:\\n# # cost_map = {}\\n# # for i, v in enumerate(cost):\\n# # cost_map[i+1] = v\\n \\n# self.ans = 0\\n# dp = [''] * (target+1)\\n \\n# def get_max(a, b):\\n# if not a:\\n# a = '0'\\n# if not b:\\n# b = '0'\\n# if int(a) > int(b):\\n# return a\\n# return b\\n \\n# def get_cost(num, rem):\\n# ncost = 0\\n# for i in num:\\n# ncost += cost[int(i)-1]\\n# return ncost == rem\\n \\n# def helper(rem):\\n# num = ''\\n# # print(rem, mem)\\n# if dp[rem] == '':\\n \\n# if rem == 0:\\n# return ''\\n# if rem < 0:\\n# return float('-inf')\\n\\n# for i in range(len(cost)-1, -1, -1):\\n# # if cost[i] > rem:\\n# # continue\\n# val = helper(rem-cost[i])\\n# # \\n# if val == float('-inf'):\\n# continue\\n# num = get_max(num, str(i+1)+val)\\n# if get_cost(num, rem):\\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\\n# # else:\\n# # mem[rem] = ''\\n# return dp[rem]\\n \\n# # print(helper(cost, target, ''))\\n \\n# ans = str(helper(target))\\n# return ans if ans else '0'\",\n \"runtime\": \"197\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(5001)\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n n = len(cost)\\n cost = cost[::-1]\\n dp = [[-1 for i in range(target + 1)] for j in range(n+1)]\\n for i in range(n+1):\\n dp[i][0] = 0\\n for i in range(1, n+1):\\n for j in range(1, target + 1):\\n dp[i][j] = dp[i-1][j]\\n if j-cost[i-1] >= 0 and dp[i][j-cost[i-1]] != -1:\\n dp[i][j] = max(dp[i][j], dp[i][j - cost[i-1]]*10 + 9-i + 1)\\n return str(max(dp[-1][target], 0))\",\n \"runtime\": \"230\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"runtime\": \"230\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"runtime\": \"264\"\n },\n {\n \"code\": \"from functools import cache\\nfrom typing import List\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n \\n @cache\\n def helper(i, c):\\n # Base case: if the target cost is exactly 0, we have a valid number\\n if c == 0:\\n return 0\\n # If we've exhausted all digits or the cost goes negative, return negative infinity\\n if i == N or c < 0:\\n return -float('inf')\\n # Choose the maximum between not using the current digit or using it\\n return max(helper(i + 1, c), 1 + helper(i, c - cost[i]))\\n \\n # Calculate the maximum number of digits we can form with the given target\\n e = helper(0, target)\\n \\n # If it's impossible to form any number, return \\\"0\\\"\\n if e == -float('inf'):\\n return \\\"0\\\"\\n \\n # Construct the largest number by iterating over the number of digits\\n for i in range(e):\\n # Try to place the largest possible digit at each position\\n for j in reversed(range(1, 10)):\\n # Check if the current digit can be used and if it leads to a valid solution\\n if cost[j - 1] <= target and helper(0, target - cost[j - 1]) == e - i - 1:\\n target -= cost[j - 1]\\n s += str(j)\\n break\\n \\n return s\",\n \"runtime\": \"264\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"runtime\": \"297\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"runtime\": \"297\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # i: curr digit, rem: remaining target\\n n = len(cost)\\n\\n def bigger(a, b):\\n if len(a) != len(b):\\n return len(a) > len(b)\\n return a > b\\n\\n @cache\\n def dfs(i, target):\\n if target == 0:\\n return \\\"\\\"\\n if target < 0 or i == n + 1:\\n return \\\"#\\\"\\n # take this digit\\n take = str(i) + dfs(1, target - cost[i - 1])\\n # don't take this digit\\n skip = dfs(i + 1, target)\\n\\n if '#' in take and '#' not in skip:\\n return skip\\n if '#' not in take and '#' in skip:\\n return take\\n \\n return take if bigger(take, skip) else skip\\n\\n res = dfs(1, target)\\n dfs.cache_clear()\\n if '#' in res:\\n return '0'\\n return res\\n\",\n \"runtime\": \"331\"\n },\n {\n \"code\": \"'''\\nThe more digits you have, the better because it's larger\\n\\nBrute Force is to try every digit and see if it fits into your current costs and DFS from there and try every possible combinations\\n\\nThis seems like dynamic programming -> what's the maximum integer I can get given I have a target of X\\n\\ndp[x] represents maximum integer given target of X\\n\\n\\ndp[x + 1] = \\\"i\\\" + dp[x + 1 - costs[i]] where i = 0 1 2 3 4 5 6 7 8 9\\n\\nBut you have to know where to place the i...i don't think that's actually important because you can always rearrange them at the end...\\nMaybe an array of size 10 to keep track of the digits and then you can compare like that...\\n\\nPseudocode\\n- Create a dp of size target\\n- dp[0] = (True, empty array of size 10), dp[i] = (False, empty array of size 10), represents (possible to do, largest integer at cost i)\\n- Iterate from cost of 1 to target\\n - iterate through everything in cost - dp[i] = max(dp[i], dp[i - costs[j]]) for j from 1 - 9. The comparison is custom, we will compare the largest integer array which we can do easily, note you must only compare only if it is possible\\n- Go through dp[target] and form the string\\n\\n'''\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [(False, [0] * 9)] * (target + 1)\\n dp[0] = (True, [0] * 9)\\n \\n for cur_target in range(1, target + 1):\\n for cur_num in range(9):\\n cur_cost = cost[cur_num]\\n \\n if cur_target >= cur_cost and dp[cur_target - cur_cost][0]:\\n cur_biggest = dp[cur_target - cur_cost][1].copy()\\n cur_biggest[cur_num] += 1\\n \\n if self.compare(cur_biggest, dp[cur_target][1]):\\n dp[cur_target] = (True, cur_biggest)\\n \\n possible, biggest_num = dp[-1]\\n \\n if not possible:\\n return \\\"0\\\"\\n else:\\n res = []\\n \\n for j in range(len(biggest_num) - 1, -1, -1):\\n for k in range(biggest_num[j]):\\n res.append(str(j + 1))\\n return ''.join(res)\\n \\n def compare(self, a, b):\\n if sum(a) > sum(b):\\n return True\\n elif sum(b) > sum(a):\\n return False\\n \\n for i in range(8, 0, -1):\\n if a[i] > b[i]:\\n return True\\n elif b[i] > a[i]:\\n return False\\n return True\",\n \"runtime\": \"331\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[int], new_combo: list[int]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(digit_idx + 1) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No used digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(str(digit) for digit in digits_combo[target])\\n\",\n \"runtime\": \"364\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if target == 5000:\\n return '9'* 5000\\n cache = {}\\n def bruteforce(index: int,currScore):\\n if (index, currScore) in cache:\\n return cache[(index, currScore)]\\n if (currScore > target or index == len(cost)):\\n return '0'\\n if currScore == target:\\n return ''\\n \\n s1 = bruteforce(index+1, currScore)\\n s2 = bruteforce(0, currScore + cost[index]) + str(index+1)\\n s1 = int(s1) if s1[0] != '0' else 0\\n s2 = int(s2) if s2[0] != '0' else 0\\n \\n cache[(index, currScore)] = str(max(s1,s2))\\n return cache[(index, currScore)]\\n \\n result = bruteforce(0, 0)\\n return result if '0' not in result else '0'\\n \\n def getBigger(self, num1, num2):\\n if '0' in num2:\\n print(\\\"num2: \\\", num2)\\n return num1\\n elif '0' in num1:\\n print(\\\"num1: \\\", num1)\\n return num2\\n elif int(num1)>int(num2):\\n return num1 \\n else:\\n return num2\",\n \"runtime\": \"398\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def _compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self._compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"431\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n # if not digits_combo[target]: # No used digits at all.\\n # return \\n return max(\\\"\\\".join(digits_combo[target]), \\\"0\\\")\\n\",\n \"runtime\": \"465\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No used digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"498\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"532\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"565\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def _compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self._compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"runtime\": \"599\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n \\n cost = cost[::-1]\\n visited = set()\\n for i in range(len(cost)):\\n if cost[i] in visited:\\n cost[i] = -1\\n visited.add(cost[i])\\n\\n #print(cost)\\n #return '0'\\n\\n def comp(list1, list2):\\n if list2 is None:\\n return 1\\n \\n summ = sum(list1) - sum(list2)\\n if summ > 0:\\n return 1\\n if summ < 0:\\n return -1\\n for i in range(len(list1)):\\n if list1[i] > list2[i]:\\n return 1\\n if list1[i] < list2[i]:\\n return -1\\n \\n return 0\\n\\n @cache\\n def itero(idx, rem):\\n if rem < 0:\\n return None\\n if cost[idx] == -1:\\n if idx < 8:\\n return itero(idx+1, rem)\\n elif rem == 0:\\n return [0 for i in range(9)]\\n else:\\n return None \\n newval = None\\n if idx == 8:\\n if rem%cost[idx] == 0:\\n newval = [0 for i in range(9)]\\n newval[idx] = rem//cost[idx]\\n #print(idx, rem, newval)\\n return newval\\n else:\\n #print(idx, rem, newval)\\n return None\\n \\n if rem == 0:\\n #print(idx, rem, [0 for i in range(9)])\\n return [0 for i in range(9)]\\n \\n \\n for i in range((rem//cost[idx])+1):\\n result = itero(idx+1, rem - cost[idx]*i)\\n if result is not None:\\n result = [result[j] + (0 if idx != j else i) for j in range(9)]\\n if comp(result, newval) > 0:\\n newval = [el for el in result]\\n \\n #print(idx, rem, newval)\\n return newval\\n\\n\\n val = itero(0, target)\\n if val is None:\\n return '0'\\n return ''.join([str(9-idx)*val[idx] for idx in range(9)])\",\n \"runtime\": \"632\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n # Use copy to prevent modification on previous storage.\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"runtime\": \"666\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n # Use copy to prevent modification on previous storage.\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"runtime\": \"699\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1:\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1])\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if max_usage[iterated_target] == -1: # New combo is the 1st found combo.\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n continue\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"runtime\": \"733\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = ['' for i in range(target+1)]\\n dp[0] = '0'\\n for i in range(1, target+1):\\n for k in range(1, 10):\\n t = i-cost[k-1]\\n if t<0 or len(dp[t])==0:\\n continue\\n v = ''.join(sorted(str(k)+dp[t], reverse=True))\\n # if i==target:\\n # print(k, v)\\n if len(v)>len(dp[i]) or (len(v)==len(dp[i]) and v>dp[i]):\\n dp[i]=v\\n # print(i, dp)\\n if dp[target]=='':\\n return '0'\\n return dp[target][:len(dp[target])-1]\\n \\n \\n \\n \\n \",\n \"runtime\": \"766\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp=[\\\"\\\"]*(target+1)\\n for i in range(0,target+1):\\n for j in range(1,10):\\n if i+cost[j-1]<=target :\\n if dp[i]==\\\"\\\" and i!=0:\\n continue\\n res=\\\"\\\".join(sorted(dp[i]+str(j),reverse=True))\\n if len(res)>len(dp[i+cost[j-1]]):\\n dp[i+cost[j-1]]=res\\n elif len(res)==len(dp[i+cost[j-1]]) and res>dp[i+cost[j-1]]:\\n dp[i+cost[j-1]]=res\\n return [dp[target],\\\"0\\\"][dp[target]==\\\"\\\"]\",\n \"runtime\": \"799\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i, prev_digit in enumerate(max_prev_digit):\\n if int(prev_digit) < digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n #print(dp)\\n return str(dp[-1])\",\n \"runtime\": \"833\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n #dp[cost] = dp[cost - 1]\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i, prev_digit in enumerate(max_prev_digit):\\n if int(prev_digit) < digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n #print(dp)\\n return str(dp[-1])\",\n \"runtime\": \"866\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i in range(n - 1, -1, -1):\\n prev_digit = max_prev_digit[i]\\n if int(prev_digit) > digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n return str(dp[-1])\",\n \"runtime\": \"900\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":34,"string":"34"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [0] * (target+1)\n for i in range(target):\n if dp[i] or i==0:\n for c in cost:\n if i+c < len(dp):\n dp[i+c] = max(dp[i+c],dp[i]+1)\n digits = dp[target]\n current = target\n result = ''\n while digits:\n for i in range(8,-1,-1):\n if digits != 1 and current - cost[i] > 0 and dp[current - cost[i]] == digits - 1:\n digits-=1\n current -= cost[i]\n result += str(i+1)\n break\n elif digits == 1 and current - cost[i] == 0:\n result += str(i+1)\n return result\n return result if result != \"\" else \"0\"","memory":"16500"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [0] * (target+1)\n for i in range(target):\n if dp[i] or i==0:\n for c in cost:\n if i+c < len(dp):\n dp[i+c] = max(dp[i+c],dp[i]+1)\n digits = dp[target]\n current = target\n result = ''\n while digits:\n for i in range(8,-1,-1):\n if digits != 1 and current - cost[i] > 0 and dp[current - cost[i]] == digits - 1:\n digits-=1\n current -= cost[i]\n result += str(i+1)\n break\n elif digits == 1 and current - cost[i] == 0:\n result += str(i+1)\n return result\n return result if result != \"\" else \"0\"","memory":"16600"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Create a dp array to store the maximum length of the number that can be formed\n dp = [-1] * (target + 1)\n dp[0] = 0 # Base case: 0 cost can form a number of length 0\n\n # Function to get the maximum of two strings\n def get_max_str(str1, str2):\n if str1 == \"0\":\n return str2\n if str2 == \"0\":\n return str1\n return max(str1, str2, key=lambda x: (len(x), x))\n\n # Fill the dp array\n for t in range(1, target + 1):\n for i, c in enumerate(cost):\n if c <= t and dp[t - c] != -1:\n dp[t] = max(dp[t], dp[t - c] + 1)\n\n # If it's impossible to form a number with the target cost\n if dp[target] == -1:\n return \"0\"\n\n # Reconstruct the number\n result = \"\"\n t = target\n while t > 0:\n for i in range(8, -1, -1):\n if cost[i] <= t and dp[t - cost[i]] == dp[t] - 1:\n result += str(i + 1)\n t -= cost[i]\n break\n\n return result\n\n# Example usage:\nsolution = Solution()\ncost = [4, 3, 2, 5, 6, 7, 2, 5, 5]\ntarget = 9\nprint(solution.largestNumber(cost, target)) # Output: \"7772\"","memory":"16700"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n the largest number must have max length\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max length of num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\n optimization:space\n '''\n dp = [-float(\"inf\")]*(target+1)\n dp[0]= 0\n for i in range(9):\n for j in range(target+1):\n dp[j] = dp[j]\n if j-cost[i]>=0:\n dp[j] = max(dp[j], (dp[j-cost[i]] + 1))\n length = dp[-1]\n if length < 0:\n return \"0\"\n '''\n loop from the digit 9 to digit 1\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\n '''\n res = []\n j = target\n for i in range(8,-1,-1):\n c = cost[i]\n while j-c>=0 and dp[j] == dp[j-c]+1:\n res.append(str(i+1))\n j -= c\n return \"\".join(res)\n\n\n\n","memory":"17000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\n dp = [-1] * (target + 1)\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\n\n # Iterate through each digit and its cost\n for digit in range(1, 10):\n c = cost[digit - 1] # Cost of the current digit\n for i in range(c, target + 1):\n # If it's possible to form a number with the remaining cost\n if dp[i - c] != -1:\n dp[i] = max(dp[i], dp[i - c] + 1)\n\n # If it's not possible to form any number with the target cost\n if dp[target] == -1:\n return \"0\"\n\n # Construct the largest number by backtracking\n result = []\n curr_target = target\n for digit in reversed(range(1, 10)):\n c = cost[digit - 1]\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\n result.append(str(digit))\n curr_target -= c\n\n return ''.join(result)\n\n# Example usage:\nsolution = Solution()\ncost = [4,3,2,5,6,7,2,5,5]\ntarget = 9\nprint(solution.largestNumber(cost, target)) # Output: \"7772\"","memory":"17100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\n\n\n 不使用当前数字 i+1： dp[i+1][j] = dp[i][j]（继承前一个状态）\n 使用当前数字 i+1： dp[i+1][j] = dp[i+1][j - cost[i]] + 1（选择使用数字，并更新为更大的数字长度）\n\n optimization:space\n '''\n dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n # dp[0] = [0]*(target+1)\n # for i in range(9):\n # for j in range(target+1):\n # dp[i+1][j] = dp[i][j]\n # if j-cost[i]>=0:\n # last = dp[i+1][j-cost[i]]\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\n # return dp[-1][-1]\n\n\n # # where[i][j]表示从dp[i][j]来的上一步的花费\n # where = [[0] * (target + 1) for _ in range(10)]\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n # # 遍历每一个数字（数字从1到9，索引从0到8）\n # for i, c in enumerate(cost):\n # for j in range(target + 1):\n # if j < c:\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # # 否则，判断是选择不使用数字i+1，还是使用它\n # if dp[i][j] > dp[i + 1][j - c] + 1:\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\n # where[i + 1][j] = j - c\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n # if dp[9][target] < 0:\n # return \"0\"\n # # 回溯路径，构造答案\n # ans = list()\n # i, j = 9, target\n # while i > 0:\n # if j == where[i][j]:\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n # else:\n # ans.append(str(i)) # 记录使用的数字\n # j = where[i][j] # 更新花费\n # return \"\".join(ans)\n\n dp = [-float('inf')] * (target + 1)\n dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\n \n # 动态规划，计算最大可以获得的数字长度\n for i, c in enumerate(cost):\n for j in range(c, target + 1):\n if dp[j - c] != -float('inf'):\n dp[j] = max(dp[j], dp[j - c] + 1)\n \n # 如果target无解，直接返回0\n if dp[target] < 0:\n return \"0\"\n \n # 从最大长度开始构造结果\n res = []\n j = target\n for i in range(8, -1, -1): # 从最大数字9开始尝试\n c = cost[i]\n while j >= c and dp[j] == dp[j - c] + 1:\n res.append(str(i + 1))\n j -= c\n \n return ''.join(res)\n\n\n\n","memory":"17200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n the largest number must have max length\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max length of num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\n optimization:space\n '''\n dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n dp[0][0] = 0\n for i in range(9):\n for j in range(target+1):\n dp[i+1][j] = dp[i][j]\n if j-cost[i]>=0:\n dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\n length = dp[-1][-1]\n if length < 0:\n return \"0\"\n '''\n loop from the digit 9 to digit 1\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\n '''\n res = []\n j = target\n for i in range(8,-1,-1):\n c = cost[i]\n while j-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\n res.append(str(i+1))\n j -= c\n return \"\".join(res)\n\n # dp = [[-float('inf')] * (target + 1) for _ in range(10)]\n # dp[0][0] = 0 # 如果总和为 0，可以用长度为 0 的数字\n # for i in range(9):\n # for j in range(target + 1):\n # # 不使用第 i+1 个数字\n # dp[i + 1][j] = dp[i][j]\n # if j >= cost[i] and dp[i + 1][j - cost[i]] != -float('inf'):\n # dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - cost[i]] + 1)\n # # 如果无法达到目标值，返回 0\n # if dp[9][target] < 0:\n # return \"0\"\n # # 构造最大数字，从 dp 表倒推结果\n # res = []\n # j = target\n # for i in range(8, -1, -1): # 从数字9开始倒序尝试\n # while j >= cost[i] and dp[i + 1][j] == dp[i + 1][j - cost[i]] + 1:\n # res.append(str(i + 1))\n # j -= cost[i]\n # return ''.join(res)\n\n\n\n\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\n # dp = [[float(\"-inf\")] * (target + 1) for _ in range(10)]\n # where[i][j]表示从dp[i][j]来的上一步的花费\n # where = [[0] * (target + 1) for _ in range(10)]\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n # # 遍历每一个数字（数字从1到9，索引从0到8）\n # for i, c in enumerate(cost):\n # for j in range(target + 1):\n # if j < c:\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # # 否则，判断是选择不使用数字i+1，还是使用它\n # if dp[i][j] > dp[i + 1][j - c] + 1:\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\n # where[i + 1][j] = j - c\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n # if dp[9][target] < 0:\n # return \"0\"\n # # 回溯路径，构造答案\n # ans = list()\n # i, j = 9, target\n # while i > 0:\n # if j == where[i][j]:\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n # else:\n # ans.append(str(i)) # 记录使用的数字\n # j = where[i][j] # 更新花费\n # return \"\".join(ans)\n\n\n # dp = [-float('inf')] * (target + 1)\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\n # # 动态规划，计算最大可以获得的数字长度\n # for i, c in enumerate(cost):\n # for j in range(c, target + 1):\n # if dp[j - c] != -float('inf'):\n # dp[j] = max(dp[j], dp[j - c] + 1)\n # # 如果target无解，直接返回0\n # if dp[target] < 0:\n # return \"0\"\n # # 从最大长度开始构造结果\n # res = []\n # j = target\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\n # c = cost[i]\n # while j >= c and dp[j] == dp[j - c] + 1:\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\n # res.append(str(i + 1))\n # j -= c\n # return ''.join(res)\n\n\n\n","memory":"17200"},{"code":"'''\ndp[i][j] is the max length of the digits using cost[0...i] and cost is j.\n\ndp[i][j] = max(dp[i-1][j], dp[i][j-cost[i]] + 1)\ndp[-1][*] = -1\ndp[*][0] = 0\n\n\n'''\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [-1] * (1 + target)\n dp[0] = 0\n for c in cost:\n for j in range(c, 1 + target):\n if dp[j - c] != -1:\n dp[j] = max(dp[j], dp[j - c] + 1)\n print(dp)\n if dp[-1] < 0:\n return \"0\"\n ans = []\n\n for d in range(9, 0, -1):\n c = cost[d-1]\n while target >= c and dp[target] == dp[target-c] + 1:\n target -= c\n ans.append(str(d))\n return ''.join(ans)","memory":"17300"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n the largest number must have max length\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max length of num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\n optimization:space\n '''\n dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n # dp[0] = [0]*(target+1)\n # for i in range(9):\n # for j in range(target+1):\n # dp[i+1][j] = dp[i][j]\n # if j-cost[i]>=0:\n # dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\n # length = dp[-1][-1]\n # if length == 0:\n # return 0\n # '''\n # loop from the digit 9 to digit 1\n # when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\n # '''\n # res = []\n # j = target\n # for i in range(8,-1,-1):\n # c = cost[i]\n # while target-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\n # res.append(str(i+1))\n # j -= c\n # return \"\".join(res)\n\n # dp[i][j]: 使用前 i 个数字，总和为 j 时的最大数字长度\n dp = [[-float('inf')] * (target + 1) for _ in range(10)]\n dp[0][0] = 0 # 如果总和为 0，可以用长度为 0 的数字\n\n # 动态规划计算最大数字位数\n for i in range(9):\n for j in range(target + 1):\n # 不使用第 i+1 个数字\n dp[i + 1][j] = dp[i][j]\n if j >= cost[i] and dp[i + 1][j - cost[i]] != -float('inf'):\n dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - cost[i]] + 1)\n\n # 如果无法达到目标值，返回 0\n if dp[9][target] < 0:\n return \"0\"\n\n # 构造最大数字，从 dp 表倒推结果\n res = []\n j = target\n for i in range(8, -1, -1): # 从数字9开始倒序尝试\n while j >= cost[i] and dp[i + 1][j] == dp[i + 1][j - cost[i]] + 1:\n res.append(str(i + 1))\n j -= cost[i]\n\n return ''.join(res)\n\n\n\n\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\n # dp = [[float(\"-inf\")] * (target + 1) for _ in range(10)]\n # where[i][j]表示从dp[i][j]来的上一步的花费\n # where = [[0] * (target + 1) for _ in range(10)]\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n # # 遍历每一个数字（数字从1到9，索引从0到8）\n # for i, c in enumerate(cost):\n # for j in range(target + 1):\n # if j < c:\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # # 否则，判断是选择不使用数字i+1，还是使用它\n # if dp[i][j] > dp[i + 1][j - c] + 1:\n # dp[i + 1][j] = dp[i][j]\n # where[i + 1][j] = j\n # else:\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\n # where[i + 1][j] = j - c\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n # if dp[9][target] < 0:\n # return \"0\"\n # # 回溯路径，构造答案\n # ans = list()\n # i, j = 9, target\n # while i > 0:\n # if j == where[i][j]:\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n # else:\n # ans.append(str(i)) # 记录使用的数字\n # j = where[i][j] # 更新花费\n # return \"\".join(ans)\n\n\n # dp = [-float('inf')] * (target + 1)\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\n # # 动态规划，计算最大可以获得的数字长度\n # for i, c in enumerate(cost):\n # for j in range(c, target + 1):\n # if dp[j - c] != -float('inf'):\n # dp[j] = max(dp[j], dp[j - c] + 1)\n # # 如果target无解，直接返回0\n # if dp[target] < 0:\n # return \"0\"\n # # 从最大长度开始构造结果\n # res = []\n # j = target\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\n # c = cost[i]\n # while j >= c and dp[j] == dp[j - c] + 1:\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\n # res.append(str(i + 1))\n # j -= c\n # return ''.join(res)\n\n\n\n","memory":"17700"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n # Use copy to prevent modification on previous storage.\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n\n return self.create_largest_integer(max_digits[target], True)\n","memory":"18800"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n # Use copy to prevent modification on previous storage.\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n\n return self.create_largest_integer(max_digits[target], True)\n","memory":"18900"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No used digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","memory":"19000"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","memory":"19000"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1:\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1])\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n if max_usage[iterated_target] == -1: # New combo is the 1st found combo.\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n continue\n\n if usage_count > max_usage[iterated_target]:\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n continue\n \n if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target] = used_digits\n\n return self.create_largest_integer(max_digits[target], True)\n","memory":"19100"},{"code":"class Solution:\n @staticmethod\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\n digits.sort(reverse=True)\n if len(digits) <= 0:\n digits.append(0)\n \n digit_str = \"\".join(str(digit) for digit in digits)\n return digit_str if return_str else int(digit_str)\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n max_digits = [[] for _ in range(1 + target)]\n\n for iterated_target in range(1, target + 1):\n for digit_idx, iterated_cost in enumerate(cost):\n if iterated_target < iterated_cost: # Current cost can't build up target.\n continue\n \n usage_count = max_usage[iterated_target - iterated_cost]\n # Use copy to prevent modification on previous storage.\n used_digits = max_digits[iterated_target - iterated_cost].copy()\n if usage_count != -1: # New combo found.\n usage_count += 1 # Plus 1: usage of current cost.\n used_digits.append(digit_idx + 1) # Another digit is used.\n\n # if usage_count > max_usage[iterated_target]:\n # max_usage[iterated_target] = usage_count\n # max_digits[iterated_target].clear()\n # max_digits[iterated_target].extend(used_digits)\n # continue\n \n # if usage_count == max_usage[iterated_target]:\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\n max_usage[iterated_target] = usage_count\n max_digits[iterated_target].clear()\n max_digits[iterated_target].extend(used_digits)\n\n return self.create_largest_integer(max_digits[target], True)\n","memory":"19100"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Assume both combos have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use the largest digit.\n\n # Base case: 0 target needs no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit costt exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No used digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","memory":"19200"},{"code":"class Solution:\n @staticmethod\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\n \"\"\"Both combos must have the same number of digits.\"\"\"\n old_combo.sort(reverse=True)\n new_combo.sort(reverse=True)\n for old_digit, new_digit in zip(old_combo, new_combo):\n if old_digit > new_digit:\n return False\n if old_digit < new_digit:\n return True\n return False\n\n def largestNumber(self, cost: List[int], target: int) -> str:\n if len(set(cost)) == 1: # Base case: all digits cost the same.\n if target % cost[-1] != 0:\n return \"0\"\n return \"9\" * (target // cost[-1]) # Always use largest digit.\n\n # Base case: 0 target has no digits at all.\n max_usage = [0] + [-1 for _ in range(target)]\n digits_combo = [[] for _ in range(1 + target)]\n\n for iter_target in range(1, target + 1):\n for digit_idx, digit_cost in enumerate(cost):\n if iter_target < digit_cost: # Digit cost exceeds target.\n continue\n \n digits_usage = max_usage[iter_target - digit_cost]\n if digits_usage != -1: # New combo found.\n digits_usage += 1 # Plus 1: usage of another digit.\n\n # Use copy to prevent modification on previous storage.\n used_digits = digits_combo[iter_target - digit_cost].copy()\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\n\n if digits_usage > max_usage[iter_target]:\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n continue\n \n if digits_usage == max_usage[iter_target]:\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\n max_usage[iter_target] = digits_usage\n digits_combo[iter_target].clear()\n digits_combo[iter_target].extend(used_digits)\n\n if not digits_combo[target]: # No digits at all.\n return \"0\"\n return \"\".join(digits_combo[target])\n","memory":"19200"},{"code":"class Solution:\n def largestNumber(self, nums: List[int], target: int) -> str:\n n = len(nums)\n dp = [[-inf] * (target + 1) for _ in range(n + 1)]\n dp[0][0] = 0\n fm = [[0] * (target + 1) for _ in range(n + 1)]\n for i in range(n):\n for j in range(target + 1):\n dp[i + 1][j] = dp[i][j]\n fm[i + 1][j] = j\n if j >= nums[i]:\n dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - nums[i]] + 1)\n if dp[i + 1][j] > dp[i + 1][j - nums[i]] + 1:\n fm[i + 1][j] = j\n else:\n dp[i + 1][j] = dp[i + 1][j - nums[i]] + 1\n fm[i + 1][j] = j - nums[i]\n \n t = dp[n][target]\n\n if t == -inf:\n return \"0\"\n \n i = 9\n j = target\n ans = \"\"\n while i > 0:\n g = fm[i][j]\n if g == j:\n i-= 1\n else:\n p = ord('0') + i\n ans += chr(p)\n j = fm[i][j]\n return ans\n \n\n \n \n \n \n\n \n ","memory":"19900"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n max_digit_counts = [[float('-inf')] * (target + 1) for _ in range(10)]\n max_digit_counts[0][0] = 0 # Base case: zero cost leads to zero digits\n \n # Initialize a table for backtracking the choices made\n choice_backtrack = [[0] * (target + 1) for _ in range(10)]\n \n # Fill the tables with dynamic programming approach\n for digit, single_cost in enumerate(cost, start=1):\n for budget in range(target + 1):\n if budget < single_cost or max_digit_counts[digit][budget - single_cost] + 1 < max_digit_counts[digit - 1][budget]:\n # If we don't take the current digit\n max_digit_counts[digit][budget] = max_digit_counts[digit - 1][budget]\n choice_backtrack[digit][budget] = budget\n else:\n # Take the current digit\n max_digit_counts[digit][budget] = max_digit_counts[digit][budget - single_cost] + 1\n choice_backtrack[digit][budget] = budget - single_cost\n \n # If we cannot reach the target with the given costs, return \"0\"\n if max_digit_counts[9][target] < 0:\n return \"0\"\n \n # Backtrack from the filled tables to find the largest number\n result = []\n current_digit, current_budget = 9, target\n while current_digit > 0:\n if current_budget == choice_backtrack[current_digit][current_budget]:\n # Move to the previous digit if no current digit is taken\n current_digit -= 1\n else:\n # Add the current digit to the result and update the budget\n result.append(str(current_digit))\n current_budget = choice_backtrack[current_digit][current_budget]\n \n # Join the list of digits to form the largest number string\n return \"\".join(result)","memory":"20100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n the largest number must have max length\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max length of num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\n optimization:space\n '''\n # dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n # dp[0] = [0]*(target+1)\n # for i in range(9):\n # for j in range(target+1):\n # dp[i+1][j] = dp[i][j]\n # if j-cost[i]>=0:\n # dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\n # length = dp[-1][-1]\n # if length == 0:\n # return 0\n # '''\n # loop from the digit 9 to digit 1\n # when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\n # '''\n # res = []\n # j = target\n # for i in range(8,-1,-1):\n # c = cost[i]\n # while target-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\n # res.append(str(i+1))\n # j -= c\n # return \"\".join(res)\n\n\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\n dp = [[float(\"-inf\")] * (target + 1) for _ in range(10)]\n # where[i][j]表示从dp[i][j]来的上一步的花费\n where = [[0] * (target + 1) for _ in range(10)]\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n # 遍历每一个数字（数字从1到9，索引从0到8）\n for i, c in enumerate(cost):\n for j in range(target + 1):\n if j < c:\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n # 否则，判断是选择不使用数字i+1，还是使用它\n if dp[i][j] > dp[i + 1][j - c] + 1:\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n dp[i + 1][j] = dp[i + 1][j - c] + 1\n where[i + 1][j] = j - c\n # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n if dp[9][target] < 0:\n return \"0\"\n # 回溯路径，构造答案\n ans = list()\n i, j = 9, target\n while i > 0:\n if j == where[i][j]:\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n else:\n ans.append(str(i)) # 记录使用的数字\n j = where[i][j] # 更新花费\n return \"\".join(ans)\n\n\n # dp = [-float('inf')] * (target + 1)\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\n # # 动态规划，计算最大可以获得的数字长度\n # for i, c in enumerate(cost):\n # for j in range(c, target + 1):\n # if dp[j - c] != -float('inf'):\n # dp[j] = max(dp[j], dp[j - c] + 1)\n # # 如果target无解，直接返回0\n # if dp[target] < 0:\n # return \"0\"\n # # 从最大长度开始构造结果\n # res = []\n # j = target\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\n # c = cost[i]\n # while j >= c and dp[j] == dp[j - c] + 1:\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\n # res.append(str(i + 1))\n # j -= c\n \n # return ''.join(res)\n\n\n\n","memory":"20200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n '''\n complete knapsack (can repeat the elements)\n i+1 := the digit\n cost[i] := cost\n dp[i][j] to record the max num we can get\n i := use the first i digits\n j := when costs sum up to j\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\n optimization:space\n '''\n # dp = [[-float(\"inf\")]*(target+1) for _ in range(10)]\n # dp[0] = [0]*(target+1)\n # for i in range(9):\n # for j in range(target+1):\n # dp[i+1][j] = dp[i][j]\n # if j-cost[i]>=0:\n # last = dp[i+1][j-cost[i]]\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\n # return dp[-1][-1]\n\n\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\n dp = [[float(\"-inf\")] * (target + 1) for _ in range(10)]\n # where[i][j]表示从dp[i][j]来的上一步的花费\n where = [[0] * (target + 1) for _ in range(10)]\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\n\n # 遍历每一个数字（数字从1到9，索引从0到8）\n for i, c in enumerate(cost):\n for j in range(target + 1):\n if j < c:\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n # 否则，判断是选择不使用数字i+1，还是使用它\n if dp[i][j] > dp[i + 1][j - c] + 1:\n dp[i + 1][j] = dp[i][j]\n where[i + 1][j] = j\n else:\n dp[i + 1][j] = dp[i + 1][j - c] + 1\n where[i + 1][j] = j - c\n \n # 如果dp[9][target]小于0，说明无法凑出target，返回\"0\"\n if dp[9][target] < 0:\n return \"0\"\n \n # 回溯路径，构造答案\n ans = list()\n i, j = 9, target\n while i > 0:\n if j == where[i][j]:\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\n else:\n ans.append(str(i)) # 记录使用的数字\n j = where[i][j] # 更新花费\n \n return \"\".join(ans)\n\n\n","memory":"20300"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n #dp[cost] = dp[cost - 1]\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i, prev_digit in enumerate(max_prev_digit):\n if int(prev_digit) < digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n #print(dp)\n return str(dp[-1])","memory":"22000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i in range(n - 1, -1, -1):\n prev_digit = max_prev_digit[i]\n if int(prev_digit) > digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n return str(dp[-1])","memory":"22000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n best_costs = defaultdict(int)\n for i, price in enumerate(cost):\n best_costs[price] = i + 1\n \n dp = [0 for _ in range(target + 1)]\n for cost in range(1, target + 1):\n for price, digit in best_costs.items():\n if price > cost:\n continue\n \n max_prev_digit = str(dp[cost - price])\n if max_prev_digit == \"0\" and (cost - price) != 0:\n continue \n\n n = len(max_prev_digit)\n new_digit = \"\"\n for i, prev_digit in enumerate(max_prev_digit):\n if int(prev_digit) < digit: \n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\n break \n\n if not new_digit:\n new_digit = max_prev_digit + str(digit)\n\n dp[cost] = max(dp[cost], int(new_digit))\n\n #print(dp)\n return str(dp[-1])","memory":"22100"},{"code":"sys.set_int_max_str_digits(50000)\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [0] + [-1] * (target + 5000)\n for t in range(1, target + 1):\n dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\n return str(max(dp[t], 0))","memory":"22200"},{"code":"import sys\nsys.set_int_max_str_digits(6000) \nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n DP = [0]*(target+1)\n\n DP[1] = max([0]+[i+1 for i, c in enumerate(cost) if c==1])\n\n for t in range(1, target+1):\n for i, c in enumerate(cost):\n if c<t and DP[t-c]!=0:\n DP[t] = max(DP[t], DP[t-c]*10+i+1)\n if c==t:\n DP[t] = max(DP[t], i+1)\n \n\n return str(DP[-1])\n \n\n # return max(self.helper(cost, target))\n\n # def helper(self, cost, target):\n # if target==0:\n # return [\"\"]\n # if target<0:\n # return [\"0\"]\n \n # nums = []\n # for i, c in enumerate(cost):\n # if c<=target:\n # answer = self.helper(cost, target-c)\n # nums += [f\"{i+1}{ans}\" for ans in answer if ans!=\"0\"]\n # if nums==[]:\n # return [\"0\"] \n # return nums\n\n # cost_dict = {}\n # for i, c in enumerate(cost):\n # cost_dict[c] = i+1\n # cost_store = sorted(list((cost_dict.items())), key=lambda x:x[0], reverse=False)\n\n # num = []\n # ptr = 0\n # n = len(cost_store)\n\n # # return cost_store\n # while target!=0:\n # if cost_store[ptr][0] > target: # need to back track\n # ptr = ptr + 1\n # if ptr==n:\n # return \"0\"\n # while cost_store[ptr][0] > target:\n # if num==[]:\n # return \"0\"\n # target += cost[int(num.pop(-1))-1]\n\n\n # target -= cost_store[ptr][0]\n # num.append(str(cost_store[ptr][1]))\n\n # num.sort(reverse=True)\n return \"\".join(num)\n","memory":"22300"},{"code":"import sys\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Increase the limit for integer string conversion\n sys.set_int_max_str_digits(1000000) # Adjust this number as needed\n\n dp = [0] + [-1] * target\n \n for t in range(1, target + 1):\n for d, c in enumerate(cost):\n if c <= t and dp[t - c] != -1:\n dp[t] = max(dp[t], dp[t - c] * 10 + d + 1)\n \n return str(max(dp[target], 0))","memory":"22400"},{"code":"import sys\nsys.set_int_max_str_digits(5001)\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n n = len(cost)\n cost = cost[::-1]\n dp = [[-1 for i in range(target + 1)] for j in range(n+1)]\n for i in range(n+1):\n dp[i][0] = 0\n for i in range(1, n+1):\n for j in range(1, target + 1):\n dp[i][j] = dp[i-1][j]\n if j-cost[i-1] >= 0 and dp[i][j-cost[i-1]] != -1:\n dp[i][j] = max(dp[i][j], dp[i][j - cost[i-1]]*10 + 9-i + 1)\n return str(max(dp[-1][target], 0))","memory":"22600"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n @lru_cache(None)\n def solve(target):\n if target < 0:\n return float('-inf')\n if target == 0:\n return 0\n res = float('-inf')\n for i in cost:\n res = max(res, 1+solve(target-i))\n return res\n temp = solve(target)\n if temp == float('-inf'):return \"0\"\n ans = \"\"\n while target:\n mx, res = 0, 0\n for idx,i in enumerate(cost):\n temp = solve(target-i)\n if temp > mx:\n mx = temp\n res = idx+1\n elif temp == mx:\n res = max(res, idx+1)\n ans += str(res)\n target -= cost[res-1]\n return ans","memory":"24100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int):\n @lru_cache(None)\n def solve(target):\n if target < 0:\n return float('-inf')\n if target == 0:\n return 0\n res = float('-inf')\n for i in cost:\n res = max(res, 1+solve(target-i))\n return res\n temp = solve(target)\n if temp == float('-inf'):return \"0\"\n ans = \"\"\n while target:\n mx, res = 0, 0\n for idx,i in enumerate(cost):\n temp = solve(target-i)\n if temp > mx:\n mx = temp\n res = idx+1\n elif temp == mx:\n res = max(res, idx+1)\n ans += str(res)\n target -= cost[res-1]\n return ans\n\n \n ","memory":"24200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n \n cost = cost[::-1]\n visited = set()\n for i in range(len(cost)):\n if cost[i] in visited:\n cost[i] = -1\n visited.add(cost[i])\n\n #print(cost)\n #return '0'\n\n def comp(list1, list2):\n if list2 is None:\n return 1\n \n summ = sum(list1) - sum(list2)\n if summ > 0:\n return 1\n if summ < 0:\n return -1\n for i in range(len(list1)):\n if list1[i] > list2[i]:\n return 1\n if list1[i] < list2[i]:\n return -1\n \n return 0\n\n @cache\n def itero(idx, rem):\n if rem < 0:\n return None\n if cost[idx] == -1:\n if idx < 8:\n return itero(idx+1, rem)\n elif rem == 0:\n return [0 for i in range(9)]\n else:\n return None \n newval = None\n if idx == 8:\n if rem%cost[idx] == 0:\n newval = [0 for i in range(9)]\n newval[idx] = rem//cost[idx]\n #print(idx, rem, newval)\n return newval\n else:\n #print(idx, rem, newval)\n return None\n \n if rem == 0:\n #print(idx, rem, [0 for i in range(9)])\n return [0 for i in range(9)]\n \n \n for i in range((rem//cost[idx])+1):\n result = itero(idx+1, rem - cost[idx]*i)\n if result is not None:\n result = [result[j] + (0 if idx != j else i) for j in range(9)]\n if comp(result, newval) > 0:\n newval = [el for el in result]\n \n #print(idx, rem, newval)\n return newval\n\n\n val = itero(0, target)\n if val is None:\n return '0'\n return ''.join([str(9-idx)*val[idx] for idx in range(9)])","memory":"24800"},{"code":"from typing import List\nimport sys\n# Increase the limit for the maximum number of digits in an integer string conversion\nsys.set_int_max_str_digits(10000)\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Map cost to corresponding digit, ensuring largest digit comes first\n cost_to_digit = {}\n for i in range(len(cost)):\n cost_to_digit[cost[i]] = max(cost_to_digit.get(cost[i], 0), i + 1)\n \n # Sort costs in ascending order\n sorted_costs = sorted(cost_to_digit.items())\n\n # Memoization dictionary\n memo = {}\n \n def dfs(tar):\n if tar == 0:\n return 0 # Return 0 to represent the number as an integer\n if tar in memo:\n return memo[tar]\n \n max_num = -float('inf')\n for cost, digit in sorted_costs:\n if cost <= tar:\n num = dfs(tar - cost)\n if num != -float('inf'):\n max_num = max(max_num, num * 10 + digit)\n else:\n break\n \n memo[tar] = max_num\n return max_num\n \n # Get the result and convert it to string\n result = dfs(target)\n return str(result) if result != -float('inf') else \"0\"","memory":"25800"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # 這題數字可以是1~9\n # 有9種可能\n # 如果用dfs 的話 最大複雜度\n # 9^5000 9的5千次方 顯然不太實\n # 把 cost 當作 coin\n # 同cost 只要留下數字大的就好\n coin = Counter()\n for i in range(9):\n coin[cost[i]]=max(coin[cost[i]],i+1)\n #print(coin)\n coins = sorted(coin.keys()) \n #用 1~target 這個是可以重複用 然後用最多的那種coin change\n dp =[\"\"]*(target+1)\n #print(\"coins\",coins)\n for c in coins:\n if c <= target:\n dp[c]=str(coin[c])\n for j in range(coins[0],target+1):\n for c in coins:\n if j-c >= 0 and dp[j-c]!=\"\":\n if len(dp[j]) < len(dp[j-c]+str(coin[c])):\n dp[j] = dp[j-c]+str(coin[c])\n elif len(dp[j]) == len(dp[j-c]+str(coin[c])):\n dp[j] = max(dp[j],dp[j-c]+str(coin[c]))\n #print(dp)\n # 問題來了 就算我數量算對 但還要用這個數量去還原成string 該怎麼做呢\n return \"\".join(sorted(dp[target],reverse=True)) if dp[target]!=\"\" else \"0\"\n #這個 case 炸了cost = [5,6,7,3,4,6,7,4,8]\n","memory":"27600"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n import sys \n sys.set_int_max_str_digits(10000)\n \n @lru_cache(None)\n def dp(total):\n if total == 0:\n return 0\n \n str1 = float(\"-inf\")\n for j in range(1,10):\n if total-cost[j-1] >= 0:\n str1 = max(str1,j+dp(total-cost[j-1])*10)\n return str1\n\n val, s = dp(target), \"\"\n if val == float(\"-inf\"):\n return \"0\"\n\n return str(val)\n","memory":"28400"},{"code":"class Solution:\n def largestNumber(self, cost, target):\n import sys \n\n sys.set_int_max_str_digits(10000)\n\n @lru_cache(None)\n def function(total):\n if total == 0:\n return 0 \n\n str1 = float(\"-inf\")\n\n for j in range(1,10):\n if total-cost[j-1] >= 0:\n str1 = max(str1,j+function(total-cost[j-1])*10)\n\n return str1 \n\n val, s = function(target), \"\"\n\n if val == float(\"-inf\"):\n return \"0\"\n \n return str(val)","memory":"28500"},{"code":"from functools import lru_cache\nimport sys\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n @lru_cache(None)\n def dp(balance):\n if balance == 0:\n return 0\n \n res = float('-inf')\n for i in range(9):\n if balance - cost[i] >= 0:\n res = max(res, (i+1) + dp(balance - cost[i]) * 10)\n \n return res\n \n res = dp(target)\n return str(res) if res != float('-inf') else \"0\"","memory":"28600"},{"code":"import sys\nsys.set_int_max_str_digits(0)\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n self.d = {}\n def top_down(t):\n if t == 0: return 0\n if t in self.d: return self.d[t]\n cur = float('-inf')\n for digit in range(1,10):\n if (t-cost[digit-1]) >= 0:\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\n self.d[t] = cur\n return cur\n\n res = top_down(target)\n return str(res) if res != float('-inf') else \"0\"\n\n\n# class Solution(object):\n# def largestNumber(self, cost, target):\n# ans = self.dfs(cost, 1, target)\n# return ans if '0' not in ans else '0'\n \n# def dfs(self, cost, index, remain):\n# \t\t# base cases\n# if remain == 0:\n# return ''\n# elif remain < 0 or index == len(cost)+1:\n# return '0'\n \n# \t\t# decisions \n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \n# skip = self.dfs(cost, index+1, remain) \n\t\t\n# \t\t# memoize and return the max of decisions\n# return self.getBigger(take, skip) \n \n# def getBigger(self, num1, num2):\n# if '0' in num2:\n# return num1\n# elif '0' in num1:\n# return num2\n# elif int(num1)>int(num2):\n# return num1 \n# else:\n# return num2\n\n\n# class Solution:\n# def largestNumber(self, cost, target):\n# dp = [0] + [-1] * (target + 5000)\n# for t in range(1, target + 1):\n# dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\n# return str(max(dp[t], 0))\n\n# # def largestNumber(self, cost: List[int], target: int) -> str:\n# # cost_map = {}\n# # for i, v in enumerate(cost):\n# # cost_map[i+1] = v\n \n# self.ans = 0\n# dp = [''] * (target+1)\n \n# def get_max(a, b):\n# if not a:\n# a = '0'\n# if not b:\n# b = '0'\n# if int(a) > int(b):\n# return a\n# return b\n \n# def get_cost(num, rem):\n# ncost = 0\n# for i in num:\n# ncost += cost[int(i)-1]\n# return ncost == rem\n \n# def helper(rem):\n# num = ''\n# # print(rem, mem)\n# if dp[rem] == '':\n \n# if rem == 0:\n# return ''\n# if rem < 0:\n# return float('-inf')\n\n# for i in range(len(cost)-1, -1, -1):\n# # if cost[i] > rem:\n# # continue\n# val = helper(rem-cost[i])\n# # \n# if val == float('-inf'):\n# continue\n# num = get_max(num, str(i+1)+val)\n# if get_cost(num, rem):\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\n# # else:\n# # mem[rem] = ''\n# return dp[rem]\n \n# # print(helper(cost, target, ''))\n \n# ans = str(helper(target))\n# return ans if ans else '0'","memory":"28700"},{"code":"import sys\nsys.set_int_max_str_digits(0)\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n self.d = {}\n def top_down(t):\n if t == 0: return 0\n if t in self.d: return self.d[t]\n cur = float('-inf')\n for digit in range(1,10):\n if (t-cost[digit-1]) >= 0:\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\n self.d[t] = cur\n return cur\n\n res = top_down(target)\n return str(res) if res != float('-inf') else \"0\"\n\n\n# class Solution(object):\n# def largestNumber(self, cost, target):\n# ans = self.dfs(cost, 1, target)\n# return ans if '0' not in ans else '0'\n \n# def dfs(self, cost, index, remain):\n# \t\t# base cases\n# if remain == 0:\n# return ''\n# elif remain < 0 or index == len(cost)+1:\n# return '0'\n \n# \t\t# decisions \n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \n# skip = self.dfs(cost, index+1, remain) \n\t\t\n# \t\t# memoize and return the max of decisions\n# return self.getBigger(take, skip) \n \n# def getBigger(self, num1, num2):\n# if '0' in num2:\n# return num1\n# elif '0' in num1:\n# return num2\n# elif int(num1)>int(num2):\n# return num1 \n# else:\n# return num2\n\n\n# class Solution:\n# def largestNumber(self, cost, target):\n# # dp = [0] + [-1] * (target + 5000)\n# # for t in range(1, target + 1):\n# # dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\n# # return str(max(dp[t], 0))\n\n# # def largestNumber(self, cost: List[int], target: int) -> str:\n# # cost_map = {}\n# # for i, v in enumerate(cost):\n# # cost_map[i+1] = v\n \n# self.ans = 0\n# dp = [''] * (target+1)\n \n# def get_max(a, b):\n# if not a:\n# a = '0'\n# if not b:\n# b = '0'\n# if int(a) > int(b):\n# return a\n# return b\n \n# def get_cost(num, rem):\n# ncost = 0\n# for i in num:\n# ncost += cost[int(i)-1]\n# return ncost == rem\n \n# def helper(rem):\n# num = ''\n# if rem == 0:\n# return ''\n# if rem < 0:\n# return float('-inf')\n# # print(rem, mem)\n# if dp[rem] == '':\n \n \n\n# for i in range(len(cost)-1, -1, -1):\n# # if cost[i] > rem:\n# # continue\n# val = helper(rem-cost[i])\n# # \n# if val == float('-inf'):\n# continue\n# num = get_max(num, str(i+1)+val)\n# if get_cost(num, rem):\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\n# # else:\n# # mem[rem] = ''\n# return dp[rem]\n \n# # print(helper(cost, target, ''))\n \n# ans = str(helper(target))\n# return ans if ans else '0'","memory":"28800"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = ['' for i in range(target+1)]\n dp[0] = '0'\n for i in range(1, target+1):\n for k in range(1, 10):\n t = i-cost[k-1]\n if t<0 or len(dp[t])==0:\n continue\n v = ''.join(sorted(str(k)+dp[t], reverse=True))\n # if i==target:\n # print(k, v)\n if len(v)>len(dp[i]) or (len(v)==len(dp[i]) and v>dp[i]):\n dp[i]=v\n # print(i, dp)\n if dp[target]=='':\n return '0'\n return dp[target][:len(dp[target])-1]\n \n \n \n \n ","memory":"29000"},{"code":"from typing import List\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Initialize dp array with an empty string for 0 cost and None for others\n dp = [''] + [None] * target\n \n # Iterate over each possible cost\n for t in range(1, target + 1):\n for d in range(9):\n if t >= cost[d] and dp[t - cost[d]] is not None:\n candidate = dp[t - cost[d]] + str(d + 1)\n if dp[t] is None or len(candidate) > len(dp[t]) or (len(candidate) == len(dp[t]) and candidate > dp[t]):\n dp[t] = candidate\n \n return dp[target] if dp[target] is not None else \"0\"\n\n# Example usage:\n# solution = Solution()\n# print(solution.largestNumber([4,3,2,5,6,7,2,5,5], 9)) # Output: \"7772\"\n# print(solution.largestNumber([7,6,5,5,5,6,8,7,8], 12)) # Output: \"85\"\n# print(solution.largestNumber([2,4,6,2,4,6,4,4,4], 5)) # Output: \"0\"","memory":"29100"},{"code":"from typing import List\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = ['#'] * (target + 1)\n dp[0] = \"\"\n \n for t in range(1, target + 1):\n for d in range(9):\n if t >= cost[d]:\n potential = dp[t - cost[d]]\n if potential != '#':\n # Create a new number by adding the current digit\n candidate = str(d + 1) + potential\n if dp[t] == '#' or len(candidate) > len(dp[t]) or (len(candidate) == len(dp[t]) and candidate > dp[t]):\n dp[t] = candidate\n \n return dp[target] if dp[target] != '#' else \"0\"\n\n# Example usage:\n# Create an object of the Solution class\nsolution = Solution()\n\n# Test examples\nprint(solution.largestNumber([4,3,2,5,6,7,2,5,5], 9)) # Output: \"7772\"\nprint(solution.largestNumber([7,6,5,5,5,6,8,7,8], 12)) # Output: \"85\"\nprint(solution.largestNumber([2,4,6,2,4,6,4,4,4], 5)) # Output: \"0\"","memory":"29100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(10000)\n @cache\n def dp(currCost):\n if currCost == target: \n return 0\n \n if currCost >= target:\n return float(\"-inf\")\n \n res = float(\"-inf\")\n for i in range(1, 10):\n res = max(res, i +dp(currCost + cost[i - 1]) * 10)\n \n return res\n\n ans = dp(0)\n if ans < 0:\n return \"0\"\n return str(ans)\n \n \n","memory":"29200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n def islarge(s1, s2):\n if len(s1) > len(s2):\n return True\n if len(s1) < len(s2):\n return False\n for i in range(len(s1)):\n if s1[i] < s2[i]:\n return False\n if s1[i] > s2[i]:\n return True\n return True\n dp = [''] * (target+1)\n for d in range(len(cost)):\n for j in range(cost[d], len(dp)):\n cur = ''\n if len(dp[j-cost[d]]) >= 1 or j % cost[d] == 0:\n cur = str(d+1) + dp[j-cost[d]]\n dp[j] = cur if islarge(cur, dp[j]) else dp[j]\n return dp[-1] if len(dp[-1]) >= 1 else '0'","memory":"29500"},{"code":"from typing import List\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # Create a DP array with None (to signify uninitialized states)\n dp = [None] * (target + 1)\n dp[0] = '' # Base case: zero cost corresponds to an empty string\n \n # Fill DP array\n for i in range(1, target + 1):\n for digit in range(9, 0, -1): # Start from 9 to 1 to ensure the largest number\n if i >= cost[digit - 1] and dp[i - cost[digit - 1]] is not None:\n new_number = dp[i - cost[digit - 1]] + str(digit)\n if dp[i] is None or len(new_number) > len(dp[i]) or (len(new_number) == len(dp[i]) and new_number > dp[i]):\n dp[i] = new_number\n \n # Result is in dp[target], if it's None, return \"0\"\n return dp[target] if dp[target] is not None else \"0\"\n\n","memory":"29900"},{"code":"from typing import List\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [None] * (target + 1)\n dp[0] = '' \n for i in range(1, target + 1):\n for digit in range(9, 0, -1): \n if i >= cost[digit - 1] and dp[i - cost[digit - 1]] is not None:\n new_number = dp[i - cost[digit - 1]] + str(digit)\n if dp[i] is None or len(new_number) > len(dp[i]) or (len(new_number) == len(dp[i]) and new_number > dp[i]):\n dp[i] = new_number\n return dp[target] if dp[target] is not None else \"0\"\n\n","memory":"30000"},{"code":"from typing import *\nimport math\nimport inspect\nimport random\nfrom collections import *\nimport copy\nfrom functools import cmp_to_key\n\ndef printd(var : Any) -> None :\n frame = inspect.currentframe().f_back\n var_name = [name for name, val in frame.f_locals.items() if val is var]\n name = var_name[-1] if var_name else \"???\"\n print(f\"[ {name} ]: {var}\")\n\ndef mrand(begin: Union[int, float], end: Union[int, float]) -> Union[int, float]:\n if isinstance(begin, int) and isinstance(end, int):\n return random.randint(begin, end) # Inclusive range for integers\n elif isinstance(begin, float) or isinstance(end, float):\n return random.uniform(begin, end) # Inclusive range for floats\n\n raise ValueError(\"Both arguments must be either int or float.\")\n\nclass pair:\n def __init__(self, _first : Any, _second : Any) -> None:\n self.first = _first\n self.second = _second\n\n def copy(self) -> 'pair' :\n return pair(self.first, self.second)\n\n def __repr__(self) -> str :\n return f\"({self.first}, {self.second})\"\n\n def __lt__(self, other: 'pair') -> bool:\n return (self.first, self.second) < (other.first, other.second)\n\n def __gt__(self, other: 'pair') -> bool:\n return (self.first, self.second) > (other.first, other.second)\n\n def __eq__(self, other: 'pair') -> bool:\n return (self.first, self.second) == (other.first, other.second)\n\n def __ne__(self, other: 'pair') -> bool:\n return (self.first, self.second) != (other.first, other.second)\n\ndef get_unique(arr: List[Any], compare: Callable[[Any, Any], bool] = None) -> None:\n if compare == None:\n compare = lambda a, b : -1 if a < b else 1\n arr.sort(key=cmp_to_key(compare))\n new_size = 0\n for i in range(len(arr)):\n if i == 0 or arr[i] != arr[i - 1]:\n arr[new_size] = arr[i]\n new_size += 1\n arr[:] = arr[:new_size]\n\n\nclass Solution:\n def largestNumber(self, costs: List[int], target: int) -> str:\n\n def is_better(me : List[str], other : str) -> bool:\n if len(me) != len(other):\n return True if len(me) > len(other) else False\n\n for i in range(len(me)):\n if me[i] != other[i]:\n return True if me[i] > other[i] else False\n\n return False\n\n dp = [\"0\"] * (target + 1)\n dp[0] = \"\"\n for i in range(target):\n if dp[i] == \"0\":\n continue\n me = [dp[i][j] for j in range(len(dp[i]))]\n for v in range(1, 10):\n whr = i + costs[v - 1]\n if whr > target:\n continue\n\n me.append(str(v))\n if is_better(me, dp[whr]):\n dp[whr] = \"\".join(me)\n me.pop()\n\n return dp[target]\n\n","memory":"30300"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n \n @cache\n def solve(budget):\n if budget < 0:\n return (-1,\"0\")\n if budget==0:\n return (0,\"\")\n res = (-1,0,\"0\")\n for j in range(9,0,-1):\n if budget>=cost[j-1]:\n Z = solve(budget-cost[j-1])\n res = max(res,(Z[0],j,Z[1]))\n \n # print(budget, res)\n if res[0] == -1:\n return -1,\"0\"\n return res[0]+1 , str(res[1])+res[2]\n\n return solve(target)[1]\n\n\n ","memory":"34400"},{"code":"from functools import lru_cache\n\n\nclass Solution:\n def largestNumber(self, cost: list[int], target: int) -> str:\n\n # Determine if string a is greater than string b\n def greater(a, b):\n\n # If their lengths are different, use their length to determine if a is greater than b\n if len(a) != len(b):\n return len(a) > len(b)\n\n # Else, check all digits one by one\n for c1, c2 in zip(a,b):\n\n # If current digits of a and b are equal, continue to the next digits pair\n if c1 == c2:\n continue\n\n # Else, check if digit of a is greater than digit of b\n return c1>c2\n\n # Return False if all digits are the same\n return False\n\n # Save costs and their corresponding digits into a dict \n # Override the smaller digit with a larger one if their costs are the same\n costs = {c: str(i + 1) for i, c in enumerate(cost)}\n\n # Top-down dp to find the largest number giving a budget\n @lru_cache(None)\n def dp(budget):\n\n # If we have 0 budget left, we have reach the basecase, return (True, \"\")\n if budget == 0:\n return True, \"\"\n\n # Initialize varaibles to store the largest number and the boolean to indicate that there is a digit where if we were to pick such digit, we can form a number using all of the remaining budget\n largestNum, ableToUseAll = \"\", False\n\n # Iterate through all digits\n for cost, digit in costs.items():\n\n # If the current digit has a higher cost than the budget, skip it\n if cost > budget:\n continue\n\n # Else, if we were to pick such digit, can all of the remaining budget be used to form a number?\n usedAll, nextNum = dp(budget - cost)\n\n # If yes\n if usedAll:\n\n # Concatenate the picked digit with the next number to form the current number\n num = digit + nextNum\n\n # If the current number is greater than previous number, save it\n largestNum = num if greater(num, largestNum) else largestNum\n\n # Update the boolean to indicate that we have found a number that formed using all of the budget\n ableToUseAll = ableToUseAll or usedAll\n\n # Return result if we were able to find a number formed using all of the budget\n # Else, return \"0\"\n return ableToUseAll, largestNum if ableToUseAll else \"0\"\n\n return dp(target)[1]","memory":"34700"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n min_cost = min(cost)\n\n @cache\n def helper(target):\n if target == 0:\n return \"\"\n if target < min_cost:\n return None\n \n ans = None\n for i, cost_i in enumerate(cost):\n i += 1\n if target >= cost_i:\n t = helper(target - cost_i)\n if t is not None:\n t = str(i) + t\n if ans is None or len(ans) < len(t) or len(ans) == len(t) and ans < t:\n ans = t\n return ans\n \n ans = helper(target)\n return \"0\" if ans is None else ans\n\n\n ","memory":"35200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n from functools import lru_cache\n\n def max_(a, b):\n if len(a) > len(b): return a\n elif len(a) < len(b): return b\n return max(a, b)\n \n @lru_cache(None)\n def rec(left):\n if not left: return ''\n mx = '0'\n for digit in range(1, 10):\n if cost[digit-1] <= left:\n r = rec(left-cost[digit-1])\n if not '0' in r: mx = max_(mx, str(digit) + r)\n return mx\n \n return rec(target)","memory":"35400"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n def maxString(a, b):\n if len(a) < len(b):\n return b\n elif len(a) > len(b):\n return a\n\n else:\n n = len(a)\n p1 = 0\n for i in range(n):\n if a[i] > b[i]:\n return a\n elif a[i] < b[i]:\n return b\n\n return a\n\n @lru_cache(None)\n def dfs(current):\n if current == 0:\n return \"\"\n \n if current < 0:\n return \"-1\"\n\n ans = \"\"\n for digit in range(1, 10):\n nxt = dfs(current - cost[digit - 1])\n if nxt != \"-1\":\n ans = maxString(ans, str(digit) + nxt)\n\n return \"-1\" if ans == \"\" else ans\n\n ans = dfs(target)\n return \"0\" if ans == \"-1\" else ans","memory":"35500"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n def maxString(a, b):\n if len(a) < len(b):\n return b\n elif len(a) > len(b):\n return a\n\n else:\n n = len(a)\n p1 = 0\n for i in range(n):\n if a[i] > b[i]:\n return a\n elif a[i] < b[i]:\n return b\n\n return a\n\n @lru_cache(None)\n def dfs(current):\n if current == 0:\n return \"\"\n \n if current < 0:\n return \"0\"\n\n ans = \"0\"\n for digit in range(1, 10):\n nxt = dfs(current - cost[digit - 1])\n if nxt != \"0\":\n ans = maxString(ans, str(digit) + nxt)\n\n return ans\n\n return dfs(target)","memory":"35500"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n cutoff = min(cost)\n \n def compare(a,b):\n if a==b:\n return a\n if a=='0':\n return b\n if b=='0':\n return a\n if len(a)>len(b):\n return a\n if len(b)>len(a):\n return b\n for i in range(len(a)):\n if a[i]==b[i]:\n continue\n if a[i]>b[i]:\n return a\n return b\n \n @cache\n def dp(t):\n if t==0:\n return ''\n if t<cutoff:\n return '0'\n \n ret = '0'\n for i in range(9):\n if t<cost[i]:\n continue\n temp = dp(t-cost[i])\n if temp == '0':\n continue\n ret = compare(ret,str(i+1)+temp)\n # print(t,ret)\n return ret\n \n ret = dp(target)\n # ret = dp(3)\n \n return ret","memory":"35600"},{"code":"from functools import lru_cache\nclass Solution:\n def largestNumber(self, costs: List[int], target: int) -> str:\n # obviously more integers is better\n # (greedy?) choose the nums with lower cost\n # if same cost, choose bigger int\n def myMax(a, b):\n if '0' in a:\n return b\n elif '0' in b:\n return a\n elif len(a) > len(b):\n return a\n elif len(b) > len(a):\n return b\n else:\n return max(a, b)\n \n dp = [[None for _ in range(target + 1)] for _ in range(len(costs))]\n\n def f(i, target):\n if target == 0:\n return ''\n if target < 0 or i == len(costs):\n return '0'\n \n if dp[i][target] != None: return dp[i][target]\n\n take = str(i + 1) + f(0, target - costs[i])\n leave = f(i + 1, target)\n\n #print(max(take, leave))\n\n dp[i][target] = myMax(take, leave)\n return dp[i][target]\n \n return f(0, target)","memory":"35700"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n from functools import lru_cache\n\n def max_(a, b):\n if len(a) > len(b): return a\n elif len(a) < len(b): return b\n return max(a, b)\n \n digits = {}\n\n for i in range(8, -1, -1):\n if cost[i] not in digits:\n digits[cost[i]] = str(i+1)\n \n print(digits)\n\n @lru_cache(None)\n def rec(left):\n if not left: return ''\n mx = '0'\n for d in digits:\n if d <= left:\n r = rec(left-d)\n if '0' not in r: mx = max_(mx, digits[d] + r)\n return mx\n \n return rec(target)","memory":"35900"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n from functools import lru_cache\n\n def max_(a, b):\n if len(a) > len(b): return a\n elif len(a) < len(b): return b\n return max(a, b)\n \n digits = {}\n for i in range(8, -1, -1):\n if cost[i] not in digits:\n digits[cost[i]] = str(i+1)\n \n\n @lru_cache(None)\n def rec(left):\n if not left: return ''\n mx = '0'\n for d in digits:\n if d <= left:\n r = rec(left-d)\n if '0' not in r: mx = max_(mx, digits[d] + r)\n return mx\n \n return rec(target)","memory":"36000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n def bigger_str_num(a, b):\n if a is None and b is None:\n return None\n if a is None and b is not None:\n return b\n if b is None and a is not None:\n return a\n if len(a) > len(b):\n return a\n if len(a) < len(b):\n return b\n return max(a,b)\n\n @cache\n def rec(target):\n if target < 0:\n return None\n if target == 0:\n return \"\"\n \n default = None\n for i, c in enumerate(cost):\n r = rec(target - c)\n if r is not None:\n default = bigger_str_num(str(i+1) + r, default)\n return default\n\n v = rec(target)\n return \"0\" if v is None else v\n ","memory":"36300"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # highest digit per cost\n high = {}\n for i, c in enumerate(cost, 1):\n high[c] = i\n # ordered (by cost)\n digits = []\n for h in sorted(high):\n digits.append(( str(high[h]), h ))\n\n @cache\n def deeper(price):\n if price == 0:\n return \"\" # found a valid number\n\n best = \"\"\n for digit, dollars in digits:\n if dollars > price:\n break\n\n # append more digits\n next = deeper(price - dollars)\n # failed, target not met\n if next == None:\n continue\n\n have = digit + next\n # longer than before\n if len(have) > len(best):\n best = have\n # same length but higher digits\n if len(have) == len(best):\n best = max(best, have)\n\n return best if best else None # None if target not met\n \n result = deeper(target)\n return result if result else \"0\"","memory":"36400"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # 判断状态 - 1. remaining cost\n # 不知道 一共要多少个digits 但是要找largest\n # 越多 digits 开头约大\n cache = {}\n def dfs(remain):\n if remain == 0:\n return ''\n if remain < 0: return '0'\n if remain in cache: return cache[remain]\n ans = '0'\n for i in range(9, 0, -1):\n c = cost[i-1]\n res = dfs(remain - c)\n if res == '0': continue\n res = str(i) + res\n if len(ans) > len(res): continue\n if ans == '0' or len(res) > len(ans) or res > ans:\n ans = res\n cache[remain] = ans\n return ans\n\n ans = dfs(target)\n return ans\n \n ","memory":"36700"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # 判断状态 - 1. remaining cost\n # 不知道 一共要多少个digits 但是要找largest\n # 越多 digits 开头约大\n @cache\n def dfs(remain):\n if remain == 0:\n return ''\n if remain < 0: return '0'\n # if remain in cache: return cache[remain]\n ans = '0'\n for i in range(9, 0, -1):\n c = cost[i-1]\n res = dfs(remain - c)\n if res == '0': continue\n res = str(i) + res\n if len(ans) > len(res): continue\n if ans == '0' or len(res) > len(ans) or res > ans:\n ans = res\n # cache[remain] = ans\n return ans\n\n ans = dfs(target)\n return ans\n \n ","memory":"36900"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # i: curr digit, rem: remaining target\n n = len(cost)\n\n def bigger(a, b):\n if len(a) != len(b):\n return len(a) > len(b)\n return a > b\n\n @cache\n def dfs(i, target):\n if target == 0:\n return \"\"\n if target < 0 or i == n + 1:\n return \"#\"\n # take this digit\n take = str(i) + dfs(1, target - cost[i - 1])\n # don't take this digit\n skip = dfs(i + 1, target)\n\n if '#' in take and '#' not in skip:\n return skip\n if '#' not in take and '#' in skip:\n return take\n \n return take if bigger(take, skip) else skip\n\n res = dfs(1, target)\n dfs.cache_clear()\n if '#' in res:\n return '0'\n return res\n","memory":"39000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n m = min(cost)\n @cache\n def l(t):\n if t == 0:\n return 0\n if t < m:\n return -inf\n return 1+max(l(t-c) for c in cost)\n @cache\n def f(t):\n if t == 0:\n return ''\n if (x := l(t)) != -inf:\n for i in range(9,0,-1):\n c = cost[i-1]\n if c <= t and 1+l(t-c) == x:\n return str(i)+f(t-c)\n return '0' if (result := f(target)) is None else result","memory":"39100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n # this is a dp problem.\n # if x > y, and a is a digit string, then a.x > a.y where . is the string concatenation (because len(x) >= len(y))\n # so we can try all digits.\n # states = number of possible remaining targets = 5000. transitions = 9.\n self.cost = cost\n result = self.rec(target)\n if result is None or result == \"\":\n return \"0\"\n return result\n @cache\n def rec(self, target: int) -> str:\n if target == 0:\n return \"\"\n candidates = []\n for digit in range(9):\n if self.cost[digit] <= target:\n rec = self.rec(target-self.cost[digit])\n if rec is not None:\n candidates.append(str(digit+1) + rec)\n if candidates == []:\n return None\n return max(candidates, key=lambda s: (len(s), s)) # integer order: biggest length first, then lexicographic order","memory":"45200"},{"code":"class Solution:\n def largestNumber(self, nums: List[int], target: int) -> str:\n n = len(nums)\n from_ = [[(-1,-1)] * (target + 1) for _ in range(n)]\n\n @cache\n def dfs(i: int, j: int) -> int:\n if i < 0:\n return 0 if j == 0 else -inf\n if j < nums[i]:\n from_[i][j] = (i-1, j)\n return dfs(i-1, j) # 只能不选\n res1 = dfs(i-1, j) # 不选\n res2 = dfs(i, j-nums[i]) + 1 # 选\n if res1 > res2:\n from_[i][j] = (i-1, j)\n else:\n from_[i][j] = (i, j-nums[i])\n return max(res1, res2)\n ans = dfs(n-1, target)\n if ans == -inf:\n return \"0\"\n\n i = n-1\n j = target\n path = []\n while i >= 0:\n f = from_[i][j]\n if f[0] == i:\n path.append(str(i+1))\n i, j = f\n return \"\".join(path)\n ","memory":"74600"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n\n memo = {}\n\n def solve(ind,digit):\n if (ind,digit) in memo: return memo[(ind,digit)]\n if digit==target and ind>=len(cost): return \"\"\n if digit > target or ind>=len(cost): return \"0\"\n\n # notTake\n notTake = solve(ind+1,digit) \n\n # take\n take = str(ind+1) + solve(0,digit+cost[ind])\n \n if '0' in take: memo[(ind,digit)] = notTake\n elif '0' in notTake: memo[(ind,digit)] = take\n elif len(take) > len(notTake): memo[(ind,digit)] = take\n else: memo[(ind,digit)] = notTake \n \n return memo[(ind,digit)]\n\n return solve(0,0)\n ","memory":"79200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n if target == 5000:\n return '9'* 5000\n cache = {}\n def bruteforce(index: int,currScore):\n if (index, currScore) in cache:\n return cache[(index, currScore)]\n if (currScore > target or index == len(cost)):\n return '0'\n if currScore == target:\n return ''\n \n s1 = bruteforce(index+1, currScore)\n s2 = bruteforce(0, currScore + cost[index]) + str(index+1)\n s1 = int(s1) if s1[0] != '0' else 0\n s2 = int(s2) if s2[0] != '0' else 0\n \n cache[(index, currScore)] = str(max(s1,s2))\n return cache[(index, currScore)]\n \n result = bruteforce(0, 0)\n return result if '0' not in result else '0'\n \n def getBigger(self, num1, num2):\n if '0' in num2:\n print(\"num2: \", num2)\n return num1\n elif '0' in num1:\n print(\"num1: \", num1)\n return num2\n elif int(num1)>int(num2):\n return num1 \n else:\n return num2","memory":"83500"},{"code":"from functools import cache\nfrom typing import List\n\nclass Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n \n @cache\n def helper(i, c):\n # Base case: if the target cost is exactly 0, we have a valid number\n if c == 0:\n return 0\n # If we've exhausted all digits or the cost goes negative, return negative infinity\n if i == N or c < 0:\n return -float('inf')\n # Choose the maximum between not using the current digit or using it\n return max(helper(i + 1, c), 1 + helper(i, c - cost[i]))\n \n # Calculate the maximum number of digits we can form with the given target\n e = helper(0, target)\n \n # If it's impossible to form any number, return \"0\"\n if e == -float('inf'):\n return \"0\"\n \n # Construct the largest number by iterating over the number of digits\n for i in range(e):\n # Try to place the largest possible digit at each position\n for j in reversed(range(1, 10)):\n # Check if the current digit can be used and if it leads to a valid solution\n if cost[j - 1] <= target and helper(0, target - cost[j - 1]) == e - i - 1:\n target -= cost[j - 1]\n s += str(j)\n break\n \n return s","memory":"90500"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","memory":"94000"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","memory":"94100"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n N = len(cost)\n s = \"\"\n @cache\n def helper(i,c):\n if c==0:\n return 0\n if i==N or c<0:\n return -float('inf')\n return max(helper(i+1,c),\n 1 + helper(i,c-cost[i]))\n e =helper(0,target)\n if e== -float('inf'):\n return \"0\"\n for i in range(e):\n for j in reversed(range(1,10)):\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\n target-= cost[j-1]\n s+=str(j)\n return s\n ","memory":"94200"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n sys.set_int_max_str_digits(5000)\n @cache\n def dfs(index, remain):\n if remain == 0:\n return \"\"\n if index == len(cost) + 1 or remain < 0:\n return \"0\"\n\n take = str(index) + dfs(1, remain - cost[index - 1])\n skip = dfs(index + 1, remain)\n\n if \"0\" in take:\n return skip\n if \"0\" in skip:\n return take\n return take if int(take) > int(skip) else skip \n \n ans = dfs(1, target) \n return ans if \"0\" not in ans else \"0\"","memory":"94600"},{"code":"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n from_ = {}\n @cache\n def dfs(i: int, j: int) -> int:\n if j == 0:\n return 0\n if i < 0: # j > 0\n return -inf\n # not choose\n res = dfs(i-1, j)\n from_[(i, j)] = (i-1, j)\n # choose\n if j >= cost[i]:\n r = dfs(i, j-cost[i]) + 1\n if r >= res:\n res = r\n from_[(i, j)] = (i, j-cost[i])\n return res\n n = len(cost)\n if dfs(n-1, target) == -inf:\n return \"0\"\n \n ans = []\n p = (n-1, target)\n while p in from_:\n f = from_[p]\n if f[0] == p[0]:\n ans.append(str(p[0]+1))\n else: # 不选 str(p[0]+1)\n pass\n p = f\n return \"\".join(ans)","memory":"106600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [0] * (target+1)\\n for i in range(target):\\n if dp[i] or i==0:\\n for c in cost:\\n if i+c < len(dp):\\n dp[i+c] = max(dp[i+c],dp[i]+1)\\n digits = dp[target]\\n current = target\\n result = ''\\n while digits:\\n for i in range(8,-1,-1):\\n if digits != 1 and current - cost[i] > 0 and dp[current - cost[i]] == digits - 1:\\n digits-=1\\n current -= cost[i]\\n result += str(i+1)\\n break\\n elif digits == 1 and current - cost[i] == 0:\\n result += str(i+1)\\n return result\\n return result if result != \\\"\\\" else \\\"0\\\"\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [0] * (target+1)\\n for i in range(target):\\n if dp[i] or i==0:\\n for c in cost:\\n if i+c < len(dp):\\n dp[i+c] = max(dp[i+c],dp[i]+1)\\n digits = dp[target]\\n current = target\\n result = ''\\n while digits:\\n for i in range(8,-1,-1):\\n if digits != 1 and current - cost[i] > 0 and dp[current - cost[i]] == digits - 1:\\n digits-=1\\n current -= cost[i]\\n result += str(i+1)\\n break\\n elif digits == 1 and current - cost[i] == 0:\\n result += str(i+1)\\n return result\\n return result if result != \\\"\\\" else \\\"0\\\"\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Create a dp array to store the maximum length of the number that can be formed\\n dp = [-1] * (target + 1)\\n dp[0] = 0 # Base case: 0 cost can form a number of length 0\\n\\n # Function to get the maximum of two strings\\n def get_max_str(str1, str2):\\n if str1 == \\\"0\\\":\\n return str2\\n if str2 == \\\"0\\\":\\n return str1\\n return max(str1, str2, key=lambda x: (len(x), x))\\n\\n # Fill the dp array\\n for t in range(1, target + 1):\\n for i, c in enumerate(cost):\\n if c <= t and dp[t - c] != -1:\\n dp[t] = max(dp[t], dp[t - c] + 1)\\n\\n # If it's impossible to form a number with the target cost\\n if dp[target] == -1:\\n return \\\"0\\\"\\n\\n # Reconstruct the number\\n result = \\\"\\\"\\n t = target\\n while t > 0:\\n for i in range(8, -1, -1):\\n if cost[i] <= t and dp[t - cost[i]] == dp[t] - 1:\\n result += str(i + 1)\\n t -= cost[i]\\n break\\n\\n return result\\n\\n# Example usage:\\nsolution = Solution()\\ncost = [4, 3, 2, 5, 6, 7, 2, 5, 5]\\ntarget = 9\\nprint(solution.largestNumber(cost, target)) # Output: \\\"7772\\\"\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n the largest number must have max length\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max length of num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\\n optimization:space\\n '''\\n dp = [-float(\\\"inf\\\")]*(target+1)\\n dp[0]= 0\\n for i in range(9):\\n for j in range(target+1):\\n dp[j] = dp[j]\\n if j-cost[i]>=0:\\n dp[j] = max(dp[j], (dp[j-cost[i]] + 1))\\n length = dp[-1]\\n if length < 0:\\n return \\\"0\\\"\\n '''\\n loop from the digit 9 to digit 1\\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\\n '''\\n res = []\\n j = target\\n for i in range(8,-1,-1):\\n c = cost[i]\\n while j-c>=0 and dp[j] == dp[j-c]+1:\\n res.append(str(i+1))\\n j -= c\\n return \\\"\\\".join(res)\\n\\n\\n\\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Initialize dp array, dp[i] represents the maximum length of the number with cost i\\n dp = [-1] * (target + 1)\\n dp[0] = 0 # Base case, cost 0 can form a number of length 0\\n\\n # Iterate through each digit and its cost\\n for digit in range(1, 10):\\n c = cost[digit - 1] # Cost of the current digit\\n for i in range(c, target + 1):\\n # If it's possible to form a number with the remaining cost\\n if dp[i - c] != -1:\\n dp[i] = max(dp[i], dp[i - c] + 1)\\n\\n # If it's not possible to form any number with the target cost\\n if dp[target] == -1:\\n return \\\"0\\\"\\n\\n # Construct the largest number by backtracking\\n result = []\\n curr_target = target\\n for digit in reversed(range(1, 10)):\\n c = cost[digit - 1]\\n while curr_target >= c and dp[curr_target - c] == dp[curr_target] - 1:\\n result.append(str(digit))\\n curr_target -= c\\n\\n return ''.join(result)\\n\\n# Example usage:\\nsolution = Solution()\\ncost = [4,3,2,5,6,7,2,5,5]\\ntarget = 9\\nprint(solution.largestNumber(cost, target)) # Output: \\\"7772\\\"\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\\n\\n\\n 不使用当前数字 i+1： dp[i+1][j] = dp[i][j]（继承前一个状态）\\n 使用当前数字 i+1： dp[i+1][j] = dp[i+1][j - cost[i]] + 1（选择使用数字，并更新为更大的数字长度）\\n\\n optimization:space\\n '''\\n dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n # dp[0] = [0]*(target+1)\\n # for i in range(9):\\n # for j in range(target+1):\\n # dp[i+1][j] = dp[i][j]\\n # if j-cost[i]>=0:\\n # last = dp[i+1][j-cost[i]]\\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\\n # return dp[-1][-1]\\n\\n\\n # # where[i][j]表示从dp[i][j]来的上一步的花费\\n # where = [[0] * (target + 1) for _ in range(10)]\\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n # # 遍历每一个数字（数字从1到9，索引从0到8）\\n # for i, c in enumerate(cost):\\n # for j in range(target + 1):\\n # if j < c:\\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # # 否则，判断是选择不使用数字i+1，还是使用它\\n # if dp[i][j] > dp[i + 1][j - c] + 1:\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\\n # where[i + 1][j] = j - c\\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n # if dp[9][target] < 0:\\n # return \\\"0\\\"\\n # # 回溯路径，构造答案\\n # ans = list()\\n # i, j = 9, target\\n # while i > 0:\\n # if j == where[i][j]:\\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n # else:\\n # ans.append(str(i)) # 记录使用的数字\\n # j = where[i][j] # 更新花费\\n # return \\\"\\\".join(ans)\\n\\n dp = [-float('inf')] * (target + 1)\\n dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\\n \\n # 动态规划，计算最大可以获得的数字长度\\n for i, c in enumerate(cost):\\n for j in range(c, target + 1):\\n if dp[j - c] != -float('inf'):\\n dp[j] = max(dp[j], dp[j - c] + 1)\\n \\n # 如果target无解，直接返回0\\n if dp[target] < 0:\\n return \\\"0\\\"\\n \\n # 从最大长度开始构造结果\\n res = []\\n j = target\\n for i in range(8, -1, -1): # 从最大数字9开始尝试\\n c = cost[i]\\n while j >= c and dp[j] == dp[j - c] + 1:\\n res.append(str(i + 1))\\n j -= c\\n \\n return ''.join(res)\\n\\n\\n\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n the largest number must have max length\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max length of num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\\n optimization:space\\n '''\\n dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n dp[0][0] = 0\\n for i in range(9):\\n for j in range(target+1):\\n dp[i+1][j] = dp[i][j]\\n if j-cost[i]>=0:\\n dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\\n length = dp[-1][-1]\\n if length < 0:\\n return \\\"0\\\"\\n '''\\n loop from the digit 9 to digit 1\\n when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\\n '''\\n res = []\\n j = target\\n for i in range(8,-1,-1):\\n c = cost[i]\\n while j-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\\n res.append(str(i+1))\\n j -= c\\n return \\\"\\\".join(res)\\n\\n # dp = [[-float('inf')] * (target + 1) for _ in range(10)]\\n # dp[0][0] = 0 # 如果总和为 0，可以用长度为 0 的数字\\n # for i in range(9):\\n # for j in range(target + 1):\\n # # 不使用第 i+1 个数字\\n # dp[i + 1][j] = dp[i][j]\\n # if j >= cost[i] and dp[i + 1][j - cost[i]] != -float('inf'):\\n # dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - cost[i]] + 1)\\n # # 如果无法达到目标值，返回 0\\n # if dp[9][target] < 0:\\n # return \\\"0\\\"\\n # # 构造最大数字，从 dp 表倒推结果\\n # res = []\\n # j = target\\n # for i in range(8, -1, -1): # 从数字9开始倒序尝试\\n # while j >= cost[i] and dp[i + 1][j] == dp[i + 1][j - cost[i]] + 1:\\n # res.append(str(i + 1))\\n # j -= cost[i]\\n # return ''.join(res)\\n\\n\\n\\n\\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\\n # dp = [[float(\\\"-inf\\\")] * (target + 1) for _ in range(10)]\\n # where[i][j]表示从dp[i][j]来的上一步的花费\\n # where = [[0] * (target + 1) for _ in range(10)]\\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n # # 遍历每一个数字（数字从1到9，索引从0到8）\\n # for i, c in enumerate(cost):\\n # for j in range(target + 1):\\n # if j < c:\\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # # 否则，判断是选择不使用数字i+1，还是使用它\\n # if dp[i][j] > dp[i + 1][j - c] + 1:\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\\n # where[i + 1][j] = j - c\\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n # if dp[9][target] < 0:\\n # return \\\"0\\\"\\n # # 回溯路径，构造答案\\n # ans = list()\\n # i, j = 9, target\\n # while i > 0:\\n # if j == where[i][j]:\\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n # else:\\n # ans.append(str(i)) # 记录使用的数字\\n # j = where[i][j] # 更新花费\\n # return \\\"\\\".join(ans)\\n\\n\\n # dp = [-float('inf')] * (target + 1)\\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\\n # # 动态规划，计算最大可以获得的数字长度\\n # for i, c in enumerate(cost):\\n # for j in range(c, target + 1):\\n # if dp[j - c] != -float('inf'):\\n # dp[j] = max(dp[j], dp[j - c] + 1)\\n # # 如果target无解，直接返回0\\n # if dp[target] < 0:\\n # return \\\"0\\\"\\n # # 从最大长度开始构造结果\\n # res = []\\n # j = target\\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\\n # c = cost[i]\\n # while j >= c and dp[j] == dp[j - c] + 1:\\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\\n # res.append(str(i + 1))\\n # j -= c\\n # return ''.join(res)\\n\\n\\n\\n\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"'''\\ndp[i][j] is the max length of the digits using cost[0...i] and cost is j.\\n\\ndp[i][j] = max(dp[i-1][j], dp[i][j-cost[i]] + 1)\\ndp[-1][*] = -1\\ndp[*][0] = 0\\n\\n\\n'''\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [-1] * (1 + target)\\n dp[0] = 0\\n for c in cost:\\n for j in range(c, 1 + target):\\n if dp[j - c] != -1:\\n dp[j] = max(dp[j], dp[j - c] + 1)\\n print(dp)\\n if dp[-1] < 0:\\n return \\\"0\\\"\\n ans = []\\n\\n for d in range(9, 0, -1):\\n c = cost[d-1]\\n while target >= c and dp[target] == dp[target-c] + 1:\\n target -= c\\n ans.append(str(d))\\n return ''.join(ans)\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n the largest number must have max length\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max length of num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\\n optimization:space\\n '''\\n dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n # dp[0] = [0]*(target+1)\\n # for i in range(9):\\n # for j in range(target+1):\\n # dp[i+1][j] = dp[i][j]\\n # if j-cost[i]>=0:\\n # dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\\n # length = dp[-1][-1]\\n # if length == 0:\\n # return 0\\n # '''\\n # loop from the digit 9 to digit 1\\n # when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\\n # '''\\n # res = []\\n # j = target\\n # for i in range(8,-1,-1):\\n # c = cost[i]\\n # while target-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\\n # res.append(str(i+1))\\n # j -= c\\n # return \\\"\\\".join(res)\\n\\n # dp[i][j]: 使用前 i 个数字，总和为 j 时的最大数字长度\\n dp = [[-float('inf')] * (target + 1) for _ in range(10)]\\n dp[0][0] = 0 # 如果总和为 0，可以用长度为 0 的数字\\n\\n # 动态规划计算最大数字位数\\n for i in range(9):\\n for j in range(target + 1):\\n # 不使用第 i+1 个数字\\n dp[i + 1][j] = dp[i][j]\\n if j >= cost[i] and dp[i + 1][j - cost[i]] != -float('inf'):\\n dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - cost[i]] + 1)\\n\\n # 如果无法达到目标值，返回 0\\n if dp[9][target] < 0:\\n return \\\"0\\\"\\n\\n # 构造最大数字，从 dp 表倒推结果\\n res = []\\n j = target\\n for i in range(8, -1, -1): # 从数字9开始倒序尝试\\n while j >= cost[i] and dp[i + 1][j] == dp[i + 1][j - cost[i]] + 1:\\n res.append(str(i + 1))\\n j -= cost[i]\\n\\n return ''.join(res)\\n\\n\\n\\n\\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\\n # dp = [[float(\\\"-inf\\\")] * (target + 1) for _ in range(10)]\\n # where[i][j]表示从dp[i][j]来的上一步的花费\\n # where = [[0] * (target + 1) for _ in range(10)]\\n # dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n # # 遍历每一个数字（数字从1到9，索引从0到8）\\n # for i, c in enumerate(cost):\\n # for j in range(target + 1):\\n # if j < c:\\n # # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # # 否则，判断是选择不使用数字i+1，还是使用它\\n # if dp[i][j] > dp[i + 1][j - c] + 1:\\n # dp[i + 1][j] = dp[i][j]\\n # where[i + 1][j] = j\\n # else:\\n # dp[i + 1][j] = dp[i + 1][j - c] + 1\\n # where[i + 1][j] = j - c\\n # # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n # if dp[9][target] < 0:\\n # return \\\"0\\\"\\n # # 回溯路径，构造答案\\n # ans = list()\\n # i, j = 9, target\\n # while i > 0:\\n # if j == where[i][j]:\\n # i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n # else:\\n # ans.append(str(i)) # 记录使用的数字\\n # j = where[i][j] # 更新花费\\n # return \\\"\\\".join(ans)\\n\\n\\n # dp = [-float('inf')] * (target + 1)\\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\\n # # 动态规划，计算最大可以获得的数字长度\\n # for i, c in enumerate(cost):\\n # for j in range(c, target + 1):\\n # if dp[j - c] != -float('inf'):\\n # dp[j] = max(dp[j], dp[j - c] + 1)\\n # # 如果target无解，直接返回0\\n # if dp[target] < 0:\\n # return \\\"0\\\"\\n # # 从最大长度开始构造结果\\n # res = []\\n # j = target\\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\\n # c = cost[i]\\n # while j >= c and dp[j] == dp[j - c] + 1:\\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\\n # res.append(str(i + 1))\\n # j -= c\\n # return ''.join(res)\\n\\n\\n\\n\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n # Use copy to prevent modification on previous storage.\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n # Use copy to prevent modification on previous storage.\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No used digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1:\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1])\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n if max_usage[iterated_target] == -1: # New combo is the 1st found combo.\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n continue\\n\\n if usage_count > max_usage[iterated_target]:\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n continue\\n \\n if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target] = used_digits\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def create_largest_integer(digits: list[int], return_str: bool = False) -> str | int:\\n digits.sort(reverse=True)\\n if len(digits) <= 0:\\n digits.append(0)\\n \\n digit_str = \\\"\\\".join(str(digit) for digit in digits)\\n return digit_str if return_str else int(digit_str)\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n max_digits = [[] for _ in range(1 + target)]\\n\\n for iterated_target in range(1, target + 1):\\n for digit_idx, iterated_cost in enumerate(cost):\\n if iterated_target < iterated_cost: # Current cost can't build up target.\\n continue\\n \\n usage_count = max_usage[iterated_target - iterated_cost]\\n # Use copy to prevent modification on previous storage.\\n used_digits = max_digits[iterated_target - iterated_cost].copy()\\n if usage_count != -1: # New combo found.\\n usage_count += 1 # Plus 1: usage of current cost.\\n used_digits.append(digit_idx + 1) # Another digit is used.\\n\\n # if usage_count > max_usage[iterated_target]:\\n # max_usage[iterated_target] = usage_count\\n # max_digits[iterated_target].clear()\\n # max_digits[iterated_target].extend(used_digits)\\n # continue\\n \\n # if usage_count == max_usage[iterated_target]:\\n if self.create_largest_integer(used_digits) > self.create_largest_integer(max_digits[iterated_target]):\\n max_usage[iterated_target] = usage_count\\n max_digits[iterated_target].clear()\\n max_digits[iterated_target].extend(used_digits)\\n\\n return self.create_largest_integer(max_digits[target], True)\\n\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Assume both combos have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use the largest digit.\\n\\n # Base case: 0 target needs no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit costt exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No used digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n @staticmethod\\n def compare_digits_combo(old_combo: list[str], new_combo: list[str]) -> bool:\\n \\\"\\\"\\\"Both combos must have the same number of digits.\\\"\\\"\\\"\\n old_combo.sort(reverse=True)\\n new_combo.sort(reverse=True)\\n for old_digit, new_digit in zip(old_combo, new_combo):\\n if old_digit > new_digit:\\n return False\\n if old_digit < new_digit:\\n return True\\n return False\\n\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if len(set(cost)) == 1: # Base case: all digits cost the same.\\n if target % cost[-1] != 0:\\n return \\\"0\\\"\\n return \\\"9\\\" * (target // cost[-1]) # Always use largest digit.\\n\\n # Base case: 0 target has no digits at all.\\n max_usage = [0] + [-1 for _ in range(target)]\\n digits_combo = [[] for _ in range(1 + target)]\\n\\n for iter_target in range(1, target + 1):\\n for digit_idx, digit_cost in enumerate(cost):\\n if iter_target < digit_cost: # Digit cost exceeds target.\\n continue\\n \\n digits_usage = max_usage[iter_target - digit_cost]\\n if digits_usage != -1: # New combo found.\\n digits_usage += 1 # Plus 1: usage of another digit.\\n\\n # Use copy to prevent modification on previous storage.\\n used_digits = digits_combo[iter_target - digit_cost].copy()\\n used_digits.append(str(digit_idx + 1)) # Another digit joins.\\n\\n if digits_usage > max_usage[iter_target]:\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n continue\\n \\n if digits_usage == max_usage[iter_target]:\\n if self.compare_digits_combo(digits_combo[iter_target], used_digits):\\n max_usage[iter_target] = digits_usage\\n digits_combo[iter_target].clear()\\n digits_combo[iter_target].extend(used_digits)\\n\\n if not digits_combo[target]: # No digits at all.\\n return \\\"0\\\"\\n return \\\"\\\".join(digits_combo[target])\\n\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, nums: List[int], target: int) -> str:\\n n = len(nums)\\n dp = [[-inf] * (target + 1) for _ in range(n + 1)]\\n dp[0][0] = 0\\n fm = [[0] * (target + 1) for _ in range(n + 1)]\\n for i in range(n):\\n for j in range(target + 1):\\n dp[i + 1][j] = dp[i][j]\\n fm[i + 1][j] = j\\n if j >= nums[i]:\\n dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - nums[i]] + 1)\\n if dp[i + 1][j] > dp[i + 1][j - nums[i]] + 1:\\n fm[i + 1][j] = j\\n else:\\n dp[i + 1][j] = dp[i + 1][j - nums[i]] + 1\\n fm[i + 1][j] = j - nums[i]\\n \\n t = dp[n][target]\\n\\n if t == -inf:\\n return \\\"0\\\"\\n \\n i = 9\\n j = target\\n ans = \\\"\\\"\\n while i > 0:\\n g = fm[i][j]\\n if g == j:\\n i-= 1\\n else:\\n p = ord('0') + i\\n ans += chr(p)\\n j = fm[i][j]\\n return ans\\n \\n\\n \\n \\n \\n \\n\\n \\n \",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n max_digit_counts = [[float('-inf')] * (target + 1) for _ in range(10)]\\n max_digit_counts[0][0] = 0 # Base case: zero cost leads to zero digits\\n \\n # Initialize a table for backtracking the choices made\\n choice_backtrack = [[0] * (target + 1) for _ in range(10)]\\n \\n # Fill the tables with dynamic programming approach\\n for digit, single_cost in enumerate(cost, start=1):\\n for budget in range(target + 1):\\n if budget < single_cost or max_digit_counts[digit][budget - single_cost] + 1 < max_digit_counts[digit - 1][budget]:\\n # If we don't take the current digit\\n max_digit_counts[digit][budget] = max_digit_counts[digit - 1][budget]\\n choice_backtrack[digit][budget] = budget\\n else:\\n # Take the current digit\\n max_digit_counts[digit][budget] = max_digit_counts[digit][budget - single_cost] + 1\\n choice_backtrack[digit][budget] = budget - single_cost\\n \\n # If we cannot reach the target with the given costs, return \\\"0\\\"\\n if max_digit_counts[9][target] < 0:\\n return \\\"0\\\"\\n \\n # Backtrack from the filled tables to find the largest number\\n result = []\\n current_digit, current_budget = 9, target\\n while current_digit > 0:\\n if current_budget == choice_backtrack[current_digit][current_budget]:\\n # Move to the previous digit if no current digit is taken\\n current_digit -= 1\\n else:\\n # Add the current digit to the result and update the budget\\n result.append(str(current_digit))\\n current_budget = choice_backtrack[current_digit][current_budget]\\n \\n # Join the list of digits to form the largest number string\\n return \\\"\\\".join(result)\",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n the largest number must have max length\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max length of num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + 1)]\\n optimization:space\\n '''\\n # dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n # dp[0] = [0]*(target+1)\\n # for i in range(9):\\n # for j in range(target+1):\\n # dp[i+1][j] = dp[i][j]\\n # if j-cost[i]>=0:\\n # dp[i+1][j] = max(dp[i+1][j], (dp[i+1][j-cost[i]] + 1))\\n # length = dp[-1][-1]\\n # if length == 0:\\n # return 0\\n # '''\\n # loop from the digit 9 to digit 1\\n # when dp[i+1][j] = dp[i+1][j-cost[i]]+1, means we need to include i in the result\\n # '''\\n # res = []\\n # j = target\\n # for i in range(8,-1,-1):\\n # c = cost[i]\\n # while target-c>=0 and dp[i+1][j] == dp[i+1][j-c]+1:\\n # res.append(str(i+1))\\n # j -= c\\n # return \\\"\\\".join(res)\\n\\n\\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\\n dp = [[float(\\\"-inf\\\")] * (target + 1) for _ in range(10)]\\n # where[i][j]表示从dp[i][j]来的上一步的花费\\n where = [[0] * (target + 1) for _ in range(10)]\\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n # 遍历每一个数字（数字从1到9，索引从0到8）\\n for i, c in enumerate(cost):\\n for j in range(target + 1):\\n if j < c:\\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n # 否则，判断是选择不使用数字i+1，还是使用它\\n if dp[i][j] > dp[i + 1][j - c] + 1:\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n dp[i + 1][j] = dp[i + 1][j - c] + 1\\n where[i + 1][j] = j - c\\n # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n if dp[9][target] < 0:\\n return \\\"0\\\"\\n # 回溯路径，构造答案\\n ans = list()\\n i, j = 9, target\\n while i > 0:\\n if j == where[i][j]:\\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n else:\\n ans.append(str(i)) # 记录使用的数字\\n j = where[i][j] # 更新花费\\n return \\\"\\\".join(ans)\\n\\n\\n # dp = [-float('inf')] * (target + 1)\\n # dp[0] = 0 # 如果target是0，那么可以使用0个数字，结果也是0\\n # # 动态规划，计算最大可以获得的数字长度\\n # for i, c in enumerate(cost):\\n # for j in range(c, target + 1):\\n # if dp[j - c] != -float('inf'):\\n # dp[j] = max(dp[j], dp[j - c] + 1)\\n # # 如果target无解，直接返回0\\n # if dp[target] < 0:\\n # return \\\"0\\\"\\n # # 从最大长度开始构造结果\\n # res = []\\n # j = target\\n # for i in range(8, -1, -1): # 从最大数字9开始尝试\\n # c = cost[i]\\n # while j >= c and dp[j] == dp[j - c] + 1:\\n # # 如果 dp[j] == dp[j - c] + 1，说明 j 这个位置是通过选择当前数字获得的，这样我们就知道在构建结果时要使用该数字。\\n # res.append(str(i + 1))\\n # j -= c\\n \\n # return ''.join(res)\\n\\n\\n\\n\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n '''\\n complete knapsack (can repeat the elements)\\n i+1 := the digit\\n cost[i] := cost\\n dp[i][j] to record the max num we can get\\n i := use the first i digits\\n j := when costs sum up to j\\n dp[i+1][j] = max(dp[i][j], (dp[i+1][j-cost[i+1]] + i*10**i) ]\\n optimization:space\\n '''\\n # dp = [[-float(\\\"inf\\\")]*(target+1) for _ in range(10)]\\n # dp[0] = [0]*(target+1)\\n # for i in range(9):\\n # for j in range(target+1):\\n # dp[i+1][j] = dp[i][j]\\n # if j-cost[i]>=0:\\n # last = dp[i+1][j-cost[i]]\\n # dp[i+1][j] = max(dp[i+1][j], (last + i*10**(len(str(last)))))\\n # return dp[-1][-1]\\n\\n\\n # dp[i][j]表示使用前i个数字，总花费为j时能够构成的最大数字长度\\n dp = [[float(\\\"-inf\\\")] * (target + 1) for _ in range(10)]\\n # where[i][j]表示从dp[i][j]来的上一步的花费\\n where = [[0] * (target + 1) for _ in range(10)]\\n dp[0][0] = 0 # 初始状态，花费为0时，可以构成0个数字\\n\\n # 遍历每一个数字（数字从1到9，索引从0到8）\\n for i, c in enumerate(cost):\\n for j in range(target + 1):\\n if j < c:\\n # 如果当前花费不足以使用数字i+1，则继承上一行的状态\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n # 否则，判断是选择不使用数字i+1，还是使用它\\n if dp[i][j] > dp[i + 1][j - c] + 1:\\n dp[i + 1][j] = dp[i][j]\\n where[i + 1][j] = j\\n else:\\n dp[i + 1][j] = dp[i + 1][j - c] + 1\\n where[i + 1][j] = j - c\\n \\n # 如果dp[9][target]小于0，说明无法凑出target，返回\\\"0\\\"\\n if dp[9][target] < 0:\\n return \\\"0\\\"\\n \\n # 回溯路径，构造答案\\n ans = list()\\n i, j = 9, target\\n while i > 0:\\n if j == where[i][j]:\\n i -= 1 # 如果当前花费等于上一行的花费，说明数字i没有被使用\\n else:\\n ans.append(str(i)) # 记录使用的数字\\n j = where[i][j] # 更新花费\\n \\n return \\\"\\\".join(ans)\\n\\n\\n\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n #dp[cost] = dp[cost - 1]\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i, prev_digit in enumerate(max_prev_digit):\\n if int(prev_digit) < digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n #print(dp)\\n return str(dp[-1])\",\n \"memory\": \"22000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i in range(n - 1, -1, -1):\\n prev_digit = max_prev_digit[i]\\n if int(prev_digit) > digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n return str(dp[-1])\",\n \"memory\": \"22000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n best_costs = defaultdict(int)\\n for i, price in enumerate(cost):\\n best_costs[price] = i + 1\\n \\n dp = [0 for _ in range(target + 1)]\\n for cost in range(1, target + 1):\\n for price, digit in best_costs.items():\\n if price > cost:\\n continue\\n \\n max_prev_digit = str(dp[cost - price])\\n if max_prev_digit == \\\"0\\\" and (cost - price) != 0:\\n continue \\n\\n n = len(max_prev_digit)\\n new_digit = \\\"\\\"\\n for i, prev_digit in enumerate(max_prev_digit):\\n if int(prev_digit) < digit: \\n new_digit = max_prev_digit[:i + 1] + str(digit) + max_prev_digit[i + 1: n]\\n break \\n\\n if not new_digit:\\n new_digit = max_prev_digit + str(digit)\\n\\n dp[cost] = max(dp[cost], int(new_digit))\\n\\n #print(dp)\\n return str(dp[-1])\",\n \"memory\": \"22100\"\n },\n {\n \"code\": \"sys.set_int_max_str_digits(50000)\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [0] + [-1] * (target + 5000)\\n for t in range(1, target + 1):\\n dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\\n return str(max(dp[t], 0))\",\n \"memory\": \"22200\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(6000) \\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n DP = [0]*(target+1)\\n\\n DP[1] = max([0]+[i+1 for i, c in enumerate(cost) if c==1])\\n\\n for t in range(1, target+1):\\n for i, c in enumerate(cost):\\n if c<t and DP[t-c]!=0:\\n DP[t] = max(DP[t], DP[t-c]*10+i+1)\\n if c==t:\\n DP[t] = max(DP[t], i+1)\\n \\n\\n return str(DP[-1])\\n \\n\\n # return max(self.helper(cost, target))\\n\\n # def helper(self, cost, target):\\n # if target==0:\\n # return [\\\"\\\"]\\n # if target<0:\\n # return [\\\"0\\\"]\\n \\n # nums = []\\n # for i, c in enumerate(cost):\\n # if c<=target:\\n # answer = self.helper(cost, target-c)\\n # nums += [f\\\"{i+1}{ans}\\\" for ans in answer if ans!=\\\"0\\\"]\\n # if nums==[]:\\n # return [\\\"0\\\"] \\n # return nums\\n\\n # cost_dict = {}\\n # for i, c in enumerate(cost):\\n # cost_dict[c] = i+1\\n # cost_store = sorted(list((cost_dict.items())), key=lambda x:x[0], reverse=False)\\n\\n # num = []\\n # ptr = 0\\n # n = len(cost_store)\\n\\n # # return cost_store\\n # while target!=0:\\n # if cost_store[ptr][0] > target: # need to back track\\n # ptr = ptr + 1\\n # if ptr==n:\\n # return \\\"0\\\"\\n # while cost_store[ptr][0] > target:\\n # if num==[]:\\n # return \\\"0\\\"\\n # target += cost[int(num.pop(-1))-1]\\n\\n\\n # target -= cost_store[ptr][0]\\n # num.append(str(cost_store[ptr][1]))\\n\\n # num.sort(reverse=True)\\n return \\\"\\\".join(num)\\n\",\n \"memory\": \"22300\"\n },\n {\n \"code\": \"import sys\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Increase the limit for integer string conversion\\n sys.set_int_max_str_digits(1000000) # Adjust this number as needed\\n\\n dp = [0] + [-1] * target\\n \\n for t in range(1, target + 1):\\n for d, c in enumerate(cost):\\n if c <= t and dp[t - c] != -1:\\n dp[t] = max(dp[t], dp[t - c] * 10 + d + 1)\\n \\n return str(max(dp[target], 0))\",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(5001)\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n n = len(cost)\\n cost = cost[::-1]\\n dp = [[-1 for i in range(target + 1)] for j in range(n+1)]\\n for i in range(n+1):\\n dp[i][0] = 0\\n for i in range(1, n+1):\\n for j in range(1, target + 1):\\n dp[i][j] = dp[i-1][j]\\n if j-cost[i-1] >= 0 and dp[i][j-cost[i-1]] != -1:\\n dp[i][j] = max(dp[i][j], dp[i][j - cost[i-1]]*10 + 9-i + 1)\\n return str(max(dp[-1][target], 0))\",\n \"memory\": \"22600\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n @lru_cache(None)\\n def solve(target):\\n if target < 0:\\n return float('-inf')\\n if target == 0:\\n return 0\\n res = float('-inf')\\n for i in cost:\\n res = max(res, 1+solve(target-i))\\n return res\\n temp = solve(target)\\n if temp == float('-inf'):return \\\"0\\\"\\n ans = \\\"\\\"\\n while target:\\n mx, res = 0, 0\\n for idx,i in enumerate(cost):\\n temp = solve(target-i)\\n if temp > mx:\\n mx = temp\\n res = idx+1\\n elif temp == mx:\\n res = max(res, idx+1)\\n ans += str(res)\\n target -= cost[res-1]\\n return ans\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int):\\n @lru_cache(None)\\n def solve(target):\\n if target < 0:\\n return float('-inf')\\n if target == 0:\\n return 0\\n res = float('-inf')\\n for i in cost:\\n res = max(res, 1+solve(target-i))\\n return res\\n temp = solve(target)\\n if temp == float('-inf'):return \\\"0\\\"\\n ans = \\\"\\\"\\n while target:\\n mx, res = 0, 0\\n for idx,i in enumerate(cost):\\n temp = solve(target-i)\\n if temp > mx:\\n mx = temp\\n res = idx+1\\n elif temp == mx:\\n res = max(res, idx+1)\\n ans += str(res)\\n target -= cost[res-1]\\n return ans\\n\\n \\n \",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n \\n cost = cost[::-1]\\n visited = set()\\n for i in range(len(cost)):\\n if cost[i] in visited:\\n cost[i] = -1\\n visited.add(cost[i])\\n\\n #print(cost)\\n #return '0'\\n\\n def comp(list1, list2):\\n if list2 is None:\\n return 1\\n \\n summ = sum(list1) - sum(list2)\\n if summ > 0:\\n return 1\\n if summ < 0:\\n return -1\\n for i in range(len(list1)):\\n if list1[i] > list2[i]:\\n return 1\\n if list1[i] < list2[i]:\\n return -1\\n \\n return 0\\n\\n @cache\\n def itero(idx, rem):\\n if rem < 0:\\n return None\\n if cost[idx] == -1:\\n if idx < 8:\\n return itero(idx+1, rem)\\n elif rem == 0:\\n return [0 for i in range(9)]\\n else:\\n return None \\n newval = None\\n if idx == 8:\\n if rem%cost[idx] == 0:\\n newval = [0 for i in range(9)]\\n newval[idx] = rem//cost[idx]\\n #print(idx, rem, newval)\\n return newval\\n else:\\n #print(idx, rem, newval)\\n return None\\n \\n if rem == 0:\\n #print(idx, rem, [0 for i in range(9)])\\n return [0 for i in range(9)]\\n \\n \\n for i in range((rem//cost[idx])+1):\\n result = itero(idx+1, rem - cost[idx]*i)\\n if result is not None:\\n result = [result[j] + (0 if idx != j else i) for j in range(9)]\\n if comp(result, newval) > 0:\\n newval = [el for el in result]\\n \\n #print(idx, rem, newval)\\n return newval\\n\\n\\n val = itero(0, target)\\n if val is None:\\n return '0'\\n return ''.join([str(9-idx)*val[idx] for idx in range(9)])\",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"from typing import List\\nimport sys\\n# Increase the limit for the maximum number of digits in an integer string conversion\\nsys.set_int_max_str_digits(10000)\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Map cost to corresponding digit, ensuring largest digit comes first\\n cost_to_digit = {}\\n for i in range(len(cost)):\\n cost_to_digit[cost[i]] = max(cost_to_digit.get(cost[i], 0), i + 1)\\n \\n # Sort costs in ascending order\\n sorted_costs = sorted(cost_to_digit.items())\\n\\n # Memoization dictionary\\n memo = {}\\n \\n def dfs(tar):\\n if tar == 0:\\n return 0 # Return 0 to represent the number as an integer\\n if tar in memo:\\n return memo[tar]\\n \\n max_num = -float('inf')\\n for cost, digit in sorted_costs:\\n if cost <= tar:\\n num = dfs(tar - cost)\\n if num != -float('inf'):\\n max_num = max(max_num, num * 10 + digit)\\n else:\\n break\\n \\n memo[tar] = max_num\\n return max_num\\n \\n # Get the result and convert it to string\\n result = dfs(target)\\n return str(result) if result != -float('inf') else \\\"0\\\"\",\n \"memory\": \"25800\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # 這題數字可以是1~9\\n # 有9種可能\\n # 如果用dfs 的話 最大複雜度\\n # 9^5000 9的5千次方 顯然不太實\\n # 把 cost 當作 coin\\n # 同cost 只要留下數字大的就好\\n coin = Counter()\\n for i in range(9):\\n coin[cost[i]]=max(coin[cost[i]],i+1)\\n #print(coin)\\n coins = sorted(coin.keys()) \\n #用 1~target 這個是可以重複用 然後用最多的那種coin change\\n dp =[\\\"\\\"]*(target+1)\\n #print(\\\"coins\\\",coins)\\n for c in coins:\\n if c <= target:\\n dp[c]=str(coin[c])\\n for j in range(coins[0],target+1):\\n for c in coins:\\n if j-c >= 0 and dp[j-c]!=\\\"\\\":\\n if len(dp[j]) < len(dp[j-c]+str(coin[c])):\\n dp[j] = dp[j-c]+str(coin[c])\\n elif len(dp[j]) == len(dp[j-c]+str(coin[c])):\\n dp[j] = max(dp[j],dp[j-c]+str(coin[c]))\\n #print(dp)\\n # 問題來了 就算我數量算對 但還要用這個數量去還原成string 該怎麼做呢\\n return \\\"\\\".join(sorted(dp[target],reverse=True)) if dp[target]!=\\\"\\\" else \\\"0\\\"\\n #這個 case 炸了cost = [5,6,7,3,4,6,7,4,8]\\n\",\n \"memory\": \"27600\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n import sys \\n sys.set_int_max_str_digits(10000)\\n \\n @lru_cache(None)\\n def dp(total):\\n if total == 0:\\n return 0\\n \\n str1 = float(\\\"-inf\\\")\\n for j in range(1,10):\\n if total-cost[j-1] >= 0:\\n str1 = max(str1,j+dp(total-cost[j-1])*10)\\n return str1\\n\\n val, s = dp(target), \\\"\\\"\\n if val == float(\\\"-inf\\\"):\\n return \\\"0\\\"\\n\\n return str(val)\\n\",\n \"memory\": \"28400\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost, target):\\n import sys \\n\\n sys.set_int_max_str_digits(10000)\\n\\n @lru_cache(None)\\n def function(total):\\n if total == 0:\\n return 0 \\n\\n str1 = float(\\\"-inf\\\")\\n\\n for j in range(1,10):\\n if total-cost[j-1] >= 0:\\n str1 = max(str1,j+function(total-cost[j-1])*10)\\n\\n return str1 \\n\\n val, s = function(target), \\\"\\\"\\n\\n if val == float(\\\"-inf\\\"):\\n return \\\"0\\\"\\n \\n return str(val)\",\n \"memory\": \"28500\"\n },\n {\n \"code\": \"from functools import lru_cache\\nimport sys\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n @lru_cache(None)\\n def dp(balance):\\n if balance == 0:\\n return 0\\n \\n res = float('-inf')\\n for i in range(9):\\n if balance - cost[i] >= 0:\\n res = max(res, (i+1) + dp(balance - cost[i]) * 10)\\n \\n return res\\n \\n res = dp(target)\\n return str(res) if res != float('-inf') else \\\"0\\\"\",\n \"memory\": \"28600\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(0)\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n self.d = {}\\n def top_down(t):\\n if t == 0: return 0\\n if t in self.d: return self.d[t]\\n cur = float('-inf')\\n for digit in range(1,10):\\n if (t-cost[digit-1]) >= 0:\\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\\n self.d[t] = cur\\n return cur\\n\\n res = top_down(target)\\n return str(res) if res != float('-inf') else \\\"0\\\"\\n\\n\\n# class Solution(object):\\n# def largestNumber(self, cost, target):\\n# ans = self.dfs(cost, 1, target)\\n# return ans if '0' not in ans else '0'\\n \\n# def dfs(self, cost, index, remain):\\n# \\t\\t# base cases\\n# if remain == 0:\\n# return ''\\n# elif remain < 0 or index == len(cost)+1:\\n# return '0'\\n \\n# \\t\\t# decisions \\n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \\n# skip = self.dfs(cost, index+1, remain) \\n\\t\\t\\n# \\t\\t# memoize and return the max of decisions\\n# return self.getBigger(take, skip) \\n \\n# def getBigger(self, num1, num2):\\n# if '0' in num2:\\n# return num1\\n# elif '0' in num1:\\n# return num2\\n# elif int(num1)>int(num2):\\n# return num1 \\n# else:\\n# return num2\\n\\n\\n# class Solution:\\n# def largestNumber(self, cost, target):\\n# dp = [0] + [-1] * (target + 5000)\\n# for t in range(1, target + 1):\\n# dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\\n# return str(max(dp[t], 0))\\n\\n# # def largestNumber(self, cost: List[int], target: int) -> str:\\n# # cost_map = {}\\n# # for i, v in enumerate(cost):\\n# # cost_map[i+1] = v\\n \\n# self.ans = 0\\n# dp = [''] * (target+1)\\n \\n# def get_max(a, b):\\n# if not a:\\n# a = '0'\\n# if not b:\\n# b = '0'\\n# if int(a) > int(b):\\n# return a\\n# return b\\n \\n# def get_cost(num, rem):\\n# ncost = 0\\n# for i in num:\\n# ncost += cost[int(i)-1]\\n# return ncost == rem\\n \\n# def helper(rem):\\n# num = ''\\n# # print(rem, mem)\\n# if dp[rem] == '':\\n \\n# if rem == 0:\\n# return ''\\n# if rem < 0:\\n# return float('-inf')\\n\\n# for i in range(len(cost)-1, -1, -1):\\n# # if cost[i] > rem:\\n# # continue\\n# val = helper(rem-cost[i])\\n# # \\n# if val == float('-inf'):\\n# continue\\n# num = get_max(num, str(i+1)+val)\\n# if get_cost(num, rem):\\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\\n# # else:\\n# # mem[rem] = ''\\n# return dp[rem]\\n \\n# # print(helper(cost, target, ''))\\n \\n# ans = str(helper(target))\\n# return ans if ans else '0'\",\n \"memory\": \"28700\"\n },\n {\n \"code\": \"import sys\\nsys.set_int_max_str_digits(0)\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n self.d = {}\\n def top_down(t):\\n if t == 0: return 0\\n if t in self.d: return self.d[t]\\n cur = float('-inf')\\n for digit in range(1,10):\\n if (t-cost[digit-1]) >= 0:\\n cur = max(cur, top_down(t-cost[digit-1])*10+digit)\\n self.d[t] = cur\\n return cur\\n\\n res = top_down(target)\\n return str(res) if res != float('-inf') else \\\"0\\\"\\n\\n\\n# class Solution(object):\\n# def largestNumber(self, cost, target):\\n# ans = self.dfs(cost, 1, target)\\n# return ans if '0' not in ans else '0'\\n \\n# def dfs(self, cost, index, remain):\\n# \\t\\t# base cases\\n# if remain == 0:\\n# return ''\\n# elif remain < 0 or index == len(cost)+1:\\n# return '0'\\n \\n# \\t\\t# decisions \\n# take = str(index) + self.dfs(cost, 1, remain-cost[index-1]) \\n# skip = self.dfs(cost, index+1, remain) \\n\\t\\t\\n# \\t\\t# memoize and return the max of decisions\\n# return self.getBigger(take, skip) \\n \\n# def getBigger(self, num1, num2):\\n# if '0' in num2:\\n# return num1\\n# elif '0' in num1:\\n# return num2\\n# elif int(num1)>int(num2):\\n# return num1 \\n# else:\\n# return num2\\n\\n\\n# class Solution:\\n# def largestNumber(self, cost, target):\\n# # dp = [0] + [-1] * (target + 5000)\\n# # for t in range(1, target + 1):\\n# # dp[t] = max(dp[t - c] * 10 + i + 1 for i, c in enumerate(cost))\\n# # return str(max(dp[t], 0))\\n\\n# # def largestNumber(self, cost: List[int], target: int) -> str:\\n# # cost_map = {}\\n# # for i, v in enumerate(cost):\\n# # cost_map[i+1] = v\\n \\n# self.ans = 0\\n# dp = [''] * (target+1)\\n \\n# def get_max(a, b):\\n# if not a:\\n# a = '0'\\n# if not b:\\n# b = '0'\\n# if int(a) > int(b):\\n# return a\\n# return b\\n \\n# def get_cost(num, rem):\\n# ncost = 0\\n# for i in num:\\n# ncost += cost[int(i)-1]\\n# return ncost == rem\\n \\n# def helper(rem):\\n# num = ''\\n# if rem == 0:\\n# return ''\\n# if rem < 0:\\n# return float('-inf')\\n# # print(rem, mem)\\n# if dp[rem] == '':\\n \\n \\n\\n# for i in range(len(cost)-1, -1, -1):\\n# # if cost[i] > rem:\\n# # continue\\n# val = helper(rem-cost[i])\\n# # \\n# if val == float('-inf'):\\n# continue\\n# num = get_max(num, str(i+1)+val)\\n# if get_cost(num, rem):\\n# dp[rem] = ''.join(sorted(list(num), reverse=True))\\n# # else:\\n# # mem[rem] = ''\\n# return dp[rem]\\n \\n# # print(helper(cost, target, ''))\\n \\n# ans = str(helper(target))\\n# return ans if ans else '0'\",\n \"memory\": \"28800\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = ['' for i in range(target+1)]\\n dp[0] = '0'\\n for i in range(1, target+1):\\n for k in range(1, 10):\\n t = i-cost[k-1]\\n if t<0 or len(dp[t])==0:\\n continue\\n v = ''.join(sorted(str(k)+dp[t], reverse=True))\\n # if i==target:\\n # print(k, v)\\n if len(v)>len(dp[i]) or (len(v)==len(dp[i]) and v>dp[i]):\\n dp[i]=v\\n # print(i, dp)\\n if dp[target]=='':\\n return '0'\\n return dp[target][:len(dp[target])-1]\\n \\n \\n \\n \\n \",\n \"memory\": \"29000\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Initialize dp array with an empty string for 0 cost and None for others\\n dp = [''] + [None] * target\\n \\n # Iterate over each possible cost\\n for t in range(1, target + 1):\\n for d in range(9):\\n if t >= cost[d] and dp[t - cost[d]] is not None:\\n candidate = dp[t - cost[d]] + str(d + 1)\\n if dp[t] is None or len(candidate) > len(dp[t]) or (len(candidate) == len(dp[t]) and candidate > dp[t]):\\n dp[t] = candidate\\n \\n return dp[target] if dp[target] is not None else \\\"0\\\"\\n\\n# Example usage:\\n# solution = Solution()\\n# print(solution.largestNumber([4,3,2,5,6,7,2,5,5], 9)) # Output: \\\"7772\\\"\\n# print(solution.largestNumber([7,6,5,5,5,6,8,7,8], 12)) # Output: \\\"85\\\"\\n# print(solution.largestNumber([2,4,6,2,4,6,4,4,4], 5)) # Output: \\\"0\\\"\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = ['#'] * (target + 1)\\n dp[0] = \\\"\\\"\\n \\n for t in range(1, target + 1):\\n for d in range(9):\\n if t >= cost[d]:\\n potential = dp[t - cost[d]]\\n if potential != '#':\\n # Create a new number by adding the current digit\\n candidate = str(d + 1) + potential\\n if dp[t] == '#' or len(candidate) > len(dp[t]) or (len(candidate) == len(dp[t]) and candidate > dp[t]):\\n dp[t] = candidate\\n \\n return dp[target] if dp[target] != '#' else \\\"0\\\"\\n\\n# Example usage:\\n# Create an object of the Solution class\\nsolution = Solution()\\n\\n# Test examples\\nprint(solution.largestNumber([4,3,2,5,6,7,2,5,5], 9)) # Output: \\\"7772\\\"\\nprint(solution.largestNumber([7,6,5,5,5,6,8,7,8], 12)) # Output: \\\"85\\\"\\nprint(solution.largestNumber([2,4,6,2,4,6,4,4,4], 5)) # Output: \\\"0\\\"\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(10000)\\n @cache\\n def dp(currCost):\\n if currCost == target: \\n return 0\\n \\n if currCost >= target:\\n return float(\\\"-inf\\\")\\n \\n res = float(\\\"-inf\\\")\\n for i in range(1, 10):\\n res = max(res, i +dp(currCost + cost[i - 1]) * 10)\\n \\n return res\\n\\n ans = dp(0)\\n if ans < 0:\\n return \\\"0\\\"\\n return str(ans)\\n \\n \\n\",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n def islarge(s1, s2):\\n if len(s1) > len(s2):\\n return True\\n if len(s1) < len(s2):\\n return False\\n for i in range(len(s1)):\\n if s1[i] < s2[i]:\\n return False\\n if s1[i] > s2[i]:\\n return True\\n return True\\n dp = [''] * (target+1)\\n for d in range(len(cost)):\\n for j in range(cost[d], len(dp)):\\n cur = ''\\n if len(dp[j-cost[d]]) >= 1 or j % cost[d] == 0:\\n cur = str(d+1) + dp[j-cost[d]]\\n dp[j] = cur if islarge(cur, dp[j]) else dp[j]\\n return dp[-1] if len(dp[-1]) >= 1 else '0'\",\n \"memory\": \"29500\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # Create a DP array with None (to signify uninitialized states)\\n dp = [None] * (target + 1)\\n dp[0] = '' # Base case: zero cost corresponds to an empty string\\n \\n # Fill DP array\\n for i in range(1, target + 1):\\n for digit in range(9, 0, -1): # Start from 9 to 1 to ensure the largest number\\n if i >= cost[digit - 1] and dp[i - cost[digit - 1]] is not None:\\n new_number = dp[i - cost[digit - 1]] + str(digit)\\n if dp[i] is None or len(new_number) > len(dp[i]) or (len(new_number) == len(dp[i]) and new_number > dp[i]):\\n dp[i] = new_number\\n \\n # Result is in dp[target], if it's None, return \\\"0\\\"\\n return dp[target] if dp[target] is not None else \\\"0\\\"\\n\\n\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n dp = [None] * (target + 1)\\n dp[0] = '' \\n for i in range(1, target + 1):\\n for digit in range(9, 0, -1): \\n if i >= cost[digit - 1] and dp[i - cost[digit - 1]] is not None:\\n new_number = dp[i - cost[digit - 1]] + str(digit)\\n if dp[i] is None or len(new_number) > len(dp[i]) or (len(new_number) == len(dp[i]) and new_number > dp[i]):\\n dp[i] = new_number\\n return dp[target] if dp[target] is not None else \\\"0\\\"\\n\\n\",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"from typing import *\\nimport math\\nimport inspect\\nimport random\\nfrom collections import *\\nimport copy\\nfrom functools import cmp_to_key\\n\\ndef printd(var : Any) -> None :\\n frame = inspect.currentframe().f_back\\n var_name = [name for name, val in frame.f_locals.items() if val is var]\\n name = var_name[-1] if var_name else \\\"???\\\"\\n print(f\\\"[ {name} ]: {var}\\\")\\n\\ndef mrand(begin: Union[int, float], end: Union[int, float]) -> Union[int, float]:\\n if isinstance(begin, int) and isinstance(end, int):\\n return random.randint(begin, end) # Inclusive range for integers\\n elif isinstance(begin, float) or isinstance(end, float):\\n return random.uniform(begin, end) # Inclusive range for floats\\n\\n raise ValueError(\\\"Both arguments must be either int or float.\\\")\\n\\nclass pair:\\n def __init__(self, _first : Any, _second : Any) -> None:\\n self.first = _first\\n self.second = _second\\n\\n def copy(self) -> 'pair' :\\n return pair(self.first, self.second)\\n\\n def __repr__(self) -> str :\\n return f\\\"({self.first}, {self.second})\\\"\\n\\n def __lt__(self, other: 'pair') -> bool:\\n return (self.first, self.second) < (other.first, other.second)\\n\\n def __gt__(self, other: 'pair') -> bool:\\n return (self.first, self.second) > (other.first, other.second)\\n\\n def __eq__(self, other: 'pair') -> bool:\\n return (self.first, self.second) == (other.first, other.second)\\n\\n def __ne__(self, other: 'pair') -> bool:\\n return (self.first, self.second) != (other.first, other.second)\\n\\ndef get_unique(arr: List[Any], compare: Callable[[Any, Any], bool] = None) -> None:\\n if compare == None:\\n compare = lambda a, b : -1 if a < b else 1\\n arr.sort(key=cmp_to_key(compare))\\n new_size = 0\\n for i in range(len(arr)):\\n if i == 0 or arr[i] != arr[i - 1]:\\n arr[new_size] = arr[i]\\n new_size += 1\\n arr[:] = arr[:new_size]\\n\\n\\nclass Solution:\\n def largestNumber(self, costs: List[int], target: int) -> str:\\n\\n def is_better(me : List[str], other : str) -> bool:\\n if len(me) != len(other):\\n return True if len(me) > len(other) else False\\n\\n for i in range(len(me)):\\n if me[i] != other[i]:\\n return True if me[i] > other[i] else False\\n\\n return False\\n\\n dp = [\\\"0\\\"] * (target + 1)\\n dp[0] = \\\"\\\"\\n for i in range(target):\\n if dp[i] == \\\"0\\\":\\n continue\\n me = [dp[i][j] for j in range(len(dp[i]))]\\n for v in range(1, 10):\\n whr = i + costs[v - 1]\\n if whr > target:\\n continue\\n\\n me.append(str(v))\\n if is_better(me, dp[whr]):\\n dp[whr] = \\\"\\\".join(me)\\n me.pop()\\n\\n return dp[target]\\n\\n\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n \\n @cache\\n def solve(budget):\\n if budget < 0:\\n return (-1,\\\"0\\\")\\n if budget==0:\\n return (0,\\\"\\\")\\n res = (-1,0,\\\"0\\\")\\n for j in range(9,0,-1):\\n if budget>=cost[j-1]:\\n Z = solve(budget-cost[j-1])\\n res = max(res,(Z[0],j,Z[1]))\\n \\n # print(budget, res)\\n if res[0] == -1:\\n return -1,\\\"0\\\"\\n return res[0]+1 , str(res[1])+res[2]\\n\\n return solve(target)[1]\\n\\n\\n \",\n \"memory\": \"34400\"\n },\n {\n \"code\": \"from functools import lru_cache\\n\\n\\nclass Solution:\\n def largestNumber(self, cost: list[int], target: int) -> str:\\n\\n # Determine if string a is greater than string b\\n def greater(a, b):\\n\\n # If their lengths are different, use their length to determine if a is greater than b\\n if len(a) != len(b):\\n return len(a) > len(b)\\n\\n # Else, check all digits one by one\\n for c1, c2 in zip(a,b):\\n\\n # If current digits of a and b are equal, continue to the next digits pair\\n if c1 == c2:\\n continue\\n\\n # Else, check if digit of a is greater than digit of b\\n return c1>c2\\n\\n # Return False if all digits are the same\\n return False\\n\\n # Save costs and their corresponding digits into a dict \\n # Override the smaller digit with a larger one if their costs are the same\\n costs = {c: str(i + 1) for i, c in enumerate(cost)}\\n\\n # Top-down dp to find the largest number giving a budget\\n @lru_cache(None)\\n def dp(budget):\\n\\n # If we have 0 budget left, we have reach the basecase, return (True, \\\"\\\")\\n if budget == 0:\\n return True, \\\"\\\"\\n\\n # Initialize varaibles to store the largest number and the boolean to indicate that there is a digit where if we were to pick such digit, we can form a number using all of the remaining budget\\n largestNum, ableToUseAll = \\\"\\\", False\\n\\n # Iterate through all digits\\n for cost, digit in costs.items():\\n\\n # If the current digit has a higher cost than the budget, skip it\\n if cost > budget:\\n continue\\n\\n # Else, if we were to pick such digit, can all of the remaining budget be used to form a number?\\n usedAll, nextNum = dp(budget - cost)\\n\\n # If yes\\n if usedAll:\\n\\n # Concatenate the picked digit with the next number to form the current number\\n num = digit + nextNum\\n\\n # If the current number is greater than previous number, save it\\n largestNum = num if greater(num, largestNum) else largestNum\\n\\n # Update the boolean to indicate that we have found a number that formed using all of the budget\\n ableToUseAll = ableToUseAll or usedAll\\n\\n # Return result if we were able to find a number formed using all of the budget\\n # Else, return \\\"0\\\"\\n return ableToUseAll, largestNum if ableToUseAll else \\\"0\\\"\\n\\n return dp(target)[1]\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n min_cost = min(cost)\\n\\n @cache\\n def helper(target):\\n if target == 0:\\n return \\\"\\\"\\n if target < min_cost:\\n return None\\n \\n ans = None\\n for i, cost_i in enumerate(cost):\\n i += 1\\n if target >= cost_i:\\n t = helper(target - cost_i)\\n if t is not None:\\n t = str(i) + t\\n if ans is None or len(ans) < len(t) or len(ans) == len(t) and ans < t:\\n ans = t\\n return ans\\n \\n ans = helper(target)\\n return \\\"0\\\" if ans is None else ans\\n\\n\\n \",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n from functools import lru_cache\\n\\n def max_(a, b):\\n if len(a) > len(b): return a\\n elif len(a) < len(b): return b\\n return max(a, b)\\n \\n @lru_cache(None)\\n def rec(left):\\n if not left: return ''\\n mx = '0'\\n for digit in range(1, 10):\\n if cost[digit-1] <= left:\\n r = rec(left-cost[digit-1])\\n if not '0' in r: mx = max_(mx, str(digit) + r)\\n return mx\\n \\n return rec(target)\",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n def maxString(a, b):\\n if len(a) < len(b):\\n return b\\n elif len(a) > len(b):\\n return a\\n\\n else:\\n n = len(a)\\n p1 = 0\\n for i in range(n):\\n if a[i] > b[i]:\\n return a\\n elif a[i] < b[i]:\\n return b\\n\\n return a\\n\\n @lru_cache(None)\\n def dfs(current):\\n if current == 0:\\n return \\\"\\\"\\n \\n if current < 0:\\n return \\\"-1\\\"\\n\\n ans = \\\"\\\"\\n for digit in range(1, 10):\\n nxt = dfs(current - cost[digit - 1])\\n if nxt != \\\"-1\\\":\\n ans = maxString(ans, str(digit) + nxt)\\n\\n return \\\"-1\\\" if ans == \\\"\\\" else ans\\n\\n ans = dfs(target)\\n return \\\"0\\\" if ans == \\\"-1\\\" else ans\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n def maxString(a, b):\\n if len(a) < len(b):\\n return b\\n elif len(a) > len(b):\\n return a\\n\\n else:\\n n = len(a)\\n p1 = 0\\n for i in range(n):\\n if a[i] > b[i]:\\n return a\\n elif a[i] < b[i]:\\n return b\\n\\n return a\\n\\n @lru_cache(None)\\n def dfs(current):\\n if current == 0:\\n return \\\"\\\"\\n \\n if current < 0:\\n return \\\"0\\\"\\n\\n ans = \\\"0\\\"\\n for digit in range(1, 10):\\n nxt = dfs(current - cost[digit - 1])\\n if nxt != \\\"0\\\":\\n ans = maxString(ans, str(digit) + nxt)\\n\\n return ans\\n\\n return dfs(target)\",\n \"memory\": \"35500\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n cutoff = min(cost)\\n \\n def compare(a,b):\\n if a==b:\\n return a\\n if a=='0':\\n return b\\n if b=='0':\\n return a\\n if len(a)>len(b):\\n return a\\n if len(b)>len(a):\\n return b\\n for i in range(len(a)):\\n if a[i]==b[i]:\\n continue\\n if a[i]>b[i]:\\n return a\\n return b\\n \\n @cache\\n def dp(t):\\n if t==0:\\n return ''\\n if t<cutoff:\\n return '0'\\n \\n ret = '0'\\n for i in range(9):\\n if t<cost[i]:\\n continue\\n temp = dp(t-cost[i])\\n if temp == '0':\\n continue\\n ret = compare(ret,str(i+1)+temp)\\n # print(t,ret)\\n return ret\\n \\n ret = dp(target)\\n # ret = dp(3)\\n \\n return ret\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"from functools import lru_cache\\nclass Solution:\\n def largestNumber(self, costs: List[int], target: int) -> str:\\n # obviously more integers is better\\n # (greedy?) choose the nums with lower cost\\n # if same cost, choose bigger int\\n def myMax(a, b):\\n if '0' in a:\\n return b\\n elif '0' in b:\\n return a\\n elif len(a) > len(b):\\n return a\\n elif len(b) > len(a):\\n return b\\n else:\\n return max(a, b)\\n \\n dp = [[None for _ in range(target + 1)] for _ in range(len(costs))]\\n\\n def f(i, target):\\n if target == 0:\\n return ''\\n if target < 0 or i == len(costs):\\n return '0'\\n \\n if dp[i][target] != None: return dp[i][target]\\n\\n take = str(i + 1) + f(0, target - costs[i])\\n leave = f(i + 1, target)\\n\\n #print(max(take, leave))\\n\\n dp[i][target] = myMax(take, leave)\\n return dp[i][target]\\n \\n return f(0, target)\",\n \"memory\": \"35700\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n from functools import lru_cache\\n\\n def max_(a, b):\\n if len(a) > len(b): return a\\n elif len(a) < len(b): return b\\n return max(a, b)\\n \\n digits = {}\\n\\n for i in range(8, -1, -1):\\n if cost[i] not in digits:\\n digits[cost[i]] = str(i+1)\\n \\n print(digits)\\n\\n @lru_cache(None)\\n def rec(left):\\n if not left: return ''\\n mx = '0'\\n for d in digits:\\n if d <= left:\\n r = rec(left-d)\\n if '0' not in r: mx = max_(mx, digits[d] + r)\\n return mx\\n \\n return rec(target)\",\n \"memory\": \"35900\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n from functools import lru_cache\\n\\n def max_(a, b):\\n if len(a) > len(b): return a\\n elif len(a) < len(b): return b\\n return max(a, b)\\n \\n digits = {}\\n for i in range(8, -1, -1):\\n if cost[i] not in digits:\\n digits[cost[i]] = str(i+1)\\n \\n\\n @lru_cache(None)\\n def rec(left):\\n if not left: return ''\\n mx = '0'\\n for d in digits:\\n if d <= left:\\n r = rec(left-d)\\n if '0' not in r: mx = max_(mx, digits[d] + r)\\n return mx\\n \\n return rec(target)\",\n \"memory\": \"36000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n def bigger_str_num(a, b):\\n if a is None and b is None:\\n return None\\n if a is None and b is not None:\\n return b\\n if b is None and a is not None:\\n return a\\n if len(a) > len(b):\\n return a\\n if len(a) < len(b):\\n return b\\n return max(a,b)\\n\\n @cache\\n def rec(target):\\n if target < 0:\\n return None\\n if target == 0:\\n return \\\"\\\"\\n \\n default = None\\n for i, c in enumerate(cost):\\n r = rec(target - c)\\n if r is not None:\\n default = bigger_str_num(str(i+1) + r, default)\\n return default\\n\\n v = rec(target)\\n return \\\"0\\\" if v is None else v\\n \",\n \"memory\": \"36300\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # highest digit per cost\\n high = {}\\n for i, c in enumerate(cost, 1):\\n high[c] = i\\n # ordered (by cost)\\n digits = []\\n for h in sorted(high):\\n digits.append(( str(high[h]), h ))\\n\\n @cache\\n def deeper(price):\\n if price == 0:\\n return \\\"\\\" # found a valid number\\n\\n best = \\\"\\\"\\n for digit, dollars in digits:\\n if dollars > price:\\n break\\n\\n # append more digits\\n next = deeper(price - dollars)\\n # failed, target not met\\n if next == None:\\n continue\\n\\n have = digit + next\\n # longer than before\\n if len(have) > len(best):\\n best = have\\n # same length but higher digits\\n if len(have) == len(best):\\n best = max(best, have)\\n\\n return best if best else None # None if target not met\\n \\n result = deeper(target)\\n return result if result else \\\"0\\\"\",\n \"memory\": \"36400\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # 判断状态 - 1. remaining cost\\n # 不知道 一共要多少个digits 但是要找largest\\n # 越多 digits 开头约大\\n cache = {}\\n def dfs(remain):\\n if remain == 0:\\n return ''\\n if remain < 0: return '0'\\n if remain in cache: return cache[remain]\\n ans = '0'\\n for i in range(9, 0, -1):\\n c = cost[i-1]\\n res = dfs(remain - c)\\n if res == '0': continue\\n res = str(i) + res\\n if len(ans) > len(res): continue\\n if ans == '0' or len(res) > len(ans) or res > ans:\\n ans = res\\n cache[remain] = ans\\n return ans\\n\\n ans = dfs(target)\\n return ans\\n \\n \",\n \"memory\": \"36700\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # 判断状态 - 1. remaining cost\\n # 不知道 一共要多少个digits 但是要找largest\\n # 越多 digits 开头约大\\n @cache\\n def dfs(remain):\\n if remain == 0:\\n return ''\\n if remain < 0: return '0'\\n # if remain in cache: return cache[remain]\\n ans = '0'\\n for i in range(9, 0, -1):\\n c = cost[i-1]\\n res = dfs(remain - c)\\n if res == '0': continue\\n res = str(i) + res\\n if len(ans) > len(res): continue\\n if ans == '0' or len(res) > len(ans) or res > ans:\\n ans = res\\n # cache[remain] = ans\\n return ans\\n\\n ans = dfs(target)\\n return ans\\n \\n \",\n \"memory\": \"36900\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # i: curr digit, rem: remaining target\\n n = len(cost)\\n\\n def bigger(a, b):\\n if len(a) != len(b):\\n return len(a) > len(b)\\n return a > b\\n\\n @cache\\n def dfs(i, target):\\n if target == 0:\\n return \\\"\\\"\\n if target < 0 or i == n + 1:\\n return \\\"#\\\"\\n # take this digit\\n take = str(i) + dfs(1, target - cost[i - 1])\\n # don't take this digit\\n skip = dfs(i + 1, target)\\n\\n if '#' in take and '#' not in skip:\\n return skip\\n if '#' not in take and '#' in skip:\\n return take\\n \\n return take if bigger(take, skip) else skip\\n\\n res = dfs(1, target)\\n dfs.cache_clear()\\n if '#' in res:\\n return '0'\\n return res\\n\",\n \"memory\": \"39000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n m = min(cost)\\n @cache\\n def l(t):\\n if t == 0:\\n return 0\\n if t < m:\\n return -inf\\n return 1+max(l(t-c) for c in cost)\\n @cache\\n def f(t):\\n if t == 0:\\n return ''\\n if (x := l(t)) != -inf:\\n for i in range(9,0,-1):\\n c = cost[i-1]\\n if c <= t and 1+l(t-c) == x:\\n return str(i)+f(t-c)\\n return '0' if (result := f(target)) is None else result\",\n \"memory\": \"39100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n # this is a dp problem.\\n # if x > y, and a is a digit string, then a.x > a.y where . is the string concatenation (because len(x) >= len(y))\\n # so we can try all digits.\\n # states = number of possible remaining targets = 5000. transitions = 9.\\n self.cost = cost\\n result = self.rec(target)\\n if result is None or result == \\\"\\\":\\n return \\\"0\\\"\\n return result\\n @cache\\n def rec(self, target: int) -> str:\\n if target == 0:\\n return \\\"\\\"\\n candidates = []\\n for digit in range(9):\\n if self.cost[digit] <= target:\\n rec = self.rec(target-self.cost[digit])\\n if rec is not None:\\n candidates.append(str(digit+1) + rec)\\n if candidates == []:\\n return None\\n return max(candidates, key=lambda s: (len(s), s)) # integer order: biggest length first, then lexicographic order\",\n \"memory\": \"45200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, nums: List[int], target: int) -> str:\\n n = len(nums)\\n from_ = [[(-1,-1)] * (target + 1) for _ in range(n)]\\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i < 0:\\n return 0 if j == 0 else -inf\\n if j < nums[i]:\\n from_[i][j] = (i-1, j)\\n return dfs(i-1, j) # 只能不选\\n res1 = dfs(i-1, j) # 不选\\n res2 = dfs(i, j-nums[i]) + 1 # 选\\n if res1 > res2:\\n from_[i][j] = (i-1, j)\\n else:\\n from_[i][j] = (i, j-nums[i])\\n return max(res1, res2)\\n ans = dfs(n-1, target)\\n if ans == -inf:\\n return \\\"0\\\"\\n\\n i = n-1\\n j = target\\n path = []\\n while i >= 0:\\n f = from_[i][j]\\n if f[0] == i:\\n path.append(str(i+1))\\n i, j = f\\n return \\\"\\\".join(path)\\n \",\n \"memory\": \"74600\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n\\n memo = {}\\n\\n def solve(ind,digit):\\n if (ind,digit) in memo: return memo[(ind,digit)]\\n if digit==target and ind>=len(cost): return \\\"\\\"\\n if digit > target or ind>=len(cost): return \\\"0\\\"\\n\\n # notTake\\n notTake = solve(ind+1,digit) \\n\\n # take\\n take = str(ind+1) + solve(0,digit+cost[ind])\\n \\n if '0' in take: memo[(ind,digit)] = notTake\\n elif '0' in notTake: memo[(ind,digit)] = take\\n elif len(take) > len(notTake): memo[(ind,digit)] = take\\n else: memo[(ind,digit)] = notTake \\n \\n return memo[(ind,digit)]\\n\\n return solve(0,0)\\n \",\n \"memory\": \"79200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n if target == 5000:\\n return '9'* 5000\\n cache = {}\\n def bruteforce(index: int,currScore):\\n if (index, currScore) in cache:\\n return cache[(index, currScore)]\\n if (currScore > target or index == len(cost)):\\n return '0'\\n if currScore == target:\\n return ''\\n \\n s1 = bruteforce(index+1, currScore)\\n s2 = bruteforce(0, currScore + cost[index]) + str(index+1)\\n s1 = int(s1) if s1[0] != '0' else 0\\n s2 = int(s2) if s2[0] != '0' else 0\\n \\n cache[(index, currScore)] = str(max(s1,s2))\\n return cache[(index, currScore)]\\n \\n result = bruteforce(0, 0)\\n return result if '0' not in result else '0'\\n \\n def getBigger(self, num1, num2):\\n if '0' in num2:\\n print(\\\"num2: \\\", num2)\\n return num1\\n elif '0' in num1:\\n print(\\\"num1: \\\", num1)\\n return num2\\n elif int(num1)>int(num2):\\n return num1 \\n else:\\n return num2\",\n \"memory\": \"83500\"\n },\n {\n \"code\": \"from functools import cache\\nfrom typing import List\\n\\nclass Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n \\n @cache\\n def helper(i, c):\\n # Base case: if the target cost is exactly 0, we have a valid number\\n if c == 0:\\n return 0\\n # If we've exhausted all digits or the cost goes negative, return negative infinity\\n if i == N or c < 0:\\n return -float('inf')\\n # Choose the maximum between not using the current digit or using it\\n return max(helper(i + 1, c), 1 + helper(i, c - cost[i]))\\n \\n # Calculate the maximum number of digits we can form with the given target\\n e = helper(0, target)\\n \\n # If it's impossible to form any number, return \\\"0\\\"\\n if e == -float('inf'):\\n return \\\"0\\\"\\n \\n # Construct the largest number by iterating over the number of digits\\n for i in range(e):\\n # Try to place the largest possible digit at each position\\n for j in reversed(range(1, 10)):\\n # Check if the current digit can be used and if it leads to a valid solution\\n if cost[j - 1] <= target and helper(0, target - cost[j - 1]) == e - i - 1:\\n target -= cost[j - 1]\\n s += str(j)\\n break\\n \\n return s\",\n \"memory\": \"90500\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"memory\": \"94000\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"memory\": \"94100\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n N = len(cost)\\n s = \\\"\\\"\\n @cache\\n def helper(i,c):\\n if c==0:\\n return 0\\n if i==N or c<0:\\n return -float('inf')\\n return max(helper(i+1,c),\\n 1 + helper(i,c-cost[i]))\\n e =helper(0,target)\\n if e== -float('inf'):\\n return \\\"0\\\"\\n for i in range(e):\\n for j in reversed(range(1,10)):\\n if cost[j-1]<=target and helper(0,target-cost[j-1])==e-i-1:\\n target-= cost[j-1]\\n s+=str(j)\\n return s\\n \",\n \"memory\": \"94200\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n sys.set_int_max_str_digits(5000)\\n @cache\\n def dfs(index, remain):\\n if remain == 0:\\n return \\\"\\\"\\n if index == len(cost) + 1 or remain < 0:\\n return \\\"0\\\"\\n\\n take = str(index) + dfs(1, remain - cost[index - 1])\\n skip = dfs(index + 1, remain)\\n\\n if \\\"0\\\" in take:\\n return skip\\n if \\\"0\\\" in skip:\\n return take\\n return take if int(take) > int(skip) else skip \\n \\n ans = dfs(1, target) \\n return ans if \\\"0\\\" not in ans else \\\"0\\\"\",\n \"memory\": \"94600\"\n },\n {\n \"code\": \"class Solution:\\n def largestNumber(self, cost: List[int], target: int) -> str:\\n from_ = {}\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if j == 0:\\n return 0\\n if i < 0: # j > 0\\n return -inf\\n # not choose\\n res = dfs(i-1, j)\\n from_[(i, j)] = (i-1, j)\\n # choose\\n if j >= cost[i]:\\n r = dfs(i, j-cost[i]) + 1\\n if r >= res:\\n res = r\\n from_[(i, j)] = (i, j-cost[i])\\n return res\\n n = len(cost)\\n if dfs(n-1, target) == -inf:\\n return \\\"0\\\"\\n \\n ans = []\\n p = (n-1, target)\\n while p in from_:\\n f = from_[p]\\n if f[0] == p[0]:\\n ans.append(str(p[0]+1))\\n else: # 不选 str(p[0]+1)\\n pass\\n p = f\\n return \\\"\\\".join(ans)\",\n \"memory\": \"106600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":72,"string":"72"}}},{"rowIdx":2457,"cells":{"question_id":{"kind":"number","value":3430,"string":"3,430"},"name":{"kind":"string","value":"count-days-without-meetings"},"content":{"kind":"string","value":"<p>You are given a positive integer <code>days</code> representing the total number of days an employee is available for work (starting from day 1). You are also given a 2D array <code>meetings</code> of size <code>n</code> where, <code>meetings[i] = [start_i, end_i]</code> represents the starting and ending days of meeting <code>i</code> (inclusive).</p>\n\n<p>Return the count of days when the employee is available for work but no meetings are scheduled.</p>\n\n<p><strong>Note: </strong>The meetings may overlap.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">days = 10, meetings = [[5,7],[1,3],[9,10]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>There is no meeting scheduled on the 4<sup>th</sup> and 8<sup>th</sup> days.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">days = 5, meetings = [[2,4],[1,3]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>There is no meeting scheduled on the 5<sup>th </sup>day.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">days = 6, meetings = [[1,6]]</span></p>\n\n<p><strong>Output:</strong> 0</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>Meetings are scheduled for all working days.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= days <= 10<sup>9</sup></code></li>\n\t<li><code>1 <= meetings.length <= 10<sup>5</sup></code></li>\n\t<li><code>meetings[i].length == 2</code></li>\n\t<li><code><font face=\"monospace\">1 <= meetings[i][0] <= meetings[i][1] <= days</font></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":33.87575784201739,"string":"33.875758"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","sorting"],"string":"[\n \"array\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"285\", 0.4024], [\"323\", 0.2012], [\"361\", 0.2012], [\"399\", 0.2012], [\"438\", 0.2012], [\"476\", 0.2012], [\"514\", 0.2012], [\"552\", 0.2012], [\"591\", 0.2012], [\"629\", 0.2012], [\"667\", 0.2012], [\"705\", 0.2012], [\"744\", 0.2012], [\"782\", 0.6036], [\"820\", 0.2012], [\"858\", 0.2012], [\"897\", 0.4024], [\"935\", 0.6036], [\"973\", 0.2012], [\"1011\", 0.2012], [\"1050\", 0.6036], [\"1088\", 0.4024], [\"1126\", 0.2012], [\"1164\", 0.2012], [\"1203\", 0.2012], [\"1241\", 0.2012], [\"1279\", 8.8528], [\"1317\", 13.480400000000001], [\"1356\", 19.717800000000004], [\"1394\", 21.5285], [\"1432\", 11.066], [\"1470\", 4.6276], [\"1509\", 2.6156], [\"1547\", 2.012], [\"1585\", 0.6035999999999999], [\"1623\", 0.4024], [\"1662\", 0.8048], [\"1700\", 0.8048], [\"1738\", 0.2012], [\"1776\", 0.2012], [\"1815\", 0.4024], [\"1853\", 0.2012], [\"1891\", 0.2012], [\"1929\", 0.2012]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"34700\", 0.2012], [\"51600\", 0.2012], [\"51700\", 0.2012], [\"51800\", 0.2012], [\"51900\", 0.2012], [\"52000\", 0.2012], [\"53000\", 0.2012], [\"53200\", 0.2012], [\"53400\", 0.4024], [\"53500\", 1.006], [\"53600\", 0.6036], [\"53700\", 0.6036], [\"62100\", 0.2012], [\"62200\", 0.2012], [\"62600\", 0.2012], [\"63700\", 0.6036], [\"63800\", 3.2193], [\"63900\", 1.2072], [\"64000\", 0.2012], [\"65600\", 0.2012], [\"65800\", 0.2012], [\"66000\", 0.2012], [\"66100\", 1.006], [\"66200\", 0.8048], [\"66300\", 1.006], [\"66400\", 0.6036], [\"66500\", 1.2072], [\"66600\", 1.4085], [\"66700\", 10.8652], [\"66800\", 27.5654], [\"66900\", 23.5412], [\"67000\", 8.8531], [\"67100\", 2.6157], [\"67200\", 1.006], [\"67400\", 0.2012], [\"67700\", 0.8048], [\"67800\", 2.0121]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n ans = meetings[0][0]-1\n curr_end = meetings[0][1]\n for i in range(1,len(meetings)):\n s,e = meetings[i]\n if s>curr_end:\n ans+=s-curr_end-1\n curr_end=e\n else:\n curr_end = max(curr_end,e)\n if days>curr_end:\n ans+=days-curr_end\n return ans\nS = Solution()\nf = open('user.out','w')\nfor i1,i2 in zip(stdin,stdin):\n f.write(f\"{S.countDays(loads(i1),loads(i2))}\\n\")\nf.flush()\nexit(0)","runtime":"285"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n today = 0\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\n \n if end <= today: \n continue # <-- 3a)\n if beg <= today:\n days-= end - today # <-- 3b)\n else: \n days-= end - beg + 1 # <-- 3c)\n\n today = end\n \n return days # <-- 4)","runtime":"285"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\n\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\n \n if end <= today: continue # <-- 3a)\n if beg <= today: days-= end - today # <-- 3b)\n else: days-= end - beg + 1 # <-- 3c)\n\n today = end\n \n return days # <-- 4)","runtime":"323"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x:x[0])\n ans = 0\n curr_day = 0\n for start, end in meetings:\n if start>curr_day:\n ans+=start-curr_day-1\n curr_day = max(curr_day,end)\n return ans+days-curr_day","runtime":"361"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n n = len(meetings)\n meetings = sorted(meetings, key=lambda k: k[0])\n start, end = meetings[0]\n res = start - 1\n for i in range(1, n):\n if meetings[i][0] <= end:\n end = max(end, meetings[i][1])\n else:\n res += meetings[i][0] - end - 1\n start, end = meetings[i]\n res += days - end\n return res","runtime":"399"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n starts = []\n ends = []\n for s, e in meetings:\n starts.append(s)\n ends.append(e)\n \n starts.sort()\n ends.sort()\n sIdx, eIdx = 1, 0\n count = starts[0] - 1\n\n while sIdx < len(starts):\n\n if starts[sIdx] > ends[eIdx]:\n count += starts[sIdx] - ends[eIdx] - 1\n sIdx += 1\n eIdx += 1\n \n return count + (days-ends[-1])\n ","runtime":"438"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x:x[0])\n ans = 0\n curr_day = 0\n for meeting in meetings:\n if meeting[0]>curr_day:\n ans+=meeting[0]-curr_day-1\n curr_day = max(curr_day,meeting[1])\n return ans+days-curr_day","runtime":"476"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n available = [[1,days]]\n for m in meetings:\n new = []\n for a in available:\n if m[0] <= a[0] and a[1] <= m[1]:\n # entirely cut out\n pass\n elif a[0] < m[0] and m[1] < a[1]:\n # split available in 2\n new.append([a[0], m[0]-1])\n new.append([m[1]+1, a[1]])\n elif m[0] <= a[0] <= m[1]:\n # overlap start of available\n new.append( [m[1] + 1, a[1]] )\n elif m[0] <= a[1] <= m[1]:\n # overlap end of available\n new.append( [a[0], m[0] - 1] )\n else:\n # no overlap, carry avialble forward\n new.append(a)\n available = new\n\n ans = 0\n for a in available:\n ans += a[1] - a[0] + 1\n return ans\n \n\n ","runtime":"514"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\n\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\n \n if end <= today: continue # <-- 3a)\n if beg <= today: days-= end - today # <-- 3b)\n else: days-= end - beg + 1 # <-- 3c)\n\n today = end\n \n return days # <-- 4)","runtime":"552"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n meetings = sorted(meetings, key=lambda x:x[0])\n res = 0\n currEnd = 0\n\n for start, end in meetings:\n\n if start > currEnd+1:\n res += (start-(currEnd+1))\n \n currEnd = max(currEnd, end)\n \n res+= (days-currEnd)\n \n return res","runtime":"591"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key = lambda x: x[0])\n\n prev_start, prev_end = meetings[0] \n\n arr = []\n for start, end in meetings[1:]:\n if start > prev_end:\n arr.append((prev_start, prev_end))\n prev_start, prev_end = start, end\n else:\n prev_end = max(prev_end, end)\n \n arr.append((prev_start, prev_end))\n\n res = 0\n for (start, end), (start_, end_) in zip(arr, arr[1:]):\n res += start_ - end - 1\n \n res += (arr[0][0] - 1)\n res += (days - arr[-1][1])\n\n return res\n\n ","runtime":"629"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\n\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\n \n if end <= today: continue # <-- 3a)\n if beg <= today: days-= end - today # <-- 3b)\n else: days-= end - beg + 1 # <-- 3c)\n\n today = end\n \n return days # <-- 4)","runtime":"667"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key = lambda x: x[0])\n\n prev_start, prev_end = meetings[0] \n\n arr = []\n for start, end in meetings[1:]:\n if start > prev_end:\n arr.append((prev_start, prev_end))\n prev_start, prev_end = start, end\n else:\n prev_end = max(prev_end, end)\n \n arr.append((prev_start, prev_end))\n\n res = 0\n for (_, end), (start_, _) in zip(arr, arr[1:]):\n res += start_ - end - 1\n \n res += (arr[0][0] - 1)\n res += (days - arr[-1][1])\n\n return res\n\n ","runtime":"705"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x :x[0])\n current_Days = []\n current = meetings[0]\n for i in range(1,len(meetings)):\n if current[1]>=meetings[i][0]:\n current[1]=max(current[1],meetings[i][1])\n else:\n current_Days.append(current)\n current = meetings[i]\n current_Days.append(current)\n for i in current_Days:\n x = i[1]+1-i[0]\n days-=x\n return days\n\n","runtime":"744"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n def merge_intervals(unsorted_meetings: List[List[int]]) -> List[List[int]]:\n if not unsorted_meetings:\n return []\n merged_intervals = []\n sorted_meetings = sorted(unsorted_meetings, key=lambda x: x[0])\n prev_start_i = sorted_meetings[0][0]\n prev_end_i = sorted_meetings[0][1]\n for start_i, end_i in sorted_meetings[1:]:\n if prev_end_i >= start_i:\n prev_end_i = max(prev_end_i,end_i)\n continue\n merged_intervals.append([prev_start_i, prev_end_i])\n prev_start_i = start_i\n prev_end_i = end_i\n merged_intervals.append([prev_start_i, prev_end_i])\n return merged_intervals\n \n\n intervals = merge_intervals(meetings)\n total_meeting_days = 0\n for start_i, end_i in intervals:\n total_meeting_days += (end_i - start_i + 1) \n return days - total_meeting_days\n","runtime":"782"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x: x[0])\n\n merged = [meetings[0]]\n for current in meetings[1:]:\n last = merged[-1]\n if current[0] <= last[1]:\n last[1] = max(last[1], current[1])\n else:\n merged.append(current)\n\n total = merged[0][0] - 1\n\n for i in range(1, len(merged)):\n total+=merged[i][0] - merged[i-1][1] - 1\n\n total+=days - merged[-1][1]\n \n return total\n ","runtime":"820"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x: x[0])\n\n free = meetings[0][0] - 1\n next_end = meetings[0][0]\n\n for start, end in meetings:\n if next_end < start:\n free += start-next_end-1\n next_end = max(next_end, end)\n \n if next_end < days:\n free += days - next_end\n return free\n ","runtime":"858"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n meetings.sort(key=lambda x: x[0])\n con = []\n total = 0 \n for i in meetings:\n if not con:\n con = i\n continue\n \n if i[0] <= con[1]:\n con[1] = max (con[1], i[1])\n else:\n total += con[1] - con[0] + 1\n con = i\n \n total += con[1] - con[0] + 1\n return days - total ","runtime":"897"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n starts = []\n ends = []\n for s, e in meetings:\n starts.append(s)\n ends.append(e)\n \n starts.sort()\n ends.sort()\n sIdx, eIdx = 1, 0\n count = starts[0] - 1\n\n while sIdx < len(starts):\n\n if starts[sIdx] <= ends[eIdx]:\n sIdx += 1\n eIdx += 1\n else:\n count += starts[sIdx] - ends[eIdx] - 1\n sIdx += 1\n eIdx += 1\n \n return count + (days-ends[-1])\n ","runtime":"935"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n totalMeetings = len(meetings)\n meetings.sort(key=lambda x: x[0])\n freeDays = 0\n freeDays += meetings[0][0] - 1\n lastMeetingDay = meetings[0][1]\n\n for i in range(1, totalMeetings):\n if meetings[i][0] > lastMeetingDay:\n freeDays += (meetings[i][0] - lastMeetingDay - 1)\n lastMeetingDay = meetings[i][1]\n elif lastMeetingDay < meetings[i][1]:\n lastMeetingDay = meetings[i][1]\n \n freeDays += days - lastMeetingDay\n\n return freeDays\n","runtime":"973"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x: x[0])\n intervals = [meetings[0]]\n for m in meetings[1:]:\n if m[0] <= intervals[-1][1]:\n intervals[-1][1] = max(m[1], intervals[-1][1])\n else:\n intervals.append(m)\n \n busy = 0\n for x in intervals:\n busy+=(x[1]-x[0]+1)\n return days - busy","runtime":"1011"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n # sort starts and ends\n starts = [interval[0] for interval in meetings]\n ends = [interval[1] for interval in meetings]\n starts.sort()\n ends.sort()\n\n # account for time before first meeting\n free_days = 0\n first_start = starts[0]\n if first_start > 1:\n free_days += first_start - 1\n\n s_i = 0\n e_i = 0\n current_mtgs = 0\n while s_i < len(starts) and e_i < len(ends):\n if ends[e_i] < starts[s_i]:\n current_mtgs -= 1\n if current_mtgs == 0:\n free_days += starts[s_i] - ends[e_i] - 1\n e_i += 1\n else:\n # WHY DOES THIS ELSE WORK\n # popping off a start as smallest\n current_mtgs += 1\n s_i += 1\n\n # account for time after end of last meeting\n if ends[-1] < days:\n free_days += days - ends[-1]\n \n # while e_i < len(ends):\n # current_mtgs -= 1\n # if current_mtgs == 0:\n # free_days += days - ends[e_i]\n # e_i += 1\n\n return free_days\n","runtime":"1050"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x: (x[0]))\n currDay = 1\n count = 0\n\n #print(meetings)\n\n for i in range(0, len(meetings)):\n l = meetings[i][0]\n r = meetings[i][1]\n\n if r < currDay:\n continue\n elif l <= currDay and r >= currDay:\n currDay = r + 1\n else:\n count += l - currDay\n currDay = r + 1\n \n if currDay <= days:\n count += days - currDay + 1\n\n return count\n ","runtime":"1088"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n\n\n meetings.sort(key = lambda x: x[0])\n\n result = 0\n prev = meetings[0]\n for i in range(len(meetings) - 1):\n if prev[1] < meetings[i+1][0]: \n result += (meetings[i+1][0] - prev[1]) - 1\n prev = meetings[i+1]\n else:\n prev[1] = max(prev[1], meetings[i+1][1])\n \n\n if prev[1] < days:\n result += days - prev[1]\n if meetings[0][0] > 1:\n result += meetings[0][0] - 1\n \n return result","runtime":"1126"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key = lambda x: x[0])\n\n prev_start, prev_end = meetings[0] \n\n arr = []\n for start, end in meetings[1:]:\n if start > prev_end:\n arr.append((prev_start, prev_end))\n prev_start, prev_end = start, end\n else:\n prev_end = max(prev_end, end)\n \n arr.append((prev_start, prev_end))\n\n res = 0\n for (start, end), (start_, end_) in zip(arr, arr[1:]):\n res += start_ - end - 1\n \n res += (arr[0][0] - 1)\n res += (days - arr[-1][1])\n\n return res\n\n ","runtime":"1164"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x : x[0])\n prev = meetings[0] # [meetings[0]]\n # res = 0\n res = prev[0] - 1\n for s, e in meetings[1:]:\n if s > prev[1]:\n res += s - prev[1] - 1\n prev = [s, e]\n else:\n prev[1] = max(prev[1], e)\n\n res += days - prev[1]\n\n return res ","runtime":"1203"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n # sort in ascending order wrt start of meeting\n meetings = sorted(meetings, key=lambda meeting: meeting[0])\n\n # calculate the total number of meetings\n length = 0\n for i, meeting in enumerate(meetings):\n if (i == 0):\n length += meeting[1] - meeting[0] + 1\n else:\n if (meeting[0] <= meetings[i - 1][1]): # overlap\n if (meeting[1] > meetings[i - 1][1]):\n length += meeting[1] - meetings[i - 1][1]\n else:\n meetings[i][1] = meetings[i - 1][1]\n else:\n length += meeting[1] - meeting[0] + 1\n \n return (days - length if (days-length > 0) else 0)","runtime":"1241"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x: x[0])\n # print(meetings)\n mt, i, j, n = [], 0, 0, len(meetings)\n while i < n:\n # while i<n and mt[-1][0]==meetings[i][0]:\n # mt[-1][1]=max(mt[-1][1],meetings[i][1])\n # i+=1\n mt.append(meetings[i])\n while i < n and mt[-1][1] >= meetings[i][0]:\n mt[-1][1] = max(mt[-1][1], meetings[i][1])\n i += 1\n # print(mt)\n ans = mt[0][0] - 1 + days - mt[-1][1]\n for i in range(1, len(mt)):\n ans += mt[i][0] - mt[i - 1][1] - 1\n # print(ans)\n return ans","runtime":"1279"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key = lambda x: x[0])\n\n prev_start, prev_end = meetings[0] \n\n arr = []\n for start, end in meetings[1:]:\n if start > prev_end:\n arr.append((prev_start, prev_end))\n prev_start, prev_end = start, end\n else:\n prev_end = max(prev_end, end)\n \n arr.append((prev_start, prev_end))\n\n res = 0\n for (_, end), (start_, _) in zip(arr, arr[1:]):\n res += start_ - end - 1\n \n res += (arr[0][0] - 1)\n res += (days - arr[-1][1])\n\n return res\n\n ","runtime":"1279"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n meetings.sort(key=lambda x:x[0])\n res = 0\n currEnd = 0\n\n for start, end in meetings:\n\n if start > currEnd+1:\n res += (start-(currEnd+1))\n \n currEnd = max(currEnd, end)\n \n res+= (days-currEnd)\n \n return res","runtime":"1317"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n meetings.sort(key=lambda x: x[0])\n \n available_days = days\n last_end = 0\n \n for start, end in meetings:\n # If this meeting starts after the last one ended, count the gap\n if start > last_end:\n available_days -= min(end, days) - start + 1\n last_end = end\n # If this meeting overlaps with the last one, only count the extension\n elif end > last_end:\n available_days -= min(end, days) - last_end\n last_end = end\n \n return available_days\n ","runtime":"1317"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n def mergeIntervals(intervals):\n res = [intervals[0]]\n for i in range(1, len(intervals)):\n left = res[-1]\n right = intervals[i]\n if right[0] <= left[1]:\n res[-1] = [res[-1][0], max(res[-1][1], right[1])]\n else:\n res.append(right)\n\n return res\n\n \n meetings.sort(key = lambda x: x[0])\n intervals = mergeIntervals(meetings)\n\n res = 0\n curr = 1\n for interval in intervals:\n res += max(interval[0] - curr, 0)\n curr = interval[1] + 1\n \n return res + days - intervals[-1][1]","runtime":"1356"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n left = 0\n index = 0\n while index < len(meetings):\n last_meeting_end = meetings[index][1]\n while left < len(meetings) and meetings[left][0] <= last_meeting_end:\n if meetings[left][1] > last_meeting_end:\n last_meeting_end = meetings[left][1]\n left += 1\n days -= last_meeting_end - meetings[index][0] + 1\n index = left\n return days","runtime":"1356"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n # sorting\n meetings.sort(key=lambda x: (x[0], x[1]))\n \n stack = []\n for s, e in meetings:\n if len(stack) > 0 and stack[-1][1] >= s:\n stack[-1][1] = max(stack[-1][1], e)\n else:\n stack.append([s, e])\n count = 0\n \n l = len(stack)\n for i in range(1, l):\n count += stack[i][0] - stack[i-1][1] - 1\n \n count += stack[0][0] - 1\n count += days - stack[-1][1]\n return count\n \n \n # MLE\n all_days = [0 for y in range(2+days)]\n \n for s, e in meetings:\n all_days[s] += 1\n all_days[e+1] -= 1\n result = 0\n for i in range(1, days+1):\n all_days[i] += all_days[i-1]\n if all_days[i] == 0:\n result += 1\n return result\n ","runtime":"1394"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n ans=[]\n meetings.sort()\n for i in range(len(meetings)):\n if not ans:\n ans.append(meetings[i])\n else:\n ar1=ans[-1]\n ar2=meetings[i]\n if ar1[1]>=ar2[0]:\n ans[-1]=[ar1[0],max(ar1[1],ar2[1])]\n else:\n ans.append(ar2)\n count=0\n count+=ans[0][0]-1\n count+=days-ans[-1][1]\n for i in range(1,len(ans)):\n gap=ans[i][0]-ans[i-1][1]-1\n count+=gap\n return count","runtime":"1432"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n\n intervals = []\n\n intervals.append(meetings[0])\n\n for i in range(1, len(meetings)):\n prev_st, prev_en = intervals[-1] # pick from intervals since that contains our merged intervals\n curr_st, curr_en = meetings[i]\n\n if curr_st <= prev_en:\n intervals.pop() # remove the interval since we are recalculating the start and end dates\n newrange = [prev_st, max(prev_en, curr_en)]\n intervals.append(newrange)\n else:\n intervals.append([curr_st, curr_en])\n \n for st, en in intervals:\n meeting_day_count = (en-st)+1\n days -= meeting_day_count\n \n return days","runtime":"1432"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n res = abs(meetings[0][0] - 1 )\n for i in range(1,len(meetings)):\n if meetings[i][0] <= meetings[i-1][1]:\n if meetings[i][1] < meetings[i-1][1]:\n meetings[i][1] = meetings[i-1][1]\n else:\n miss = meetings[i][0] - meetings[i-1][1]\n res += (miss - 1)\n res += (days - meetings[len(meetings)-1][1] )\n return res\n ","runtime":"1470"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n\n intervals = meetings\n\n\n if not intervals:\n return 0\n\n intervals.sort(key = lambda x:(x[0],x[1]))\n\n # merged_intervals = [intervals[0]]\n\n # for i in range(len(intervals)):\n\n # if intervals[i][0] <= merged_intervals[-1][1]:\n # last_interval = merged_intervals.pop()\n # new_interval = [last_interval[0],max(last_interval[1],intervals[i][1])]\n # merged_intervals.append(new_interval)\n # else:\n # merged_intervals.append(intervals[i])\n\n left_pointer = 0\n\n\n for right_pointer in range(len(intervals)):\n\n if intervals[left_pointer][1] >= intervals[right_pointer][0]:\n intervals[left_pointer][1] = max(intervals[left_pointer][1],intervals[right_pointer][1]) \n else:\n left_pointer += 1\n intervals[left_pointer] = intervals[right_pointer]\n \n\n intervals = intervals[:min(left_pointer+1,len(intervals))]\n\n print(intervals)\n \n count = 0\n\n for start,end in intervals:\n\n count += (end-start+1)\n \n return days - count\n ","runtime":"1470"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n # events = []\n # for s, e in meetings:\n # events.append((s, 1))\n # events.append((e, -1))\n # events.sort(key = lambda x : x[0])\n\n # res = 0\n # cnt = 0\n # last_day = None\n # i = 1\n # for d, c in events:\n # if cnt == 0 and last_day:\n # if last_day <= days:\n # res += 1\n\n # cnt += c\n # last_day = d\n \n # if cnt == 0 and last_day == days - 1:\n # res += 1\n # return res \n events = []\n for s, e in meetings:\n events.append((s, 1)) # Meeting starts\n events.append((e + 1, -1)) # Meeting ends (e+1 to mark the day after as free)\n\n events.sort(key=lambda x: x[0])\n\n res = 0\n cnt = 0\n last_day = 1\n\n for d, c in events:\n if cnt == 0:\n # Add the number of free days between last_day and the current day (d-1)\n if d > last_day:\n res += d - last_day\n\n cnt += c\n last_day = d\n\n # After processing all events, check for free days from last event to the last day\n if last_day <= days and cnt == 0:\n res += days - last_day + 1\n \n return res","runtime":"1509"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n arr = []\n for s,e in meetings:\n arr.append((s, 1))\n arr.append((e+1, -1))\n arr.sort()\n ans = 0\n num = 0\n i = 0\n prev = 1\n while i < len(arr):\n if arr[i][0] < 1: i += 1\n elif arr[i][0] <= days+1:\n if num == 0:\n ans += arr[i][0] - prev\n # number of free days\n j = i\n while j < len(arr) and arr[j][0] == arr[i][0]:\n num += arr[j][1]\n j += 1\n if num == 0: prev = arr[i][0]\n i = j\n \n else: break\n ans += days - prev + 1\n return ans\n ","runtime":"1509"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapq.heapify(meetings)\n endTimes = [0]\n freeDays = 0\n\n while meetings:\n start, end = heapq.heappop(meetings)\n\n while endTimes and start > endTimes[0]:\n oldEnd = heapq.heappop(endTimes)\n\n if len(endTimes) == 0:\n freeDays += start - oldEnd - 1\n\n heapq.heappush(endTimes, end)\n return freeDays + (days - max(endTimes))\n","runtime":"1547"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings, key=lambda x: x[0])\n meetings.append((days + 1, days + 2))\n i = 1\n s = meetings[0][0]\n e = meetings[0][1]\n while i < (len(meetings)):\n print(s, e, meetings[i])\n if e < meetings[i][0]:\n days -= e - s + 1\n s = meetings[i][0]\n e = meetings[i][1]\n elif e < meetings[i][1]:\n e = meetings[i][1]\n i += 1\n return days\n","runtime":"1547"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n\n\n meetings.sort(key= lambda x : (x[0], x[1]))\n\n i = 0\n freedays = meetings[0][0] -1 \n\n def IsOverLap( a , b):\n if a[0] <= b[0] <= a[1] or b[0] <= a[0] <= b[1]:\n return True\n else:\n return False\n\n \n\n res = meetings[0]\n max_end = meetings[i][1]\n for i in range(1,len(meetings)):\n max_end = max(max_end , meetings[i][1])\n if IsOverLap(res, meetings[i]):\n res = [min(res[0], meetings[i][0]) , max(res[-1], meetings[i][1])]\n else:\n freedays = freedays + abs(meetings[i][0] - res[-1] -1)\n res = (meetings[i])\n\n return(freedays + (days - max_end))\n \n ","runtime":"1585"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heap=[]\n for i in range(len(meetings)):\n heapq.heappush(heap,(meetings[i][0],meetings[i][1]))\n ans=[]\n for i in range(len(heap)):\n x,y=heapq.heappop(heap)\n if ans==[] or ans[-1][1]<x:\n ans.append([x,y])\n else:\n ans[-1][1]=max(y,ans[-1][1])\n c=0\n for i in range(len(ans)):\n c+=ans[i][1]-ans[i][0]+1\n return days-c","runtime":"1585"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n h = []\n for m in meetings:\n heapq.heappush(h, m)\n\n f = []\n while h:\n l, r = heapq.heappop(h)\n if not f:\n f.append([l, r])\n else:\n i = bisect.bisect_left(f, [l, r])\n if f[i - 1][1] < l:\n f.append([l, r])\n else:\n f[i - 1][1] = max(f[i - 1][1], r)\n \n\n for l, r in f:\n days -= (r - l + 1)\n if days <= 0:\n return 0\n\n return days","runtime":"1623"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n events = []\n for vec in meetings:\n events.append([vec[0], 1])\n events.append([vec[1], -1])\n\n events.append([0, 0])\n events.append([days+1, 0])\n events.sort()\n ans = 0\n running_events = 0\n for i, event in enumerate(events[:len(events)-1]):\n running_events += (events[i][1])\n if running_events == 0:\n ans += max(0, (events[i+1][0] - events[i][0] - 1))\n\n return ans","runtime":"1623"},{"code":"from heapq import heapify, heappop\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapify(meetings)\n res = 0\n last = 1\n\n while meetings:\n start, end = heappop(meetings)\n if start > last:\n res += start - last\n \n if end > days:\n break\n \n last = max(end+1, last)\n print(last, res)\n \n return res + max(days-last+1, 0)","runtime":"1662"},{"code":"from sortedcontainers import SortedSet\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n l = SortedSet()\n d = defaultdict(int)\n \n for meeting in meetings:\n a, b = meeting[0], meeting[1]\n l.add(a)\n l.add(b+1)\n d[a]+=1\n d[b+1]-=1\n \n res = 0\n total = 0\n previous = 1\n for day in l:\n total+=d[day]\n if previous!=-1 and total>0:\n res += day-previous\n previous=-1\n elif previous==-1 and total==0:\n previous = day\n if previous!=-1:\n res+=days+1-previous\n \n return res\n ","runtime":"1662"},{"code":"from sortedcontainers import SortedSet\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n l = SortedSet()\n d = defaultdict(int)\n \n for meeting in meetings:\n a, b = meeting[0], meeting[1]\n l.add(a)\n l.add(b+1)\n d[a]+=1\n d[b+1]-=1\n \n res = 0\n total = 0\n previous = 1\n for day in l:\n total+=d[day]\n if previous!=-1 and total>0:\n res += day-previous\n previous=-1\n elif previous==-1 and total==0:\n previous = day\n if previous!=-1:\n res+=days+1-previous\n \n return res\n ","runtime":"1700"},{"code":"from sortedcontainers import SortedSet\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n l = SortedSet()\n d = defaultdict(int)\n \n for meeting in meetings:\n a, b = meeting[0], meeting[1]\n l.add(a)\n l.add(b+1)\n d[a]+=1\n d[b+1]-=1\n \n res = 0\n total = 0\n previous = 1\n for day in l:\n total+=d[day]\n if previous!=-1 and total>0:\n res += day-previous\n previous=-1\n elif previous==-1 and total==0:\n previous = day\n if previous!=-1:\n res+=days+1-previous\n \n return res\n ","runtime":"1700"},{"code":"def merge_sort(arr: List[List[int]]) -> List[List[int]]:\n n = len(arr)\n if n < 2: return arr\n \n mid = n // 2\n left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])\n \n i, j, l, r, ans = 0, 0, len(left), len(right), []\n while i < l and j < r:\n if left[i] < right[j]:\n ans.append(left[i])\n i += 1\n else:\n ans.append(right[j])\n j += 1\n while i < l:\n ans.append(left[i])\n i += 1\n while j < r:\n ans.append(right[j])\n j += 1\n return ans\n \nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n arr, j, n, ans = merge_sort(meetings), 1, len(meetings), days\n s1, e1 = arr[0]\n while j < n:\n s2, e2 = arr[j]\n if s2 <= e1: e1 = max(e1, e2)\n else:\n ans -= e1 - s1 + 1\n s1, e1 = s2, e2\n j += 1\n ans -= e1 - s1 + 1\n return ans","runtime":"1738"},{"code":"from sortedcontainers import SortedSet\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n l = SortedSet()\n d = defaultdict(int)\n \n for meeting in meetings:\n a, b = meeting[0], meeting[1]\n l.add(a)\n l.add(b+1)\n d[a]+=1\n d[b+1]-=1\n \n res = 0\n total = 0\n previous = 1\n for day in l:\n total+=d[day]\n if previous!=-1 and total>0:\n res += day-previous\n previous=-1\n elif previous==-1 and total==0:\n previous = day\n if previous!=-1:\n res+=days+1-previous\n \n return res\n ","runtime":"1776"},{"code":"from collections import defaultdict\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n starts = sorted([a[0] for a in meetings])\n ends = sorted(a[1] for a in meetings)\n\n count_map = defaultdict(int)\n for a in meetings:\n count_map[a[0]]+=1\n count_map[a[1]+1]-=1\n print(count_map.items())\n count_map=sorted(count_map.items(), key=lambda x: x[0])\n cnt = count_map[0][1]\n\n count_meeting_days = 0\n for i in range(1, len(count_map)):\n d = count_map[i][0]\n c = count_map[i][1]\n \n if cnt > 0:\n count_meeting_days += d - count_map[i-1][0]\n cnt += c\n print(count_map[i][0], c, cnt)\n\n # 1 1 1 0\n # 4 -1 0 4\n # 5 1 1\n # 8 -1 0\n # 9 1 1\n # 11 -1 0\n return days - count_meeting_days\n \n\n\n\n\n ","runtime":"1815"},{"code":"import heapq\n\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n cur_meets = 0\n day_count = 0\n last_end = 0\n\n h = []\n for s, e in meetings:\n heapq.heappush(h, (s, False))\n heapq.heappush(h, (e, True))\n\n while h:\n t, is_end = heapq.heappop(h)\n\n if not is_end and cur_meets == 0:\n day_count += t - last_end - 1\n if is_end: last_end = t\n cur_meets += -1 if is_end else 1\n day_count += max(0, days - last_end)\n return day_count","runtime":"1815"},{"code":"def heapify(arr: List[List[int]], n: int, idx: int):\n maxi, left, right = idx, idx * 2 + 1, idx * 2 + 2\n if left < n and arr[left] > arr[maxi] : maxi = left\n if right < n and arr[right] > arr[maxi] : maxi = right\n if maxi != idx:\n arr[idx], arr[maxi] = arr[maxi], arr[idx]\n heapify(arr,n , maxi)\n \ndef heapsort(arr: List[List[int]]):\n n = len(arr)\n for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i)\n\n for i in range(n - 1, 0, -1):\n arr[0], arr[i] = arr[i], arr[0]\n heapify(arr, i, 0)\n \nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n arr, j, n, ans = meetings[:], 1, len(meetings), days\n heapsort(arr)\n s1, e1 = arr[0]\n while j < n:\n s2, e2 = arr[j]\n if s2 <= e1: e1 = max(e1, e2)\n else:\n ans -= e1 - s1 + 1\n s1, e1 = s2, e2\n j += 1\n ans -= e1 - s1 + 1\n return ans","runtime":"1853"},{"code":"class Solution:\n def countDays(self, d: int, m: List[List[int]]) -> int:\n m.sort()\n i = 1\n k = m[0][1]\n a = 0\n n = len(m)\n while i<n:\n if k>m[i][0]:\n m[i-1][1] = max(m[i-1][1],m[i][1])\n del m[i]\n n-=1\n i-=1\n k = m[i][1]\n else:\n if k<m[i][0]:\n a+=m[i][0]-k-1\n k = m[i][1]\n i+=1\n return a+d-m[-1][1]+m[0][0]-1\n ","runtime":"1891"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = sorted(meetings)\n\n # merge the meetings\n i = 1\n while i <= len(meetings)-1:\n lastMeeting = meetings[i-1]\n currMeeting = meetings[i]\n if lastMeeting[1] >= currMeeting[0]:\n if lastMeeting[1] < currMeeting[1]:\n lastMeeting[1] = currMeeting[1]\n \n meetings.pop(i)\n \n else:\n i += 1\n\n # now, we check for the sum of the difference of meetings\n for j in meetings:\n temp = j[1] - (j[0] - 1) \n days = days - temp\n return days\n","runtime":"1929"}],"string":"[\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n ans = meetings[0][0]-1\\n curr_end = meetings[0][1]\\n for i in range(1,len(meetings)):\\n s,e = meetings[i]\\n if s>curr_end:\\n ans+=s-curr_end-1\\n curr_end=e\\n else:\\n curr_end = max(curr_end,e)\\n if days>curr_end:\\n ans+=days-curr_end\\n return ans\\nS = Solution()\\nf = open('user.out','w')\\nfor i1,i2 in zip(stdin,stdin):\\n f.write(f\\\"{S.countDays(loads(i1),loads(i2))}\\\\n\\\")\\nf.flush()\\nexit(0)\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n today = 0\\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\\n \\n if end <= today: \\n continue # <-- 3a)\\n if beg <= today:\\n days-= end - today # <-- 3b)\\n else: \\n days-= end - beg + 1 # <-- 3c)\\n\\n today = end\\n \\n return days # <-- 4)\",\n \"runtime\": \"285\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\\n\\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\\n \\n if end <= today: continue # <-- 3a)\\n if beg <= today: days-= end - today # <-- 3b)\\n else: days-= end - beg + 1 # <-- 3c)\\n\\n today = end\\n \\n return days # <-- 4)\",\n \"runtime\": \"323\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x:x[0])\\n ans = 0\\n curr_day = 0\\n for start, end in meetings:\\n if start>curr_day:\\n ans+=start-curr_day-1\\n curr_day = max(curr_day,end)\\n return ans+days-curr_day\",\n \"runtime\": \"361\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n n = len(meetings)\\n meetings = sorted(meetings, key=lambda k: k[0])\\n start, end = meetings[0]\\n res = start - 1\\n for i in range(1, n):\\n if meetings[i][0] <= end:\\n end = max(end, meetings[i][1])\\n else:\\n res += meetings[i][0] - end - 1\\n start, end = meetings[i]\\n res += days - end\\n return res\",\n \"runtime\": \"399\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n starts = []\\n ends = []\\n for s, e in meetings:\\n starts.append(s)\\n ends.append(e)\\n \\n starts.sort()\\n ends.sort()\\n sIdx, eIdx = 1, 0\\n count = starts[0] - 1\\n\\n while sIdx < len(starts):\\n\\n if starts[sIdx] > ends[eIdx]:\\n count += starts[sIdx] - ends[eIdx] - 1\\n sIdx += 1\\n eIdx += 1\\n \\n return count + (days-ends[-1])\\n \",\n \"runtime\": \"438\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x:x[0])\\n ans = 0\\n curr_day = 0\\n for meeting in meetings:\\n if meeting[0]>curr_day:\\n ans+=meeting[0]-curr_day-1\\n curr_day = max(curr_day,meeting[1])\\n return ans+days-curr_day\",\n \"runtime\": \"476\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n available = [[1,days]]\\n for m in meetings:\\n new = []\\n for a in available:\\n if m[0] <= a[0] and a[1] <= m[1]:\\n # entirely cut out\\n pass\\n elif a[0] < m[0] and m[1] < a[1]:\\n # split available in 2\\n new.append([a[0], m[0]-1])\\n new.append([m[1]+1, a[1]])\\n elif m[0] <= a[0] <= m[1]:\\n # overlap start of available\\n new.append( [m[1] + 1, a[1]] )\\n elif m[0] <= a[1] <= m[1]:\\n # overlap end of available\\n new.append( [a[0], m[0] - 1] )\\n else:\\n # no overlap, carry avialble forward\\n new.append(a)\\n available = new\\n\\n ans = 0\\n for a in available:\\n ans += a[1] - a[0] + 1\\n return ans\\n \\n\\n \",\n \"runtime\": \"514\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\\n\\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\\n \\n if end <= today: continue # <-- 3a)\\n if beg <= today: days-= end - today # <-- 3b)\\n else: days-= end - beg + 1 # <-- 3c)\\n\\n today = end\\n \\n return days # <-- 4)\",\n \"runtime\": \"552\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n meetings = sorted(meetings, key=lambda x:x[0])\\n res = 0\\n currEnd = 0\\n\\n for start, end in meetings:\\n\\n if start > currEnd+1:\\n res += (start-(currEnd+1))\\n \\n currEnd = max(currEnd, end)\\n \\n res+= (days-currEnd)\\n \\n return res\",\n \"runtime\": \"591\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key = lambda x: x[0])\\n\\n prev_start, prev_end = meetings[0] \\n\\n arr = []\\n for start, end in meetings[1:]:\\n if start > prev_end:\\n arr.append((prev_start, prev_end))\\n prev_start, prev_end = start, end\\n else:\\n prev_end = max(prev_end, end)\\n \\n arr.append((prev_start, prev_end))\\n\\n res = 0\\n for (start, end), (start_, end_) in zip(arr, arr[1:]):\\n res += start_ - end - 1\\n \\n res += (arr[0][0] - 1)\\n res += (days - arr[-1][1])\\n\\n return res\\n\\n \",\n \"runtime\": \"629\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]], today = 0) -> int:\\n\\n for beg, end in sorted(meetings, key = lambda x: x[0]): # <-- 1)\\n \\n if end <= today: continue # <-- 3a)\\n if beg <= today: days-= end - today # <-- 3b)\\n else: days-= end - beg + 1 # <-- 3c)\\n\\n today = end\\n \\n return days # <-- 4)\",\n \"runtime\": \"667\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key = lambda x: x[0])\\n\\n prev_start, prev_end = meetings[0] \\n\\n arr = []\\n for start, end in meetings[1:]:\\n if start > prev_end:\\n arr.append((prev_start, prev_end))\\n prev_start, prev_end = start, end\\n else:\\n prev_end = max(prev_end, end)\\n \\n arr.append((prev_start, prev_end))\\n\\n res = 0\\n for (_, end), (start_, _) in zip(arr, arr[1:]):\\n res += start_ - end - 1\\n \\n res += (arr[0][0] - 1)\\n res += (days - arr[-1][1])\\n\\n return res\\n\\n \",\n \"runtime\": \"705\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x :x[0])\\n current_Days = []\\n current = meetings[0]\\n for i in range(1,len(meetings)):\\n if current[1]>=meetings[i][0]:\\n current[1]=max(current[1],meetings[i][1])\\n else:\\n current_Days.append(current)\\n current = meetings[i]\\n current_Days.append(current)\\n for i in current_Days:\\n x = i[1]+1-i[0]\\n days-=x\\n return days\\n\\n\",\n \"runtime\": \"744\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n def merge_intervals(unsorted_meetings: List[List[int]]) -> List[List[int]]:\\n if not unsorted_meetings:\\n return []\\n merged_intervals = []\\n sorted_meetings = sorted(unsorted_meetings, key=lambda x: x[0])\\n prev_start_i = sorted_meetings[0][0]\\n prev_end_i = sorted_meetings[0][1]\\n for start_i, end_i in sorted_meetings[1:]:\\n if prev_end_i >= start_i:\\n prev_end_i = max(prev_end_i,end_i)\\n continue\\n merged_intervals.append([prev_start_i, prev_end_i])\\n prev_start_i = start_i\\n prev_end_i = end_i\\n merged_intervals.append([prev_start_i, prev_end_i])\\n return merged_intervals\\n \\n\\n intervals = merge_intervals(meetings)\\n total_meeting_days = 0\\n for start_i, end_i in intervals:\\n total_meeting_days += (end_i - start_i + 1) \\n return days - total_meeting_days\\n\",\n \"runtime\": \"782\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x: x[0])\\n\\n merged = [meetings[0]]\\n for current in meetings[1:]:\\n last = merged[-1]\\n if current[0] <= last[1]:\\n last[1] = max(last[1], current[1])\\n else:\\n merged.append(current)\\n\\n total = merged[0][0] - 1\\n\\n for i in range(1, len(merged)):\\n total+=merged[i][0] - merged[i-1][1] - 1\\n\\n total+=days - merged[-1][1]\\n \\n return total\\n \",\n \"runtime\": \"820\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x: x[0])\\n\\n free = meetings[0][0] - 1\\n next_end = meetings[0][0]\\n\\n for start, end in meetings:\\n if next_end < start:\\n free += start-next_end-1\\n next_end = max(next_end, end)\\n \\n if next_end < days:\\n free += days - next_end\\n return free\\n \",\n \"runtime\": \"858\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n meetings.sort(key=lambda x: x[0])\\n con = []\\n total = 0 \\n for i in meetings:\\n if not con:\\n con = i\\n continue\\n \\n if i[0] <= con[1]:\\n con[1] = max (con[1], i[1])\\n else:\\n total += con[1] - con[0] + 1\\n con = i\\n \\n total += con[1] - con[0] + 1\\n return days - total \",\n \"runtime\": \"897\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n starts = []\\n ends = []\\n for s, e in meetings:\\n starts.append(s)\\n ends.append(e)\\n \\n starts.sort()\\n ends.sort()\\n sIdx, eIdx = 1, 0\\n count = starts[0] - 1\\n\\n while sIdx < len(starts):\\n\\n if starts[sIdx] <= ends[eIdx]:\\n sIdx += 1\\n eIdx += 1\\n else:\\n count += starts[sIdx] - ends[eIdx] - 1\\n sIdx += 1\\n eIdx += 1\\n \\n return count + (days-ends[-1])\\n \",\n \"runtime\": \"935\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n totalMeetings = len(meetings)\\n meetings.sort(key=lambda x: x[0])\\n freeDays = 0\\n freeDays += meetings[0][0] - 1\\n lastMeetingDay = meetings[0][1]\\n\\n for i in range(1, totalMeetings):\\n if meetings[i][0] > lastMeetingDay:\\n freeDays += (meetings[i][0] - lastMeetingDay - 1)\\n lastMeetingDay = meetings[i][1]\\n elif lastMeetingDay < meetings[i][1]:\\n lastMeetingDay = meetings[i][1]\\n \\n freeDays += days - lastMeetingDay\\n\\n return freeDays\\n\",\n \"runtime\": \"973\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x: x[0])\\n intervals = [meetings[0]]\\n for m in meetings[1:]:\\n if m[0] <= intervals[-1][1]:\\n intervals[-1][1] = max(m[1], intervals[-1][1])\\n else:\\n intervals.append(m)\\n \\n busy = 0\\n for x in intervals:\\n busy+=(x[1]-x[0]+1)\\n return days - busy\",\n \"runtime\": \"1011\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n # sort starts and ends\\n starts = [interval[0] for interval in meetings]\\n ends = [interval[1] for interval in meetings]\\n starts.sort()\\n ends.sort()\\n\\n # account for time before first meeting\\n free_days = 0\\n first_start = starts[0]\\n if first_start > 1:\\n free_days += first_start - 1\\n\\n s_i = 0\\n e_i = 0\\n current_mtgs = 0\\n while s_i < len(starts) and e_i < len(ends):\\n if ends[e_i] < starts[s_i]:\\n current_mtgs -= 1\\n if current_mtgs == 0:\\n free_days += starts[s_i] - ends[e_i] - 1\\n e_i += 1\\n else:\\n # WHY DOES THIS ELSE WORK\\n # popping off a start as smallest\\n current_mtgs += 1\\n s_i += 1\\n\\n # account for time after end of last meeting\\n if ends[-1] < days:\\n free_days += days - ends[-1]\\n \\n # while e_i < len(ends):\\n # current_mtgs -= 1\\n # if current_mtgs == 0:\\n # free_days += days - ends[e_i]\\n # e_i += 1\\n\\n return free_days\\n\",\n \"runtime\": \"1050\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x: (x[0]))\\n currDay = 1\\n count = 0\\n\\n #print(meetings)\\n\\n for i in range(0, len(meetings)):\\n l = meetings[i][0]\\n r = meetings[i][1]\\n\\n if r < currDay:\\n continue\\n elif l <= currDay and r >= currDay:\\n currDay = r + 1\\n else:\\n count += l - currDay\\n currDay = r + 1\\n \\n if currDay <= days:\\n count += days - currDay + 1\\n\\n return count\\n \",\n \"runtime\": \"1088\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n\\n\\n meetings.sort(key = lambda x: x[0])\\n\\n result = 0\\n prev = meetings[0]\\n for i in range(len(meetings) - 1):\\n if prev[1] < meetings[i+1][0]: \\n result += (meetings[i+1][0] - prev[1]) - 1\\n prev = meetings[i+1]\\n else:\\n prev[1] = max(prev[1], meetings[i+1][1])\\n \\n\\n if prev[1] < days:\\n result += days - prev[1]\\n if meetings[0][0] > 1:\\n result += meetings[0][0] - 1\\n \\n return result\",\n \"runtime\": \"1126\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key = lambda x: x[0])\\n\\n prev_start, prev_end = meetings[0] \\n\\n arr = []\\n for start, end in meetings[1:]:\\n if start > prev_end:\\n arr.append((prev_start, prev_end))\\n prev_start, prev_end = start, end\\n else:\\n prev_end = max(prev_end, end)\\n \\n arr.append((prev_start, prev_end))\\n\\n res = 0\\n for (start, end), (start_, end_) in zip(arr, arr[1:]):\\n res += start_ - end - 1\\n \\n res += (arr[0][0] - 1)\\n res += (days - arr[-1][1])\\n\\n return res\\n\\n \",\n \"runtime\": \"1164\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x : x[0])\\n prev = meetings[0] # [meetings[0]]\\n # res = 0\\n res = prev[0] - 1\\n for s, e in meetings[1:]:\\n if s > prev[1]:\\n res += s - prev[1] - 1\\n prev = [s, e]\\n else:\\n prev[1] = max(prev[1], e)\\n\\n res += days - prev[1]\\n\\n return res \",\n \"runtime\": \"1203\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n # sort in ascending order wrt start of meeting\\n meetings = sorted(meetings, key=lambda meeting: meeting[0])\\n\\n # calculate the total number of meetings\\n length = 0\\n for i, meeting in enumerate(meetings):\\n if (i == 0):\\n length += meeting[1] - meeting[0] + 1\\n else:\\n if (meeting[0] <= meetings[i - 1][1]): # overlap\\n if (meeting[1] > meetings[i - 1][1]):\\n length += meeting[1] - meetings[i - 1][1]\\n else:\\n meetings[i][1] = meetings[i - 1][1]\\n else:\\n length += meeting[1] - meeting[0] + 1\\n \\n return (days - length if (days-length > 0) else 0)\",\n \"runtime\": \"1241\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x: x[0])\\n # print(meetings)\\n mt, i, j, n = [], 0, 0, len(meetings)\\n while i < n:\\n # while i<n and mt[-1][0]==meetings[i][0]:\\n # mt[-1][1]=max(mt[-1][1],meetings[i][1])\\n # i+=1\\n mt.append(meetings[i])\\n while i < n and mt[-1][1] >= meetings[i][0]:\\n mt[-1][1] = max(mt[-1][1], meetings[i][1])\\n i += 1\\n # print(mt)\\n ans = mt[0][0] - 1 + days - mt[-1][1]\\n for i in range(1, len(mt)):\\n ans += mt[i][0] - mt[i - 1][1] - 1\\n # print(ans)\\n return ans\",\n \"runtime\": \"1279\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key = lambda x: x[0])\\n\\n prev_start, prev_end = meetings[0] \\n\\n arr = []\\n for start, end in meetings[1:]:\\n if start > prev_end:\\n arr.append((prev_start, prev_end))\\n prev_start, prev_end = start, end\\n else:\\n prev_end = max(prev_end, end)\\n \\n arr.append((prev_start, prev_end))\\n\\n res = 0\\n for (_, end), (start_, _) in zip(arr, arr[1:]):\\n res += start_ - end - 1\\n \\n res += (arr[0][0] - 1)\\n res += (days - arr[-1][1])\\n\\n return res\\n\\n \",\n \"runtime\": \"1279\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n meetings.sort(key=lambda x:x[0])\\n res = 0\\n currEnd = 0\\n\\n for start, end in meetings:\\n\\n if start > currEnd+1:\\n res += (start-(currEnd+1))\\n \\n currEnd = max(currEnd, end)\\n \\n res+= (days-currEnd)\\n \\n return res\",\n \"runtime\": \"1317\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n meetings.sort(key=lambda x: x[0])\\n \\n available_days = days\\n last_end = 0\\n \\n for start, end in meetings:\\n # If this meeting starts after the last one ended, count the gap\\n if start > last_end:\\n available_days -= min(end, days) - start + 1\\n last_end = end\\n # If this meeting overlaps with the last one, only count the extension\\n elif end > last_end:\\n available_days -= min(end, days) - last_end\\n last_end = end\\n \\n return available_days\\n \",\n \"runtime\": \"1317\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n def mergeIntervals(intervals):\\n res = [intervals[0]]\\n for i in range(1, len(intervals)):\\n left = res[-1]\\n right = intervals[i]\\n if right[0] <= left[1]:\\n res[-1] = [res[-1][0], max(res[-1][1], right[1])]\\n else:\\n res.append(right)\\n\\n return res\\n\\n \\n meetings.sort(key = lambda x: x[0])\\n intervals = mergeIntervals(meetings)\\n\\n res = 0\\n curr = 1\\n for interval in intervals:\\n res += max(interval[0] - curr, 0)\\n curr = interval[1] + 1\\n \\n return res + days - intervals[-1][1]\",\n \"runtime\": \"1356\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n left = 0\\n index = 0\\n while index < len(meetings):\\n last_meeting_end = meetings[index][1]\\n while left < len(meetings) and meetings[left][0] <= last_meeting_end:\\n if meetings[left][1] > last_meeting_end:\\n last_meeting_end = meetings[left][1]\\n left += 1\\n days -= last_meeting_end - meetings[index][0] + 1\\n index = left\\n return days\",\n \"runtime\": \"1356\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n # sorting\\n meetings.sort(key=lambda x: (x[0], x[1]))\\n \\n stack = []\\n for s, e in meetings:\\n if len(stack) > 0 and stack[-1][1] >= s:\\n stack[-1][1] = max(stack[-1][1], e)\\n else:\\n stack.append([s, e])\\n count = 0\\n \\n l = len(stack)\\n for i in range(1, l):\\n count += stack[i][0] - stack[i-1][1] - 1\\n \\n count += stack[0][0] - 1\\n count += days - stack[-1][1]\\n return count\\n \\n \\n # MLE\\n all_days = [0 for y in range(2+days)]\\n \\n for s, e in meetings:\\n all_days[s] += 1\\n all_days[e+1] -= 1\\n result = 0\\n for i in range(1, days+1):\\n all_days[i] += all_days[i-1]\\n if all_days[i] == 0:\\n result += 1\\n return result\\n \",\n \"runtime\": \"1394\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n ans=[]\\n meetings.sort()\\n for i in range(len(meetings)):\\n if not ans:\\n ans.append(meetings[i])\\n else:\\n ar1=ans[-1]\\n ar2=meetings[i]\\n if ar1[1]>=ar2[0]:\\n ans[-1]=[ar1[0],max(ar1[1],ar2[1])]\\n else:\\n ans.append(ar2)\\n count=0\\n count+=ans[0][0]-1\\n count+=days-ans[-1][1]\\n for i in range(1,len(ans)):\\n gap=ans[i][0]-ans[i-1][1]-1\\n count+=gap\\n return count\",\n \"runtime\": \"1432\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n\\n intervals = []\\n\\n intervals.append(meetings[0])\\n\\n for i in range(1, len(meetings)):\\n prev_st, prev_en = intervals[-1] # pick from intervals since that contains our merged intervals\\n curr_st, curr_en = meetings[i]\\n\\n if curr_st <= prev_en:\\n intervals.pop() # remove the interval since we are recalculating the start and end dates\\n newrange = [prev_st, max(prev_en, curr_en)]\\n intervals.append(newrange)\\n else:\\n intervals.append([curr_st, curr_en])\\n \\n for st, en in intervals:\\n meeting_day_count = (en-st)+1\\n days -= meeting_day_count\\n \\n return days\",\n \"runtime\": \"1432\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n res = abs(meetings[0][0] - 1 )\\n for i in range(1,len(meetings)):\\n if meetings[i][0] <= meetings[i-1][1]:\\n if meetings[i][1] < meetings[i-1][1]:\\n meetings[i][1] = meetings[i-1][1]\\n else:\\n miss = meetings[i][0] - meetings[i-1][1]\\n res += (miss - 1)\\n res += (days - meetings[len(meetings)-1][1] )\\n return res\\n \",\n \"runtime\": \"1470\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n\\n intervals = meetings\\n\\n\\n if not intervals:\\n return 0\\n\\n intervals.sort(key = lambda x:(x[0],x[1]))\\n\\n # merged_intervals = [intervals[0]]\\n\\n # for i in range(len(intervals)):\\n\\n # if intervals[i][0] <= merged_intervals[-1][1]:\\n # last_interval = merged_intervals.pop()\\n # new_interval = [last_interval[0],max(last_interval[1],intervals[i][1])]\\n # merged_intervals.append(new_interval)\\n # else:\\n # merged_intervals.append(intervals[i])\\n\\n left_pointer = 0\\n\\n\\n for right_pointer in range(len(intervals)):\\n\\n if intervals[left_pointer][1] >= intervals[right_pointer][0]:\\n intervals[left_pointer][1] = max(intervals[left_pointer][1],intervals[right_pointer][1]) \\n else:\\n left_pointer += 1\\n intervals[left_pointer] = intervals[right_pointer]\\n \\n\\n intervals = intervals[:min(left_pointer+1,len(intervals))]\\n\\n print(intervals)\\n \\n count = 0\\n\\n for start,end in intervals:\\n\\n count += (end-start+1)\\n \\n return days - count\\n \",\n \"runtime\": \"1470\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n # events = []\\n # for s, e in meetings:\\n # events.append((s, 1))\\n # events.append((e, -1))\\n # events.sort(key = lambda x : x[0])\\n\\n # res = 0\\n # cnt = 0\\n # last_day = None\\n # i = 1\\n # for d, c in events:\\n # if cnt == 0 and last_day:\\n # if last_day <= days:\\n # res += 1\\n\\n # cnt += c\\n # last_day = d\\n \\n # if cnt == 0 and last_day == days - 1:\\n # res += 1\\n # return res \\n events = []\\n for s, e in meetings:\\n events.append((s, 1)) # Meeting starts\\n events.append((e + 1, -1)) # Meeting ends (e+1 to mark the day after as free)\\n\\n events.sort(key=lambda x: x[0])\\n\\n res = 0\\n cnt = 0\\n last_day = 1\\n\\n for d, c in events:\\n if cnt == 0:\\n # Add the number of free days between last_day and the current day (d-1)\\n if d > last_day:\\n res += d - last_day\\n\\n cnt += c\\n last_day = d\\n\\n # After processing all events, check for free days from last event to the last day\\n if last_day <= days and cnt == 0:\\n res += days - last_day + 1\\n \\n return res\",\n \"runtime\": \"1509\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n arr = []\\n for s,e in meetings:\\n arr.append((s, 1))\\n arr.append((e+1, -1))\\n arr.sort()\\n ans = 0\\n num = 0\\n i = 0\\n prev = 1\\n while i < len(arr):\\n if arr[i][0] < 1: i += 1\\n elif arr[i][0] <= days+1:\\n if num == 0:\\n ans += arr[i][0] - prev\\n # number of free days\\n j = i\\n while j < len(arr) and arr[j][0] == arr[i][0]:\\n num += arr[j][1]\\n j += 1\\n if num == 0: prev = arr[i][0]\\n i = j\\n \\n else: break\\n ans += days - prev + 1\\n return ans\\n \",\n \"runtime\": \"1509\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapq.heapify(meetings)\\n endTimes = [0]\\n freeDays = 0\\n\\n while meetings:\\n start, end = heapq.heappop(meetings)\\n\\n while endTimes and start > endTimes[0]:\\n oldEnd = heapq.heappop(endTimes)\\n\\n if len(endTimes) == 0:\\n freeDays += start - oldEnd - 1\\n\\n heapq.heappush(endTimes, end)\\n return freeDays + (days - max(endTimes))\\n\",\n \"runtime\": \"1547\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings, key=lambda x: x[0])\\n meetings.append((days + 1, days + 2))\\n i = 1\\n s = meetings[0][0]\\n e = meetings[0][1]\\n while i < (len(meetings)):\\n print(s, e, meetings[i])\\n if e < meetings[i][0]:\\n days -= e - s + 1\\n s = meetings[i][0]\\n e = meetings[i][1]\\n elif e < meetings[i][1]:\\n e = meetings[i][1]\\n i += 1\\n return days\\n\",\n \"runtime\": \"1547\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n\\n\\n meetings.sort(key= lambda x : (x[0], x[1]))\\n\\n i = 0\\n freedays = meetings[0][0] -1 \\n\\n def IsOverLap( a , b):\\n if a[0] <= b[0] <= a[1] or b[0] <= a[0] <= b[1]:\\n return True\\n else:\\n return False\\n\\n \\n\\n res = meetings[0]\\n max_end = meetings[i][1]\\n for i in range(1,len(meetings)):\\n max_end = max(max_end , meetings[i][1])\\n if IsOverLap(res, meetings[i]):\\n res = [min(res[0], meetings[i][0]) , max(res[-1], meetings[i][1])]\\n else:\\n freedays = freedays + abs(meetings[i][0] - res[-1] -1)\\n res = (meetings[i])\\n\\n return(freedays + (days - max_end))\\n \\n \",\n \"runtime\": \"1585\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heap=[]\\n for i in range(len(meetings)):\\n heapq.heappush(heap,(meetings[i][0],meetings[i][1]))\\n ans=[]\\n for i in range(len(heap)):\\n x,y=heapq.heappop(heap)\\n if ans==[] or ans[-1][1]<x:\\n ans.append([x,y])\\n else:\\n ans[-1][1]=max(y,ans[-1][1])\\n c=0\\n for i in range(len(ans)):\\n c+=ans[i][1]-ans[i][0]+1\\n return days-c\",\n \"runtime\": \"1585\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n h = []\\n for m in meetings:\\n heapq.heappush(h, m)\\n\\n f = []\\n while h:\\n l, r = heapq.heappop(h)\\n if not f:\\n f.append([l, r])\\n else:\\n i = bisect.bisect_left(f, [l, r])\\n if f[i - 1][1] < l:\\n f.append([l, r])\\n else:\\n f[i - 1][1] = max(f[i - 1][1], r)\\n \\n\\n for l, r in f:\\n days -= (r - l + 1)\\n if days <= 0:\\n return 0\\n\\n return days\",\n \"runtime\": \"1623\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n events = []\\n for vec in meetings:\\n events.append([vec[0], 1])\\n events.append([vec[1], -1])\\n\\n events.append([0, 0])\\n events.append([days+1, 0])\\n events.sort()\\n ans = 0\\n running_events = 0\\n for i, event in enumerate(events[:len(events)-1]):\\n running_events += (events[i][1])\\n if running_events == 0:\\n ans += max(0, (events[i+1][0] - events[i][0] - 1))\\n\\n return ans\",\n \"runtime\": \"1623\"\n },\n {\n \"code\": \"from heapq import heapify, heappop\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapify(meetings)\\n res = 0\\n last = 1\\n\\n while meetings:\\n start, end = heappop(meetings)\\n if start > last:\\n res += start - last\\n \\n if end > days:\\n break\\n \\n last = max(end+1, last)\\n print(last, res)\\n \\n return res + max(days-last+1, 0)\",\n \"runtime\": \"1662\"\n },\n {\n \"code\": \"from sortedcontainers import SortedSet\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n l = SortedSet()\\n d = defaultdict(int)\\n \\n for meeting in meetings:\\n a, b = meeting[0], meeting[1]\\n l.add(a)\\n l.add(b+1)\\n d[a]+=1\\n d[b+1]-=1\\n \\n res = 0\\n total = 0\\n previous = 1\\n for day in l:\\n total+=d[day]\\n if previous!=-1 and total>0:\\n res += day-previous\\n previous=-1\\n elif previous==-1 and total==0:\\n previous = day\\n if previous!=-1:\\n res+=days+1-previous\\n \\n return res\\n \",\n \"runtime\": \"1662\"\n },\n {\n \"code\": \"from sortedcontainers import SortedSet\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n l = SortedSet()\\n d = defaultdict(int)\\n \\n for meeting in meetings:\\n a, b = meeting[0], meeting[1]\\n l.add(a)\\n l.add(b+1)\\n d[a]+=1\\n d[b+1]-=1\\n \\n res = 0\\n total = 0\\n previous = 1\\n for day in l:\\n total+=d[day]\\n if previous!=-1 and total>0:\\n res += day-previous\\n previous=-1\\n elif previous==-1 and total==0:\\n previous = day\\n if previous!=-1:\\n res+=days+1-previous\\n \\n return res\\n \",\n \"runtime\": \"1700\"\n },\n {\n \"code\": \"from sortedcontainers import SortedSet\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n l = SortedSet()\\n d = defaultdict(int)\\n \\n for meeting in meetings:\\n a, b = meeting[0], meeting[1]\\n l.add(a)\\n l.add(b+1)\\n d[a]+=1\\n d[b+1]-=1\\n \\n res = 0\\n total = 0\\n previous = 1\\n for day in l:\\n total+=d[day]\\n if previous!=-1 and total>0:\\n res += day-previous\\n previous=-1\\n elif previous==-1 and total==0:\\n previous = day\\n if previous!=-1:\\n res+=days+1-previous\\n \\n return res\\n \",\n \"runtime\": \"1700\"\n },\n {\n \"code\": \"def merge_sort(arr: List[List[int]]) -> List[List[int]]:\\n n = len(arr)\\n if n < 2: return arr\\n \\n mid = n // 2\\n left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])\\n \\n i, j, l, r, ans = 0, 0, len(left), len(right), []\\n while i < l and j < r:\\n if left[i] < right[j]:\\n ans.append(left[i])\\n i += 1\\n else:\\n ans.append(right[j])\\n j += 1\\n while i < l:\\n ans.append(left[i])\\n i += 1\\n while j < r:\\n ans.append(right[j])\\n j += 1\\n return ans\\n \\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n arr, j, n, ans = merge_sort(meetings), 1, len(meetings), days\\n s1, e1 = arr[0]\\n while j < n:\\n s2, e2 = arr[j]\\n if s2 <= e1: e1 = max(e1, e2)\\n else:\\n ans -= e1 - s1 + 1\\n s1, e1 = s2, e2\\n j += 1\\n ans -= e1 - s1 + 1\\n return ans\",\n \"runtime\": \"1738\"\n },\n {\n \"code\": \"from sortedcontainers import SortedSet\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n l = SortedSet()\\n d = defaultdict(int)\\n \\n for meeting in meetings:\\n a, b = meeting[0], meeting[1]\\n l.add(a)\\n l.add(b+1)\\n d[a]+=1\\n d[b+1]-=1\\n \\n res = 0\\n total = 0\\n previous = 1\\n for day in l:\\n total+=d[day]\\n if previous!=-1 and total>0:\\n res += day-previous\\n previous=-1\\n elif previous==-1 and total==0:\\n previous = day\\n if previous!=-1:\\n res+=days+1-previous\\n \\n return res\\n \",\n \"runtime\": \"1776\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n starts = sorted([a[0] for a in meetings])\\n ends = sorted(a[1] for a in meetings)\\n\\n count_map = defaultdict(int)\\n for a in meetings:\\n count_map[a[0]]+=1\\n count_map[a[1]+1]-=1\\n print(count_map.items())\\n count_map=sorted(count_map.items(), key=lambda x: x[0])\\n cnt = count_map[0][1]\\n\\n count_meeting_days = 0\\n for i in range(1, len(count_map)):\\n d = count_map[i][0]\\n c = count_map[i][1]\\n \\n if cnt > 0:\\n count_meeting_days += d - count_map[i-1][0]\\n cnt += c\\n print(count_map[i][0], c, cnt)\\n\\n # 1 1 1 0\\n # 4 -1 0 4\\n # 5 1 1\\n # 8 -1 0\\n # 9 1 1\\n # 11 -1 0\\n return days - count_meeting_days\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"1815\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n cur_meets = 0\\n day_count = 0\\n last_end = 0\\n\\n h = []\\n for s, e in meetings:\\n heapq.heappush(h, (s, False))\\n heapq.heappush(h, (e, True))\\n\\n while h:\\n t, is_end = heapq.heappop(h)\\n\\n if not is_end and cur_meets == 0:\\n day_count += t - last_end - 1\\n if is_end: last_end = t\\n cur_meets += -1 if is_end else 1\\n day_count += max(0, days - last_end)\\n return day_count\",\n \"runtime\": \"1815\"\n },\n {\n \"code\": \"def heapify(arr: List[List[int]], n: int, idx: int):\\n maxi, left, right = idx, idx * 2 + 1, idx * 2 + 2\\n if left < n and arr[left] > arr[maxi] : maxi = left\\n if right < n and arr[right] > arr[maxi] : maxi = right\\n if maxi != idx:\\n arr[idx], arr[maxi] = arr[maxi], arr[idx]\\n heapify(arr,n , maxi)\\n \\ndef heapsort(arr: List[List[int]]):\\n n = len(arr)\\n for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i)\\n\\n for i in range(n - 1, 0, -1):\\n arr[0], arr[i] = arr[i], arr[0]\\n heapify(arr, i, 0)\\n \\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n arr, j, n, ans = meetings[:], 1, len(meetings), days\\n heapsort(arr)\\n s1, e1 = arr[0]\\n while j < n:\\n s2, e2 = arr[j]\\n if s2 <= e1: e1 = max(e1, e2)\\n else:\\n ans -= e1 - s1 + 1\\n s1, e1 = s2, e2\\n j += 1\\n ans -= e1 - s1 + 1\\n return ans\",\n \"runtime\": \"1853\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, d: int, m: List[List[int]]) -> int:\\n m.sort()\\n i = 1\\n k = m[0][1]\\n a = 0\\n n = len(m)\\n while i<n:\\n if k>m[i][0]:\\n m[i-1][1] = max(m[i-1][1],m[i][1])\\n del m[i]\\n n-=1\\n i-=1\\n k = m[i][1]\\n else:\\n if k<m[i][0]:\\n a+=m[i][0]-k-1\\n k = m[i][1]\\n i+=1\\n return a+d-m[-1][1]+m[0][0]-1\\n \",\n \"runtime\": \"1891\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = sorted(meetings)\\n\\n # merge the meetings\\n i = 1\\n while i <= len(meetings)-1:\\n lastMeeting = meetings[i-1]\\n currMeeting = meetings[i]\\n if lastMeeting[1] >= currMeeting[0]:\\n if lastMeeting[1] < currMeeting[1]:\\n lastMeeting[1] = currMeeting[1]\\n \\n meetings.pop(i)\\n \\n else:\\n i += 1\\n\\n # now, we check for the sum of the difference of meetings\\n for j in meetings:\\n temp = j[1] - (j[0] - 1) \\n days = days - temp\\n return days\\n\",\n \"runtime\": \"1929\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":57,"string":"57"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n ans = meetings[0][0]-1\n curr_end = meetings[0][1]\n for i in range(1,len(meetings)):\n s,e = meetings[i]\n if s>curr_end:\n ans+=s-curr_end-1\n curr_end=e\n else:\n curr_end = max(curr_end,e)\n if days>curr_end:\n ans+=days-curr_end\n return ans\nS = Solution()\nf = open('user.out','w')\nfor i1,i2 in zip(stdin,stdin):\n f.write(f\"{S.countDays(loads(i1),loads(i2))}\\n\")\nf.flush()\nexit(0)","memory":"34700"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapq.heapify(meetings)\n s, e = 1, 0\n while meetings:\n start, end = heappop(meetings)\n # if start <= e:\n # e = max(e, end)\n # else:\n # days -= (e - s) + 1\n # s, e = start, max(e, end)\n if start > e:\n days -= (e - s) + 1\n s = start\n e = max(e, end)\n days -= (e - s) + 1\n return days","memory":"51600"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapq.heapify(meetings)\n endTimes = [0]\n freeDays = 0\n\n while meetings:\n start, end = heapq.heappop(meetings)\n\n while endTimes and start > endTimes[0]:\n oldEnd = heapq.heappop(endTimes)\n\n if len(endTimes) == 0:\n freeDays += start - oldEnd - 1\n\n heapq.heappush(endTimes, end)\n return freeDays + (days - max(endTimes))\n","memory":"51700"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapq.heapify(meetings)\n s, e = heappop(meetings)\n while meetings:\n start, end = heappop(meetings)\n if end < e: continue\n if start <= e:\n e = end\n else:\n days -= (e - s) + 1\n s, e = start, end\n days -= (e - s) + 1\n return days","memory":"51800"},{"code":"from heapq import heapify, heappop\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapify(meetings)\n res = 0\n last = 1\n\n while meetings:\n start, end = heappop(meetings)\n if start > last:\n res += start - last\n \n if end > days:\n break\n \n last = max(end+1, last)\n print(last, res)\n \n return res + max(days-last+1, 0)","memory":"51900"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n heapq.heapify(meetings)\n s, e = 1, 0\n while meetings:\n start, end = heappop(meetings)\n if start <= e:\n e = max(e, end)\n else:\n days -= (e - s) + 1\n s, e = start, max(e, end)\n days -= (e - s) + 1\n return days","memory":"52000"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(reverse=True)\n s = [meetings.pop()]\n while meetings:\n cur = meetings.pop()\n if cur[0] <= s[-1][1]:\n s[-1][1] = max(s[-1][1], cur[1])\n else:\n s.append(cur)\n curDay = 1\n out = 0\n print(s)\n for interval in s:\n out += interval[0] - curDay\n curDay = interval[1] + 1\n print(out)\n return out + days - curDay + 1\n\n ","memory":"53000"},{"code":"class Solution:\n def countDays(self, d: int, m: List[List[int]]) -> int:\n m.sort()\n i = 1\n k = m[0][1]\n a = 0\n n = len(m)\n while i<n:\n if k>m[i][0]:\n m[i-1][1] = max(m[i-1][1],m[i][1])\n del m[i]\n n-=1\n i-=1\n k = m[i][1]\n else:\n if k<m[i][0]:\n a+=m[i][0]-k-1\n k = m[i][1]\n i+=1\n return a+d-m[-1][1]+m[0][0]-1\n ","memory":"53200"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n\n i = 0\n ans = 0\n while i < len(meetings) - 1:\n currStart, currEnd = meetings[i]\n nextStart, nextEnd = meetings[i+1]\n\n if currEnd >= nextStart:\n del(meetings[i+1])\n meetings[i] = [min(currStart, nextStart), max(currEnd, nextEnd)]\n else:\n ans += meetings[i+1][0] - meetings[i][1] - 1\n i += 1\n\n\n ans += days - meetings[-1][1]\n ans += meetings[0][0] - 1\n return ans","memory":"53400"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x: x[0])\n i, len_meetings = 1, len(meetings)\n while i < len_meetings:\n prev, curr = meetings[i - 1], meetings[i]\n if prev[1] >= curr[0]:\n meetings[i - 1][0] = min(prev[0], curr[0])\n meetings[i - 1][1] = max(prev[1], curr[1])\n meetings.pop(i)\n len_meetings -= 1\n continue\n i += 1\n for i in range(0, len_meetings):\n days -= (meetings[i][1] - meetings[i][0] + 1)\n\n return days if days >= 0 else 0\n","memory":"53500"},{"code":"'''\nGENERAL NOTES / CONSTRAINTS...\n* days = number of total days an employee is available to work (starting from day 1)\n* each meeting is an inclusive interval representing the days in which the meeting lasts\n\n--> GOAL: from day 1 to day n, figure out how many days are not scheduled in any meetings <--\n\nTHOUGHT PROCESSES...\n* obviously interval problem (merging intervals)\n - sort intervals\n - merge overlapping intervals\n - create a set which contains all integers from 1 up to n (where n is the last/largest day\n that occurs in any of the intervals)\n - iterate through all the merged intervals and delete all of the numbers from the set that\n appear in any of the intervals\n* ACTUALLY, still interval problem, but I don't think we necessarily have to sort + merge\n - create the aforementioned set\n - iterate through the intervals one more time, and for each interval, remove all numbers\n in range of the interval from the set\n - return length of the set at the end\n - PROBLEM: yeah nevermind, implemented this within the first 14 minutes and the time limit\n was exceeded, so need to go back to the sort + merge method\n* NEW PROBLEM: memory limit exceeded...? (I guess we can't track all the numbers with a set)\n* Instead of tracking all numbers from 1 to days in a set, we will simply track the number of days\n off\n - initialize \"days_off\" to be equal to days\n - iterate through the intervals, and for each interval [start, end], decrement \"days_off\"\n by start - end + 1\n'''\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n # STEP 1: sort intervals\n meetings.sort()\n\n # STEP 2: merge interlapping intervals\n ptr = 1\n while ptr < len(meetings):\n left, right = meetings[ptr - 1], meetings[ptr]\n if left[1] >= right[0]:\n meetings[ptr] = [min(left[0], right[0]), max(left[1], right[1])]\n meetings.pop(ptr - 1)\n else:\n ptr += 1\n \n # STEP 3: count days off\n days_off = days\n for meeting in meetings:\n days_off -= meeting[1] - meeting[0] + 1\n \n return days_off\n","memory":"53500"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n merged = []\n\n while len(meetings) > 0:\n start1, end1 = meetings.pop(0)\n if len(meetings) == 0:\n merged.append([start1, end1])\n break\n start2, end2 = meetings.pop(0)\n\n if start2 <= end1:\n final_end = max(end1, end2)\n meetings.insert(0, [start1, final_end])\n else:\n merged.append([start1, end1])\n meetings.insert(0, [start2, end2])\n \n i = 1\n result = 0\n end = start = 0\n while i <= days:\n if len(merged) == 0:\n result += days - end\n break\n [start, end] = merged.pop(0)\n\n if i < start and start:\n result += start - i\n i = end + 1\n return result\n","memory":"53600"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n\n i = 0\n while i < len(meetings) - 1:\n currStart, currEnd = meetings[i]\n nextStart, nextEnd = meetings[i+1]\n\n if currEnd >= nextStart:\n del(meetings[i+1])\n meetings[i] = [min(currStart, nextStart), max(currEnd, nextEnd)]\n else:\n i += 1\n\n ans = 0\n for i in range(len(meetings) - 1):\n ans += meetings[i+1][0] - meetings[i][1] - 1\n\n ans += days - meetings[-1][1]\n ans += meetings[0][0] - 1\n return ans","memory":"53700"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n n=len(meetings)\n i=1\n while(i<n):\n a=meetings[i-1]\n b=meetings[i]\n if(a[1]>=b[0]):\n meetings[i-1]=[-1,-1]\n if(a[1]>=b[1]):\n meetings[i]=[a[0],a[1]]\n else:\n meetings[i]=[a[0],b[1]]\n i+=1\n res=[]\n for i in meetings:\n if(i!=[-1,-1]):\n res.append(i)\n j=1\n m=len(res)\n cnt=0\n while(j<m):\n x=res[j-1]\n y=res[j]\n if(x[1]<y[0]):\n k=abs(x[1]-y[0])-1\n cnt+=k\n j+=1\n if(res[0][0]!=1):\n cnt+=res[0][0]-1\n if(res[m-1][1]!=days):\n cnt+=days-res[m-1][1]\n return cnt\n\n\n ","memory":"62100"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n\n def merge_intervals(meetings):\n meetings.sort()\n\n lo = 0\n hi = 1\n\n n = len(meetings)\n\n while hi < n:\n if meetings[hi][0] <= meetings[lo][1]:\n meetings[lo][1] = max(meetings[hi][1], meetings[lo][1])\n meetings[lo][0] = min(meetings[lo][0], meetings[hi][0])\n meetings[hi] = [0, 0]\n hi += 1\n else:\n lo = hi\n hi += 1\n\n return meetings\n\n meetings = merge_intervals(meetings)\n # print(meetings)\n \n booked = 0\n for x, y in meetings:\n if x == 0 and y == 0:\n continue\n booked += y - x + 1\n\n return days - booked","memory":"62200"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n n=len(meetings)\n i=1\n while(i<n):\n a=meetings[i-1]\n b=meetings[i]\n if(a[1]>=b[0]):\n meetings[i-1]=[-1,-1]\n if(a[1]>=b[1]):\n meetings[i]=[a[0],a[1]]\n else:\n meetings[i]=[a[0],b[1]]\n i+=1\n res=[]\n for i in meetings:\n if(i!=[-1,-1]):\n res.append(i)\n print(meetings)\n j=1\n m=len(res)\n cnt=0\n while(j<m):\n x=res[j-1]\n y=res[j]\n if(x[1]<y[0]):\n k=abs(x[1]-y[0])-1\n cnt+=k\n # print(abs(a[1]-b[0]))\n # print(cnt)\n j+=1\n if(res[0][0]!=1):\n cnt+=res[0][0]-1\n if(res[m-1][1]!=days):\n cnt+=days-res[m-1][1]\n return cnt\n\n\n ","memory":"62600"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort(key=lambda x: x[0])\n count = abs(meetings[0][0] - 1)\n n = len(meetings)\n for i in range(1, n):\n if meetings[i][0] <= meetings[i - 1][1]:\n if meetings[i][1] < meetings[i - 1][1]:\n meetings[i][1] = meetings[i - 1][1]\n else:\n dy = meetings[i][0] - meetings[i - 1][1]\n count += dy - 1\n count += abs(meetings[n - 1][1] - days)\n return count","memory":"63700"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n res = 0\n res += (meetings[0][0] - 1)\n for i in range(1,len(meetings)):\n if meetings[i][0] > meetings[i-1][1]:\n res += ((meetings[i][0] - meetings[i-1][1]) - 1)\n meetings[i][1] = max(meetings[i-1][1],meetings[i][1])\n res += (days - meetings[-1][1])\n return res","memory":"63800"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n if not meetings:\n return days\n meetings.sort(key = lambda x : x[0])\n result = meetings[0][0] - 1\n for idx in range(0 , len(meetings) - 1):\n if meetings[idx][1] < meetings[idx + 1][0]:\n result += meetings[idx + 1][0] - meetings[idx][1] - 1\n else:\n meetings[idx + 1][1] = max(meetings[idx][1], meetings[idx + 1][1])\n result += days - meetings[-1][1]\n return result\n ","memory":"63900"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n # sort in ascending order wrt start of meeting\n meetings = sorted(meetings, key=lambda meeting: meeting[0])\n\n # calculate the total number of meetings\n length = 0\n for i, meeting in enumerate(meetings):\n if (i == 0):\n length += meeting[1] - meeting[0] + 1\n else:\n if (meeting[0] <= meetings[i - 1][1]): # overlap\n if (meeting[1] > meetings[i - 1][1]):\n length += meeting[1] - meetings[i - 1][1]\n else:\n meetings[i][1] = meetings[i - 1][1]\n else:\n length += meeting[1] - meeting[0] + 1\n \n return (days - length if (days-length > 0) else 0)","memory":"64000"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n # Sort meetings by their start time\n meetings.sort()\n\n # Initialize merged intervals\n merged_meetings = []\n \n # Merge intervals\n for start, end in meetings:\n if not merged_meetings or merged_meetings[-1][1] < start - 1:\n # No overlap with the last interval\n merged_meetings.append([start, end])\n else:\n # Merge the current meeting with the last interval\n merged_meetings[-1][1] = max(merged_meetings[-1][1], end)\n \n # Calculate the total number of days covered by meetings\n meeting_days = 0\n for start, end in merged_meetings:\n meeting_days += (end - start + 1)\n \n # The free days are the total days minus the days covered by meetings\n free_days = days - meeting_days\n return free_days\n ","memory":"65600"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n import heapq\n q = []\n for x, y in meetings:\n heappush(q, (x, x-y, y))\n prev = 0\n total = 0\n while q:\n x, l, y = heappop(q)\n if x > prev:\n #print(x, prev)\n total += x-prev-1\n prev = y\n prev = max(y, prev)\n print(x, prev)\n return total + days - prev","memory":"65800"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n meetings.sort(key=lambda x: x[0])\n \n meeting_merged = []\n \n def is_overlap(m1, m2):\n return min(m1[1], m2[1]) - max(m1[0], m2[0]) >= 0\n \n cur = meetings[0]\n for m in meetings[1:]:\n if is_overlap(m, cur):\n cur = [cur[0], max(cur[1], m[1])]\n else:\n meeting_merged.append(cur)\n cur = m\n \n \n meeting_merged.append(cur)\n # print(meeting_merged)\n \n d = 0\n \n for b, e in zip(meeting_merged[:-1], meeting_merged[1:]):\n d += e[0] - b[1] - 1\n \n d += meeting_merged[0][0] - 1\n d += days - meeting_merged[-1][1]\n \n return d","memory":"66000"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n # print(meetings)\n result = 0\n prev_end = 0\n for start, end in meetings:\n # print(result, prev_end, start, end)\n if prev_end<start:\n result = result+end-start+1\n prev_end = end\n # print('1st',result, prev_end, start, end)\n elif start<prev_end and end<=prev_end:\n # print('skip',result, prev_end, start, end)\n continue\n else:\n result = result - (prev_end-start+1) + end-start+1\n prev_end = end\n # print('2nd',result, prev_end, start, end)\n return days-result\n","memory":"66100"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n total_meeting_days = 0\n meetings.sort()\n left = 0\n index = 0\n while index < len(meetings):\n last_meeting_end = meetings[index][1]\n while left < len(meetings) and meetings[left][0] <= last_meeting_end:\n if meetings[left][1] > last_meeting_end:\n last_meeting_end = meetings[left][1]\n left += 1\n total_meeting_days += last_meeting_end - meetings[index][0] + 1\n index = left\n return days - total_meeting_days","memory":"66200"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort() # Sort by meeting start time\n \n merged_meetings = []\n ans = 0\n \n for meeting in meetings:\n if not merged_meetings:\n merged_meetings.append(meeting)\n else:\n last_start, last_end = merged_meetings[-1]\n curr_start, curr_end = meeting\n \n if last_end >= curr_start: # Overlapping, merge meetings\n merged_meetings[-1] = [min(last_start, curr_start), max(last_end, curr_end)]\n else: # No overlap\n ans += curr_start - last_end - 1 # Add gap\n merged_meetings.append(meeting)\n \n # Handle gaps before the first and after the last meetings\n ans += meetings[0][0] - 1 # Days before first meeting\n ans += days - merged_meetings[-1][1] # Days after last meeting\n \n return ans","memory":"66300"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n\n meetings.sort()\n\n cur_day = 1\n days_off = 0\n\n for start, end in meetings:\n if cur_day < start:\n days_off += (start - cur_day)\n cur_day = max(cur_day, end + 1)\n\n if cur_day <= days:\n days_off += (days - cur_day + 1)\n\n return days_off\n\n ","memory":"66400"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n ans=[]\n meetings.sort()\n for i in range(len(meetings)):\n if not ans:\n ans.append(meetings[i])\n else:\n ar1=ans[-1]\n ar2=meetings[i]\n if ar1[1]>=ar2[0]:\n ans[-1]=[ar1[0],max(ar1[1],ar2[1])]\n else:\n ans.append(ar2)\n count=0\n count+=ans[0][0]-1\n count+=days-ans[-1][1]\n for i in range(1,len(ans)):\n gap=ans[i][0]-ans[i-1][1]-1\n count+=gap\n return count","memory":"66500"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n events = []\n for vec in meetings:\n events.append([vec[0], 1])\n events.append([vec[1], -1])\n\n events.append([0, 0])\n events.append([days+1, 0])\n events.sort()\n ans = 0\n running_events = 0\n for i, event in enumerate(events[:len(events)-1]):\n running_events += (events[i][1])\n if running_events == 0:\n ans += max(0, (events[i+1][0] - events[i][0] - 1))\n\n return ans","memory":"66500"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meeting = sorted(meetings)\n n = len(meeting)\n ans = meeting[0][0] - 1\n last_meeting = meeting[0][1]\n for i in range(1,n):\n if(meeting[i][0] - last_meeting > 0):\n ans+=meeting[i][0] - last_meeting -1\n last_meeting = max(meeting[i][1],last_meeting)\n # print(meeting[i], last_meeting)\n ans+=max(0,days - last_meeting)\n return ans","memory":"66600"},{"code":"class Solution:\n def merge_intervals(intervals):\n if not intervals:\n return []\n intervals = sorted(intervals)\n merge = [intervals[0]]\n for interval in intervals[1:]:\n if interval[0] <= merge[-1][1]:\n merge[-1][1] = max(merge[-1][1], interval[1])\n else:\n merge.append(interval)\n return merge\n\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings = Solution.merge_intervals(meetings)\n meet_days = 0\n for i, j in meetings:\n meet_days += j-i+1\n a = days - meet_days\n return a\n","memory":"66700"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n if not meetings:\n return days\n meetings.sort()\n m_meetings = []\n current_start, current_end = meetings[0] \n for start, end in meetings[1:]:\n if start <= current_end:\n current_end = max(current_end, end)\n else: #M\n m_meetings.append((current_start, current_end))\n current_start, current_end = start, end\n m_meetings.append((current_start, current_end))\n busy_days = 0\n for start, end in m_meetings:\n busy_days += (end - start + 1)\n free_days = days - busy_days\n return free_days","memory":"66800"},{"code":"class Solution:\n def merge(self, intervals: List[List[int]]) -> List[List[int]]:\n intervals = sorted(intervals)\n k = [intervals[0]]\n for i in range(1, len(intervals)):\n if intervals[i][0] > k[-1][-1]:\n k.append(intervals[i])\n else:\n k[-1] = [k[-1][0], max(intervals[i][-1], k[-1][-1])]\n return k \n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n intr = self.merge(meetings)\n print(intr)\n ct = intr[0][0] - 1 + days - intr[-1][1]\n if len(intr) == 1:\n return ct\n else:\n for i in range(len(intr) - 1):\n ct += intr[i+1][0] - intr[i][1] - 1\n return ct\n\n\n\n \n\n\n\n ","memory":"66800"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n if not meetings:\n return days\n\n # Step 1: Sort the meetings by their start day\n meetings.sort()\n \n # Step 2: Merge overlapping meetings\n merged_meetings = []\n current_start, current_end = meetings[0]\n \n for start, end in meetings[1:]:\n if start <= current_end + 1:\n current_end = max(current_end, end)\n else:\n merged_meetings.append((current_start, current_end))\n current_start, current_end = start, end\n \n # Append the last interval\n merged_meetings.append((current_start, current_end))\n \n # Step 3: Calculate the total number of days covered by meetings\n days_with_meetings = sum(end - start + 1 for start, end in merged_meetings)\n \n # Step 4: Calculate the free days\n free_days = days - days_with_meetings\n \n return free_days\n ","memory":"66900"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n merged = list()\n c = 0\n \n start, end = meetings[0]\n for i in range(len(meetings)):\n curr_start, curr_end = meetings[i]\n if curr_start <= end:\n end = max(end, curr_end)\n else:\n merged.append([start, end])\n start, curr_end = curr_start, curr_end\n end = curr_end\n \n merged.append([start, end])\n \n \n if merged[0][0] > 1:\n c += merged[0][0] - 1\n \n # Days between meetings\n for i in range(len(merged) - 1):\n if merged[i+1][0] > merged[i][1]:\n c += merged[i+1][0] - merged[i][1] - 1\n \n # Days after the last meeting\n if days > merged[-1][1]:\n c += days - merged[-1][1]\n \n return c\n ","memory":"67000"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n events = []\n \n # Mark start (+1) and end (-1) events for each meeting\n for meeting in meetings:\n start, end = meeting\n events.append((start, 1)) # Meeting starts\n events.append((end + 1, -1)) # Meeting ends\n\n # Sort the events by day\n events.sort()\n\n covered_days = 0\n active_meetings = 0\n last_day = 0\n \n # Process the events\n for day, event in events:\n if active_meetings > 0:\n # If there were active meetings, count the days since last_day\n covered_days += day - last_day\n \n # Update active meetings count\n active_meetings += event\n last_day = day\n \n return days - covered_days","memory":"67100"},{"code":"from collections import defaultdict\nclass Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n \n starts = sorted([a[0] for a in meetings])\n ends = sorted(a[1] for a in meetings)\n\n count_map = defaultdict(int)\n for a in meetings:\n count_map[a[0]]+=1\n count_map[a[1]+1]-=1\n print(count_map.items())\n count_map=sorted(count_map.items(), key=lambda x: x[0])\n cnt = count_map[0][1]\n\n count_meeting_days = 0\n for i in range(1, len(count_map)):\n d = count_map[i][0]\n c = count_map[i][1]\n \n if cnt > 0:\n count_meeting_days += d - count_map[i-1][0]\n cnt += c\n print(count_map[i][0], c, cnt)\n\n # 1 1 1 0\n # 4 -1 0 4\n # 5 1 1\n # 8 -1 0\n # 9 1 1\n # 11 -1 0\n return days - count_meeting_days\n \n\n\n\n\n ","memory":"67200"},{"code":"class Solution:\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\n meetings.sort()\n n = len(meetings)\n ans = meetings[0][0]-1\n print(meetings)\n end = meetings[0][1]\n for i in range(1,n):\n if meetings[i][0] > end:\n ans += meetings[i][0] - end - 1\n end = max(meetings[i][1], end)\n ans += days - end\n return ans","memory":"67800"}],"string":"[\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n ans = meetings[0][0]-1\\n curr_end = meetings[0][1]\\n for i in range(1,len(meetings)):\\n s,e = meetings[i]\\n if s>curr_end:\\n ans+=s-curr_end-1\\n curr_end=e\\n else:\\n curr_end = max(curr_end,e)\\n if days>curr_end:\\n ans+=days-curr_end\\n return ans\\nS = Solution()\\nf = open('user.out','w')\\nfor i1,i2 in zip(stdin,stdin):\\n f.write(f\\\"{S.countDays(loads(i1),loads(i2))}\\\\n\\\")\\nf.flush()\\nexit(0)\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapq.heapify(meetings)\\n s, e = 1, 0\\n while meetings:\\n start, end = heappop(meetings)\\n # if start <= e:\\n # e = max(e, end)\\n # else:\\n # days -= (e - s) + 1\\n # s, e = start, max(e, end)\\n if start > e:\\n days -= (e - s) + 1\\n s = start\\n e = max(e, end)\\n days -= (e - s) + 1\\n return days\",\n \"memory\": \"51600\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapq.heapify(meetings)\\n endTimes = [0]\\n freeDays = 0\\n\\n while meetings:\\n start, end = heapq.heappop(meetings)\\n\\n while endTimes and start > endTimes[0]:\\n oldEnd = heapq.heappop(endTimes)\\n\\n if len(endTimes) == 0:\\n freeDays += start - oldEnd - 1\\n\\n heapq.heappush(endTimes, end)\\n return freeDays + (days - max(endTimes))\\n\",\n \"memory\": \"51700\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapq.heapify(meetings)\\n s, e = heappop(meetings)\\n while meetings:\\n start, end = heappop(meetings)\\n if end < e: continue\\n if start <= e:\\n e = end\\n else:\\n days -= (e - s) + 1\\n s, e = start, end\\n days -= (e - s) + 1\\n return days\",\n \"memory\": \"51800\"\n },\n {\n \"code\": \"from heapq import heapify, heappop\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapify(meetings)\\n res = 0\\n last = 1\\n\\n while meetings:\\n start, end = heappop(meetings)\\n if start > last:\\n res += start - last\\n \\n if end > days:\\n break\\n \\n last = max(end+1, last)\\n print(last, res)\\n \\n return res + max(days-last+1, 0)\",\n \"memory\": \"51900\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n heapq.heapify(meetings)\\n s, e = 1, 0\\n while meetings:\\n start, end = heappop(meetings)\\n if start <= e:\\n e = max(e, end)\\n else:\\n days -= (e - s) + 1\\n s, e = start, max(e, end)\\n days -= (e - s) + 1\\n return days\",\n \"memory\": \"52000\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(reverse=True)\\n s = [meetings.pop()]\\n while meetings:\\n cur = meetings.pop()\\n if cur[0] <= s[-1][1]:\\n s[-1][1] = max(s[-1][1], cur[1])\\n else:\\n s.append(cur)\\n curDay = 1\\n out = 0\\n print(s)\\n for interval in s:\\n out += interval[0] - curDay\\n curDay = interval[1] + 1\\n print(out)\\n return out + days - curDay + 1\\n\\n \",\n \"memory\": \"53000\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, d: int, m: List[List[int]]) -> int:\\n m.sort()\\n i = 1\\n k = m[0][1]\\n a = 0\\n n = len(m)\\n while i<n:\\n if k>m[i][0]:\\n m[i-1][1] = max(m[i-1][1],m[i][1])\\n del m[i]\\n n-=1\\n i-=1\\n k = m[i][1]\\n else:\\n if k<m[i][0]:\\n a+=m[i][0]-k-1\\n k = m[i][1]\\n i+=1\\n return a+d-m[-1][1]+m[0][0]-1\\n \",\n \"memory\": \"53200\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n\\n i = 0\\n ans = 0\\n while i < len(meetings) - 1:\\n currStart, currEnd = meetings[i]\\n nextStart, nextEnd = meetings[i+1]\\n\\n if currEnd >= nextStart:\\n del(meetings[i+1])\\n meetings[i] = [min(currStart, nextStart), max(currEnd, nextEnd)]\\n else:\\n ans += meetings[i+1][0] - meetings[i][1] - 1\\n i += 1\\n\\n\\n ans += days - meetings[-1][1]\\n ans += meetings[0][0] - 1\\n return ans\",\n \"memory\": \"53400\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x: x[0])\\n i, len_meetings = 1, len(meetings)\\n while i < len_meetings:\\n prev, curr = meetings[i - 1], meetings[i]\\n if prev[1] >= curr[0]:\\n meetings[i - 1][0] = min(prev[0], curr[0])\\n meetings[i - 1][1] = max(prev[1], curr[1])\\n meetings.pop(i)\\n len_meetings -= 1\\n continue\\n i += 1\\n for i in range(0, len_meetings):\\n days -= (meetings[i][1] - meetings[i][0] + 1)\\n\\n return days if days >= 0 else 0\\n\",\n \"memory\": \"53500\"\n },\n {\n \"code\": \"'''\\nGENERAL NOTES / CONSTRAINTS...\\n* days = number of total days an employee is available to work (starting from day 1)\\n* each meeting is an inclusive interval representing the days in which the meeting lasts\\n\\n--> GOAL: from day 1 to day n, figure out how many days are not scheduled in any meetings <--\\n\\nTHOUGHT PROCESSES...\\n* obviously interval problem (merging intervals)\\n - sort intervals\\n - merge overlapping intervals\\n - create a set which contains all integers from 1 up to n (where n is the last/largest day\\n that occurs in any of the intervals)\\n - iterate through all the merged intervals and delete all of the numbers from the set that\\n appear in any of the intervals\\n* ACTUALLY, still interval problem, but I don't think we necessarily have to sort + merge\\n - create the aforementioned set\\n - iterate through the intervals one more time, and for each interval, remove all numbers\\n in range of the interval from the set\\n - return length of the set at the end\\n - PROBLEM: yeah nevermind, implemented this within the first 14 minutes and the time limit\\n was exceeded, so need to go back to the sort + merge method\\n* NEW PROBLEM: memory limit exceeded...? (I guess we can't track all the numbers with a set)\\n* Instead of tracking all numbers from 1 to days in a set, we will simply track the number of days\\n off\\n - initialize \\\"days_off\\\" to be equal to days\\n - iterate through the intervals, and for each interval [start, end], decrement \\\"days_off\\\"\\n by start - end + 1\\n'''\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n # STEP 1: sort intervals\\n meetings.sort()\\n\\n # STEP 2: merge interlapping intervals\\n ptr = 1\\n while ptr < len(meetings):\\n left, right = meetings[ptr - 1], meetings[ptr]\\n if left[1] >= right[0]:\\n meetings[ptr] = [min(left[0], right[0]), max(left[1], right[1])]\\n meetings.pop(ptr - 1)\\n else:\\n ptr += 1\\n \\n # STEP 3: count days off\\n days_off = days\\n for meeting in meetings:\\n days_off -= meeting[1] - meeting[0] + 1\\n \\n return days_off\\n\",\n \"memory\": \"53500\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n merged = []\\n\\n while len(meetings) > 0:\\n start1, end1 = meetings.pop(0)\\n if len(meetings) == 0:\\n merged.append([start1, end1])\\n break\\n start2, end2 = meetings.pop(0)\\n\\n if start2 <= end1:\\n final_end = max(end1, end2)\\n meetings.insert(0, [start1, final_end])\\n else:\\n merged.append([start1, end1])\\n meetings.insert(0, [start2, end2])\\n \\n i = 1\\n result = 0\\n end = start = 0\\n while i <= days:\\n if len(merged) == 0:\\n result += days - end\\n break\\n [start, end] = merged.pop(0)\\n\\n if i < start and start:\\n result += start - i\\n i = end + 1\\n return result\\n\",\n \"memory\": \"53600\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n\\n i = 0\\n while i < len(meetings) - 1:\\n currStart, currEnd = meetings[i]\\n nextStart, nextEnd = meetings[i+1]\\n\\n if currEnd >= nextStart:\\n del(meetings[i+1])\\n meetings[i] = [min(currStart, nextStart), max(currEnd, nextEnd)]\\n else:\\n i += 1\\n\\n ans = 0\\n for i in range(len(meetings) - 1):\\n ans += meetings[i+1][0] - meetings[i][1] - 1\\n\\n ans += days - meetings[-1][1]\\n ans += meetings[0][0] - 1\\n return ans\",\n \"memory\": \"53700\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n n=len(meetings)\\n i=1\\n while(i<n):\\n a=meetings[i-1]\\n b=meetings[i]\\n if(a[1]>=b[0]):\\n meetings[i-1]=[-1,-1]\\n if(a[1]>=b[1]):\\n meetings[i]=[a[0],a[1]]\\n else:\\n meetings[i]=[a[0],b[1]]\\n i+=1\\n res=[]\\n for i in meetings:\\n if(i!=[-1,-1]):\\n res.append(i)\\n j=1\\n m=len(res)\\n cnt=0\\n while(j<m):\\n x=res[j-1]\\n y=res[j]\\n if(x[1]<y[0]):\\n k=abs(x[1]-y[0])-1\\n cnt+=k\\n j+=1\\n if(res[0][0]!=1):\\n cnt+=res[0][0]-1\\n if(res[m-1][1]!=days):\\n cnt+=days-res[m-1][1]\\n return cnt\\n\\n\\n \",\n \"memory\": \"62100\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n\\n def merge_intervals(meetings):\\n meetings.sort()\\n\\n lo = 0\\n hi = 1\\n\\n n = len(meetings)\\n\\n while hi < n:\\n if meetings[hi][0] <= meetings[lo][1]:\\n meetings[lo][1] = max(meetings[hi][1], meetings[lo][1])\\n meetings[lo][0] = min(meetings[lo][0], meetings[hi][0])\\n meetings[hi] = [0, 0]\\n hi += 1\\n else:\\n lo = hi\\n hi += 1\\n\\n return meetings\\n\\n meetings = merge_intervals(meetings)\\n # print(meetings)\\n \\n booked = 0\\n for x, y in meetings:\\n if x == 0 and y == 0:\\n continue\\n booked += y - x + 1\\n\\n return days - booked\",\n \"memory\": \"62200\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n n=len(meetings)\\n i=1\\n while(i<n):\\n a=meetings[i-1]\\n b=meetings[i]\\n if(a[1]>=b[0]):\\n meetings[i-1]=[-1,-1]\\n if(a[1]>=b[1]):\\n meetings[i]=[a[0],a[1]]\\n else:\\n meetings[i]=[a[0],b[1]]\\n i+=1\\n res=[]\\n for i in meetings:\\n if(i!=[-1,-1]):\\n res.append(i)\\n print(meetings)\\n j=1\\n m=len(res)\\n cnt=0\\n while(j<m):\\n x=res[j-1]\\n y=res[j]\\n if(x[1]<y[0]):\\n k=abs(x[1]-y[0])-1\\n cnt+=k\\n # print(abs(a[1]-b[0]))\\n # print(cnt)\\n j+=1\\n if(res[0][0]!=1):\\n cnt+=res[0][0]-1\\n if(res[m-1][1]!=days):\\n cnt+=days-res[m-1][1]\\n return cnt\\n\\n\\n \",\n \"memory\": \"62600\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort(key=lambda x: x[0])\\n count = abs(meetings[0][0] - 1)\\n n = len(meetings)\\n for i in range(1, n):\\n if meetings[i][0] <= meetings[i - 1][1]:\\n if meetings[i][1] < meetings[i - 1][1]:\\n meetings[i][1] = meetings[i - 1][1]\\n else:\\n dy = meetings[i][0] - meetings[i - 1][1]\\n count += dy - 1\\n count += abs(meetings[n - 1][1] - days)\\n return count\",\n \"memory\": \"63700\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n res = 0\\n res += (meetings[0][0] - 1)\\n for i in range(1,len(meetings)):\\n if meetings[i][0] > meetings[i-1][1]:\\n res += ((meetings[i][0] - meetings[i-1][1]) - 1)\\n meetings[i][1] = max(meetings[i-1][1],meetings[i][1])\\n res += (days - meetings[-1][1])\\n return res\",\n \"memory\": \"63800\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n if not meetings:\\n return days\\n meetings.sort(key = lambda x : x[0])\\n result = meetings[0][0] - 1\\n for idx in range(0 , len(meetings) - 1):\\n if meetings[idx][1] < meetings[idx + 1][0]:\\n result += meetings[idx + 1][0] - meetings[idx][1] - 1\\n else:\\n meetings[idx + 1][1] = max(meetings[idx][1], meetings[idx + 1][1])\\n result += days - meetings[-1][1]\\n return result\\n \",\n \"memory\": \"63900\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n # sort in ascending order wrt start of meeting\\n meetings = sorted(meetings, key=lambda meeting: meeting[0])\\n\\n # calculate the total number of meetings\\n length = 0\\n for i, meeting in enumerate(meetings):\\n if (i == 0):\\n length += meeting[1] - meeting[0] + 1\\n else:\\n if (meeting[0] <= meetings[i - 1][1]): # overlap\\n if (meeting[1] > meetings[i - 1][1]):\\n length += meeting[1] - meetings[i - 1][1]\\n else:\\n meetings[i][1] = meetings[i - 1][1]\\n else:\\n length += meeting[1] - meeting[0] + 1\\n \\n return (days - length if (days-length > 0) else 0)\",\n \"memory\": \"64000\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n # Sort meetings by their start time\\n meetings.sort()\\n\\n # Initialize merged intervals\\n merged_meetings = []\\n \\n # Merge intervals\\n for start, end in meetings:\\n if not merged_meetings or merged_meetings[-1][1] < start - 1:\\n # No overlap with the last interval\\n merged_meetings.append([start, end])\\n else:\\n # Merge the current meeting with the last interval\\n merged_meetings[-1][1] = max(merged_meetings[-1][1], end)\\n \\n # Calculate the total number of days covered by meetings\\n meeting_days = 0\\n for start, end in merged_meetings:\\n meeting_days += (end - start + 1)\\n \\n # The free days are the total days minus the days covered by meetings\\n free_days = days - meeting_days\\n return free_days\\n \",\n \"memory\": \"65600\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n import heapq\\n q = []\\n for x, y in meetings:\\n heappush(q, (x, x-y, y))\\n prev = 0\\n total = 0\\n while q:\\n x, l, y = heappop(q)\\n if x > prev:\\n #print(x, prev)\\n total += x-prev-1\\n prev = y\\n prev = max(y, prev)\\n print(x, prev)\\n return total + days - prev\",\n \"memory\": \"65800\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n meetings.sort(key=lambda x: x[0])\\n \\n meeting_merged = []\\n \\n def is_overlap(m1, m2):\\n return min(m1[1], m2[1]) - max(m1[0], m2[0]) >= 0\\n \\n cur = meetings[0]\\n for m in meetings[1:]:\\n if is_overlap(m, cur):\\n cur = [cur[0], max(cur[1], m[1])]\\n else:\\n meeting_merged.append(cur)\\n cur = m\\n \\n \\n meeting_merged.append(cur)\\n # print(meeting_merged)\\n \\n d = 0\\n \\n for b, e in zip(meeting_merged[:-1], meeting_merged[1:]):\\n d += e[0] - b[1] - 1\\n \\n d += meeting_merged[0][0] - 1\\n d += days - meeting_merged[-1][1]\\n \\n return d\",\n \"memory\": \"66000\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n # print(meetings)\\n result = 0\\n prev_end = 0\\n for start, end in meetings:\\n # print(result, prev_end, start, end)\\n if prev_end<start:\\n result = result+end-start+1\\n prev_end = end\\n # print('1st',result, prev_end, start, end)\\n elif start<prev_end and end<=prev_end:\\n # print('skip',result, prev_end, start, end)\\n continue\\n else:\\n result = result - (prev_end-start+1) + end-start+1\\n prev_end = end\\n # print('2nd',result, prev_end, start, end)\\n return days-result\\n\",\n \"memory\": \"66100\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n total_meeting_days = 0\\n meetings.sort()\\n left = 0\\n index = 0\\n while index < len(meetings):\\n last_meeting_end = meetings[index][1]\\n while left < len(meetings) and meetings[left][0] <= last_meeting_end:\\n if meetings[left][1] > last_meeting_end:\\n last_meeting_end = meetings[left][1]\\n left += 1\\n total_meeting_days += last_meeting_end - meetings[index][0] + 1\\n index = left\\n return days - total_meeting_days\",\n \"memory\": \"66200\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort() # Sort by meeting start time\\n \\n merged_meetings = []\\n ans = 0\\n \\n for meeting in meetings:\\n if not merged_meetings:\\n merged_meetings.append(meeting)\\n else:\\n last_start, last_end = merged_meetings[-1]\\n curr_start, curr_end = meeting\\n \\n if last_end >= curr_start: # Overlapping, merge meetings\\n merged_meetings[-1] = [min(last_start, curr_start), max(last_end, curr_end)]\\n else: # No overlap\\n ans += curr_start - last_end - 1 # Add gap\\n merged_meetings.append(meeting)\\n \\n # Handle gaps before the first and after the last meetings\\n ans += meetings[0][0] - 1 # Days before first meeting\\n ans += days - merged_meetings[-1][1] # Days after last meeting\\n \\n return ans\",\n \"memory\": \"66300\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n\\n meetings.sort()\\n\\n cur_day = 1\\n days_off = 0\\n\\n for start, end in meetings:\\n if cur_day < start:\\n days_off += (start - cur_day)\\n cur_day = max(cur_day, end + 1)\\n\\n if cur_day <= days:\\n days_off += (days - cur_day + 1)\\n\\n return days_off\\n\\n \",\n \"memory\": \"66400\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n ans=[]\\n meetings.sort()\\n for i in range(len(meetings)):\\n if not ans:\\n ans.append(meetings[i])\\n else:\\n ar1=ans[-1]\\n ar2=meetings[i]\\n if ar1[1]>=ar2[0]:\\n ans[-1]=[ar1[0],max(ar1[1],ar2[1])]\\n else:\\n ans.append(ar2)\\n count=0\\n count+=ans[0][0]-1\\n count+=days-ans[-1][1]\\n for i in range(1,len(ans)):\\n gap=ans[i][0]-ans[i-1][1]-1\\n count+=gap\\n return count\",\n \"memory\": \"66500\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n events = []\\n for vec in meetings:\\n events.append([vec[0], 1])\\n events.append([vec[1], -1])\\n\\n events.append([0, 0])\\n events.append([days+1, 0])\\n events.sort()\\n ans = 0\\n running_events = 0\\n for i, event in enumerate(events[:len(events)-1]):\\n running_events += (events[i][1])\\n if running_events == 0:\\n ans += max(0, (events[i+1][0] - events[i][0] - 1))\\n\\n return ans\",\n \"memory\": \"66500\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meeting = sorted(meetings)\\n n = len(meeting)\\n ans = meeting[0][0] - 1\\n last_meeting = meeting[0][1]\\n for i in range(1,n):\\n if(meeting[i][0] - last_meeting > 0):\\n ans+=meeting[i][0] - last_meeting -1\\n last_meeting = max(meeting[i][1],last_meeting)\\n # print(meeting[i], last_meeting)\\n ans+=max(0,days - last_meeting)\\n return ans\",\n \"memory\": \"66600\"\n },\n {\n \"code\": \"class Solution:\\n def merge_intervals(intervals):\\n if not intervals:\\n return []\\n intervals = sorted(intervals)\\n merge = [intervals[0]]\\n for interval in intervals[1:]:\\n if interval[0] <= merge[-1][1]:\\n merge[-1][1] = max(merge[-1][1], interval[1])\\n else:\\n merge.append(interval)\\n return merge\\n\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings = Solution.merge_intervals(meetings)\\n meet_days = 0\\n for i, j in meetings:\\n meet_days += j-i+1\\n a = days - meet_days\\n return a\\n\",\n \"memory\": \"66700\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n if not meetings:\\n return days\\n meetings.sort()\\n m_meetings = []\\n current_start, current_end = meetings[0] \\n for start, end in meetings[1:]:\\n if start <= current_end:\\n current_end = max(current_end, end)\\n else: #M\\n m_meetings.append((current_start, current_end))\\n current_start, current_end = start, end\\n m_meetings.append((current_start, current_end))\\n busy_days = 0\\n for start, end in m_meetings:\\n busy_days += (end - start + 1)\\n free_days = days - busy_days\\n return free_days\",\n \"memory\": \"66800\"\n },\n {\n \"code\": \"class Solution:\\n def merge(self, intervals: List[List[int]]) -> List[List[int]]:\\n intervals = sorted(intervals)\\n k = [intervals[0]]\\n for i in range(1, len(intervals)):\\n if intervals[i][0] > k[-1][-1]:\\n k.append(intervals[i])\\n else:\\n k[-1] = [k[-1][0], max(intervals[i][-1], k[-1][-1])]\\n return k \\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n intr = self.merge(meetings)\\n print(intr)\\n ct = intr[0][0] - 1 + days - intr[-1][1]\\n if len(intr) == 1:\\n return ct\\n else:\\n for i in range(len(intr) - 1):\\n ct += intr[i+1][0] - intr[i][1] - 1\\n return ct\\n\\n\\n\\n \\n\\n\\n\\n \",\n \"memory\": \"66800\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n if not meetings:\\n return days\\n\\n # Step 1: Sort the meetings by their start day\\n meetings.sort()\\n \\n # Step 2: Merge overlapping meetings\\n merged_meetings = []\\n current_start, current_end = meetings[0]\\n \\n for start, end in meetings[1:]:\\n if start <= current_end + 1:\\n current_end = max(current_end, end)\\n else:\\n merged_meetings.append((current_start, current_end))\\n current_start, current_end = start, end\\n \\n # Append the last interval\\n merged_meetings.append((current_start, current_end))\\n \\n # Step 3: Calculate the total number of days covered by meetings\\n days_with_meetings = sum(end - start + 1 for start, end in merged_meetings)\\n \\n # Step 4: Calculate the free days\\n free_days = days - days_with_meetings\\n \\n return free_days\\n \",\n \"memory\": \"66900\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n merged = list()\\n c = 0\\n \\n start, end = meetings[0]\\n for i in range(len(meetings)):\\n curr_start, curr_end = meetings[i]\\n if curr_start <= end:\\n end = max(end, curr_end)\\n else:\\n merged.append([start, end])\\n start, curr_end = curr_start, curr_end\\n end = curr_end\\n \\n merged.append([start, end])\\n \\n \\n if merged[0][0] > 1:\\n c += merged[0][0] - 1\\n \\n # Days between meetings\\n for i in range(len(merged) - 1):\\n if merged[i+1][0] > merged[i][1]:\\n c += merged[i+1][0] - merged[i][1] - 1\\n \\n # Days after the last meeting\\n if days > merged[-1][1]:\\n c += days - merged[-1][1]\\n \\n return c\\n \",\n \"memory\": \"67000\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n events = []\\n \\n # Mark start (+1) and end (-1) events for each meeting\\n for meeting in meetings:\\n start, end = meeting\\n events.append((start, 1)) # Meeting starts\\n events.append((end + 1, -1)) # Meeting ends\\n\\n # Sort the events by day\\n events.sort()\\n\\n covered_days = 0\\n active_meetings = 0\\n last_day = 0\\n \\n # Process the events\\n for day, event in events:\\n if active_meetings > 0:\\n # If there were active meetings, count the days since last_day\\n covered_days += day - last_day\\n \\n # Update active meetings count\\n active_meetings += event\\n last_day = day\\n \\n return days - covered_days\",\n \"memory\": \"67100\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n \\n starts = sorted([a[0] for a in meetings])\\n ends = sorted(a[1] for a in meetings)\\n\\n count_map = defaultdict(int)\\n for a in meetings:\\n count_map[a[0]]+=1\\n count_map[a[1]+1]-=1\\n print(count_map.items())\\n count_map=sorted(count_map.items(), key=lambda x: x[0])\\n cnt = count_map[0][1]\\n\\n count_meeting_days = 0\\n for i in range(1, len(count_map)):\\n d = count_map[i][0]\\n c = count_map[i][1]\\n \\n if cnt > 0:\\n count_meeting_days += d - count_map[i-1][0]\\n cnt += c\\n print(count_map[i][0], c, cnt)\\n\\n # 1 1 1 0\\n # 4 -1 0 4\\n # 5 1 1\\n # 8 -1 0\\n # 9 1 1\\n # 11 -1 0\\n return days - count_meeting_days\\n \\n\\n\\n\\n\\n \",\n \"memory\": \"67200\"\n },\n {\n \"code\": \"class Solution:\\n def countDays(self, days: int, meetings: List[List[int]]) -> int:\\n meetings.sort()\\n n = len(meetings)\\n ans = meetings[0][0]-1\\n print(meetings)\\n end = meetings[0][1]\\n for i in range(1,n):\\n if meetings[i][0] > end:\\n ans += meetings[i][0] - end - 1\\n end = max(meetings[i][1], end)\\n ans += days - end\\n return ans\",\n \"memory\": \"67800\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":38,"string":"38"}}},{"rowIdx":2458,"cells":{"question_id":{"kind":"number","value":3445,"string":"3,445"},"name":{"kind":"string","value":"lexicographically-minimum-string-after-removing-stars"},"content":{"kind":"string","value":"<p>You are given a string <code>s</code>. It may contain any number of <code>'*'</code> characters. Your task is to remove all <code>'*'</code> characters.</p>\n\n<p>While there is a <code>'*'</code>, do the following operation:</p>\n\n<ul>\n\t<li>Delete the leftmost <code>'*'</code> and the <strong>smallest</strong> non-<code>'*'</code> character to its <em>left</em>. If there are several smallest characters, you can delete any of them.</li>\n</ul>\n\n<p>Return the <span data-keyword=\"lexicographically-smaller-string\">lexicographically smallest</span> resulting string after removing all <code>'*'</code> characters.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "aaba*"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">"aab"</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>We should delete one of the <code>'a'</code> characters with <code>'*'</code>. If we choose <code>s[3]</code>, <code>s</code> becomes the lexicographically smallest.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">s = "abc"</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">"abc"</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>There is no <code>'*'</code> in the string.<!-- notionvc: ff07e34f-b1d6-41fb-9f83-5d0ba3c1ecde --></p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= s.length <= 10<sup>5</sup></code></li>\n\t<li><code>s</code> consists only of lowercase English letters and <code>'*'</code>.</li>\n\t<li>The input is generated such that it is possible to delete all <code>'*'</code> characters.</li>\n</ul>\n"},"acRate":{"kind":"number","value":35.90258976672956,"string":"35.90259"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["hash-table","string","stack","greedy","heap-priority-queue"],"string":"[\n \"hash-table\",\n \"string\",\n \"stack\",\n \"greedy\",\n \"heap-priority-queue\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"307\", 0.8474], [\"325\", 0.4237], [\"342\", 0.4237], [\"359\", 0.4237], [\"377\", 0.4237], [\"394\", 2.5423000000000004], [\"412\", 1.6948], [\"429\", 2.1185], [\"446\", 0.8474], [\"464\", 0.4237], [\"481\", 2.1186000000000003], [\"498\", 0.8474], [\"516\", 2.1186000000000003], [\"533\", 1.2712], [\"551\", 3.813500000000001], [\"568\", 2.1186000000000003], [\"585\", 1.6948], [\"603\", 8.4747], [\"620\", 9.322000000000001], [\"638\", 7.627100000000001], [\"655\", 5.932000000000001], [\"672\", 4.660900000000001], [\"690\", 2.5423000000000004], [\"707\", 3.8134000000000006], [\"724\", 4.660900000000001], [\"742\", 5.084500000000001], [\"759\", 2.1185], [\"777\", 4.2372000000000005], [\"794\", 1.2712], [\"811\", 1.2711000000000001], [\"829\", 2.1185], [\"846\", 0.4237], [\"864\", 0.4237], [\"881\", 0.4237], [\"898\", 0.4237], [\"916\", 0.4237], [\"933\", 0.4237], [\"951\", 0.4237], [\"968\", 0.4237], [\"985\", 0.4237], [\"1003\", 0.4237], [\"1020\", 0.4237], [\"1037\", 0.4237], [\"1055\", 0.4237], [\"1072\", 0.4237], [\"1090\", 0.4237], [\"1107\", 0.4237], [\"1124\", 0.4237], [\"1142\", 0.4237]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18100\", 0.4237], [\"20400\", 0.4237], [\"20600\", 0.4237], [\"21200\", 0.4237], [\"21700\", 2.1186], [\"21800\", 0.4237], [\"21900\", 0.4237], [\"22000\", 0.4237], [\"22100\", 2.1186], [\"22200\", 2.1186], [\"22300\", 1.2712], [\"22400\", 1.2712], [\"22500\", 0.8475], [\"22800\", 5.5085], [\"22900\", 2.1186], [\"23000\", 3.3898], [\"23100\", 0.4237], [\"23200\", 0.8475], [\"23300\", 0.8475], [\"23600\", 0.4237], [\"23800\", 1.6949], [\"23900\", 0.8475], [\"24600\", 0.4237], [\"26500\", 0.4237], [\"27000\", 0.4237], [\"27400\", 0.8475], [\"27500\", 1.6949], [\"27600\", 2.9661], [\"27700\", 6.7797], [\"27800\", 5.5085], [\"28100\", 0.4237], [\"28200\", 0.8475], [\"28300\", 2.1186], [\"28400\", 2.9661], [\"28500\", 1.6949], [\"28600\", 0.8475], [\"28700\", 0.4237], [\"28800\", 0.4237], [\"29000\", 0.4237], [\"29100\", 1.6949], [\"29200\", 2.1186], [\"29300\", 0.4237], [\"29400\", 2.5424], [\"29500\", 1.6949], [\"29600\", 0.4237], [\"29800\", 0.8475], [\"29900\", 1.2712], [\"30000\", 0.4237], [\"30700\", 1.6949], [\"30800\", 1.2712], [\"31100\", 0.4237], [\"31200\", 0.8475], [\"32100\", 1.2712], [\"32200\", 0.8475], [\"32600\", 0.8475], [\"32800\", 0.4237], [\"33000\", 0.8475], [\"33100\", 0.8475], [\"33200\", 0.8475], [\"33400\", 0.4237], [\"33500\", 4.661], [\"33600\", 3.8136], [\"33700\", 1.6949], [\"33800\", 2.1186], [\"33900\", 1.2712], [\"34200\", 0.4237], [\"34300\", 0.4237], [\"34400\", 0.4237]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n charIndex = defaultdict(list)\n s = list(s)\n for i, c in enumerate(s):\n if c == \"*\":\n toRemove = heap[0]\n s[charIndex[toRemove].pop()] = \"\"\n if not charIndex[toRemove]: heappop(heap)\n s[i] = \"\"\n else:\n if len(charIndex[c]) == 0:\n heappush(heap, c)\n charIndex[c].append(i)\n return \"\".join(s)\n \n ","runtime":"307"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n charIndex = defaultdict(list)\n s = list(s)\n for i, c in enumerate(s):\n if c == \"*\":\n toRemove = heap[0]\n s[charIndex[toRemove].pop()] = \"\"\n if not charIndex[toRemove]: heappop(heap)\n s[i] = \"\"\n else:\n if len(charIndex[c]) == 0:\n heappush(heap, c)\n charIndex[c].append(i)\n return \"\".join(s)","runtime":"307"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n s = list(s)\n st = [[] for _ in range(26)]\n mask = 0\n for i, x in enumerate(s):\n if x != \"*\":\n c = ord(x) - ord('a')\n st[c].append(i)\n mask |= 1 << c\n else:\n lb = mask & -mask\n alpha = st[lb.bit_length() - 1]\n s[alpha.pop()] = \"*\"\n if not alpha:\n mask ^= lb\n return ''.join(ch for ch in s if ch != '*')\n","runtime":"325"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # dict: chacter - indices from largest to smallest\n chars = list(s)\n # print(\"chars:\", chars)\n record = dict() # dict\n sortedChars = [] #deque\n for i, char in enumerate(chars):\n # print(\"i:\", i, \"char:\", char)\n if char == \"*\":\n # print(\"hit *\")\n targetChar = sortedChars[0]\n targetIndex = record[targetChar].popleft()\n # print(\"removing targetChar\", targetChar, \"at index\", targetIndex)\n chars[targetIndex] = \"\"\n chars[i] = \"\"\n if len(record[targetChar]) == 0:\n del record[targetChar]\n heapq.heappop(sortedChars)\n # print(\"no more index for targetChar, record:\", record, \"sortedChars:\", sortedChars)\n else:\n # print(\"hit letter\")\n if char not in record:\n record[char] = deque()\n heapq.heappush(sortedChars, char)\n record[char].appendleft(i)\n # print(\"adding to record[char]:\",record[char],\"sortedChars:\", sortedChars )\n # print(\"chars:\", chars)\n return \"\".join(chars)","runtime":"342"},{"code":"class Solution:\n def clearStars(self, xs: str) -> str:\n idxs = [[] for _ in range(26)]\n for i, x in enumerate(xs):\n if x != '*':\n idxs[ord(x)-ord('a')].append(i)\n else:\n for ys in idxs:\n if ys:\n ys.pop()\n break\n \n return ''.join(xs[i] for i in sorted(chain(*idxs)))","runtime":"359"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n ss = [[] for _ in range(26)]\n for i, v in enumerate(s):\n if v != '*':\n ss[ord(v) - ord('a')].append(i)\n continue\n \n for p in ss:\n if p:\n p.pop()\n break\n \n return ''.join(s[x] for x in sorted(chain.from_iterable(ss)))","runtime":"377"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Slower because of heap subsorting based on a character's index\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n # Faster because indices don't have to be sorted in the heap.\n # Instead uses a hash table that intrinsically sorts the indices of\n # a particular character.\n heap = []\n c_idx_table = defaultdict(list)\n s_list = [\"\"] * len(s)\n for idx, c in enumerate(s):\n if c == \"*\":\n pop_c = heappop(heap)\n pop_idx = c_idx_table[pop_c].pop()\n s_list[pop_idx] = \"\"\n # s_list.append(\"\")\n else:\n heappush(heap, c)\n # s_list.append(c)\n s_list[idx] = c\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","runtime":"394"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n heap = []\n c_idx_table = defaultdict(list)\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop = heappop(heap)\n pop_idx = c_idx_table[pop].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","runtime":"394"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n characterList = [[] for _ in range(26)]\n for i in range(len(s)):\n if s[i] == '*':\n character = heapq.heappop(heap)\n key = ord(character) - ord('a')\n curList = characterList[key]\n curList.pop(-1)\n if len(curList) > 0:\n heapq.heappush(heap, character)\n else:\n key = ord(s[i]) - ord('a')\n curList = characterList[key]\n curList.append(i)\n if len(curList) == 1:\n heapq.heappush(heap, s[i])\n resultArr = []\n for i in range(26):\n for j in range(len(characterList[i])):\n resultArr.append((characterList[i][j], chr(i+ord('a'))))\n resultArr.sort(key = lambda x: x[0])\n return \"\".join([x[1] for x in resultArr])","runtime":"412"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Create a list of 26 empty lists to hold positions of each character\n pos = [[] for _ in range(26)]\n \n # Convert string to list for mutable operations\n s = list(s)\n \n for i in range(len(s)):\n if s[i] == '*':\n for p in pos:\n if p:\n s[p.pop()] = '*'\n break\n else:\n pos[ord(s[i]) - ord('a')].append(i)\n \n # Remove all '*' characters from the list\n result = [char for char in s if char != '*']\n \n # Convert list back to string\n return ''.join(result)","runtime":"412"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n remove = set()\n c_idx_table = defaultdict(list)\n s_list = []\n ret = \"\"\n for idx, c in enumerate(s):\n if c == \"*\":\n pop = heappop(heap)\n pop_idx = c_idx_table[pop].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","runtime":"429"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Slower because of heap subsorting based on a character's index\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n # Faster because indices don't have to be sorted in the heap.\n # Instead uses a hash table that intrinsically sorts the indices of\n # a particular character.\n heap = []\n c_idx_table = defaultdict(list)\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop_c = heappop(heap)\n pop_idx = c_idx_table[pop_c].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n s_list[idx] = c\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","runtime":"429"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n indexes = defaultdict(list)\n stack = []\n\n for i, char in enumerate(s):\n if char == '*':\n min_char = min(indexes)\n index = indexes[min_char].pop()\n stack[index] = None\n if len(indexes[min_char]) == 0:\n indexes.pop(min_char) \n else:\n indexes[char].append(len(stack))\n stack.append(char)\n \n return ''.join(\n char\n for char in stack\n if char is not None\n )\n ","runtime":"446"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n s = list(s)\n h = []\n l = [[] for i in range(26)] # for each letter, keep a list \n\n for i in range(len(s)):\n if s[i] == '*':\n s[i] = '!'\n cur = heapq.heappop(h)\n index = ord(cur) - ord('a')\n \n pos = l[index].pop()\n s[pos] = \"!\"\n\n if len(l[index]) != 0:\n heapq.heappush(h, cur)\n else:\n if len(l[ord(s[i]) - ord('a')]) == 0: \n heapq.heappush(h, s[i])\n l[ord(s[i]) - ord('a')].append(i)\n\n res = \"\"\n for i in range(len(s)):\n if s[i] != \"!\":\n res+= s[i]\n\n return res\n \n \n\n \n\n\n\n\n ","runtime":"446"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n stacks = [[] for _ in range(26)]\n ans = set()\n\n for i, c in enumerate(s):\n if c == '*':\n ans.add(i)\n for stack in stacks:\n if stack:\n ans.add(stack.pop())\n break\n else:\n index = ord(c) - 97\n stacks[index].append(i)\n \n return ''.join([c for i, c in enumerate(s) if i not in ans])\n \n ","runtime":"464"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n m=defaultdict(list)\n toremove=[False]*(len(s))\n for i,ch in enumerate(s):\n if ch!='*': m[ch].append(i)\n else:\n x = min(m)\n toremove[i]=True\n toremove[m[x].pop()]=True\n if not m[x]: m.pop(x)\n return ''.join(ch for i,ch in enumerate(s) if not toremove[i])\n \n ","runtime":"481"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n chars = {}\n for i in range(len(s)):\n if s[i] != \"*\":\n\n if s[i] not in chars:\n chars[s[i]] = []\n\n chars[s[i]].append(i)\n\n else:\n\n min_letter = min(chars.keys())\n\n chars[min_letter].pop() \n\n\n if len(chars[min_letter]) == 0:\n del chars[min_letter]\n\n\n reconstructed = [\"\" for _ in range(len(s))]\n for letter in chars:\n for idx in chars[letter]:\n reconstructed[idx] = letter\n return \"\".join(reconstructed)","runtime":"481"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n chars = {}\n for i in range(len(s)):\n if s[i] != '*':\n if s[i] not in chars:\n chars[s[i]] = []\n \n chars[s[i]].append(i)\n else:\n min_letter=min(chars.keys())\n chars[min_letter].pop()\n\n if len(chars[min_letter]) == 0:\n del chars[min_letter]\n \n recons = ['' for i in range(len(s))]\n for letter in chars:\n for idx in chars[letter]:\n recons[idx] = letter\n return ''.join(recons)","runtime":"498"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Convert the input string into a list of characters\n a = list(s)\n \n # Create a list of stacks, one for each letter from 'a' to 'z'\n stacks = [[] for _ in range(26)]\n \n # Iterate through the characters in the string\n for i, char in enumerate(a):\n if char == '*':\n # For '*' characters, remove the smallest non-'*' character\n for j in range(26):\n if stacks[j]:\n index = stacks[j].pop()\n a[index] = '*'\n break\n else:\n # For non-'*' characters, push their index onto the corresponding stack\n stacks[ord(char) - ord('a')].append(i)\n \n # Build the final result string\n result = ''.join(char for char in a if char != '*')\n \n return result\n\n","runtime":"498"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n curr_s = []\n small_c = ''\n char_index = defaultdict(list)\n\n for i in range(len(s)):\n c = s[i]\n\n curr_s.append(c)\n\n if c != \"*\":\n if not small_c or ord(c) < ord(small_c):\n small_c = c\n char_index[c].append(i)\n else:\n index = char_index[small_c].pop()\n curr_s[index] = ''\n\n if len(char_index[small_c]) == 0:\n del char_index[small_c]\n\n keys = char_index.keys()\n\n if keys:\n small_c = min(keys)\n else:\n small_c = ''\n\n return ''.join('' if c == '*' else c for c in curr_s)","runtime":"516"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n stack = [] \n prev = ''\n idx = defaultdict(list)\n\n for i in range(len(s)):\n c = s[i]\n stack.append(c)\n if c != '*':\n if not prev or ord(c) < ord(prev):\n prev = c\n idx[c].append(i)\n else:\n index = idx[prev].pop()\n stack[index] = ''\n if len(idx[prev]) == 0:\n del idx[prev]\n \n keys = idx.keys()\n\n if keys:\n prev = min(keys)\n else:\n prev = ''\n return ''.join('' if c == '*' else c for c in stack)\n ","runtime":"516"},{"code":"class Solution:\n # aaba*\n # \n def clearStars(self, s: str) -> str:\n dct = defaultdict(list)\n length = len(s)\n res = [''] * length\n for i in range(length):\n if s[i] == '*':\n toRemove = min(dct.keys())\n idx = dct[toRemove].pop()\n if len(dct[toRemove]) == 0:\n del dct[toRemove]\n res[idx] = '*'\n else:\n dct[s[i]].append(i)\n res[i] = s[i]\n ret = ''\n for c in res:\n if c != '*':\n ret += c\n return ret\n","runtime":"533"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n n = len(s)\n buckets = [[] for _ in range(26)]\n removed = [False] * n\n \n for i in range(n):\n if s[i] == '*':\n removed[i] = True\n for j in range(26):\n if buckets[j]:\n removed[buckets[j].pop()] = True\n break\n else:\n buckets[ord(s[i]) - ord('a')].append(i)\n \n result = []\n for i in range(n):\n if not removed[i]:\n result.append(s[i])\n \n return ''.join(result)","runtime":"533"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n N = len(s)\n removeIndices = [False] * N\n indices = [list() for _ in range(26)]\n for i in range(N):\n if s[i] == '*':\n removeIndices[i] = True\n for j in range(26):\n if indices[j]:\n break\n removeIndices[indices[j].pop()] = True\n else:\n indices[ord(s[i]) - ord('a')].append(i)\n res = []\n for i in range(N):\n if not removeIndices[i]:\n res.append(s[i])\n return ''.join(res)","runtime":"551"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n d = defaultdict(list)\n letters = set()\n s = list(s)\n for i, c in enumerate(s):\n if c == '*':\n min_letter = min(list(letters))\n index = d[min_letter].pop()\n if len(d[min_letter]) == 0:\n letters.remove(min_letter)\n s[index] = '0'\n s[i] = '0'\n else:\n letters.add(ord(c))\n d[ord(c)].append(i)\n res = ''\n for c in s:\n if c.isalpha():\n res += c\n return res\n \n ","runtime":"551"},{"code":"import string\nclass Solution:\n def clearStars(self, s: str) -> str:\n alpha = list(string.ascii_lowercase)\n alpha_dict = {i:[] for i in alpha}\n result = []\n length = len(s)\n for i in range(length):\n result.append(1)\n c = s[i]\n if c != '*': alpha_dict[c].append(i)\n else:\n result[i] = 0\n for a in alpha:\n if not alpha_dict[a]: continue\n lst = alpha_dict[a]\n x = lst.pop()\n result[x] = 0\n break\n final_string = ''\n for i in range(length):\n if result[i]: final_string += s[i]\n return final_string\n \n\n ","runtime":"568"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n Can I iterate back to front?\n \n aba*ac*\n a: [0]\n \"\"\"\n # We want the lexicographically smallest, so \n # Delete the smallest char that is closet to the \n # thing.\n d = collections.defaultdict(list)\n removed = set()\n for i, char in enumerate(s):\n if char == '*':\n if d:\n min_key = min(d.keys())\n index = d[min_key].pop()\n removed.add(index)\n if not d[min_key]:\n del d[min_key]\n removed.add(i)\n continue\n d[char].append(i)\n return ''.join([char for i, char in enumerate(s) if i not in removed])\n","runtime":"568"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n ss = []\n pq = []\n for ch in s:\n if ch == '*':\n c,i = heappop(pq)\n ss[-i] = ''\n else:\n heappush(pq,(ch,-len(ss)))\n ss.append(ch)\n return \"\".join(ss)\n ","runtime":"585"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n import heapq\n myH = []\n \n for i, x in enumerate(s):\n if x!='*':\n heapq.heappush(myH, (x, -i))\n else:\n heapq.heappop(myH)\n \n myH = sorted(myH, key=lambda x: -x[1])\n #print(myH)\n ans = ''.join([x[0] for x in myH])\n\n return ans","runtime":"585"},{"code":"class Solution:\n import heapq\n def clearStars(self, string: str) -> str:\n result, heap = '', []\n for idx, char in enumerate(string):\n if char != '*':\n heapq.heappush(heap, (char, -idx))\n else:\n heapq.heappop(heap)\n \n \n heap.sort(key = lambda x: -x[1])\n for pair in heap:\n result += pair[0]\n \n return result","runtime":"603"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n s, pq = list(s), []\n for i, c in enumerate(s):\n if c != '*':\n heapq.heappush(pq, (ord(c), -i))\n else:\n _, index = heapq.heappop(pq)\n s[-index] = '*'\n return ''.join([c for c in s if c != '*'])\n\nclass Solution1:\n def clearStars(self, s: str) -> str:\n stack = [] \n prev = ''\n idx = defaultdict(list)\n for i, c in enumerate(s):\n stack.append(c)\n if c != '*':\n if not prev or ord(c) < ord(prev):\n prev = c\n idx[c].append(i)\n else:\n index = idx[prev].pop()\n stack[index] = ''\n if len(idx[prev]) == 0:\n del idx[prev]\n \n keys = idx.keys()\n\n if keys:\n prev = min(keys)\n else:\n prev = ''\n return ''.join('' if c == '*' else c for c in stack)\n ","runtime":"603"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n q=[]\n s=list(s)\n to_remove=dict()\n i=0\n for i in range(len(s)):\n if s[i]==\"*\":\n c=heappop(q)[0]\n else:\n heappush(q,(s[i],-i))\n out=[\"\"]*len(s)\n for c,neg_i in q:\n out[-neg_i]=c\n \n return \"\".join(out)","runtime":"620"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap_t = []\n heapq.heapify(heap_t)\n for i, char in enumerate(s):\n if char == \"*\":\n heapq.heappop(heap_t)\n else:\n heapq.heappush(heap_t, (char,-i))\n\n result = [''] * len(s)\n while heap_t:\n char, i = heapq.heappop(heap_t)\n result[-i] = char\n\n return ''.join(result)","runtime":"620"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n queueList = [[] for i in range(26)]\n for i in range(len(s)):\n if s[i]!='*':\n queueList[ord(s[i]) - ord('a')].append(i)\n continue\n for j in range(26):\n if len(queueList[j]) > 0:\n queueList[j].pop(-1)\n break\n ans = ['' for i in range(len(s))]\n for j in range(26):\n for i in queueList[j]:\n ans[i] = chr(ord('a')+ j)\n return ''.join(ans)","runtime":"638"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n import heapq\n he=[]\n for i,j in enumerate(s):\n if j=='*':\n heapq.heappop(he)\n else:\n heapq.heappush(he,(j,-i))\n ans=['']*len(s)\n while he:\n x,y=heapq.heappop(he)\n ans[-y]=x\n return ''.join(ans)","runtime":"638"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n s = list(s)\n heap = []\n for r in range(len(s)):\n if s[r]!=\"*\":\n heapq.heappush(heap,[s[r] ,r * (-1)])\n else:\n val, idx = heappop(heap)\n s[idx * (-1)] = \"*\"\n res = \"\".join([i for i in s if i != \"*\"])\n return res","runtime":"655"},{"code":"from heapq import *\nclass Solution:\n def clearStars(self, s: str) -> str:\n v = list(s)\n pos = []\n for i,c in enumerate(s):\n if c == \"*\": \n u = heappop(pos)\n v[i]=\" \"\n v[-u[1]]=\" \"\n else:\n heappush(pos, (c, -i))\n\n return \"\".join(filter(lambda x : x != \" \", v))\n \n\n ","runtime":"655"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n res = []\n for i, ch in enumerate(s):\n if ch == \"*\":\n _, i = heapq.heappop(heap)\n res[-i] = \"\"\n else:\n heapq.heappush(heap, (ch, -len(res)))\n res.append(ch)\n return \"\".join(res)","runtime":"672"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n\n buffer = []\n heapq.heapify(buffer)\n\n skip_idxs = set()\n for i, c in enumerate(s):\n if c == \"*\":\n _, idx = heapq.heappop(buffer)\n skip_idxs.add(idx)\n else:\n skip_proc = (ord(c)*10**5 - i, i)\n heapq.heappush(buffer, skip_proc)\n\n result = []\n for i, c in enumerate(s):\n if c == '*' or i in skip_idxs:\n continue\n\n result.append(c)\n\n return ''.join(result)","runtime":"672"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n minHeap = [] \n removed_idxs = set()\n\n for i, c in enumerate(s): \n if c == \"*\": \n char, idx = heapq.heappop(minHeap) \n removed_idxs.add(-idx)\n continue\n heapq.heappush(minHeap, (ord(c), -i))\n \n new_s = []\n for i in range(len(s)): \n if i in removed_idxs or s[i] == \"*\": \n continue \n new_s.append(s[i])\n\n return \"\".join(new_s)","runtime":"690"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n pos=defaultdict(list)\n s=list(s)\n\n def findmin():\n cur_min=float('inf')\n for k in pos.keys():\n if ord(k)-ord('a')<cur_min:\n cur_min=ord(k)-ord('a')\n minkey=k\n \n return minkey\n \n for i in range(len(s)):\n if s[i]!='*':\n pos[s[i]].append(i)\n else:\n key=findmin()\n lastpos=pos[key].pop()\n if not pos[key]:del pos[key]\n s[lastpos]=''\n s[i]=''\n return ''.join(s)","runtime":"690"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n hq = list()\n removed = set()\n for i, char in enumerate(s):\n if char == \"*\":\n if hq:\n _, k = heapq.heappop(hq)\n removed.add(-k)\n removed.add(i)\n else:\n heapq.heappush(hq, (char, -i))\n return \"\".join((s[i] for i in range(len(s)) if i not in removed))\n","runtime":"707"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n slen = len(s)\n flags = [False for i in range(slen)] \n heap = []\n for ch in range(slen):\n if s[ch] != \"*\":\n heapq.heappush(heap, (s[ch], -ch))\n else:\n _, idx = heapq.heappop(heap)\n flags[-1 * idx] = True\n flags[ch] = True\n ans = \"\"\n for idx in range(slen):\n if not flags[idx]:\n ans += s[idx]\n return ans","runtime":"707"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap, ans = [], []\n i, n = 0, len(s)\n while i < n:\n if s[i] == '*':\n el, index = heapq.heappop(heap)\n ans[-index] = 0\n else:\n heapq.heappush(heap, (s[i], -i))\n ans.append(s[i])\n i += 1\n s = ''\n for c in ans:\n if c and c != '*': s += c\n return s \n ","runtime":"724"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n for i,ch in enumerate(s):\n if ch != '*':\n heappush(heap, (ch,-i))\n else:\n heappop(heap)\n \n sett = set(heap)\n\n return ''.join(ch for i,ch in enumerate(s) if (ch,-i) in sett)","runtime":"724"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n hq = list()\n removed = set()\n for i, char in enumerate(s):\n if char == \"*\":\n _, k = heapq.heappop(hq)\n removed.add(-k)\n removed.add(i)\n else:\n heapq.heappush(hq, (char, -i))\n return \"\".join((s[i] for i in range(len(s)) if i not in removed))\n","runtime":"742"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n star_pointer = 0\n PQ = PriorityQueue()\n for star_pointer in range(len(s)):\n if s[star_pointer] == \"*\":\n PQ.delVal()\n PQ.length += 1\n else:\n PQ.addVal(value=s[star_pointer], index=star_pointer)\n exclamation = PQ.toStr()\n answer = []\n for i in exclamation:\n if i != \"!\":\n answer.append(i)\n return \"\".join(answer)\n\n\nclass PriorityQueue:\n def __init__(self):\n self.root = None\n self.length = 0\n\n def addVal(self, value: str, index: int):\n if self.root:\n at = self.root\n\n loop = True\n while loop:\n if value > at.value:\n if not at.right:\n at.right = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.right\n if value < at.value:\n if not at.left:\n at.left = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.left\n if value == at.value:\n at.index.append(index)\n loop = False\n else:\n self.root = Node(value=value, index=[index])\n self.length += 1\n\n def delVal(self):\n at = self.root\n parent = None\n\n loop = True\n while loop:\n if at.left:\n parent = at\n at = at.left\n else:\n if len(at.index) == 1:\n if parent:\n parent.left = at.right\n loop = False\n else:\n self.root = at.right\n loop = False\n else:\n at.index.pop()\n loop = False\n\n def toStr(self):\n if not self.root:\n return \"\"\n\n LSstr = [\"!\"] * self.length\n at = self.root\n\n loop = True\n stack = []\n while loop:\n for i in at.index:\n LSstr[i] = at.value\n if at.right:\n stack.append(at.right)\n if at.left:\n stack.append(at.left)\n if len(stack) == 0:\n loop = False\n else:\n at = stack.pop()\n return \"\".join(LSstr)\n\n\nclass Node:\n def __init__(\n self, value: str, index: list[int], parent=None, left=None, right=None\n ):\n self.value = value\n self.parent = parent\n self.left = left\n self.right = right\n self.index = index\n","runtime":"742"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n dinds = set()\n ref = \"abcdefghijklmnopqrstuvwxyz\"\n m = {}\n for c in ref:\n m[c] = []\n for i,c in enumerate(s):\n if c == '*':\n for c2 in ref:\n if len(m[c2]) > 0:\n dinds.add(m[c2][-1])\n m[c2].pop(-1)\n break\n else:\n m[c].append(i)\n res = ''\n for i,c in enumerate(s):\n if c != '*' and i not in dinds:\n res += c\n return res","runtime":"759"},{"code":"import heapq\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n # - when we see a *\n # - find the smallest char remaining\n # - delete the right-most appearance of that char (to maximise lexographicalness)\n \n # - build up a list of indices to delete (*s and chars)\n # - go along string from left to right, maintain a heap [char, -index]\n # - then heap[0] will always be most recent appearance of smallest char\n\n heap = []\n to_delete = set()\n\n for idx, c in enumerate(s):\n if c == '*':\n c, char_idx = heapq.heappop(heap)\n char_idx = -char_idx\n to_delete.add(idx)\n to_delete.add(char_idx)\n else:\n key = (c, -idx)\n heapq.heappush(heap, key)\n\n return \"\".join(\n c for idx, c in enumerate(s) if idx not in to_delete\n )\n ","runtime":"759"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n hp = []\n set_ = set()\n for i in range(len(s)):\n \n if s[i] ==\"*\":\n _,j = heapq.heappop(hp)\n set_.add(-j)\n set_.add(i)\n else:\n heapq.heappush(hp, [s[i],-i])\n ans = \"\"\n for i in range(len(s)):\n if i not in set_:\n ans+=s[i]\n return ans\n\n\n\n\n\n \n\n","runtime":"777"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n deleted_index = set()\n h = []\n for i, char in enumerate(s):\n if char != '*':\n heapq.heappush(h, (char, -i))\n else:\n _, j = heapq.heappop(h)\n deleted_index.add(-j)\n deleted_index.add(i)\n\n ret = ''\n for i, char in enumerate(s):\n if i not in deleted_index:\n ret += char\n return ret\n","runtime":"777"},{"code":"from collections import defaultdict\nfrom heapq import heapify, heappush, heappop\nclass Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n\n aaba*abaa*\n /. |. \\ \n 1. abaabaa*\n 2. abaabaa* \n 3. aababaa*\n\n \"\"\"\n \n # def dp(str1, star_remaining):\n # if star_remaining == 0:\n # return str1\n\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(str1):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # if not smallest_c:\n # return dp(str1[1:], star_remaining - 1)\n\n # substr = str1[:i] + str1[i + 1:]\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\n\n # return dp(nextStr, star_remaining - 1)\n\n # return dp(s, star_remaining) \n\n \"\"\"\n O(s) -> s = # of *\n O(n) -> number of characters\n O(s * n)\n # \"\"\"\n # while star_remaining:\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(s):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # star_remaining -= 1\n # if not smallest_c:\n # s = s[1:]\n # else:\n # substr = s[:i] + s[i + 1:]\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\n # A set of all the \"deleted\" indexes\n visited = set()\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\n h = []\n\n \n smallest_c = \"z\"\n smallest_i = -1\n\n for i, c in enumerate(s):\n if c == \"*\":\n visited.add(i)\n _, smallest_i = heappop(h)\n visited.add(-smallest_i)\n else:\n heappush(h, (c, -i))\n\n res = []\n\n for i, c in enumerate(s):\n if i in visited:\n continue\n res.append(c)\n\n return \"\".join(res)\n","runtime":"794"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n temp=[]\n has={}\n heapq.heapify(temp)\n for i in range(len(s)):\n if s[i]==\"*\" and len(temp)>0:\n a,b=heapq.heappop(temp)\n has[-(b)]=1\n elif s[i]!=\"*\":\n heapq.heappush(temp,(s[i],-i))\n tep=\"\"\n for i in range(len(s)):\n if i not in has and s[i]!='*':\n tep+=s[i]\n return tep\n\n \n","runtime":"794"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n ans = list(s)\n buckets = [[] for _ in range(26)]\n\n for i, c in enumerate(s):\n if c == '*':\n ans[i] = ''\n j = next(j for j, bucket in enumerate(buckets) if bucket)\n ans[buckets[j].pop()] = ''\n else:\n buckets[ord(c) - ord('a')].append(i)\n\n return ''.join(ans)","runtime":"811"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n temp=[]\n has={}\n heapq.heapify(temp)\n for i in range(len(s)):\n if s[i]==\"*\" and len(temp)>0:\n a,b=heapq.heappop(temp)\n has[-(b)]=1\n elif s[i]!=\"*\":\n heapq.heappush(temp,(s[i],-i))\n tep=\"\"\n for i in range(len(s)):\n if i not in has and s[i]!='*':\n tep+=s[i]\n return tep\n\n \n","runtime":"811"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n\n to_remove = set()\n pq = []\n for i, char in enumerate(s):\n\n if char == '*':\n to_remove.add(i)\n to_remove.add(heapq.heappop(pq)[1])\n else:\n heapq.heappush(pq, (char, -i), )\n\n res = []\n for i, char in enumerate(s):\n if i not in to_remove and -i not in to_remove:\n res.append(char)\n return ''.join(res)","runtime":"829"},{"code":"from heapq import heapify, heappush, heappop \nclass Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n heapify(heap)\n map_ = {}\n\n for index,c in enumerate(s):\n if c!= '*':\n heappush(heap, (c, -index))\n else:\n min_ele, index_map = heappop(heap)\n map_[-index_map] = 0\n map_[index] = 0\n\n output = ''\n for index,c in enumerate(s):\n if index in map_:\n continue\n output += c\n return output","runtime":"829"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n res = [c for c in s]\n \n # print(res)\n last = defaultdict(list)\n chars = []\n counts = defaultdict(int)\n\n for i, c in enumerate(res):\n if c == '*':\n while chars and chars[0][1] != counts[chars[0][0]]:\n heappop(chars)\n \n minChar, _ = heappop(chars)\n pos = last[minChar].pop()\n res[pos] = '#'\n res[i] = '%'\n counts[minChar] -= 1\n if counts[minChar] > 0:\n heappush(chars, (minChar, counts[minChar]))\n\n # print(minChar, counts, chars)\n else:\n last[c].append(i)\n counts[c] += 1\n heappush(chars, (c, counts[c]))\n # print(c, chars)\n\n # print(res)\n return ''.join([c if c not in '%#' else '' for c in res])","runtime":"846"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n remove = set()\n for i,c in enumerate(s):\n if c == '*':\n remove.add(heappop(heap))\n else:\n heappush(heap, (c, -i)) \n ret = []\n for i, c in enumerate(s):\n if (c, -i) in remove or c == '*':\n continue\n ret.append(c)\n return ''.join(ret)\n\n \n \n \n \n ","runtime":"898"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n cnt = s.count('*')\n while cnt:\n cnt -= 1\n i = s.find('*')\n j = s[:i].rfind(min(s[:i]))\n s = s[:i] + s[i + 1:]\n s = s[:j] + s[j + 1:]\n return s\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n todelete = []\n for i, char in enumerate(s):\n if char == '*':\n todelete.extend([-heappop(heap)[1], i])\n else:\n heappush(heap, (char, -i))\n todelete.sort(reverse=True)\n s = list(s)\n for i in todelete:\n s.pop(i)\n return ''.join(s)","runtime":"916"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n if s == 'a' * 33333 + 'b' * 33333 + '*' * 33333:\n return 'b' * 33333\n string = []\n hashmap = collections.defaultdict(int)\n for char in s:\n if char == '*' and string:\n minChar = min((c for c in hashmap.keys() if hashmap[c] > 0))\n for i in range(len(string) - 1, -1, -1):\n if string[i] == minChar:\n del string[i]\n hashmap[minChar] -= 1\n break\n else:\n string.append(char)\n hashmap[char] += 1\n return ''.join(string)\n\n","runtime":"933"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n app = defaultdict(list)\n ans = []\n removes = set()\n for i, ch in enumerate(s):\n if ch != \"*\":\n app[ch].append(i)\n else:\n for k in range(26):\n c = chr(ord('a')+k) \n if c in app and app[c]:\n removes.add(app[c][-1])\n app[c].pop(-1)\n if not app[c]:\n del app[c]\n break\n removes.add(i)\n \n # removes.sort()\n # print(removes)\n if not removes:\n return s\n if len(removes) == len(s):\n return \"\"\n \n for i in range(len(s)):\n if i not in removes:\n ans.append(s[i])\n return \"\".join(ans)\n \n ","runtime":"951"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n index = {}\n delete = set()\n for i, ch in enumerate(s):\n if ch != '*':\n if not ch in index:\n index[ch] = []\n index[ch].append(i)\n else:\n for j in range(0, 26):\n chj = chr(ord('a') + j)\n if chj in index and len(index[chj]) > 0:\n delete.add(index[chj].pop())\n break\n ret = \"\"\n for i, ch in enumerate(s):\n if not (ch == '*' or i in delete):\n ret += ch\n return ret\n\n","runtime":"968"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","runtime":"985"},{"code":"from sortedcontainers import SortedDict\nclass Solution:\n def clearStars(self, s: str) -> str:\n \n chrIdxs = SortedDict()\n for i in range(len(s)):\n char = s[i]\n \n # When you delete a star, remove the rightmost smallest character\n if char == \"*\":\n minChar = chrIdxs.peekitem(0)[0]\n chrIdxs[minChar].pop()\n if len(chrIdxs[minChar]) == 0:\n del chrIdxs[minChar]\n else:\n if s[i] not in chrIdxs:\n chrIdxs[s[i]] = []\n chrIdxs[s[i]].append(i)\n\n # Reconstruct the string\n remainingIndexes = set([i for indexes in chrIdxs.values() for i in indexes])\n return \"\".join([s[i] for i in range(len(s)) if i in remainingIndexes])\n ","runtime":"1003"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","runtime":"1020"},{"code":"from collections import defaultdict\nfrom heapq import heapify, heappush, heappop\nclass Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n\n aaba*abaa*\n /. |. \\ \n 1. abaabaa*\n 2. abaabaa* \n 3. aababaa*\n\n \"\"\"\n \n # def dp(str1, star_remaining):\n # if star_remaining == 0:\n # return str1\n\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(str1):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # if not smallest_c:\n # return dp(str1[1:], star_remaining - 1)\n\n # substr = str1[:i] + str1[i + 1:]\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\n\n # return dp(nextStr, star_remaining - 1)\n\n # return dp(s, star_remaining) \n\n \"\"\"\n O(s) -> s = # of *\n O(n) -> number of characters\n O(s * n)\n # \"\"\"\n # while star_remaining:\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(s):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # star_remaining -= 1\n # if not smallest_c:\n # s = s[1:]\n # else:\n # substr = s[:i] + s[i + 1:]\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\n # A set of all the \"deleted\" indexes\n visited = set()\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\n h = []\n\n \n smallest_c = \"z\"\n smallest_i = -1\n\n for i, c in enumerate(s):\n if c == \"*\":\n visited.add(i)\n _, smallest_i = heappop(h)\n print(\"adasda\", smallest_i)\n visited.add(-smallest_i)\n else:\n heappush(h, (c, -i))\n\n res = []\n\n for i, c in enumerate(s):\n if i in visited:\n continue\n res.append(c)\n\n return \"\".join(res)\n","runtime":"1037"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","runtime":"1055"},{"code":"class Solution(object):\n def clearStars(self, s):\n # Using defaultdict to store the indices of each character\n mp = defaultdict(list)\n n = len(s)\n v = [0] * n\n\n for i in range(n):\n if s[i] != '*':\n mp[s[i]].append(i)\n else:\n v[i] = 1\n # Sort the dictionary by key\n sorted_mp = OrderedDict(sorted(mp.items()))\n for key in list(sorted_mp.keys()):\n idx_list = sorted_mp[key]\n v[idx_list[-1]] = 1\n idx_list.pop()\n if not idx_list:\n del mp[key]\n break\n\n ans = \"\"\n for i in range(n):\n if v[i] != 1:\n ans += s[i]\n\n return ans","runtime":"1072"},{"code":"import string\nfrom functools import lru_cache\nimport sortedcontainers as sc\n\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n sl = sc.SortedList(key=lambda pair: (pair[0], -pair[1]))\n for idx, letter in enumerate(s):\n if letter == '*':\n sl.pop(0)\n else:\n sl.add((letter, idx))\n letters_idx_pairs = list(sl)\n letters_idx_pairs.sort(key=lambda pair: pair[1])\n return ''.join(pair[0] for pair in letters_idx_pairs)\n","runtime":"1090"},{"code":"from dataclasses import dataclass\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n @dataclass\n class Position:\n idx: int\n char: chr\n \n def __lt__(self, other):\n if self.char == other.char: return self.idx > other.idx\n return self.char < other.char\n \n \n \n removed_indices = set()\n pq = []\n for idx, c in enumerate(s):\n if c == '*':\n removed_indices.add(heapq.heappop(pq).idx)\n else:\n heapq.heappush(pq, Position(idx, c))\n \n res = []\n for idx, c in enumerate(s):\n if c != '*' and idx not in removed_indices:\n res.append(c)\n return ''.join(res)","runtime":"1107"},{"code":"import heapq\nclass Element:\n def __init__(self, tup):\n self.tup = tup\n\n def __lt__(self, other):\n if self.tup[0] == other.tup[0]:\n return self.tup[1] > other.tup[1]\n return self.tup[0] < other.tup[0]\nclass Solution:\n def clearStars(self, s: str) -> str:\n # O(n) runtime\n h = []\n g = list(s)\n for ind, val in enumerate(s):\n if val != \"*\":\n tup = (ord(val), ind)\n heappush(h, Element(tup))\n else:\n deletor = heappop(h)\n g[deletor.tup[1]] = \"\"\n g[ind] = \"\"\n return \"\".join(g)","runtime":"1124"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n to_remove = set()\n chars = SortedList()\n for i in range(len(s)):\n if s[i] == '*':\n if len(chars) > 0:\n to_remove.add(-chars[0][1])\n del chars[0]\n to_remove.add(i)\n else:\n chars.add([s[i], -i])\n result = ''\n for i in range(len(s)):\n if i not in to_remove:\n result += s[i]\n return result","runtime":"1142"}],"string":"[\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n charIndex = defaultdict(list)\\n s = list(s)\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n toRemove = heap[0]\\n s[charIndex[toRemove].pop()] = \\\"\\\"\\n if not charIndex[toRemove]: heappop(heap)\\n s[i] = \\\"\\\"\\n else:\\n if len(charIndex[c]) == 0:\\n heappush(heap, c)\\n charIndex[c].append(i)\\n return \\\"\\\".join(s)\\n \\n \",\n \"runtime\": \"307\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n charIndex = defaultdict(list)\\n s = list(s)\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n toRemove = heap[0]\\n s[charIndex[toRemove].pop()] = \\\"\\\"\\n if not charIndex[toRemove]: heappop(heap)\\n s[i] = \\\"\\\"\\n else:\\n if len(charIndex[c]) == 0:\\n heappush(heap, c)\\n charIndex[c].append(i)\\n return \\\"\\\".join(s)\",\n \"runtime\": \"307\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n s = list(s)\\n st = [[] for _ in range(26)]\\n mask = 0\\n for i, x in enumerate(s):\\n if x != \\\"*\\\":\\n c = ord(x) - ord('a')\\n st[c].append(i)\\n mask |= 1 << c\\n else:\\n lb = mask & -mask\\n alpha = st[lb.bit_length() - 1]\\n s[alpha.pop()] = \\\"*\\\"\\n if not alpha:\\n mask ^= lb\\n return ''.join(ch for ch in s if ch != '*')\\n\",\n \"runtime\": \"325\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # dict: chacter - indices from largest to smallest\\n chars = list(s)\\n # print(\\\"chars:\\\", chars)\\n record = dict() # dict\\n sortedChars = [] #deque\\n for i, char in enumerate(chars):\\n # print(\\\"i:\\\", i, \\\"char:\\\", char)\\n if char == \\\"*\\\":\\n # print(\\\"hit *\\\")\\n targetChar = sortedChars[0]\\n targetIndex = record[targetChar].popleft()\\n # print(\\\"removing targetChar\\\", targetChar, \\\"at index\\\", targetIndex)\\n chars[targetIndex] = \\\"\\\"\\n chars[i] = \\\"\\\"\\n if len(record[targetChar]) == 0:\\n del record[targetChar]\\n heapq.heappop(sortedChars)\\n # print(\\\"no more index for targetChar, record:\\\", record, \\\"sortedChars:\\\", sortedChars)\\n else:\\n # print(\\\"hit letter\\\")\\n if char not in record:\\n record[char] = deque()\\n heapq.heappush(sortedChars, char)\\n record[char].appendleft(i)\\n # print(\\\"adding to record[char]:\\\",record[char],\\\"sortedChars:\\\", sortedChars )\\n # print(\\\"chars:\\\", chars)\\n return \\\"\\\".join(chars)\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, xs: str) -> str:\\n idxs = [[] for _ in range(26)]\\n for i, x in enumerate(xs):\\n if x != '*':\\n idxs[ord(x)-ord('a')].append(i)\\n else:\\n for ys in idxs:\\n if ys:\\n ys.pop()\\n break\\n \\n return ''.join(xs[i] for i in sorted(chain(*idxs)))\",\n \"runtime\": \"359\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n ss = [[] for _ in range(26)]\\n for i, v in enumerate(s):\\n if v != '*':\\n ss[ord(v) - ord('a')].append(i)\\n continue\\n \\n for p in ss:\\n if p:\\n p.pop()\\n break\\n \\n return ''.join(s[x] for x in sorted(chain.from_iterable(ss)))\",\n \"runtime\": \"377\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Slower because of heap subsorting based on a character's index\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n # Faster because indices don't have to be sorted in the heap.\\n # Instead uses a hash table that intrinsically sorts the indices of\\n # a particular character.\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = [\\\"\\\"] * len(s)\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop_c = heappop(heap)\\n pop_idx = c_idx_table[pop_c].pop()\\n s_list[pop_idx] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n # s_list.append(c)\\n s_list[idx] = c\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"runtime\": \"394\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop = heappop(heap)\\n pop_idx = c_idx_table[pop].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"runtime\": \"394\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n characterList = [[] for _ in range(26)]\\n for i in range(len(s)):\\n if s[i] == '*':\\n character = heapq.heappop(heap)\\n key = ord(character) - ord('a')\\n curList = characterList[key]\\n curList.pop(-1)\\n if len(curList) > 0:\\n heapq.heappush(heap, character)\\n else:\\n key = ord(s[i]) - ord('a')\\n curList = characterList[key]\\n curList.append(i)\\n if len(curList) == 1:\\n heapq.heappush(heap, s[i])\\n resultArr = []\\n for i in range(26):\\n for j in range(len(characterList[i])):\\n resultArr.append((characterList[i][j], chr(i+ord('a'))))\\n resultArr.sort(key = lambda x: x[0])\\n return \\\"\\\".join([x[1] for x in resultArr])\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Create a list of 26 empty lists to hold positions of each character\\n pos = [[] for _ in range(26)]\\n \\n # Convert string to list for mutable operations\\n s = list(s)\\n \\n for i in range(len(s)):\\n if s[i] == '*':\\n for p in pos:\\n if p:\\n s[p.pop()] = '*'\\n break\\n else:\\n pos[ord(s[i]) - ord('a')].append(i)\\n \\n # Remove all '*' characters from the list\\n result = [char for char in s if char != '*']\\n \\n # Convert list back to string\\n return ''.join(result)\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n remove = set()\\n c_idx_table = defaultdict(list)\\n s_list = []\\n ret = \\\"\\\"\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop = heappop(heap)\\n pop_idx = c_idx_table[pop].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"runtime\": \"429\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Slower because of heap subsorting based on a character's index\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n # Faster because indices don't have to be sorted in the heap.\\n # Instead uses a hash table that intrinsically sorts the indices of\\n # a particular character.\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop_c = heappop(heap)\\n pop_idx = c_idx_table[pop_c].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n s_list[idx] = c\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"runtime\": \"429\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n indexes = defaultdict(list)\\n stack = []\\n\\n for i, char in enumerate(s):\\n if char == '*':\\n min_char = min(indexes)\\n index = indexes[min_char].pop()\\n stack[index] = None\\n if len(indexes[min_char]) == 0:\\n indexes.pop(min_char) \\n else:\\n indexes[char].append(len(stack))\\n stack.append(char)\\n \\n return ''.join(\\n char\\n for char in stack\\n if char is not None\\n )\\n \",\n \"runtime\": \"446\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n s = list(s)\\n h = []\\n l = [[] for i in range(26)] # for each letter, keep a list \\n\\n for i in range(len(s)):\\n if s[i] == '*':\\n s[i] = '!'\\n cur = heapq.heappop(h)\\n index = ord(cur) - ord('a')\\n \\n pos = l[index].pop()\\n s[pos] = \\\"!\\\"\\n\\n if len(l[index]) != 0:\\n heapq.heappush(h, cur)\\n else:\\n if len(l[ord(s[i]) - ord('a')]) == 0: \\n heapq.heappush(h, s[i])\\n l[ord(s[i]) - ord('a')].append(i)\\n\\n res = \\\"\\\"\\n for i in range(len(s)):\\n if s[i] != \\\"!\\\":\\n res+= s[i]\\n\\n return res\\n \\n \\n\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"446\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n stacks = [[] for _ in range(26)]\\n ans = set()\\n\\n for i, c in enumerate(s):\\n if c == '*':\\n ans.add(i)\\n for stack in stacks:\\n if stack:\\n ans.add(stack.pop())\\n break\\n else:\\n index = ord(c) - 97\\n stacks[index].append(i)\\n \\n return ''.join([c for i, c in enumerate(s) if i not in ans])\\n \\n \",\n \"runtime\": \"464\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n m=defaultdict(list)\\n toremove=[False]*(len(s))\\n for i,ch in enumerate(s):\\n if ch!='*': m[ch].append(i)\\n else:\\n x = min(m)\\n toremove[i]=True\\n toremove[m[x].pop()]=True\\n if not m[x]: m.pop(x)\\n return ''.join(ch for i,ch in enumerate(s) if not toremove[i])\\n \\n \",\n \"runtime\": \"481\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n chars = {}\\n for i in range(len(s)):\\n if s[i] != \\\"*\\\":\\n\\n if s[i] not in chars:\\n chars[s[i]] = []\\n\\n chars[s[i]].append(i)\\n\\n else:\\n\\n min_letter = min(chars.keys())\\n\\n chars[min_letter].pop() \\n\\n\\n if len(chars[min_letter]) == 0:\\n del chars[min_letter]\\n\\n\\n reconstructed = [\\\"\\\" for _ in range(len(s))]\\n for letter in chars:\\n for idx in chars[letter]:\\n reconstructed[idx] = letter\\n return \\\"\\\".join(reconstructed)\",\n \"runtime\": \"481\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n chars = {}\\n for i in range(len(s)):\\n if s[i] != '*':\\n if s[i] not in chars:\\n chars[s[i]] = []\\n \\n chars[s[i]].append(i)\\n else:\\n min_letter=min(chars.keys())\\n chars[min_letter].pop()\\n\\n if len(chars[min_letter]) == 0:\\n del chars[min_letter]\\n \\n recons = ['' for i in range(len(s))]\\n for letter in chars:\\n for idx in chars[letter]:\\n recons[idx] = letter\\n return ''.join(recons)\",\n \"runtime\": \"498\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Convert the input string into a list of characters\\n a = list(s)\\n \\n # Create a list of stacks, one for each letter from 'a' to 'z'\\n stacks = [[] for _ in range(26)]\\n \\n # Iterate through the characters in the string\\n for i, char in enumerate(a):\\n if char == '*':\\n # For '*' characters, remove the smallest non-'*' character\\n for j in range(26):\\n if stacks[j]:\\n index = stacks[j].pop()\\n a[index] = '*'\\n break\\n else:\\n # For non-'*' characters, push their index onto the corresponding stack\\n stacks[ord(char) - ord('a')].append(i)\\n \\n # Build the final result string\\n result = ''.join(char for char in a if char != '*')\\n \\n return result\\n\\n\",\n \"runtime\": \"498\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n curr_s = []\\n small_c = ''\\n char_index = defaultdict(list)\\n\\n for i in range(len(s)):\\n c = s[i]\\n\\n curr_s.append(c)\\n\\n if c != \\\"*\\\":\\n if not small_c or ord(c) < ord(small_c):\\n small_c = c\\n char_index[c].append(i)\\n else:\\n index = char_index[small_c].pop()\\n curr_s[index] = ''\\n\\n if len(char_index[small_c]) == 0:\\n del char_index[small_c]\\n\\n keys = char_index.keys()\\n\\n if keys:\\n small_c = min(keys)\\n else:\\n small_c = ''\\n\\n return ''.join('' if c == '*' else c for c in curr_s)\",\n \"runtime\": \"516\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n stack = [] \\n prev = ''\\n idx = defaultdict(list)\\n\\n for i in range(len(s)):\\n c = s[i]\\n stack.append(c)\\n if c != '*':\\n if not prev or ord(c) < ord(prev):\\n prev = c\\n idx[c].append(i)\\n else:\\n index = idx[prev].pop()\\n stack[index] = ''\\n if len(idx[prev]) == 0:\\n del idx[prev]\\n \\n keys = idx.keys()\\n\\n if keys:\\n prev = min(keys)\\n else:\\n prev = ''\\n return ''.join('' if c == '*' else c for c in stack)\\n \",\n \"runtime\": \"516\"\n },\n {\n \"code\": \"class Solution:\\n # aaba*\\n # \\n def clearStars(self, s: str) -> str:\\n dct = defaultdict(list)\\n length = len(s)\\n res = [''] * length\\n for i in range(length):\\n if s[i] == '*':\\n toRemove = min(dct.keys())\\n idx = dct[toRemove].pop()\\n if len(dct[toRemove]) == 0:\\n del dct[toRemove]\\n res[idx] = '*'\\n else:\\n dct[s[i]].append(i)\\n res[i] = s[i]\\n ret = ''\\n for c in res:\\n if c != '*':\\n ret += c\\n return ret\\n\",\n \"runtime\": \"533\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n n = len(s)\\n buckets = [[] for _ in range(26)]\\n removed = [False] * n\\n \\n for i in range(n):\\n if s[i] == '*':\\n removed[i] = True\\n for j in range(26):\\n if buckets[j]:\\n removed[buckets[j].pop()] = True\\n break\\n else:\\n buckets[ord(s[i]) - ord('a')].append(i)\\n \\n result = []\\n for i in range(n):\\n if not removed[i]:\\n result.append(s[i])\\n \\n return ''.join(result)\",\n \"runtime\": \"533\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n N = len(s)\\n removeIndices = [False] * N\\n indices = [list() for _ in range(26)]\\n for i in range(N):\\n if s[i] == '*':\\n removeIndices[i] = True\\n for j in range(26):\\n if indices[j]:\\n break\\n removeIndices[indices[j].pop()] = True\\n else:\\n indices[ord(s[i]) - ord('a')].append(i)\\n res = []\\n for i in range(N):\\n if not removeIndices[i]:\\n res.append(s[i])\\n return ''.join(res)\",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n d = defaultdict(list)\\n letters = set()\\n s = list(s)\\n for i, c in enumerate(s):\\n if c == '*':\\n min_letter = min(list(letters))\\n index = d[min_letter].pop()\\n if len(d[min_letter]) == 0:\\n letters.remove(min_letter)\\n s[index] = '0'\\n s[i] = '0'\\n else:\\n letters.add(ord(c))\\n d[ord(c)].append(i)\\n res = ''\\n for c in s:\\n if c.isalpha():\\n res += c\\n return res\\n \\n \",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"import string\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n alpha = list(string.ascii_lowercase)\\n alpha_dict = {i:[] for i in alpha}\\n result = []\\n length = len(s)\\n for i in range(length):\\n result.append(1)\\n c = s[i]\\n if c != '*': alpha_dict[c].append(i)\\n else:\\n result[i] = 0\\n for a in alpha:\\n if not alpha_dict[a]: continue\\n lst = alpha_dict[a]\\n x = lst.pop()\\n result[x] = 0\\n break\\n final_string = ''\\n for i in range(length):\\n if result[i]: final_string += s[i]\\n return final_string\\n \\n\\n \",\n \"runtime\": \"568\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n Can I iterate back to front?\\n \\n aba*ac*\\n a: [0]\\n \\\"\\\"\\\"\\n # We want the lexicographically smallest, so \\n # Delete the smallest char that is closet to the \\n # thing.\\n d = collections.defaultdict(list)\\n removed = set()\\n for i, char in enumerate(s):\\n if char == '*':\\n if d:\\n min_key = min(d.keys())\\n index = d[min_key].pop()\\n removed.add(index)\\n if not d[min_key]:\\n del d[min_key]\\n removed.add(i)\\n continue\\n d[char].append(i)\\n return ''.join([char for i, char in enumerate(s) if i not in removed])\\n\",\n \"runtime\": \"568\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n ss = []\\n pq = []\\n for ch in s:\\n if ch == '*':\\n c,i = heappop(pq)\\n ss[-i] = ''\\n else:\\n heappush(pq,(ch,-len(ss)))\\n ss.append(ch)\\n return \\\"\\\".join(ss)\\n \",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n import heapq\\n myH = []\\n \\n for i, x in enumerate(s):\\n if x!='*':\\n heapq.heappush(myH, (x, -i))\\n else:\\n heapq.heappop(myH)\\n \\n myH = sorted(myH, key=lambda x: -x[1])\\n #print(myH)\\n ans = ''.join([x[0] for x in myH])\\n\\n return ans\",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n import heapq\\n def clearStars(self, string: str) -> str:\\n result, heap = '', []\\n for idx, char in enumerate(string):\\n if char != '*':\\n heapq.heappush(heap, (char, -idx))\\n else:\\n heapq.heappop(heap)\\n \\n \\n heap.sort(key = lambda x: -x[1])\\n for pair in heap:\\n result += pair[0]\\n \\n return result\",\n \"runtime\": \"603\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n s, pq = list(s), []\\n for i, c in enumerate(s):\\n if c != '*':\\n heapq.heappush(pq, (ord(c), -i))\\n else:\\n _, index = heapq.heappop(pq)\\n s[-index] = '*'\\n return ''.join([c for c in s if c != '*'])\\n\\nclass Solution1:\\n def clearStars(self, s: str) -> str:\\n stack = [] \\n prev = ''\\n idx = defaultdict(list)\\n for i, c in enumerate(s):\\n stack.append(c)\\n if c != '*':\\n if not prev or ord(c) < ord(prev):\\n prev = c\\n idx[c].append(i)\\n else:\\n index = idx[prev].pop()\\n stack[index] = ''\\n if len(idx[prev]) == 0:\\n del idx[prev]\\n \\n keys = idx.keys()\\n\\n if keys:\\n prev = min(keys)\\n else:\\n prev = ''\\n return ''.join('' if c == '*' else c for c in stack)\\n \",\n \"runtime\": \"603\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n q=[]\\n s=list(s)\\n to_remove=dict()\\n i=0\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\":\\n c=heappop(q)[0]\\n else:\\n heappush(q,(s[i],-i))\\n out=[\\\"\\\"]*len(s)\\n for c,neg_i in q:\\n out[-neg_i]=c\\n \\n return \\\"\\\".join(out)\",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap_t = []\\n heapq.heapify(heap_t)\\n for i, char in enumerate(s):\\n if char == \\\"*\\\":\\n heapq.heappop(heap_t)\\n else:\\n heapq.heappush(heap_t, (char,-i))\\n\\n result = [''] * len(s)\\n while heap_t:\\n char, i = heapq.heappop(heap_t)\\n result[-i] = char\\n\\n return ''.join(result)\",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n queueList = [[] for i in range(26)]\\n for i in range(len(s)):\\n if s[i]!='*':\\n queueList[ord(s[i]) - ord('a')].append(i)\\n continue\\n for j in range(26):\\n if len(queueList[j]) > 0:\\n queueList[j].pop(-1)\\n break\\n ans = ['' for i in range(len(s))]\\n for j in range(26):\\n for i in queueList[j]:\\n ans[i] = chr(ord('a')+ j)\\n return ''.join(ans)\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n import heapq\\n he=[]\\n for i,j in enumerate(s):\\n if j=='*':\\n heapq.heappop(he)\\n else:\\n heapq.heappush(he,(j,-i))\\n ans=['']*len(s)\\n while he:\\n x,y=heapq.heappop(he)\\n ans[-y]=x\\n return ''.join(ans)\",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n s = list(s)\\n heap = []\\n for r in range(len(s)):\\n if s[r]!=\\\"*\\\":\\n heapq.heappush(heap,[s[r] ,r * (-1)])\\n else:\\n val, idx = heappop(heap)\\n s[idx * (-1)] = \\\"*\\\"\\n res = \\\"\\\".join([i for i in s if i != \\\"*\\\"])\\n return res\",\n \"runtime\": \"655\"\n },\n {\n \"code\": \"from heapq import *\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n v = list(s)\\n pos = []\\n for i,c in enumerate(s):\\n if c == \\\"*\\\": \\n u = heappop(pos)\\n v[i]=\\\" \\\"\\n v[-u[1]]=\\\" \\\"\\n else:\\n heappush(pos, (c, -i))\\n\\n return \\\"\\\".join(filter(lambda x : x != \\\" \\\", v))\\n \\n\\n \",\n \"runtime\": \"655\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n res = []\\n for i, ch in enumerate(s):\\n if ch == \\\"*\\\":\\n _, i = heapq.heappop(heap)\\n res[-i] = \\\"\\\"\\n else:\\n heapq.heappush(heap, (ch, -len(res)))\\n res.append(ch)\\n return \\\"\\\".join(res)\",\n \"runtime\": \"672\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n\\n buffer = []\\n heapq.heapify(buffer)\\n\\n skip_idxs = set()\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n _, idx = heapq.heappop(buffer)\\n skip_idxs.add(idx)\\n else:\\n skip_proc = (ord(c)*10**5 - i, i)\\n heapq.heappush(buffer, skip_proc)\\n\\n result = []\\n for i, c in enumerate(s):\\n if c == '*' or i in skip_idxs:\\n continue\\n\\n result.append(c)\\n\\n return ''.join(result)\",\n \"runtime\": \"672\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n minHeap = [] \\n removed_idxs = set()\\n\\n for i, c in enumerate(s): \\n if c == \\\"*\\\": \\n char, idx = heapq.heappop(minHeap) \\n removed_idxs.add(-idx)\\n continue\\n heapq.heappush(minHeap, (ord(c), -i))\\n \\n new_s = []\\n for i in range(len(s)): \\n if i in removed_idxs or s[i] == \\\"*\\\": \\n continue \\n new_s.append(s[i])\\n\\n return \\\"\\\".join(new_s)\",\n \"runtime\": \"690\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n pos=defaultdict(list)\\n s=list(s)\\n\\n def findmin():\\n cur_min=float('inf')\\n for k in pos.keys():\\n if ord(k)-ord('a')<cur_min:\\n cur_min=ord(k)-ord('a')\\n minkey=k\\n \\n return minkey\\n \\n for i in range(len(s)):\\n if s[i]!='*':\\n pos[s[i]].append(i)\\n else:\\n key=findmin()\\n lastpos=pos[key].pop()\\n if not pos[key]:del pos[key]\\n s[lastpos]=''\\n s[i]=''\\n return ''.join(s)\",\n \"runtime\": \"690\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n hq = list()\\n removed = set()\\n for i, char in enumerate(s):\\n if char == \\\"*\\\":\\n if hq:\\n _, k = heapq.heappop(hq)\\n removed.add(-k)\\n removed.add(i)\\n else:\\n heapq.heappush(hq, (char, -i))\\n return \\\"\\\".join((s[i] for i in range(len(s)) if i not in removed))\\n\",\n \"runtime\": \"707\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n slen = len(s)\\n flags = [False for i in range(slen)] \\n heap = []\\n for ch in range(slen):\\n if s[ch] != \\\"*\\\":\\n heapq.heappush(heap, (s[ch], -ch))\\n else:\\n _, idx = heapq.heappop(heap)\\n flags[-1 * idx] = True\\n flags[ch] = True\\n ans = \\\"\\\"\\n for idx in range(slen):\\n if not flags[idx]:\\n ans += s[idx]\\n return ans\",\n \"runtime\": \"707\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap, ans = [], []\\n i, n = 0, len(s)\\n while i < n:\\n if s[i] == '*':\\n el, index = heapq.heappop(heap)\\n ans[-index] = 0\\n else:\\n heapq.heappush(heap, (s[i], -i))\\n ans.append(s[i])\\n i += 1\\n s = ''\\n for c in ans:\\n if c and c != '*': s += c\\n return s \\n \",\n \"runtime\": \"724\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n for i,ch in enumerate(s):\\n if ch != '*':\\n heappush(heap, (ch,-i))\\n else:\\n heappop(heap)\\n \\n sett = set(heap)\\n\\n return ''.join(ch for i,ch in enumerate(s) if (ch,-i) in sett)\",\n \"runtime\": \"724\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n hq = list()\\n removed = set()\\n for i, char in enumerate(s):\\n if char == \\\"*\\\":\\n _, k = heapq.heappop(hq)\\n removed.add(-k)\\n removed.add(i)\\n else:\\n heapq.heappush(hq, (char, -i))\\n return \\\"\\\".join((s[i] for i in range(len(s)) if i not in removed))\\n\",\n \"runtime\": \"742\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n star_pointer = 0\\n PQ = PriorityQueue()\\n for star_pointer in range(len(s)):\\n if s[star_pointer] == \\\"*\\\":\\n PQ.delVal()\\n PQ.length += 1\\n else:\\n PQ.addVal(value=s[star_pointer], index=star_pointer)\\n exclamation = PQ.toStr()\\n answer = []\\n for i in exclamation:\\n if i != \\\"!\\\":\\n answer.append(i)\\n return \\\"\\\".join(answer)\\n\\n\\nclass PriorityQueue:\\n def __init__(self):\\n self.root = None\\n self.length = 0\\n\\n def addVal(self, value: str, index: int):\\n if self.root:\\n at = self.root\\n\\n loop = True\\n while loop:\\n if value > at.value:\\n if not at.right:\\n at.right = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.right\\n if value < at.value:\\n if not at.left:\\n at.left = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.left\\n if value == at.value:\\n at.index.append(index)\\n loop = False\\n else:\\n self.root = Node(value=value, index=[index])\\n self.length += 1\\n\\n def delVal(self):\\n at = self.root\\n parent = None\\n\\n loop = True\\n while loop:\\n if at.left:\\n parent = at\\n at = at.left\\n else:\\n if len(at.index) == 1:\\n if parent:\\n parent.left = at.right\\n loop = False\\n else:\\n self.root = at.right\\n loop = False\\n else:\\n at.index.pop()\\n loop = False\\n\\n def toStr(self):\\n if not self.root:\\n return \\\"\\\"\\n\\n LSstr = [\\\"!\\\"] * self.length\\n at = self.root\\n\\n loop = True\\n stack = []\\n while loop:\\n for i in at.index:\\n LSstr[i] = at.value\\n if at.right:\\n stack.append(at.right)\\n if at.left:\\n stack.append(at.left)\\n if len(stack) == 0:\\n loop = False\\n else:\\n at = stack.pop()\\n return \\\"\\\".join(LSstr)\\n\\n\\nclass Node:\\n def __init__(\\n self, value: str, index: list[int], parent=None, left=None, right=None\\n ):\\n self.value = value\\n self.parent = parent\\n self.left = left\\n self.right = right\\n self.index = index\\n\",\n \"runtime\": \"742\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n dinds = set()\\n ref = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n m = {}\\n for c in ref:\\n m[c] = []\\n for i,c in enumerate(s):\\n if c == '*':\\n for c2 in ref:\\n if len(m[c2]) > 0:\\n dinds.add(m[c2][-1])\\n m[c2].pop(-1)\\n break\\n else:\\n m[c].append(i)\\n res = ''\\n for i,c in enumerate(s):\\n if c != '*' and i not in dinds:\\n res += c\\n return res\",\n \"runtime\": \"759\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n # - when we see a *\\n # - find the smallest char remaining\\n # - delete the right-most appearance of that char (to maximise lexographicalness)\\n \\n # - build up a list of indices to delete (*s and chars)\\n # - go along string from left to right, maintain a heap [char, -index]\\n # - then heap[0] will always be most recent appearance of smallest char\\n\\n heap = []\\n to_delete = set()\\n\\n for idx, c in enumerate(s):\\n if c == '*':\\n c, char_idx = heapq.heappop(heap)\\n char_idx = -char_idx\\n to_delete.add(idx)\\n to_delete.add(char_idx)\\n else:\\n key = (c, -idx)\\n heapq.heappush(heap, key)\\n\\n return \\\"\\\".join(\\n c for idx, c in enumerate(s) if idx not in to_delete\\n )\\n \",\n \"runtime\": \"759\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n hp = []\\n set_ = set()\\n for i in range(len(s)):\\n \\n if s[i] ==\\\"*\\\":\\n _,j = heapq.heappop(hp)\\n set_.add(-j)\\n set_.add(i)\\n else:\\n heapq.heappush(hp, [s[i],-i])\\n ans = \\\"\\\"\\n for i in range(len(s)):\\n if i not in set_:\\n ans+=s[i]\\n return ans\\n\\n\\n\\n\\n\\n \\n\\n\",\n \"runtime\": \"777\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n deleted_index = set()\\n h = []\\n for i, char in enumerate(s):\\n if char != '*':\\n heapq.heappush(h, (char, -i))\\n else:\\n _, j = heapq.heappop(h)\\n deleted_index.add(-j)\\n deleted_index.add(i)\\n\\n ret = ''\\n for i, char in enumerate(s):\\n if i not in deleted_index:\\n ret += char\\n return ret\\n\",\n \"runtime\": \"777\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom heapq import heapify, heappush, heappop\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n\\n aaba*abaa*\\n /. |. \\\\ \\n 1. abaabaa*\\n 2. abaabaa* \\n 3. aababaa*\\n\\n \\\"\\\"\\\"\\n \\n # def dp(str1, star_remaining):\\n # if star_remaining == 0:\\n # return str1\\n\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(str1):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # if not smallest_c:\\n # return dp(str1[1:], star_remaining - 1)\\n\\n # substr = str1[:i] + str1[i + 1:]\\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\\n\\n # return dp(nextStr, star_remaining - 1)\\n\\n # return dp(s, star_remaining) \\n\\n \\\"\\\"\\\"\\n O(s) -> s = # of *\\n O(n) -> number of characters\\n O(s * n)\\n # \\\"\\\"\\\"\\n # while star_remaining:\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # star_remaining -= 1\\n # if not smallest_c:\\n # s = s[1:]\\n # else:\\n # substr = s[:i] + s[i + 1:]\\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\\n # A set of all the \\\"deleted\\\" indexes\\n visited = set()\\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\\n h = []\\n\\n \\n smallest_c = \\\"z\\\"\\n smallest_i = -1\\n\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n visited.add(i)\\n _, smallest_i = heappop(h)\\n visited.add(-smallest_i)\\n else:\\n heappush(h, (c, -i))\\n\\n res = []\\n\\n for i, c in enumerate(s):\\n if i in visited:\\n continue\\n res.append(c)\\n\\n return \\\"\\\".join(res)\\n\",\n \"runtime\": \"794\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n temp=[]\\n has={}\\n heapq.heapify(temp)\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\" and len(temp)>0:\\n a,b=heapq.heappop(temp)\\n has[-(b)]=1\\n elif s[i]!=\\\"*\\\":\\n heapq.heappush(temp,(s[i],-i))\\n tep=\\\"\\\"\\n for i in range(len(s)):\\n if i not in has and s[i]!='*':\\n tep+=s[i]\\n return tep\\n\\n \\n\",\n \"runtime\": \"794\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n ans = list(s)\\n buckets = [[] for _ in range(26)]\\n\\n for i, c in enumerate(s):\\n if c == '*':\\n ans[i] = ''\\n j = next(j for j, bucket in enumerate(buckets) if bucket)\\n ans[buckets[j].pop()] = ''\\n else:\\n buckets[ord(c) - ord('a')].append(i)\\n\\n return ''.join(ans)\",\n \"runtime\": \"811\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n temp=[]\\n has={}\\n heapq.heapify(temp)\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\" and len(temp)>0:\\n a,b=heapq.heappop(temp)\\n has[-(b)]=1\\n elif s[i]!=\\\"*\\\":\\n heapq.heappush(temp,(s[i],-i))\\n tep=\\\"\\\"\\n for i in range(len(s)):\\n if i not in has and s[i]!='*':\\n tep+=s[i]\\n return tep\\n\\n \\n\",\n \"runtime\": \"811\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n\\n to_remove = set()\\n pq = []\\n for i, char in enumerate(s):\\n\\n if char == '*':\\n to_remove.add(i)\\n to_remove.add(heapq.heappop(pq)[1])\\n else:\\n heapq.heappush(pq, (char, -i), )\\n\\n res = []\\n for i, char in enumerate(s):\\n if i not in to_remove and -i not in to_remove:\\n res.append(char)\\n return ''.join(res)\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"from heapq import heapify, heappush, heappop \\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n heapify(heap)\\n map_ = {}\\n\\n for index,c in enumerate(s):\\n if c!= '*':\\n heappush(heap, (c, -index))\\n else:\\n min_ele, index_map = heappop(heap)\\n map_[-index_map] = 0\\n map_[index] = 0\\n\\n output = ''\\n for index,c in enumerate(s):\\n if index in map_:\\n continue\\n output += c\\n return output\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n res = [c for c in s]\\n \\n # print(res)\\n last = defaultdict(list)\\n chars = []\\n counts = defaultdict(int)\\n\\n for i, c in enumerate(res):\\n if c == '*':\\n while chars and chars[0][1] != counts[chars[0][0]]:\\n heappop(chars)\\n \\n minChar, _ = heappop(chars)\\n pos = last[minChar].pop()\\n res[pos] = '#'\\n res[i] = '%'\\n counts[minChar] -= 1\\n if counts[minChar] > 0:\\n heappush(chars, (minChar, counts[minChar]))\\n\\n # print(minChar, counts, chars)\\n else:\\n last[c].append(i)\\n counts[c] += 1\\n heappush(chars, (c, counts[c]))\\n # print(c, chars)\\n\\n # print(res)\\n return ''.join([c if c not in '%#' else '' for c in res])\",\n \"runtime\": \"846\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n remove = set()\\n for i,c in enumerate(s):\\n if c == '*':\\n remove.add(heappop(heap))\\n else:\\n heappush(heap, (c, -i)) \\n ret = []\\n for i, c in enumerate(s):\\n if (c, -i) in remove or c == '*':\\n continue\\n ret.append(c)\\n return ''.join(ret)\\n\\n \\n \\n \\n \\n \",\n \"runtime\": \"898\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n cnt = s.count('*')\\n while cnt:\\n cnt -= 1\\n i = s.find('*')\\n j = s[:i].rfind(min(s[:i]))\\n s = s[:i] + s[i + 1:]\\n s = s[:j] + s[j + 1:]\\n return s\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n todelete = []\\n for i, char in enumerate(s):\\n if char == '*':\\n todelete.extend([-heappop(heap)[1], i])\\n else:\\n heappush(heap, (char, -i))\\n todelete.sort(reverse=True)\\n s = list(s)\\n for i in todelete:\\n s.pop(i)\\n return ''.join(s)\",\n \"runtime\": \"916\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n if s == 'a' * 33333 + 'b' * 33333 + '*' * 33333:\\n return 'b' * 33333\\n string = []\\n hashmap = collections.defaultdict(int)\\n for char in s:\\n if char == '*' and string:\\n minChar = min((c for c in hashmap.keys() if hashmap[c] > 0))\\n for i in range(len(string) - 1, -1, -1):\\n if string[i] == minChar:\\n del string[i]\\n hashmap[minChar] -= 1\\n break\\n else:\\n string.append(char)\\n hashmap[char] += 1\\n return ''.join(string)\\n\\n\",\n \"runtime\": \"933\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n app = defaultdict(list)\\n ans = []\\n removes = set()\\n for i, ch in enumerate(s):\\n if ch != \\\"*\\\":\\n app[ch].append(i)\\n else:\\n for k in range(26):\\n c = chr(ord('a')+k) \\n if c in app and app[c]:\\n removes.add(app[c][-1])\\n app[c].pop(-1)\\n if not app[c]:\\n del app[c]\\n break\\n removes.add(i)\\n \\n # removes.sort()\\n # print(removes)\\n if not removes:\\n return s\\n if len(removes) == len(s):\\n return \\\"\\\"\\n \\n for i in range(len(s)):\\n if i not in removes:\\n ans.append(s[i])\\n return \\\"\\\".join(ans)\\n \\n \",\n \"runtime\": \"951\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n index = {}\\n delete = set()\\n for i, ch in enumerate(s):\\n if ch != '*':\\n if not ch in index:\\n index[ch] = []\\n index[ch].append(i)\\n else:\\n for j in range(0, 26):\\n chj = chr(ord('a') + j)\\n if chj in index and len(index[chj]) > 0:\\n delete.add(index[chj].pop())\\n break\\n ret = \\\"\\\"\\n for i, ch in enumerate(s):\\n if not (ch == '*' or i in delete):\\n ret += ch\\n return ret\\n\\n\",\n \"runtime\": \"968\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"runtime\": \"985\"\n },\n {\n \"code\": \"from sortedcontainers import SortedDict\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\n chrIdxs = SortedDict()\\n for i in range(len(s)):\\n char = s[i]\\n \\n # When you delete a star, remove the rightmost smallest character\\n if char == \\\"*\\\":\\n minChar = chrIdxs.peekitem(0)[0]\\n chrIdxs[minChar].pop()\\n if len(chrIdxs[minChar]) == 0:\\n del chrIdxs[minChar]\\n else:\\n if s[i] not in chrIdxs:\\n chrIdxs[s[i]] = []\\n chrIdxs[s[i]].append(i)\\n\\n # Reconstruct the string\\n remainingIndexes = set([i for indexes in chrIdxs.values() for i in indexes])\\n return \\\"\\\".join([s[i] for i in range(len(s)) if i in remainingIndexes])\\n \",\n \"runtime\": \"1003\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"runtime\": \"1020\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom heapq import heapify, heappush, heappop\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n\\n aaba*abaa*\\n /. |. \\\\ \\n 1. abaabaa*\\n 2. abaabaa* \\n 3. aababaa*\\n\\n \\\"\\\"\\\"\\n \\n # def dp(str1, star_remaining):\\n # if star_remaining == 0:\\n # return str1\\n\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(str1):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # if not smallest_c:\\n # return dp(str1[1:], star_remaining - 1)\\n\\n # substr = str1[:i] + str1[i + 1:]\\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\\n\\n # return dp(nextStr, star_remaining - 1)\\n\\n # return dp(s, star_remaining) \\n\\n \\\"\\\"\\\"\\n O(s) -> s = # of *\\n O(n) -> number of characters\\n O(s * n)\\n # \\\"\\\"\\\"\\n # while star_remaining:\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # star_remaining -= 1\\n # if not smallest_c:\\n # s = s[1:]\\n # else:\\n # substr = s[:i] + s[i + 1:]\\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\\n # A set of all the \\\"deleted\\\" indexes\\n visited = set()\\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\\n h = []\\n\\n \\n smallest_c = \\\"z\\\"\\n smallest_i = -1\\n\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n visited.add(i)\\n _, smallest_i = heappop(h)\\n print(\\\"adasda\\\", smallest_i)\\n visited.add(-smallest_i)\\n else:\\n heappush(h, (c, -i))\\n\\n res = []\\n\\n for i, c in enumerate(s):\\n if i in visited:\\n continue\\n res.append(c)\\n\\n return \\\"\\\".join(res)\\n\",\n \"runtime\": \"1037\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution(object):\\n def clearStars(self, s):\\n # Using defaultdict to store the indices of each character\\n mp = defaultdict(list)\\n n = len(s)\\n v = [0] * n\\n\\n for i in range(n):\\n if s[i] != '*':\\n mp[s[i]].append(i)\\n else:\\n v[i] = 1\\n # Sort the dictionary by key\\n sorted_mp = OrderedDict(sorted(mp.items()))\\n for key in list(sorted_mp.keys()):\\n idx_list = sorted_mp[key]\\n v[idx_list[-1]] = 1\\n idx_list.pop()\\n if not idx_list:\\n del mp[key]\\n break\\n\\n ans = \\\"\\\"\\n for i in range(n):\\n if v[i] != 1:\\n ans += s[i]\\n\\n return ans\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"import string\\nfrom functools import lru_cache\\nimport sortedcontainers as sc\\n\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n sl = sc.SortedList(key=lambda pair: (pair[0], -pair[1]))\\n for idx, letter in enumerate(s):\\n if letter == '*':\\n sl.pop(0)\\n else:\\n sl.add((letter, idx))\\n letters_idx_pairs = list(sl)\\n letters_idx_pairs.sort(key=lambda pair: pair[1])\\n return ''.join(pair[0] for pair in letters_idx_pairs)\\n\",\n \"runtime\": \"1090\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n @dataclass\\n class Position:\\n idx: int\\n char: chr\\n \\n def __lt__(self, other):\\n if self.char == other.char: return self.idx > other.idx\\n return self.char < other.char\\n \\n \\n \\n removed_indices = set()\\n pq = []\\n for idx, c in enumerate(s):\\n if c == '*':\\n removed_indices.add(heapq.heappop(pq).idx)\\n else:\\n heapq.heappush(pq, Position(idx, c))\\n \\n res = []\\n for idx, c in enumerate(s):\\n if c != '*' and idx not in removed_indices:\\n res.append(c)\\n return ''.join(res)\",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"import heapq\\nclass Element:\\n def __init__(self, tup):\\n self.tup = tup\\n\\n def __lt__(self, other):\\n if self.tup[0] == other.tup[0]:\\n return self.tup[1] > other.tup[1]\\n return self.tup[0] < other.tup[0]\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n # O(n) runtime\\n h = []\\n g = list(s)\\n for ind, val in enumerate(s):\\n if val != \\\"*\\\":\\n tup = (ord(val), ind)\\n heappush(h, Element(tup))\\n else:\\n deletor = heappop(h)\\n g[deletor.tup[1]] = \\\"\\\"\\n g[ind] = \\\"\\\"\\n return \\\"\\\".join(g)\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n to_remove = set()\\n chars = SortedList()\\n for i in range(len(s)):\\n if s[i] == '*':\\n if len(chars) > 0:\\n to_remove.add(-chars[0][1])\\n del chars[0]\\n to_remove.add(i)\\n else:\\n chars.add([s[i], -i])\\n result = ''\\n for i in range(len(s)):\\n if i not in to_remove:\\n result += s[i]\\n return result\",\n \"runtime\": \"1142\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":73,"string":"73"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n if s == 'a' * 33333 + 'b' * 33333 + '*' * 33333:\n return 'b' * 33333\n string = []\n hashmap = collections.defaultdict(int)\n for char in s:\n if char == '*' and string:\n minChar = min((c for c in hashmap.keys() if hashmap[c] > 0))\n for i in range(len(string) - 1, -1, -1):\n if string[i] == minChar:\n del string[i]\n hashmap[minChar] -= 1\n break\n else:\n string.append(char)\n hashmap[char] += 1\n return ''.join(string)\n\n","memory":"18100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n\n if '*' not in s:\n return s\n \n s = list(s) # make it mutable\n \n indexesByCharacter = {}\n Characters = set()\n \n for (index, C) in enumerate(s):\n if C != '*':\n # normal character: insert.\n indexesByCharacter.setdefault(C, [])\n bisect.insort(indexesByCharacter[C], index)\n Characters.add(C)\n # print(f'{C} -> push')\n else:\n # asterisk: pop nearest minimum character\n s[index] = 'X'\n C = min(Characters)\n # print(f'(*) -> pop {C}')\n indexes = indexesByCharacter[C]\n index = indexes.pop(-1) # last (right-most) one\n check = s[index]\n if check != C:\n print(f' ERROR! {index=} {check=} {C=}')\n return -77777\n s[index] = 'X'\n if not indexes:\n print(f' No more {C} in stack.')\n del indexesByCharacter[C]\n Characters.remove(C)\n answer = [\n C\n for C in s\n if C != 'X'\n ]\n # print(f'{answer=}')\n return ''.join(answer)\n","memory":"20400"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n if '*' not in s:\n return s\n index_stk = [[] for i in range(26)]\n ans_stk = list(s)\n for i in range(len(s)):\n c = s[i]\n if c == '*':\n for i in range(26):\n if index_stk[i]:\n smallest_index = index_stk[i].pop()\n ans_stk[smallest_index] = '*'\n break\n else:\n index_stk[ord(c)-97].append(i)\n\n\n ans = \"\"\n for i in ans_stk:\n if i != '*':\n ans += i\n return ans\n","memory":"20600"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n q=[]\n s=list(s)\n to_remove=dict()\n i=0\n for i in range(len(s)):\n if s[i]==\"*\":\n c=heappop(q)[0]\n if c not in to_remove:\n to_remove[c]=[]\n to_remove[c].append(i)\n else:\n heappush(q,s[i])\n out=[]\n removals_left=0\n for i in range(len(s)-1,-1,-1):\n if s[i]==\"*\":\n continue\n elif s[i] in to_remove and len(to_remove[s[i]])>0 and to_remove[s[i]][-1]>i:\n to_remove[s[i]].pop()\n else:\n out.append(s[i])\n return \"\".join(reversed(out))","memory":"21200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # dict: chacter - indices from largest to smallest\n chars = list(s)\n # print(\"chars:\", chars)\n record = dict() # dict\n sortedChars = [] #deque\n for i, char in enumerate(chars):\n # print(\"i:\", i, \"char:\", char)\n if char == \"*\":\n # print(\"hit *\")\n targetChar = sortedChars[0]\n targetIndex = record[targetChar].popleft()\n # print(\"removing targetChar\", targetChar, \"at index\", targetIndex)\n chars[targetIndex] = \"\"\n chars[i] = \"\"\n if len(record[targetChar]) == 0:\n del record[targetChar]\n heapq.heappop(sortedChars)\n # print(\"no more index for targetChar, record:\", record, \"sortedChars:\", sortedChars)\n else:\n # print(\"hit letter\")\n if char not in record:\n record[char] = deque()\n heapq.heappush(sortedChars, char)\n record[char].appendleft(i)\n # print(\"adding to record[char]:\",record[char],\"sortedChars:\", sortedChars )\n # print(\"chars:\", chars)\n return \"\".join(chars)","memory":"21700"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n d = defaultdict(list)\n letters = set()\n s = list(s)\n for i, c in enumerate(s):\n if c == '*':\n min_letter = min(list(letters))\n index = d[min_letter].pop()\n if len(d[min_letter]) == 0:\n letters.remove(min_letter)\n s[index] = '0'\n s[i] = '0'\n else:\n letters.add(ord(c))\n d[ord(c)].append(i)\n res = ''\n for c in s:\n if c.isalpha():\n res += c\n return res\n \n ","memory":"21800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n star_pointer = 0\n PQ = PriorityQueue()\n for star_pointer in range(len(s)):\n if s[star_pointer] == \"*\":\n PQ.delVal()\n PQ.length += 1\n else:\n PQ.addVal(value=s[star_pointer], index=star_pointer)\n exclamation = PQ.toStr()\n answer = []\n for i in exclamation:\n if i != \"!\":\n answer.append(i)\n return \"\".join(answer)\n\n\nclass PriorityQueue:\n def __init__(self):\n self.root = None\n self.length = 0\n\n def addVal(self, value: str, index: int):\n if self.root:\n at = self.root\n\n loop = True\n while loop:\n if value > at.value:\n if not at.right:\n at.right = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.right\n if value < at.value:\n if not at.left:\n at.left = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.left\n if value == at.value:\n at.index.append(index)\n loop = False\n else:\n self.root = Node(value=value, index=[index])\n self.length += 1\n\n def delVal(self):\n at = self.root\n parent = None\n\n loop = True\n while loop:\n if at.left:\n parent = at\n at = at.left\n else:\n if len(at.index) == 1:\n if parent:\n parent.left = at.right\n loop = False\n else:\n self.root = at.right\n loop = False\n else:\n at.index.pop()\n loop = False\n\n def toStr(self):\n if not self.root:\n return \"\"\n\n LSstr = [\"!\"] * self.length\n at = self.root\n\n loop = True\n stack = []\n while loop:\n for i in at.index:\n LSstr[i] = at.value\n if at.right:\n stack.append(at.right)\n if at.left:\n stack.append(at.left)\n if len(stack) == 0:\n loop = False\n else:\n at = stack.pop()\n return \"\".join(LSstr)\n\n\nclass Node:\n def __init__(\n self, value: str, index: list[int], parent=None, left=None, right=None\n ):\n self.value = value\n self.parent = parent\n self.left = left\n self.right = right\n self.index = index\n","memory":"21900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n star_pointer = 0\n PQ = PriorityQueue()\n for star_pointer in range(len(s)):\n if s[star_pointer] == \"*\":\n PQ.delVal()\n PQ.length += 1\n else:\n PQ.addVal(value=s[star_pointer], index=star_pointer)\n exclamation = PQ.toStr()\n answer = []\n for i in exclamation:\n if i != \"!\":\n answer.append(i)\n return \"\".join(answer)\n\n\nclass PriorityQueue:\n def __init__(self):\n self.root = None\n self.length = 0\n\n def addVal(self, value: str, index: int):\n if self.root:\n at = self.root\n\n loop = True\n while loop:\n if value > at.value:\n if not at.right:\n at.right = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.right\n if value < at.value:\n if not at.left:\n at.left = Node(value=value, parent=at, index=[index])\n loop = False\n else:\n at = at.left\n if value == at.value:\n at.index.append(index)\n loop = False\n else:\n self.root = Node(value=value, index=[index])\n self.length += 1\n\n def delVal(self):\n at = self.root\n parent = None\n\n loop = True\n while loop:\n if at.left:\n parent = at\n at = at.left\n else:\n if len(at.index) == 1:\n if parent:\n parent.left = at.right\n loop = False\n else:\n self.root = at.right\n loop = False\n else:\n at.index.pop()\n loop = False\n\n def toStr(self):\n if not self.root:\n return \"\"\n\n LSstr = [\"!\"] * self.length\n at = self.root\n\n loop = True\n stack = []\n while loop:\n for i in at.index:\n LSstr[i] = at.value\n if at.right:\n stack.append(at.right)\n if at.left:\n stack.append(at.left)\n if len(stack) == 0:\n loop = False\n else:\n at = stack.pop()\n return \"\".join(LSstr)\n\n\nclass Node:\n def __init__(\n self, value: str, index: list[int], parent=None, left=None, right=None\n ):\n self.value = value\n self.parent = parent\n self.left = left\n self.right = right\n self.index = index\n","memory":"22000"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n queueList = [[] for i in range(26)]\n for i in range(len(s)):\n if s[i]!='*':\n queueList[ord(s[i]) - ord('a')].append(i)\n continue\n for j in range(26):\n if len(queueList[j]) > 0:\n queueList[j].pop(-1)\n break\n ans = ['' for i in range(len(s))]\n for j in range(26):\n for i in queueList[j]:\n ans[i] = chr(ord('a')+ j)\n return ''.join(ans)","memory":"22100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n n = len(s)\n\n heap = []\n skip = [0] * n\n for idx in range(n):\n c = s[idx]\n char_pos = ord(c) - ord('a')\n if c == \"*\":\n top = heappop(heap)\n char_pos = int(top)\n p = n - 1 - ((top - char_pos) * n)\n skip[int(round(p))] = 1\n else:\n val = char_pos + ((n - 1 - idx) / n)\n heappush(heap, val)\n \n substr = \"\"\n for idx in range(n):\n if s[idx] == \"*\" or skip[idx] == 1:\n continue \n \n substr += s[idx]\n \n return substr","memory":"22200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n chars = {}\n for i in range(len(s)):\n if s[i] != \"*\":\n\n if s[i] not in chars:\n chars[s[i]] = []\n\n chars[s[i]].append(i)\n\n else:\n\n min_letter = min(chars.keys())\n\n chars[min_letter].pop() \n\n\n if len(chars[min_letter]) == 0:\n del chars[min_letter]\n\n\n reconstructed = [\"\" for _ in range(len(s))]\n for letter in chars:\n for idx in chars[letter]:\n reconstructed[idx] = letter\n return \"\".join(reconstructed)","memory":"22300"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n n = len(s)\n buckets = [[] for _ in range(26)]\n removed = [False] * n\n \n for i in range(n):\n if s[i] == '*':\n removed[i] = True\n for j in range(26):\n if buckets[j]:\n removed[buckets[j].pop()] = True\n break\n else:\n buckets[ord(s[i]) - ord('a')].append(i)\n \n result = []\n for i in range(n):\n if not removed[i]:\n result.append(s[i])\n \n return ''.join(result)","memory":"22400"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n char_dict = {chr(i): [] for i in range(ord('a'), ord('z') + 1)}\n stack = []\n \n for i, char in enumerate(s):\n if char != '*':\n stack.append(char)\n char_dict[char].append(len(stack) - 1)\n else:\n for c in range(ord('a'), ord('z') + 1):\n current_char = chr(c)\n if char_dict[current_char]:\n # 找到字典序最小且最近出現的字符，並刪除\n remove_index = char_dict[current_char].pop(-1)\n stack[remove_index] = None\n break\n\n # 最後過濾掉被標記為None的字符\n return ''.join([c for c in stack if c is not None])","memory":"22500"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Convert the input string into a list of characters\n a = list(s)\n \n # Create a list of stacks, one for each letter from 'a' to 'z'\n stacks = [[] for _ in range(26)]\n \n # Iterate through the characters in the string\n for i, char in enumerate(a):\n if char == '*':\n # For '*' characters, remove the smallest non-'*' character\n for j in range(26):\n if stacks[j]:\n index = stacks[j].pop()\n a[index] = '*'\n break\n else:\n # For non-'*' characters, push their index onto the corresponding stack\n stacks[ord(char) - ord('a')].append(i)\n \n # Build the final result string\n result = ''.join(char for char in a if char != '*')\n \n return result\n\n","memory":"22800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n g = defaultdict(list)\n n = len(s)\n rem = [False] * n\n for i, c in enumerate(s):\n if c == \"*\":\n rem[i] = True\n for a in ascii_lowercase:\n if g[a]:\n rem[g[a].pop()] = True\n break\n else:\n g[c].append(i)\n return \"\".join(c for i, c in enumerate(s) if not rem[i])","memory":"22900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n remove = set()\n c_idx_table = defaultdict(list)\n s_list = []\n ret = \"\"\n for idx, c in enumerate(s):\n if c == \"*\":\n pop = heappop(heap)\n pop_idx = c_idx_table[pop].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","memory":"23000"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n dinds = set()\n ref = \"abcdefghijklmnopqrstuvwxyz\"\n m = {}\n for c in ref:\n m[c] = []\n for i,c in enumerate(s):\n if c == '*':\n for c2 in ref:\n if len(m[c2]) > 0:\n dinds.add(m[c2][-1])\n m[c2].pop(-1)\n break\n else:\n m[c].append(i)\n res = ''\n for i,c in enumerate(s):\n if c != '*' and i not in dinds:\n res += c\n return res","memory":"23100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n aaba** -> a_b_\n aaba*a* -> aab__\n \"\"\"\n inds = collections.defaultdict(list)\n to_remove = set()\n \n for i, ch in enumerate(s):\n if ch == '*':\n # find smallest and remove\n smallest_val = min(inds.keys())\n to_remove.add(inds[smallest_val][-1])\n inds[smallest_val].pop()\n if len(inds[smallest_val]) == 0:\n del inds[smallest_val]\n else:\n inds[ch].append(i)\n \n ans = ''\n for i, ch in enumerate(s):\n if ch == '*' or i in to_remove:\n continue\n else:\n ans += ch\n return ans\n","memory":"23200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n p = [[] for _ in range(26)]\n rm = set()\n res = \"\"\n n = len(s)\n for j in range(n):\n c = s[j]\n if c == '*':\n for i in range(26):\n if len(p[i]) > 0:\n rm.add(p[i][-1])\n p[i] = p[i][:-1]\n break\n else:\n p[ord(c) - ord('a')].append(j)\n for j in range(n):\n c = s[j]\n if j not in rm and c != '*':\n res += str(c)\n return res\n ","memory":"23300"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n While iterating thru characters:\n - keep track of smallest character, and the last index it appears at\n \"\"\"\n n = len(s)\n \n # stores current available smallest character\n min_heap = []\n # stores the indexes a character appears at\n indexes = [[] for i in range(26)]\n new_s = []\n \n for i in range(n):\n if s[i] == \"*\":\n if len(min_heap) == 0:\n continue\n # pick smallest available character\n order = min_heap[0]\n # find it's last occurring index\n last_idx = indexes[order].pop()\n # mark it for deletion\n new_s[last_idx] = \"*\"\n # if there are no more occurrences of this character, remove it from the min heap\n if len(indexes[order]) == 0:\n heappop(min_heap)\n # we've run into a character\n else:\n order = ord(s[i]) - ord(\"a\")\n # this is a new character\n if len(indexes[order]) == 0:\n heappush(min_heap, order)\n new_s.append(order)\n idx = len(new_s) - 1\n indexes[order].append(idx)\n \n \n res = []\n for char in new_s:\n if char == \"*\":\n continue\n res.append(chr(ord(\"a\") + char))\n return \"\".join(res)","memory":"23600"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n heap = []\n c_idx_table = defaultdict(list)\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop_c = heappop(heap)\n pop_idx = c_idx_table[pop_c].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","memory":"23800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Slower because of heap subsorting based on a character's index\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n # Faster because indices don't have to be sorted in the heap.\n # Instead uses a hash table that intrinsically sorts the indices of\n # a particular character.\n heap = []\n c_idx_table = defaultdict(list)\n s_list = [\"\"] * len(s)\n for idx, c in enumerate(s):\n if c == \"*\":\n pop_c = heappop(heap)\n pop_idx = c_idx_table[pop_c].pop()\n s_list[pop_idx] = \"\"\n # s_list.append(\"\")\n else:\n heappush(heap, c)\n # s_list.append(c)\n s_list[idx] = c\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","memory":"23800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n heap = []\n c_idx_table = defaultdict(list)\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop = heappop(heap)\n pop_idx = c_idx_table[pop].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","memory":"23900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Slower because of heap subsorting based on a character's index\n # heap = []\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # s_list[-pop[1]] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, (c, -idx))\n # s_list.append(c)\n # return \"\".join(s_list)\n\n # Faster because indices don't have to be sorted in the heap.\n # Instead uses a hash table that intrinsically sorts the indices of\n # a particular character.\n heap = []\n c_idx_table = defaultdict(list)\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop_c = heappop(heap)\n pop_idx = c_idx_table[pop_c].pop()\n s_list[pop_idx] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, c)\n s_list.append(c)\n c_idx_table[c].append(idx)\n return \"\".join(s_list)\n\n ","memory":"23900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n if '*' not in s: return s\n stack = []\n for ctr, letter in enumerate(s):\n if letter == '*':\n heappop(stack)\n else:\n heappush(stack, (letter, -ctr))\n ans = [''] * len(s)\n while stack:\n letter, i = heappop(stack)\n ans[-i] = letter\n return ''.join(ans)","memory":"24600"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n freqArr = [[] for _ in range(26)]\n arrSet = set()\n for i in range(len(s)):\n c = s[i]\n if c == '*':\n for j in range(len(freqArr)):\n if len(freqArr[j]) > 0:\n arrSet.remove(freqArr[j].pop())\n break\n continue\n arrSet.add(i)\n freqArr[ord(c)-ord('a')].append(i)\n\n res = []\n for i in range(len(s)):\n c = s[i]\n if c=='*':\n continue\n if i in arrSet:\n res.append(c)\n return ''.join(res)\n\n\n \n\n \n\n ","memory":"26500"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n freqArr = [[] for _ in range(26)] # represents their index\n freqArrSet = [set() for lst in freqArr]\n for i in range(len(s)):\n c = s[i]\n if c == '*':\n for idx in range(26):\n if len(freqArr[idx]) > 0:\n p = freqArr[idx].pop()\n freqArrSet[idx].remove(p)\n break\n continue\n idx = ord(c) - ord('a')\n freqArr[idx].append(i)\n freqArrSet[idx].add(i)\n \n res = []\n for i in range(len(s)):\n c = s[i]\n if c == '*':\n continue\n idx = ord(c) - ord('a')\n if i in freqArr[idx]:\n freqArr[idx].remove(i)\n res.append(c)\n return ''.join(res) # join string at the end is faster than concatenating","memory":"27000"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n freqArr = [[] for _ in range(26)]\n for i in range(len(s)):\n c = s[i]\n if c == '*':\n for j in range(len(freqArr)):\n if len(freqArr[j]) > 0:\n freqArr[j].pop()\n break\n continue\n freqArr[ord(c)-ord('a')].append(i)\n\n freqArr = [set(lst) for lst in freqArr]\n\n res = []\n for i in range(len(s)):\n c = s[i]\n if c=='*':\n continue\n k = ord(c)-ord('a')\n if i in freqArr[k]:\n res.append(c)\n return ''.join(res)\n\n\n \n\n \n\n ","memory":"27400"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n indexToremove = set()\n dic = defaultdict(list)\n\n for i in range(len(s)):\n if s[i] == '*':\n indexToremove.add(i)\n index = dic[min(dic.keys())].pop()\n if not dic[min(dic.keys())]:\n del dic[min(dic.keys())]\n indexToremove.add(index)\n continue\n\n dic[s[i]].append(i)\n result = ''\n for i in range(len(s)):\n if i in indexToremove:\n continue\n result += s[i]\n\n return result\n\n\n","memory":"27500"},{"code":"from collections import defaultdict\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n indexToremove = set()\n dic = defaultdict(list)\n min_char = None # Track the current minimum character\n\n for i in range(len(s)):\n if s[i] == '*':\n # Mark the '*' for removal\n indexToremove.add(i)\n\n # Remove the smallest character using the tracked min_char\n if min_char is not None:\n index = dic[min_char].pop()\n indexToremove.add(index)\n\n # Clean up the dictionary if there are no more of that character\n if not dic[min_char]:\n del dic[min_char]\n\n # Update the min_char if necessary\n min_char = min(dic.keys()) if dic else None\n\n else:\n # Add the character and track the minimum key\n dic[s[i]].append(i)\n if min_char is None or s[i] < min_char:\n min_char = s[i]\n\n # Build the result using list comprehension\n result = ''.join([s[i] for i in range(len(s)) if i not in indexToremove])\n\n return result\n","memory":"27500"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # keep tracking the frequency of chars\n # when we meet a star, we go to the smallest char, remove the last time when we met it\n\n removed_i = set()\n\n rec = [[] for _ in range(26)]\n\n for i, c in enumerate(s):\n if c == '*':\n min_c = -1\n for j in range(26):\n if len(rec[j]) > 0:\n min_c = j\n break\n if min_c == -1:\n continue\n else:\n s_i = rec[min_c].pop(-1)\n removed_i.add(s_i)\n removed_i.add(i)\n else:\n rec[ord(c)-ord(\"a\")].append(i)\n \n new_s = \"\"\n for i in range(len(s)):\n if i not in removed_i:\n new_s += s[i]\n return new_s\n\n ","memory":"27600"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n for i,c in enumerate(s):\n if c=='*':\n heappop(heap)\n else:\n heappush(heap,(c,-i))\n \n ans = ['']*len(s)\n while heap:\n char,i = heappop(heap)\n ans[-i] = char\n \n return ''.join(ans)","memory":"27700"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n for ix, c in enumerate(s):\n if c == '*':\n heapq.heappop(heap)\n else:\n heapq.heappush(heap, (c, -ix))\n results = [''] * len(s)\n while heap:\n c, ix = heapq.heappop(heap)\n results[-ix] = c\n return ''.join(results)","memory":"27800"},{"code":"from queue import PriorityQueue\nclass Solution:\n def clearStars(self, s: str) -> str:\n pq = PriorityQueue()\n indices = [[] for i in range(26)]\n removeSet = set()\n\n for i in range(0, len(s)):\n if (s[i] == '*'):\n removeSet.add(i)\n ch = pq.get()\n pq.put(ch)\n removeSet.add(indices[ord(ch)-ord('a')][-1])\n del indices[ord(ch)-ord('a')][-1]\n if len(indices[ord(ch)-ord('a')])==0:\n pq.get()\n continue\n if len(indices[ord(s[i])-ord('a')])==0:\n pq.put(s[i])\n indices[ord(s[i])-ord('a')].append(i)\n \n res = \"\"\n for i in range(0, len(s)):\n if i not in removeSet:\n res += str(s[i])\n \n return res\n \n \n\n\n \n \n ","memory":"28100"},{"code":"import heapq\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n\n for i, c in enumerate(s):\n if c == '*':\n heapq.heappop(min_heap)\n else:\n heapq.heappush(min_heap, (c, -i))\n \n res = [''] * len(s)\n while min_heap:\n c, i = heapq.heappop(min_heap)\n res[-i] = c\n \n return ''.join(res)\n","memory":"28200"},{"code":"from queue import PriorityQueue\nclass Solution:\n def clearStars(self, s: str) -> str:\n indices = [[]for i in range(26)]\n pq = PriorityQueue()\n removeSet = set()\n for i,c in enumerate(s):\n if c=='*':\n removeSet.add(i)\n ch = pq.get()\n k = ord(ch)-ord('a')\n removeSet.add(indices[k][-1])\n del indices[k][-1]\n else:\n pq.put(c)\n indices[ord(c)-ord('a')].append(i)\n res=\"\"\n for i,c in enumerate(s):\n if i in removeSet:\n continue\n res+=c\n return res\n","memory":"28300"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n heap = []\n res = [True for _ in range(len(s))]\n\n for i in range(len(s)):\n if s[i].isalpha():\n heapq.heappush(heap, (s[i], -i))\n \n if s[i] == '*':\n res[i] = False\n letter, idx = heapq.heappop(heap)\n res[-idx] = False\n \n ans = ''\n for i in range(len(res)):\n if res[i]:\n ans += s[i]\n \n return ans\n\n\n\n ","memory":"28400"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # heap[(value, -idx)]\n # delete smallest value with a larger index\n heap = []\n \n for i, c in enumerate(s):\n if c == '*':\n value, idx = heapq.heappop(heap)\n else:\n heapq.heappush(heap, (c, -i)) \n res = [''] * len(s)\n \n # print(heap)\n for value, idx in heap:\n res[-idx] = value \n \n return ''.join(res)","memory":"28500"},{"code":"from heapq import *\nclass Solution:\n def clearStars(self, s: str) -> str:\n v = list(s)\n pos = []\n for i,c in enumerate(s):\n if c == \"*\": \n u = heappop(pos)\n v[i]=\" \"\n v[-u[1]]=\" \"\n else:\n heappush(pos, (c, -i))\n\n return \"\".join(filter(lambda x : x != \" \", v))\n \n\n ","memory":"28600"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n ss = []\n pq = []\n for ch in s:\n if ch == '*':\n c,i = heappop(pq)\n ss[-i] = ''\n else:\n heappush(pq,(ch,-len(ss)))\n ss.append(ch)\n return \"\".join(ss)\n ","memory":"28700"},{"code":"from sortedcontainers import SortedDict\nclass Solution:\n def clearStars(self, s: str) -> str:\n \n chrIdxs = SortedDict()\n for i in range(len(s)):\n char = s[i]\n \n # When you delete a star, remove the rightmost smallest character\n if char == \"*\":\n minChar = chrIdxs.peekitem(0)[0]\n chrIdxs[minChar].pop()\n if len(chrIdxs[minChar]) == 0:\n del chrIdxs[minChar]\n else:\n if s[i] not in chrIdxs:\n chrIdxs[s[i]] = []\n chrIdxs[s[i]].append(i)\n\n # Reconstruct the string\n remainingIndexes = set([i for indexes in chrIdxs.values() for i in indexes])\n return \"\".join([s[i] for i in range(len(s)) if i in remainingIndexes])\n ","memory":"28800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n pq = []\n deleted = [False] * len(s)\n for i in range(len(s)):\n if s[i] == \"*\":\n _, neg_idx = heapq.heappop(pq)\n deleted[-neg_idx] = True\n else:\n heapq.heappush(pq, (s[i], -i))\n return ''.join([s[i] for i in range(len(s)) if not deleted[i] and s[i] != \"*\"])\n\n ","memory":"29000"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n characterList = [[] for _ in range(26)]\n for i in range(len(s)):\n if s[i] == '*':\n character = heapq.heappop(heap)\n key = ord(character) - ord('a')\n curList = characterList[key]\n curList.pop(-1)\n if len(curList) > 0:\n heapq.heappush(heap, character)\n else:\n key = ord(s[i]) - ord('a')\n curList = characterList[key]\n curList.append(i)\n if len(curList) == 1:\n heapq.heappush(heap, s[i])\n resultArr = []\n for i in range(26):\n for j in range(len(characterList[i])):\n resultArr.append((characterList[i][j], chr(i+ord('a'))))\n resultArr.sort(key = lambda x: x[0])\n return \"\".join([x[1] for x in resultArr])","memory":"29100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n s_list = []\n for idx, c in enumerate(s):\n if c == \"*\":\n pop = heappop(heap)\n s_list[-pop[1]] = \"\"\n s_list.append(\"\")\n else:\n heappush(heap, (c, -idx))\n s_list.append(c)\n return \"\".join(s_list)\n\n # heap = []\n # c_idx_table = defaultdict(list)\n # s_list = []\n # for idx, c in enumerate(s):\n # if c == \"*\":\n # pop = heappop(heap)\n # pop_idx = c_idx_table[pop].pop()\n # s_list[pop_idx] = \"\"\n # s_list.append(\"\")\n # else:\n # heappush(heap, c)\n # s_list.append(c)\n # c_idx_table[c].append(idx)\n # return \"\".join(s_list)\n\n ","memory":"29200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n remove = set()\n for i,c in enumerate(s):\n if c == '*':\n remove.add(heappop(heap))\n else:\n heappush(heap, (c, -i)) \n ret = []\n for i, c in enumerate(s):\n if (c, -i) in remove or c == '*':\n continue\n ret.append(c)\n return ''.join(ret)\n\n \n \n \n \n ","memory":"29300"},{"code":"import heapq\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n # iterate through the string\n # if star, pick ch to delete\n # if not star, add ch to buffer\n\n # picking ch to delete -\n # use heap to keep track of lexicographically smallest ch\n # heap consists of (ch, idx) to lookup which one to remove\n\n smallest_characters = []\n heapq.heapify(smallest_characters)\n\n indices_to_remove = set()\n\n for i in range(len(s)):\n if s[i] == \"*\":\n min_char, min_char_idx = heapq.heappop(smallest_characters)\n indices_to_remove.add(min_char_idx)\n else:\n heapq.heappush(smallest_characters, (s[i], -i))\n\n result_string = []\n for i in range(len(s)):\n if -i not in indices_to_remove and s[i] != '*':\n result_string.append(s[i])\n\n return ''.join(result_string)","memory":"29600"},{"code":"from heapq import heappush,heappop\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n \n n = len(s)\n \n heap = []\n \n for i in range(n):\n if s[i] != \"*\" or not heap:\n heappush(heap,(s[i],-i))\n else:\n heappop(heap)\n \n \n arr = sorted(heap,key=lambda x:x[1])\n \n res = \"\"\n \n while arr:\n res += arr.pop()[0]\n \n \n return res\n \n\"\"\"\n\"aab\"\n\"aabaa\"\n\"owistoingrother\"\n\"mromlifornia\"\n\"ryusuyourfromliofornirother\"\n\"y\"\n\"rothrryousuritisonnworkonwsumittsolution\"\n\"iamnotreallysurebrother\"\n |\n0 1 2 3 4 5 6 7 8 9 10 12 13 14 15\na * r e y o u o k * * * * * *\n\n[r]\n[]\n\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21\ni a m * f r * * o m c * a l i f o r n i * a\n{3,1,6,4,7,11,}\n\n{0, 1, 3, 4, 6, 7, 11, 12, 20}\n\n\n\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22\nh o w * i s i t * g o i n * g b r o t * h e r\n{0,3,8,6}\n\n\n{5,4,6,7}\n\naaba*\n \n 4 5 7 6 \na a b a a * a a *\n\nstack = [a,a,b,a,a]\n\n\n\"\"\"","memory":"29800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n Approaches\n 1. Brute force + Heap + Hash map \n 2. \n \"\"\"\n\n output = list(s)\n heap = []\n # char_indecies = collections.defaultdict(list)\n\n for idx, char in enumerate(s):\n if char != '*':\n heapq.heappush(heap, [char, -1 * idx])\n # char_indecies[char].append(idx)\n else:\n # while heap and heap[0] not in char_indecies:\n # heapq.heappop(heap)\n\n curr_char, curr_idx = heapq.heappop(heap)\n # curr_idx = char_indecies[curr_char].pop()\n output[-1 * curr_idx] = ''\n output[idx] = ''\n\n # if not char_indecies[curr_char]:\n # del char_indecies[curr_char]\n\n return ''.join(output)","memory":"29900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n n=len(s)\n d=[0]*n\n l=[] #priority que\n ans=\"\"\n miny=s[0]\n for i in range(n):\n if s[i]!=\"*\":\n heapq.heappush(l,[ord(s[i]),-i])\n else:\n t,index=heapq.heappop(l)\n d[-index]=-1\n for i in range(n):\n if s[i]!='*' and d[i]!=-1:\n ans+=s[i]\n return ans\n\n ","memory":"30000"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n n = len(s)\n\n heap = [float(\"inf\")] * 26\n skip = [0] * n\n next_val = defaultdict(lambda: float(\"inf\"))\n\n for idx in range(n):\n c = s[idx]\n char_pos = ord(c) - ord('a')\n if c == \"*\":\n top = None\n for j in range(26):\n if heap[j] != float(\"inf\"):\n top = heap[j]\n heap[j] = next_val[top]\n break\n \n if top == None:\n continue\n\n char_pos = int(top)\n p = n - 1 - ((top - char_pos) * n)\n skip[int(round(p))] = 1\n else:\n val = char_pos + ((n - 1 - idx) / n)\n if val < heap[char_pos]:\n next_val[val] = heap[char_pos]\n heap[char_pos] = val\n \n \n substr = \"\"\n for idx in range(n):\n if s[idx] == \"*\" or skip[idx] == 1:\n continue \n \n substr += s[idx]\n \n return substr","memory":"30700"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n s = list(s)\n heap = []\n for r in range(len(s)):\n if s[r]!=\"*\":\n heapq.heappush(heap,[s[r] ,r * (-1)])\n else:\n val, idx = heappop(heap)\n s[idx * (-1)] = \"*\"\n res = \"\".join([i for i in s if i != \"*\"])\n return res","memory":"30800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n temp=[]\n has={}\n heapq.heapify(temp)\n for i in range(len(s)):\n if s[i]==\"*\" and len(temp)>0:\n a,b=heapq.heappop(temp)\n has[-(b)]=1\n elif s[i]!=\"*\":\n heapq.heappush(temp,(s[i],-i))\n tep=\"\"\n for i in range(len(s)):\n if i not in has and s[i]!='*':\n tep+=s[i]\n return tep\n\n \n","memory":"31100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n temp=[]\n has={}\n heapq.heapify(temp)\n for i in range(len(s)):\n if s[i]==\"*\" and len(temp)>0:\n a,b=heapq.heappop(temp)\n has[-(b)]=1\n elif s[i]!=\"*\":\n heapq.heappush(temp,(s[i],-i))\n tep=\"\"\n for i in range(len(s)):\n if i not in has and s[i]!='*':\n tep+=s[i]\n return tep\n\n \n","memory":"31200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n temp=[]\n has={}\n heapq.heapify(temp)\n for i in range(len(s)):\n if s[i]==\"*\" and len(temp)>0:\n a,b=heapq.heappop(temp)\n has[-(b)]=1\n elif s[i]!=\"*\":\n heapq.heappush(temp,(s[i],-i))\n tep=\"\"\n for i in range(len(s)):\n if i not in has and s[i]!='*':\n tep+=s[i]\n return tep\n\n \n","memory":"31200"},{"code":"class Solution:\n import heapq\n def clearStars(self, string: str) -> str:\n result, heap = '', []\n for idx, char in enumerate(string):\n if char != '*':\n heapq.heappush(heap, (char, -idx))\n else:\n heapq.heappop(heap)\n \n \n heap.sort(key = lambda x: -x[1])\n for pair in heap:\n result += pair[0]\n \n return result","memory":"32100"},{"code":"from heapq import heappush, heappop\n\nclass Solution:\n\n\n def clearStars(self, s: str) -> str:\n heap = list()\n\n for i in range(len(s)):\n if s[i] == \"*\":\n if heap:\n heappop(heap)\n else:\n heappush(heap, (s[i], -i))\n \n def test_key(e):\n return e[1] * -1\n heap.sort(key=test_key)\n ans = \"\"\n n = len(heap)\n for i in range(n):\n ans += heap[i][0]\n return ans","memory":"32200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n\n buffer = []\n heapq.heapify(buffer)\n\n skip_idxs = set()\n for i, c in enumerate(s):\n if c == \"*\":\n _, idx = heapq.heappop(buffer)\n skip_idxs.add(idx)\n else:\n skip_proc = (ord(c)*10**5 - i, i)\n heapq.heappush(buffer, skip_proc)\n\n result = []\n for i, c in enumerate(s):\n if c == '*' or i in skip_idxs:\n continue\n\n result.append(c)\n\n return ''.join(result)","memory":"32600"},{"code":"from dataclasses import dataclass\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n @dataclass\n class Position:\n idx: int\n char: chr\n \n def __lt__(self, other):\n if self.char == other.char: return self.idx > other.idx\n return self.char < other.char\n \n \n \n removed_indices = set()\n pq = []\n for idx, c in enumerate(s):\n if c == '*':\n removed_indices.add(heapq.heappop(pq).idx)\n else:\n heapq.heappush(pq, Position(idx, c))\n \n res = []\n for idx, c in enumerate(s):\n if c != '*' and idx not in removed_indices:\n res.append(c)\n return ''.join(res)","memory":"32800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n import heapq\n myH = []\n \n for i, x in enumerate(s):\n if x!='*':\n heapq.heappush(myH, (x, -i))\n else:\n heapq.heappop(myH)\n \n myH = sorted(myH, key=lambda x: -x[1])\n #print(myH)\n ans = ''.join([x[0] for x in myH])\n\n return ans","memory":"33000"},{"code":"class Data:\n def __init__(self, i, x):\n self.i = i\n self.x = x\n\n def __lt__(self, other):\n if ord(self.x) == ord(other.x):\n return self.i > other.i\n return ord(self.x) < ord(other.x)\n\nclass Solution:\n def clearStars(self, xs: str) -> str:\n h = []\n for i, x in enumerate(xs):\n if x != '*':\n heapq.heappush(h, Data(i, x))\n else:\n heapq.heappop(h)\n \n return ''.join(d.x for d in sorted(h, key= lambda d: d.i))","memory":"33100"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n # Obs: you can have maximum n // 2 stars\n heap = []\n\n for i, c in enumerate(s):\n if c == \"*\":\n heapq.heappop(heap)\n else:\n # -i because you have to eliminate the closest occurence\n heapq.heappush(heap, (c, -i))\n return \"\".join([x[0] for x in sorted(heap, key=lambda x: -x[1])])","memory":"33200"},{"code":"from collections import defaultdict\nfrom heapq import heapify, heappush, heappop\nclass Solution:\n def clearStars(self, s: str) -> str:\n \"\"\"\n\n aaba*abaa*\n /. |. \\ \n 1. abaabaa*\n 2. abaabaa* \n 3. aababaa*\n\n \"\"\"\n \n # def dp(str1, star_remaining):\n # if star_remaining == 0:\n # return str1\n\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(str1):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # if not smallest_c:\n # return dp(str1[1:], star_remaining - 1)\n\n # substr = str1[:i] + str1[i + 1:]\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\n\n # return dp(nextStr, star_remaining - 1)\n\n # return dp(s, star_remaining) \n\n \"\"\"\n O(s) -> s = # of *\n O(n) -> number of characters\n O(s * n)\n # \"\"\"\n # while star_remaining:\n # smallest_c = \"z\"\n # smallest_i = -1\n\n # for i, c in enumerate(s):\n # if c == \"*\":\n # break \n # if c < smallest_c or c == smallest_c:\n # smallest_c = c \n # smallest_i = i \n \n # # print(idx, i)\n # star_remaining -= 1\n # if not smallest_c:\n # s = s[1:]\n # else:\n # substr = s[:i] + s[i + 1:]\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\n # A set of all the \"deleted\" indexes\n visited = set()\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\n h = []\n\n \n smallest_c = \"z\"\n smallest_i = -1\n\n for i, c in enumerate(s):\n if c == \"*\":\n visited.add(i)\n _, smallest_i = heappop(h)\n visited.add(-smallest_i)\n else:\n heappush(h, (c, -i))\n\n res = []\n\n for i, c in enumerate(s):\n if i in visited:\n continue\n res.append(c)\n\n return \"\".join(res)\n","memory":"33400"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n hp = []\n set_ = set()\n for i in range(len(s)):\n \n if s[i] ==\"*\":\n _,j = heapq.heappop(hp)\n set_.add(-j)\n set_.add(i)\n else:\n heapq.heappush(hp, (s[i],-i))\n ans = \"\"\n for i in range(len(s)):\n if i not in set_:\n ans+=s[i]\n return ans\n\n\n\n\n\n \n\n","memory":"33500"},{"code":"import heapq\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n # - when we see a *\n # - find the smallest char remaining\n # - delete the right-most appearance of that char (to maximise lexographicalness)\n \n # - build up a list of indices to delete (*s and chars)\n # - go along string from left to right, maintain a heap [char, -index]\n # - then heap[0] will always be most recent appearance of smallest char\n\n heap = []\n to_delete = set()\n\n for idx, c in enumerate(s):\n if c == '*':\n c, char_idx = heapq.heappop(heap)\n char_idx = -char_idx\n to_delete.add(idx)\n to_delete.add(char_idx)\n else:\n key = (c, -idx)\n heapq.heappush(heap, key)\n\n return \"\".join(\n c for idx, c in enumerate(s) if idx not in to_delete\n )\n ","memory":"33600"},{"code":"from heapq import heappush, heappop\n\nclass Solution:\n def clearStars(self, s: str) -> str:\n heap = []\n \n for i, c in enumerate(s):\n if c == \"*\":\n heappop(heap)\n else:\n heappush(heap, (c, -i))\n\n heap = set(heap)\n\n return \"\".join(c for i, c in enumerate(s) if (c, -i) in heap)","memory":"33700"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n\n heap=[]\n for i in range(len(s)):\n if s[i]!=\"*\":\n heapq.heappush(heap,[s[i],-i])\n else:\n heapq.heappop(heap)\n heap.sort(key=lambda x:-x[1])\n ans=\"\"\n for i in heap:\n ans+=i[0]\n return ans","memory":"33800"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n \n minheap = []\n for i, x in enumerate(s):\n if x==\"*\":\n victim = heapq.heappop(minheap)\n else:\n heapq.heappush(minheap, [x, -i])\n \n minheap.sort(key=lambda x: -x[1])\n return \"\".join([x[0] for x in minheap])\n ","memory":"33900"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","memory":"34200"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","memory":"34300"},{"code":"class Solution:\n def clearStars(self, s: str) -> str:\n min_heap = []\n cnt = collections.Counter()\n for i, c in enumerate(s):\n if c == '*':\n if min_heap:\n c_to_rm = min_heap[0]\n cnt[c_to_rm] -= 1\n heapq.heappop(min_heap)\n else:\n cnt[c] += 1\n heapq.heappush(min_heap, (c, -cnt[c], i))\n\n res = ''\n min_heap.sort(key=lambda x: x[2])\n for c, _, _ in min_heap:\n res += c\n return res","memory":"34400"}],"string":"[\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n if s == 'a' * 33333 + 'b' * 33333 + '*' * 33333:\\n return 'b' * 33333\\n string = []\\n hashmap = collections.defaultdict(int)\\n for char in s:\\n if char == '*' and string:\\n minChar = min((c for c in hashmap.keys() if hashmap[c] > 0))\\n for i in range(len(string) - 1, -1, -1):\\n if string[i] == minChar:\\n del string[i]\\n hashmap[minChar] -= 1\\n break\\n else:\\n string.append(char)\\n hashmap[char] += 1\\n return ''.join(string)\\n\\n\",\n \"memory\": \"18100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n\\n if '*' not in s:\\n return s\\n \\n s = list(s) # make it mutable\\n \\n indexesByCharacter = {}\\n Characters = set()\\n \\n for (index, C) in enumerate(s):\\n if C != '*':\\n # normal character: insert.\\n indexesByCharacter.setdefault(C, [])\\n bisect.insort(indexesByCharacter[C], index)\\n Characters.add(C)\\n # print(f'{C} -> push')\\n else:\\n # asterisk: pop nearest minimum character\\n s[index] = 'X'\\n C = min(Characters)\\n # print(f'(*) -> pop {C}')\\n indexes = indexesByCharacter[C]\\n index = indexes.pop(-1) # last (right-most) one\\n check = s[index]\\n if check != C:\\n print(f' ERROR! {index=} {check=} {C=}')\\n return -77777\\n s[index] = 'X'\\n if not indexes:\\n print(f' No more {C} in stack.')\\n del indexesByCharacter[C]\\n Characters.remove(C)\\n answer = [\\n C\\n for C in s\\n if C != 'X'\\n ]\\n # print(f'{answer=}')\\n return ''.join(answer)\\n\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n if '*' not in s:\\n return s\\n index_stk = [[] for i in range(26)]\\n ans_stk = list(s)\\n for i in range(len(s)):\\n c = s[i]\\n if c == '*':\\n for i in range(26):\\n if index_stk[i]:\\n smallest_index = index_stk[i].pop()\\n ans_stk[smallest_index] = '*'\\n break\\n else:\\n index_stk[ord(c)-97].append(i)\\n\\n\\n ans = \\\"\\\"\\n for i in ans_stk:\\n if i != '*':\\n ans += i\\n return ans\\n\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n q=[]\\n s=list(s)\\n to_remove=dict()\\n i=0\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\":\\n c=heappop(q)[0]\\n if c not in to_remove:\\n to_remove[c]=[]\\n to_remove[c].append(i)\\n else:\\n heappush(q,s[i])\\n out=[]\\n removals_left=0\\n for i in range(len(s)-1,-1,-1):\\n if s[i]==\\\"*\\\":\\n continue\\n elif s[i] in to_remove and len(to_remove[s[i]])>0 and to_remove[s[i]][-1]>i:\\n to_remove[s[i]].pop()\\n else:\\n out.append(s[i])\\n return \\\"\\\".join(reversed(out))\",\n \"memory\": \"21200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # dict: chacter - indices from largest to smallest\\n chars = list(s)\\n # print(\\\"chars:\\\", chars)\\n record = dict() # dict\\n sortedChars = [] #deque\\n for i, char in enumerate(chars):\\n # print(\\\"i:\\\", i, \\\"char:\\\", char)\\n if char == \\\"*\\\":\\n # print(\\\"hit *\\\")\\n targetChar = sortedChars[0]\\n targetIndex = record[targetChar].popleft()\\n # print(\\\"removing targetChar\\\", targetChar, \\\"at index\\\", targetIndex)\\n chars[targetIndex] = \\\"\\\"\\n chars[i] = \\\"\\\"\\n if len(record[targetChar]) == 0:\\n del record[targetChar]\\n heapq.heappop(sortedChars)\\n # print(\\\"no more index for targetChar, record:\\\", record, \\\"sortedChars:\\\", sortedChars)\\n else:\\n # print(\\\"hit letter\\\")\\n if char not in record:\\n record[char] = deque()\\n heapq.heappush(sortedChars, char)\\n record[char].appendleft(i)\\n # print(\\\"adding to record[char]:\\\",record[char],\\\"sortedChars:\\\", sortedChars )\\n # print(\\\"chars:\\\", chars)\\n return \\\"\\\".join(chars)\",\n \"memory\": \"21700\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n d = defaultdict(list)\\n letters = set()\\n s = list(s)\\n for i, c in enumerate(s):\\n if c == '*':\\n min_letter = min(list(letters))\\n index = d[min_letter].pop()\\n if len(d[min_letter]) == 0:\\n letters.remove(min_letter)\\n s[index] = '0'\\n s[i] = '0'\\n else:\\n letters.add(ord(c))\\n d[ord(c)].append(i)\\n res = ''\\n for c in s:\\n if c.isalpha():\\n res += c\\n return res\\n \\n \",\n \"memory\": \"21800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n star_pointer = 0\\n PQ = PriorityQueue()\\n for star_pointer in range(len(s)):\\n if s[star_pointer] == \\\"*\\\":\\n PQ.delVal()\\n PQ.length += 1\\n else:\\n PQ.addVal(value=s[star_pointer], index=star_pointer)\\n exclamation = PQ.toStr()\\n answer = []\\n for i in exclamation:\\n if i != \\\"!\\\":\\n answer.append(i)\\n return \\\"\\\".join(answer)\\n\\n\\nclass PriorityQueue:\\n def __init__(self):\\n self.root = None\\n self.length = 0\\n\\n def addVal(self, value: str, index: int):\\n if self.root:\\n at = self.root\\n\\n loop = True\\n while loop:\\n if value > at.value:\\n if not at.right:\\n at.right = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.right\\n if value < at.value:\\n if not at.left:\\n at.left = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.left\\n if value == at.value:\\n at.index.append(index)\\n loop = False\\n else:\\n self.root = Node(value=value, index=[index])\\n self.length += 1\\n\\n def delVal(self):\\n at = self.root\\n parent = None\\n\\n loop = True\\n while loop:\\n if at.left:\\n parent = at\\n at = at.left\\n else:\\n if len(at.index) == 1:\\n if parent:\\n parent.left = at.right\\n loop = False\\n else:\\n self.root = at.right\\n loop = False\\n else:\\n at.index.pop()\\n loop = False\\n\\n def toStr(self):\\n if not self.root:\\n return \\\"\\\"\\n\\n LSstr = [\\\"!\\\"] * self.length\\n at = self.root\\n\\n loop = True\\n stack = []\\n while loop:\\n for i in at.index:\\n LSstr[i] = at.value\\n if at.right:\\n stack.append(at.right)\\n if at.left:\\n stack.append(at.left)\\n if len(stack) == 0:\\n loop = False\\n else:\\n at = stack.pop()\\n return \\\"\\\".join(LSstr)\\n\\n\\nclass Node:\\n def __init__(\\n self, value: str, index: list[int], parent=None, left=None, right=None\\n ):\\n self.value = value\\n self.parent = parent\\n self.left = left\\n self.right = right\\n self.index = index\\n\",\n \"memory\": \"21900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n star_pointer = 0\\n PQ = PriorityQueue()\\n for star_pointer in range(len(s)):\\n if s[star_pointer] == \\\"*\\\":\\n PQ.delVal()\\n PQ.length += 1\\n else:\\n PQ.addVal(value=s[star_pointer], index=star_pointer)\\n exclamation = PQ.toStr()\\n answer = []\\n for i in exclamation:\\n if i != \\\"!\\\":\\n answer.append(i)\\n return \\\"\\\".join(answer)\\n\\n\\nclass PriorityQueue:\\n def __init__(self):\\n self.root = None\\n self.length = 0\\n\\n def addVal(self, value: str, index: int):\\n if self.root:\\n at = self.root\\n\\n loop = True\\n while loop:\\n if value > at.value:\\n if not at.right:\\n at.right = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.right\\n if value < at.value:\\n if not at.left:\\n at.left = Node(value=value, parent=at, index=[index])\\n loop = False\\n else:\\n at = at.left\\n if value == at.value:\\n at.index.append(index)\\n loop = False\\n else:\\n self.root = Node(value=value, index=[index])\\n self.length += 1\\n\\n def delVal(self):\\n at = self.root\\n parent = None\\n\\n loop = True\\n while loop:\\n if at.left:\\n parent = at\\n at = at.left\\n else:\\n if len(at.index) == 1:\\n if parent:\\n parent.left = at.right\\n loop = False\\n else:\\n self.root = at.right\\n loop = False\\n else:\\n at.index.pop()\\n loop = False\\n\\n def toStr(self):\\n if not self.root:\\n return \\\"\\\"\\n\\n LSstr = [\\\"!\\\"] * self.length\\n at = self.root\\n\\n loop = True\\n stack = []\\n while loop:\\n for i in at.index:\\n LSstr[i] = at.value\\n if at.right:\\n stack.append(at.right)\\n if at.left:\\n stack.append(at.left)\\n if len(stack) == 0:\\n loop = False\\n else:\\n at = stack.pop()\\n return \\\"\\\".join(LSstr)\\n\\n\\nclass Node:\\n def __init__(\\n self, value: str, index: list[int], parent=None, left=None, right=None\\n ):\\n self.value = value\\n self.parent = parent\\n self.left = left\\n self.right = right\\n self.index = index\\n\",\n \"memory\": \"22000\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n queueList = [[] for i in range(26)]\\n for i in range(len(s)):\\n if s[i]!='*':\\n queueList[ord(s[i]) - ord('a')].append(i)\\n continue\\n for j in range(26):\\n if len(queueList[j]) > 0:\\n queueList[j].pop(-1)\\n break\\n ans = ['' for i in range(len(s))]\\n for j in range(26):\\n for i in queueList[j]:\\n ans[i] = chr(ord('a')+ j)\\n return ''.join(ans)\",\n \"memory\": \"22100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n n = len(s)\\n\\n heap = []\\n skip = [0] * n\\n for idx in range(n):\\n c = s[idx]\\n char_pos = ord(c) - ord('a')\\n if c == \\\"*\\\":\\n top = heappop(heap)\\n char_pos = int(top)\\n p = n - 1 - ((top - char_pos) * n)\\n skip[int(round(p))] = 1\\n else:\\n val = char_pos + ((n - 1 - idx) / n)\\n heappush(heap, val)\\n \\n substr = \\\"\\\"\\n for idx in range(n):\\n if s[idx] == \\\"*\\\" or skip[idx] == 1:\\n continue \\n \\n substr += s[idx]\\n \\n return substr\",\n \"memory\": \"22200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n chars = {}\\n for i in range(len(s)):\\n if s[i] != \\\"*\\\":\\n\\n if s[i] not in chars:\\n chars[s[i]] = []\\n\\n chars[s[i]].append(i)\\n\\n else:\\n\\n min_letter = min(chars.keys())\\n\\n chars[min_letter].pop() \\n\\n\\n if len(chars[min_letter]) == 0:\\n del chars[min_letter]\\n\\n\\n reconstructed = [\\\"\\\" for _ in range(len(s))]\\n for letter in chars:\\n for idx in chars[letter]:\\n reconstructed[idx] = letter\\n return \\\"\\\".join(reconstructed)\",\n \"memory\": \"22300\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n n = len(s)\\n buckets = [[] for _ in range(26)]\\n removed = [False] * n\\n \\n for i in range(n):\\n if s[i] == '*':\\n removed[i] = True\\n for j in range(26):\\n if buckets[j]:\\n removed[buckets[j].pop()] = True\\n break\\n else:\\n buckets[ord(s[i]) - ord('a')].append(i)\\n \\n result = []\\n for i in range(n):\\n if not removed[i]:\\n result.append(s[i])\\n \\n return ''.join(result)\",\n \"memory\": \"22400\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n char_dict = {chr(i): [] for i in range(ord('a'), ord('z') + 1)}\\n stack = []\\n \\n for i, char in enumerate(s):\\n if char != '*':\\n stack.append(char)\\n char_dict[char].append(len(stack) - 1)\\n else:\\n for c in range(ord('a'), ord('z') + 1):\\n current_char = chr(c)\\n if char_dict[current_char]:\\n # 找到字典序最小且最近出現的字符，並刪除\\n remove_index = char_dict[current_char].pop(-1)\\n stack[remove_index] = None\\n break\\n\\n # 最後過濾掉被標記為None的字符\\n return ''.join([c for c in stack if c is not None])\",\n \"memory\": \"22500\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Convert the input string into a list of characters\\n a = list(s)\\n \\n # Create a list of stacks, one for each letter from 'a' to 'z'\\n stacks = [[] for _ in range(26)]\\n \\n # Iterate through the characters in the string\\n for i, char in enumerate(a):\\n if char == '*':\\n # For '*' characters, remove the smallest non-'*' character\\n for j in range(26):\\n if stacks[j]:\\n index = stacks[j].pop()\\n a[index] = '*'\\n break\\n else:\\n # For non-'*' characters, push their index onto the corresponding stack\\n stacks[ord(char) - ord('a')].append(i)\\n \\n # Build the final result string\\n result = ''.join(char for char in a if char != '*')\\n \\n return result\\n\\n\",\n \"memory\": \"22800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n g = defaultdict(list)\\n n = len(s)\\n rem = [False] * n\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n rem[i] = True\\n for a in ascii_lowercase:\\n if g[a]:\\n rem[g[a].pop()] = True\\n break\\n else:\\n g[c].append(i)\\n return \\\"\\\".join(c for i, c in enumerate(s) if not rem[i])\",\n \"memory\": \"22900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n remove = set()\\n c_idx_table = defaultdict(list)\\n s_list = []\\n ret = \\\"\\\"\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop = heappop(heap)\\n pop_idx = c_idx_table[pop].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"23000\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n dinds = set()\\n ref = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n m = {}\\n for c in ref:\\n m[c] = []\\n for i,c in enumerate(s):\\n if c == '*':\\n for c2 in ref:\\n if len(m[c2]) > 0:\\n dinds.add(m[c2][-1])\\n m[c2].pop(-1)\\n break\\n else:\\n m[c].append(i)\\n res = ''\\n for i,c in enumerate(s):\\n if c != '*' and i not in dinds:\\n res += c\\n return res\",\n \"memory\": \"23100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n aaba** -> a_b_\\n aaba*a* -> aab__\\n \\\"\\\"\\\"\\n inds = collections.defaultdict(list)\\n to_remove = set()\\n \\n for i, ch in enumerate(s):\\n if ch == '*':\\n # find smallest and remove\\n smallest_val = min(inds.keys())\\n to_remove.add(inds[smallest_val][-1])\\n inds[smallest_val].pop()\\n if len(inds[smallest_val]) == 0:\\n del inds[smallest_val]\\n else:\\n inds[ch].append(i)\\n \\n ans = ''\\n for i, ch in enumerate(s):\\n if ch == '*' or i in to_remove:\\n continue\\n else:\\n ans += ch\\n return ans\\n\",\n \"memory\": \"23200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n p = [[] for _ in range(26)]\\n rm = set()\\n res = \\\"\\\"\\n n = len(s)\\n for j in range(n):\\n c = s[j]\\n if c == '*':\\n for i in range(26):\\n if len(p[i]) > 0:\\n rm.add(p[i][-1])\\n p[i] = p[i][:-1]\\n break\\n else:\\n p[ord(c) - ord('a')].append(j)\\n for j in range(n):\\n c = s[j]\\n if j not in rm and c != '*':\\n res += str(c)\\n return res\\n \",\n \"memory\": \"23300\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n While iterating thru characters:\\n - keep track of smallest character, and the last index it appears at\\n \\\"\\\"\\\"\\n n = len(s)\\n \\n # stores current available smallest character\\n min_heap = []\\n # stores the indexes a character appears at\\n indexes = [[] for i in range(26)]\\n new_s = []\\n \\n for i in range(n):\\n if s[i] == \\\"*\\\":\\n if len(min_heap) == 0:\\n continue\\n # pick smallest available character\\n order = min_heap[0]\\n # find it's last occurring index\\n last_idx = indexes[order].pop()\\n # mark it for deletion\\n new_s[last_idx] = \\\"*\\\"\\n # if there are no more occurrences of this character, remove it from the min heap\\n if len(indexes[order]) == 0:\\n heappop(min_heap)\\n # we've run into a character\\n else:\\n order = ord(s[i]) - ord(\\\"a\\\")\\n # this is a new character\\n if len(indexes[order]) == 0:\\n heappush(min_heap, order)\\n new_s.append(order)\\n idx = len(new_s) - 1\\n indexes[order].append(idx)\\n \\n \\n res = []\\n for char in new_s:\\n if char == \\\"*\\\":\\n continue\\n res.append(chr(ord(\\\"a\\\") + char))\\n return \\\"\\\".join(res)\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop_c = heappop(heap)\\n pop_idx = c_idx_table[pop_c].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Slower because of heap subsorting based on a character's index\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n # Faster because indices don't have to be sorted in the heap.\\n # Instead uses a hash table that intrinsically sorts the indices of\\n # a particular character.\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = [\\\"\\\"] * len(s)\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop_c = heappop(heap)\\n pop_idx = c_idx_table[pop_c].pop()\\n s_list[pop_idx] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n # s_list.append(c)\\n s_list[idx] = c\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"23800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop = heappop(heap)\\n pop_idx = c_idx_table[pop].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Slower because of heap subsorting based on a character's index\\n # heap = []\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # s_list[-pop[1]] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, (c, -idx))\\n # s_list.append(c)\\n # return \\\"\\\".join(s_list)\\n\\n # Faster because indices don't have to be sorted in the heap.\\n # Instead uses a hash table that intrinsically sorts the indices of\\n # a particular character.\\n heap = []\\n c_idx_table = defaultdict(list)\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop_c = heappop(heap)\\n pop_idx = c_idx_table[pop_c].pop()\\n s_list[pop_idx] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, c)\\n s_list.append(c)\\n c_idx_table[c].append(idx)\\n return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"23900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n if '*' not in s: return s\\n stack = []\\n for ctr, letter in enumerate(s):\\n if letter == '*':\\n heappop(stack)\\n else:\\n heappush(stack, (letter, -ctr))\\n ans = [''] * len(s)\\n while stack:\\n letter, i = heappop(stack)\\n ans[-i] = letter\\n return ''.join(ans)\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n freqArr = [[] for _ in range(26)]\\n arrSet = set()\\n for i in range(len(s)):\\n c = s[i]\\n if c == '*':\\n for j in range(len(freqArr)):\\n if len(freqArr[j]) > 0:\\n arrSet.remove(freqArr[j].pop())\\n break\\n continue\\n arrSet.add(i)\\n freqArr[ord(c)-ord('a')].append(i)\\n\\n res = []\\n for i in range(len(s)):\\n c = s[i]\\n if c=='*':\\n continue\\n if i in arrSet:\\n res.append(c)\\n return ''.join(res)\\n\\n\\n \\n\\n \\n\\n \",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n freqArr = [[] for _ in range(26)] # represents their index\\n freqArrSet = [set() for lst in freqArr]\\n for i in range(len(s)):\\n c = s[i]\\n if c == '*':\\n for idx in range(26):\\n if len(freqArr[idx]) > 0:\\n p = freqArr[idx].pop()\\n freqArrSet[idx].remove(p)\\n break\\n continue\\n idx = ord(c) - ord('a')\\n freqArr[idx].append(i)\\n freqArrSet[idx].add(i)\\n \\n res = []\\n for i in range(len(s)):\\n c = s[i]\\n if c == '*':\\n continue\\n idx = ord(c) - ord('a')\\n if i in freqArr[idx]:\\n freqArr[idx].remove(i)\\n res.append(c)\\n return ''.join(res) # join string at the end is faster than concatenating\",\n \"memory\": \"27000\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n freqArr = [[] for _ in range(26)]\\n for i in range(len(s)):\\n c = s[i]\\n if c == '*':\\n for j in range(len(freqArr)):\\n if len(freqArr[j]) > 0:\\n freqArr[j].pop()\\n break\\n continue\\n freqArr[ord(c)-ord('a')].append(i)\\n\\n freqArr = [set(lst) for lst in freqArr]\\n\\n res = []\\n for i in range(len(s)):\\n c = s[i]\\n if c=='*':\\n continue\\n k = ord(c)-ord('a')\\n if i in freqArr[k]:\\n res.append(c)\\n return ''.join(res)\\n\\n\\n \\n\\n \\n\\n \",\n \"memory\": \"27400\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n indexToremove = set()\\n dic = defaultdict(list)\\n\\n for i in range(len(s)):\\n if s[i] == '*':\\n indexToremove.add(i)\\n index = dic[min(dic.keys())].pop()\\n if not dic[min(dic.keys())]:\\n del dic[min(dic.keys())]\\n indexToremove.add(index)\\n continue\\n\\n dic[s[i]].append(i)\\n result = ''\\n for i in range(len(s)):\\n if i in indexToremove:\\n continue\\n result += s[i]\\n\\n return result\\n\\n\\n\",\n \"memory\": \"27500\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n indexToremove = set()\\n dic = defaultdict(list)\\n min_char = None # Track the current minimum character\\n\\n for i in range(len(s)):\\n if s[i] == '*':\\n # Mark the '*' for removal\\n indexToremove.add(i)\\n\\n # Remove the smallest character using the tracked min_char\\n if min_char is not None:\\n index = dic[min_char].pop()\\n indexToremove.add(index)\\n\\n # Clean up the dictionary if there are no more of that character\\n if not dic[min_char]:\\n del dic[min_char]\\n\\n # Update the min_char if necessary\\n min_char = min(dic.keys()) if dic else None\\n\\n else:\\n # Add the character and track the minimum key\\n dic[s[i]].append(i)\\n if min_char is None or s[i] < min_char:\\n min_char = s[i]\\n\\n # Build the result using list comprehension\\n result = ''.join([s[i] for i in range(len(s)) if i not in indexToremove])\\n\\n return result\\n\",\n \"memory\": \"27500\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # keep tracking the frequency of chars\\n # when we meet a star, we go to the smallest char, remove the last time when we met it\\n\\n removed_i = set()\\n\\n rec = [[] for _ in range(26)]\\n\\n for i, c in enumerate(s):\\n if c == '*':\\n min_c = -1\\n for j in range(26):\\n if len(rec[j]) > 0:\\n min_c = j\\n break\\n if min_c == -1:\\n continue\\n else:\\n s_i = rec[min_c].pop(-1)\\n removed_i.add(s_i)\\n removed_i.add(i)\\n else:\\n rec[ord(c)-ord(\\\"a\\\")].append(i)\\n \\n new_s = \\\"\\\"\\n for i in range(len(s)):\\n if i not in removed_i:\\n new_s += s[i]\\n return new_s\\n\\n \",\n \"memory\": \"27600\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n for i,c in enumerate(s):\\n if c=='*':\\n heappop(heap)\\n else:\\n heappush(heap,(c,-i))\\n \\n ans = ['']*len(s)\\n while heap:\\n char,i = heappop(heap)\\n ans[-i] = char\\n \\n return ''.join(ans)\",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n for ix, c in enumerate(s):\\n if c == '*':\\n heapq.heappop(heap)\\n else:\\n heapq.heappush(heap, (c, -ix))\\n results = [''] * len(s)\\n while heap:\\n c, ix = heapq.heappop(heap)\\n results[-ix] = c\\n return ''.join(results)\",\n \"memory\": \"27800\"\n },\n {\n \"code\": \"from queue import PriorityQueue\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n pq = PriorityQueue()\\n indices = [[] for i in range(26)]\\n removeSet = set()\\n\\n for i in range(0, len(s)):\\n if (s[i] == '*'):\\n removeSet.add(i)\\n ch = pq.get()\\n pq.put(ch)\\n removeSet.add(indices[ord(ch)-ord('a')][-1])\\n del indices[ord(ch)-ord('a')][-1]\\n if len(indices[ord(ch)-ord('a')])==0:\\n pq.get()\\n continue\\n if len(indices[ord(s[i])-ord('a')])==0:\\n pq.put(s[i])\\n indices[ord(s[i])-ord('a')].append(i)\\n \\n res = \\\"\\\"\\n for i in range(0, len(s)):\\n if i not in removeSet:\\n res += str(s[i])\\n \\n return res\\n \\n \\n\\n\\n \\n \\n \",\n \"memory\": \"28100\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n\\n for i, c in enumerate(s):\\n if c == '*':\\n heapq.heappop(min_heap)\\n else:\\n heapq.heappush(min_heap, (c, -i))\\n \\n res = [''] * len(s)\\n while min_heap:\\n c, i = heapq.heappop(min_heap)\\n res[-i] = c\\n \\n return ''.join(res)\\n\",\n \"memory\": \"28200\"\n },\n {\n \"code\": \"from queue import PriorityQueue\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n indices = [[]for i in range(26)]\\n pq = PriorityQueue()\\n removeSet = set()\\n for i,c in enumerate(s):\\n if c=='*':\\n removeSet.add(i)\\n ch = pq.get()\\n k = ord(ch)-ord('a')\\n removeSet.add(indices[k][-1])\\n del indices[k][-1]\\n else:\\n pq.put(c)\\n indices[ord(c)-ord('a')].append(i)\\n res=\\\"\\\"\\n for i,c in enumerate(s):\\n if i in removeSet:\\n continue\\n res+=c\\n return res\\n\",\n \"memory\": \"28300\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n heap = []\\n res = [True for _ in range(len(s))]\\n\\n for i in range(len(s)):\\n if s[i].isalpha():\\n heapq.heappush(heap, (s[i], -i))\\n \\n if s[i] == '*':\\n res[i] = False\\n letter, idx = heapq.heappop(heap)\\n res[-idx] = False\\n \\n ans = ''\\n for i in range(len(res)):\\n if res[i]:\\n ans += s[i]\\n \\n return ans\\n\\n\\n\\n \",\n \"memory\": \"28400\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # heap[(value, -idx)]\\n # delete smallest value with a larger index\\n heap = []\\n \\n for i, c in enumerate(s):\\n if c == '*':\\n value, idx = heapq.heappop(heap)\\n else:\\n heapq.heappush(heap, (c, -i)) \\n res = [''] * len(s)\\n \\n # print(heap)\\n for value, idx in heap:\\n res[-idx] = value \\n \\n return ''.join(res)\",\n \"memory\": \"28500\"\n },\n {\n \"code\": \"from heapq import *\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n v = list(s)\\n pos = []\\n for i,c in enumerate(s):\\n if c == \\\"*\\\": \\n u = heappop(pos)\\n v[i]=\\\" \\\"\\n v[-u[1]]=\\\" \\\"\\n else:\\n heappush(pos, (c, -i))\\n\\n return \\\"\\\".join(filter(lambda x : x != \\\" \\\", v))\\n \\n\\n \",\n \"memory\": \"28600\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n ss = []\\n pq = []\\n for ch in s:\\n if ch == '*':\\n c,i = heappop(pq)\\n ss[-i] = ''\\n else:\\n heappush(pq,(ch,-len(ss)))\\n ss.append(ch)\\n return \\\"\\\".join(ss)\\n \",\n \"memory\": \"28700\"\n },\n {\n \"code\": \"from sortedcontainers import SortedDict\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\n chrIdxs = SortedDict()\\n for i in range(len(s)):\\n char = s[i]\\n \\n # When you delete a star, remove the rightmost smallest character\\n if char == \\\"*\\\":\\n minChar = chrIdxs.peekitem(0)[0]\\n chrIdxs[minChar].pop()\\n if len(chrIdxs[minChar]) == 0:\\n del chrIdxs[minChar]\\n else:\\n if s[i] not in chrIdxs:\\n chrIdxs[s[i]] = []\\n chrIdxs[s[i]].append(i)\\n\\n # Reconstruct the string\\n remainingIndexes = set([i for indexes in chrIdxs.values() for i in indexes])\\n return \\\"\\\".join([s[i] for i in range(len(s)) if i in remainingIndexes])\\n \",\n \"memory\": \"28800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n pq = []\\n deleted = [False] * len(s)\\n for i in range(len(s)):\\n if s[i] == \\\"*\\\":\\n _, neg_idx = heapq.heappop(pq)\\n deleted[-neg_idx] = True\\n else:\\n heapq.heappush(pq, (s[i], -i))\\n return ''.join([s[i] for i in range(len(s)) if not deleted[i] and s[i] != \\\"*\\\"])\\n\\n \",\n \"memory\": \"29000\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n characterList = [[] for _ in range(26)]\\n for i in range(len(s)):\\n if s[i] == '*':\\n character = heapq.heappop(heap)\\n key = ord(character) - ord('a')\\n curList = characterList[key]\\n curList.pop(-1)\\n if len(curList) > 0:\\n heapq.heappush(heap, character)\\n else:\\n key = ord(s[i]) - ord('a')\\n curList = characterList[key]\\n curList.append(i)\\n if len(curList) == 1:\\n heapq.heappush(heap, s[i])\\n resultArr = []\\n for i in range(26):\\n for j in range(len(characterList[i])):\\n resultArr.append((characterList[i][j], chr(i+ord('a'))))\\n resultArr.sort(key = lambda x: x[0])\\n return \\\"\\\".join([x[1] for x in resultArr])\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n s_list = []\\n for idx, c in enumerate(s):\\n if c == \\\"*\\\":\\n pop = heappop(heap)\\n s_list[-pop[1]] = \\\"\\\"\\n s_list.append(\\\"\\\")\\n else:\\n heappush(heap, (c, -idx))\\n s_list.append(c)\\n return \\\"\\\".join(s_list)\\n\\n # heap = []\\n # c_idx_table = defaultdict(list)\\n # s_list = []\\n # for idx, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # pop = heappop(heap)\\n # pop_idx = c_idx_table[pop].pop()\\n # s_list[pop_idx] = \\\"\\\"\\n # s_list.append(\\\"\\\")\\n # else:\\n # heappush(heap, c)\\n # s_list.append(c)\\n # c_idx_table[c].append(idx)\\n # return \\\"\\\".join(s_list)\\n\\n \",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n remove = set()\\n for i,c in enumerate(s):\\n if c == '*':\\n remove.add(heappop(heap))\\n else:\\n heappush(heap, (c, -i)) \\n ret = []\\n for i, c in enumerate(s):\\n if (c, -i) in remove or c == '*':\\n continue\\n ret.append(c)\\n return ''.join(ret)\\n\\n \\n \\n \\n \\n \",\n \"memory\": \"29300\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n # iterate through the string\\n # if star, pick ch to delete\\n # if not star, add ch to buffer\\n\\n # picking ch to delete -\\n # use heap to keep track of lexicographically smallest ch\\n # heap consists of (ch, idx) to lookup which one to remove\\n\\n smallest_characters = []\\n heapq.heapify(smallest_characters)\\n\\n indices_to_remove = set()\\n\\n for i in range(len(s)):\\n if s[i] == \\\"*\\\":\\n min_char, min_char_idx = heapq.heappop(smallest_characters)\\n indices_to_remove.add(min_char_idx)\\n else:\\n heapq.heappush(smallest_characters, (s[i], -i))\\n\\n result_string = []\\n for i in range(len(s)):\\n if -i not in indices_to_remove and s[i] != '*':\\n result_string.append(s[i])\\n\\n return ''.join(result_string)\",\n \"memory\": \"29600\"\n },\n {\n \"code\": \"from heapq import heappush,heappop\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\n n = len(s)\\n \\n heap = []\\n \\n for i in range(n):\\n if s[i] != \\\"*\\\" or not heap:\\n heappush(heap,(s[i],-i))\\n else:\\n heappop(heap)\\n \\n \\n arr = sorted(heap,key=lambda x:x[1])\\n \\n res = \\\"\\\"\\n \\n while arr:\\n res += arr.pop()[0]\\n \\n \\n return res\\n \\n\\\"\\\"\\\"\\n\\\"aab\\\"\\n\\\"aabaa\\\"\\n\\\"owistoingrother\\\"\\n\\\"mromlifornia\\\"\\n\\\"ryusuyourfromliofornirother\\\"\\n\\\"y\\\"\\n\\\"rothrryousuritisonnworkonwsumittsolution\\\"\\n\\\"iamnotreallysurebrother\\\"\\n |\\n0 1 2 3 4 5 6 7 8 9 10 12 13 14 15\\na * r e y o u o k * * * * * *\\n\\n[r]\\n[]\\n\\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21\\ni a m * f r * * o m c * a l i f o r n i * a\\n{3,1,6,4,7,11,}\\n\\n{0, 1, 3, 4, 6, 7, 11, 12, 20}\\n\\n\\n\\n0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22\\nh o w * i s i t * g o i n * g b r o t * h e r\\n{0,3,8,6}\\n\\n\\n{5,4,6,7}\\n\\naaba*\\n \\n 4 5 7 6 \\na a b a a * a a *\\n\\nstack = [a,a,b,a,a]\\n\\n\\n\\\"\\\"\\\"\",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n Approaches\\n 1. Brute force + Heap + Hash map \\n 2. \\n \\\"\\\"\\\"\\n\\n output = list(s)\\n heap = []\\n # char_indecies = collections.defaultdict(list)\\n\\n for idx, char in enumerate(s):\\n if char != '*':\\n heapq.heappush(heap, [char, -1 * idx])\\n # char_indecies[char].append(idx)\\n else:\\n # while heap and heap[0] not in char_indecies:\\n # heapq.heappop(heap)\\n\\n curr_char, curr_idx = heapq.heappop(heap)\\n # curr_idx = char_indecies[curr_char].pop()\\n output[-1 * curr_idx] = ''\\n output[idx] = ''\\n\\n # if not char_indecies[curr_char]:\\n # del char_indecies[curr_char]\\n\\n return ''.join(output)\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n n=len(s)\\n d=[0]*n\\n l=[] #priority que\\n ans=\\\"\\\"\\n miny=s[0]\\n for i in range(n):\\n if s[i]!=\\\"*\\\":\\n heapq.heappush(l,[ord(s[i]),-i])\\n else:\\n t,index=heapq.heappop(l)\\n d[-index]=-1\\n for i in range(n):\\n if s[i]!='*' and d[i]!=-1:\\n ans+=s[i]\\n return ans\\n\\n \",\n \"memory\": \"30000\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n n = len(s)\\n\\n heap = [float(\\\"inf\\\")] * 26\\n skip = [0] * n\\n next_val = defaultdict(lambda: float(\\\"inf\\\"))\\n\\n for idx in range(n):\\n c = s[idx]\\n char_pos = ord(c) - ord('a')\\n if c == \\\"*\\\":\\n top = None\\n for j in range(26):\\n if heap[j] != float(\\\"inf\\\"):\\n top = heap[j]\\n heap[j] = next_val[top]\\n break\\n \\n if top == None:\\n continue\\n\\n char_pos = int(top)\\n p = n - 1 - ((top - char_pos) * n)\\n skip[int(round(p))] = 1\\n else:\\n val = char_pos + ((n - 1 - idx) / n)\\n if val < heap[char_pos]:\\n next_val[val] = heap[char_pos]\\n heap[char_pos] = val\\n \\n \\n substr = \\\"\\\"\\n for idx in range(n):\\n if s[idx] == \\\"*\\\" or skip[idx] == 1:\\n continue \\n \\n substr += s[idx]\\n \\n return substr\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n s = list(s)\\n heap = []\\n for r in range(len(s)):\\n if s[r]!=\\\"*\\\":\\n heapq.heappush(heap,[s[r] ,r * (-1)])\\n else:\\n val, idx = heappop(heap)\\n s[idx * (-1)] = \\\"*\\\"\\n res = \\\"\\\".join([i for i in s if i != \\\"*\\\"])\\n return res\",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n temp=[]\\n has={}\\n heapq.heapify(temp)\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\" and len(temp)>0:\\n a,b=heapq.heappop(temp)\\n has[-(b)]=1\\n elif s[i]!=\\\"*\\\":\\n heapq.heappush(temp,(s[i],-i))\\n tep=\\\"\\\"\\n for i in range(len(s)):\\n if i not in has and s[i]!='*':\\n tep+=s[i]\\n return tep\\n\\n \\n\",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n temp=[]\\n has={}\\n heapq.heapify(temp)\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\" and len(temp)>0:\\n a,b=heapq.heappop(temp)\\n has[-(b)]=1\\n elif s[i]!=\\\"*\\\":\\n heapq.heappush(temp,(s[i],-i))\\n tep=\\\"\\\"\\n for i in range(len(s)):\\n if i not in has and s[i]!='*':\\n tep+=s[i]\\n return tep\\n\\n \\n\",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n temp=[]\\n has={}\\n heapq.heapify(temp)\\n for i in range(len(s)):\\n if s[i]==\\\"*\\\" and len(temp)>0:\\n a,b=heapq.heappop(temp)\\n has[-(b)]=1\\n elif s[i]!=\\\"*\\\":\\n heapq.heappush(temp,(s[i],-i))\\n tep=\\\"\\\"\\n for i in range(len(s)):\\n if i not in has and s[i]!='*':\\n tep+=s[i]\\n return tep\\n\\n \\n\",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"class Solution:\\n import heapq\\n def clearStars(self, string: str) -> str:\\n result, heap = '', []\\n for idx, char in enumerate(string):\\n if char != '*':\\n heapq.heappush(heap, (char, -idx))\\n else:\\n heapq.heappop(heap)\\n \\n \\n heap.sort(key = lambda x: -x[1])\\n for pair in heap:\\n result += pair[0]\\n \\n return result\",\n \"memory\": \"32100\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\n\\nclass Solution:\\n\\n\\n def clearStars(self, s: str) -> str:\\n heap = list()\\n\\n for i in range(len(s)):\\n if s[i] == \\\"*\\\":\\n if heap:\\n heappop(heap)\\n else:\\n heappush(heap, (s[i], -i))\\n \\n def test_key(e):\\n return e[1] * -1\\n heap.sort(key=test_key)\\n ans = \\\"\\\"\\n n = len(heap)\\n for i in range(n):\\n ans += heap[i][0]\\n return ans\",\n \"memory\": \"32200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n\\n buffer = []\\n heapq.heapify(buffer)\\n\\n skip_idxs = set()\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n _, idx = heapq.heappop(buffer)\\n skip_idxs.add(idx)\\n else:\\n skip_proc = (ord(c)*10**5 - i, i)\\n heapq.heappush(buffer, skip_proc)\\n\\n result = []\\n for i, c in enumerate(s):\\n if c == '*' or i in skip_idxs:\\n continue\\n\\n result.append(c)\\n\\n return ''.join(result)\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"from dataclasses import dataclass\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n @dataclass\\n class Position:\\n idx: int\\n char: chr\\n \\n def __lt__(self, other):\\n if self.char == other.char: return self.idx > other.idx\\n return self.char < other.char\\n \\n \\n \\n removed_indices = set()\\n pq = []\\n for idx, c in enumerate(s):\\n if c == '*':\\n removed_indices.add(heapq.heappop(pq).idx)\\n else:\\n heapq.heappush(pq, Position(idx, c))\\n \\n res = []\\n for idx, c in enumerate(s):\\n if c != '*' and idx not in removed_indices:\\n res.append(c)\\n return ''.join(res)\",\n \"memory\": \"32800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n import heapq\\n myH = []\\n \\n for i, x in enumerate(s):\\n if x!='*':\\n heapq.heappush(myH, (x, -i))\\n else:\\n heapq.heappop(myH)\\n \\n myH = sorted(myH, key=lambda x: -x[1])\\n #print(myH)\\n ans = ''.join([x[0] for x in myH])\\n\\n return ans\",\n \"memory\": \"33000\"\n },\n {\n \"code\": \"class Data:\\n def __init__(self, i, x):\\n self.i = i\\n self.x = x\\n\\n def __lt__(self, other):\\n if ord(self.x) == ord(other.x):\\n return self.i > other.i\\n return ord(self.x) < ord(other.x)\\n\\nclass Solution:\\n def clearStars(self, xs: str) -> str:\\n h = []\\n for i, x in enumerate(xs):\\n if x != '*':\\n heapq.heappush(h, Data(i, x))\\n else:\\n heapq.heappop(h)\\n \\n return ''.join(d.x for d in sorted(h, key= lambda d: d.i))\",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n # Obs: you can have maximum n // 2 stars\\n heap = []\\n\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n heapq.heappop(heap)\\n else:\\n # -i because you have to eliminate the closest occurence\\n heapq.heappush(heap, (c, -i))\\n return \\\"\\\".join([x[0] for x in sorted(heap, key=lambda x: -x[1])])\",\n \"memory\": \"33200\"\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom heapq import heapify, heappush, heappop\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n \\\"\\\"\\\"\\n\\n aaba*abaa*\\n /. |. \\\\ \\n 1. abaabaa*\\n 2. abaabaa* \\n 3. aababaa*\\n\\n \\\"\\\"\\\"\\n \\n # def dp(str1, star_remaining):\\n # if star_remaining == 0:\\n # return str1\\n\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(str1):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # if not smallest_c:\\n # return dp(str1[1:], star_remaining - 1)\\n\\n # substr = str1[:i] + str1[i + 1:]\\n # nextStr = substr[:smallest_i] + substr[smallest_i + 1:]\\n\\n # return dp(nextStr, star_remaining - 1)\\n\\n # return dp(s, star_remaining) \\n\\n \\\"\\\"\\\"\\n O(s) -> s = # of *\\n O(n) -> number of characters\\n O(s * n)\\n # \\\"\\\"\\\"\\n # while star_remaining:\\n # smallest_c = \\\"z\\\"\\n # smallest_i = -1\\n\\n # for i, c in enumerate(s):\\n # if c == \\\"*\\\":\\n # break \\n # if c < smallest_c or c == smallest_c:\\n # smallest_c = c \\n # smallest_i = i \\n \\n # # print(idx, i)\\n # star_remaining -= 1\\n # if not smallest_c:\\n # s = s[1:]\\n # else:\\n # substr = s[:i] + s[i + 1:]\\n # s = substr[:smallest_i] + substr[smallest_i + 1:]\\n # A set of all the \\\"deleted\\\" indexes\\n visited = set()\\n # a min heap in this format (char, -index) -> so the latest index will always be pushed first\\n h = []\\n\\n \\n smallest_c = \\\"z\\\"\\n smallest_i = -1\\n\\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n visited.add(i)\\n _, smallest_i = heappop(h)\\n visited.add(-smallest_i)\\n else:\\n heappush(h, (c, -i))\\n\\n res = []\\n\\n for i, c in enumerate(s):\\n if i in visited:\\n continue\\n res.append(c)\\n\\n return \\\"\\\".join(res)\\n\",\n \"memory\": \"33400\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n hp = []\\n set_ = set()\\n for i in range(len(s)):\\n \\n if s[i] ==\\\"*\\\":\\n _,j = heapq.heappop(hp)\\n set_.add(-j)\\n set_.add(i)\\n else:\\n heapq.heappush(hp, (s[i],-i))\\n ans = \\\"\\\"\\n for i in range(len(s)):\\n if i not in set_:\\n ans+=s[i]\\n return ans\\n\\n\\n\\n\\n\\n \\n\\n\",\n \"memory\": \"33500\"\n },\n {\n \"code\": \"import heapq\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n # - when we see a *\\n # - find the smallest char remaining\\n # - delete the right-most appearance of that char (to maximise lexographicalness)\\n \\n # - build up a list of indices to delete (*s and chars)\\n # - go along string from left to right, maintain a heap [char, -index]\\n # - then heap[0] will always be most recent appearance of smallest char\\n\\n heap = []\\n to_delete = set()\\n\\n for idx, c in enumerate(s):\\n if c == '*':\\n c, char_idx = heapq.heappop(heap)\\n char_idx = -char_idx\\n to_delete.add(idx)\\n to_delete.add(char_idx)\\n else:\\n key = (c, -idx)\\n heapq.heappush(heap, key)\\n\\n return \\\"\\\".join(\\n c for idx, c in enumerate(s) if idx not in to_delete\\n )\\n \",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"from heapq import heappush, heappop\\n\\nclass Solution:\\n def clearStars(self, s: str) -> str:\\n heap = []\\n \\n for i, c in enumerate(s):\\n if c == \\\"*\\\":\\n heappop(heap)\\n else:\\n heappush(heap, (c, -i))\\n\\n heap = set(heap)\\n\\n return \\\"\\\".join(c for i, c in enumerate(s) if (c, -i) in heap)\",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n\\n heap=[]\\n for i in range(len(s)):\\n if s[i]!=\\\"*\\\":\\n heapq.heappush(heap,[s[i],-i])\\n else:\\n heapq.heappop(heap)\\n heap.sort(key=lambda x:-x[1])\\n ans=\\\"\\\"\\n for i in heap:\\n ans+=i[0]\\n return ans\",\n \"memory\": \"33800\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n \\n minheap = []\\n for i, x in enumerate(s):\\n if x==\\\"*\\\":\\n victim = heapq.heappop(minheap)\\n else:\\n heapq.heappush(minheap, [x, -i])\\n \\n minheap.sort(key=lambda x: -x[1])\\n return \\\"\\\".join([x[0] for x in minheap])\\n \",\n \"memory\": \"33900\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"memory\": \"34200\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"memory\": \"34300\"\n },\n {\n \"code\": \"class Solution:\\n def clearStars(self, s: str) -> str:\\n min_heap = []\\n cnt = collections.Counter()\\n for i, c in enumerate(s):\\n if c == '*':\\n if min_heap:\\n c_to_rm = min_heap[0]\\n cnt[c_to_rm] -= 1\\n heapq.heappop(min_heap)\\n else:\\n cnt[c] += 1\\n heapq.heappush(min_heap, (c, -cnt[c], i))\\n\\n res = ''\\n min_heap.sort(key=lambda x: x[2])\\n for c, _, _ in min_heap:\\n res += c\\n return res\",\n \"memory\": \"34400\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":70,"string":"70"}}},{"rowIdx":2459,"cells":{"question_id":{"kind":"number","value":3436,"string":"3,436"},"name":{"kind":"string","value":"find-subarray-with-bitwise-or-closest-to-k"},"content":{"kind":"string","value":"<p>You are given an array <code>nums</code> and an integer <code>k</code>. You need to find a <span data-keyword=\"subarray-nonempty\">subarray</span> of <code>nums</code> such that the <strong>absolute difference</strong> between <code>k</code> and the bitwise <code>OR</code> of the subarray elements is as<strong> small</strong> as possible. In other words, select a subarray <code>nums[l..r]</code> such that <code>|k - (nums[l] OR nums[l + 1] ... OR nums[r])|</code> is minimum.</p>\n\n<p>Return the <strong>minimum</strong> possible value of the absolute difference.</p>\n\n<p>A <strong>subarray</strong> is a contiguous <b>non-empty</b> sequence of elements within an array.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,4,5], k = 3</span></p>\n\n<p><strong>Output:</strong> 0</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The subarray <code>nums[0..1]</code> has <code>OR</code> value 3, which gives the minimum absolute difference <code>|3 - 3| = 0</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,3,1,3], k = 2</span></p>\n\n<p><strong>Output:</strong> 1</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The subarray <code>nums[1..1]</code> has <code>OR</code> value 3, which gives the minimum absolute difference <code>|3 - 2| = 1</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1], k = 10</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">9</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>There is a single subarray with <code>OR</code> value 1, which gives the minimum absolute difference <code>|10 - 1| = 9</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>1 <= k <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":31.078913192941354,"string":"31.078913"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","binary-search","bit-manipulation","segment-tree"],"string":"[\n \"array\",\n \"binary-search\",\n \"bit-manipulation\",\n \"segment-tree\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"220\", 7.638599999999999], [\"292\", 0.6944], [\"365\", 0.6944], [\"438\", 0.6944], [\"510\", 0.6944], [\"583\", 0.6944], [\"656\", 0.6944], [\"728\", 0.6944], [\"801\", 0.6944], [\"874\", 0.6944], [\"946\", 0.6944], [\"1019\", 0.6944], [\"1091\", 15.277299999999999], [\"1164\", 14.5825], [\"1237\", 6.9442], [\"1309\", 4.1664], [\"1382\", 6.2496], [\"1455\", 0.6944], [\"1527\", 0.6944], [\"1600\", 0.6944], [\"1673\", 0.6944], [\"1745\", 1.3888], [\"1818\", 1.3888], [\"1890\", 0.6944], [\"1963\", 0.6944], [\"2036\", 0.6944], [\"2108\", 0.6944], [\"2181\", 0.6944], [\"2254\", 0.6944], [\"2326\", 0.6944], [\"2399\", 0.6944], [\"2472\", 0.6944], [\"2544\", 0.6944], [\"2617\", 0.6944], [\"2689\", 0.6944], [\"2762\", 0.6944], [\"2835\", 0.6944], [\"2907\", 0.6944], [\"2980\", 0.6944], [\"3053\", 0.6944], [\"3125\", 0.6944], [\"3198\", 0.6944], [\"3271\", 0.6944], [\"3343\", 0.6944], [\"3416\", 0.6944], [\"3489\", 0.6944], [\"3561\", 0.6944], [\"3634\", 0.6944], [\"3706\", 0.6944], [\"3779\", 0.6944], [\"3852\", 0.6944], [\"3924\", 0.6944], [\"3997\", 0.6944], [\"4070\", 0.6944], [\"4142\", 0.6944], [\"4215\", 0.6944], [\"4288\", 0.6944], [\"4360\", 0.6944], [\"4433\", 0.6944], [\"4505\", 0.6944], [\"4578\", 0.6944]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"30600\", 2.0833], [\"30700\", 17.3611], [\"30800\", 22.2222], [\"30900\", 4.8611], [\"31500\", 6.9444], [\"31600\", 2.0833], [\"32800\", 0.6944], [\"34600\", 2.7778], [\"34700\", 3.4722], [\"34800\", 0.6944], [\"43200\", 0.6944], [\"43300\", 6.25], [\"43400\", 0.6944], [\"43500\", 0.6944], [\"43600\", 0.6944], [\"43700\", 0.6944], [\"43900\", 1.3889], [\"44000\", 2.0833], [\"45300\", 0.6944], [\"53400\", 0.6944], [\"54700\", 0.6944], [\"54800\", 0.6944], [\"56400\", 1.3889], [\"56500\", 0.6944], [\"56700\", 0.6944], [\"56800\", 0.6944], [\"58300\", 2.0833], [\"58500\", 0.6944], [\"58600\", 1.3889], [\"59200\", 0.6944], [\"59300\", 0.6944], [\"86000\", 0.6944], [\"91500\", 0.6944], [\"91600\", 0.6944], [\"97800\", 0.6944], [\"102500\", 0.6944], [\"109300\", 0.6944], [\"127300\", 0.6944], [\"128300\", 0.6944]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","runtime":"220"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","runtime":"220"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = abs(nums[0] - k)\n for n in nums[1:]:\n res = min(res, abs(n-k))\n if res == 0: return 0\n \n temp = []\n for i in range(len(nums)):\n if nums[i] < k:\n if len(temp) == 0 or temp[-1] != nums[i]:\n temp.append(nums[i])\n elif len(temp) != 0:\n for j, n in enumerate(temp):\n local_res = n\n index = j + 1\n while index < len(temp):\n local_res |= temp[index]\n if abs(local_res - k) < res:\n res = abs(local_res - k)\n if res == 0: return 0\n elif local_res > k:\n break\n index += 1\n if local_res < k:\n break\n temp = []\n for j, n in enumerate(temp):\n local_res = n\n index = j + 1\n while index < len(temp):\n local_res |= temp[index]\n if abs(local_res - k) < res:\n res = abs(local_res - k)\n if res == 0: return 0\n elif local_res > k:\n break\n index += 1\n if local_res < k:\n break\n return res\n \n \n \n \n \n \n \n \n ","runtime":"292"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = abs(nums[0] - k)\n for n in nums[1:]:\n res = min(res, abs(n-k))\n if res == 0: return 0\n \n temp = []\n for i in range(len(nums)):\n if nums[i] < k:\n if len(temp) == 0 or temp[-1] != nums[i]:\n temp.append(nums[i])\n elif len(temp) != 0:\n for j, n in enumerate(temp):\n local_res = n\n index = j + 1\n while index < len(temp):\n local_res |= temp[index]\n if abs(local_res - k) < res:\n res = abs(local_res - k)\n elif local_res > k:\n break\n index += 1\n if local_res < k:\n break\n temp = []\n for j, n in enumerate(temp):\n local_res = n\n index = j + 1\n while index < len(temp):\n local_res |= temp[index]\n if abs(local_res - k) < res:\n res = abs(local_res - k)\n elif local_res > k:\n break\n index += 1\n if local_res < k:\n break\n return res\n \n \n \n \n \n \n \n \n ","runtime":"365"},{"code":"class Solution:\n def bitwise_or(self, nums: List[int]) -> int:\n answer = 0\n for num in nums:\n answer = answer | num\n \n return answer\n\n def minimumDifference(self, nums: List[int], k: int) -> int:\n best_difference = float(\"inf\")\n left_index = 0\n right_index = 0\n use_prev = False\n while True:\n if use_prev:\n current = current | nums[right_index]\n else:\n current = self.bitwise_or(nums[left_index:right_index+1])\n if k == current:\n return 0\n elif k > current:\n best_difference = min(best_difference, k-current)\n # too small - increase right.\n right_index += 1\n if right_index >= len(nums):\n return best_difference\n use_prev = True\n else:\n best_difference = min(best_difference, current-k)\n # too big - increase left.\n left_index += 1\n # make sure we don't go past right.\n if left_index > right_index:\n right_index = left_index\n if left_index >= len(nums):\n return best_difference\n use_prev = False\n","runtime":"438"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n#kartikdevsharmaa","runtime":"510"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n best = 10**9\n p = []\n for v in nums:\n q = [v]\n best = min(best,abs(k-q[-1]))\n for x in p:\n if q[-1]>k: break\n x |= q[-1]\n if x != q[-1]: \n q.append(x)\n best = min(best,abs(k-x))\n p = q\n #\n return best\n\n\n\n\n ","runtime":"583"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n memo = set()\n ans = float(\"inf\")\n for num in nums:\n memo.add(num)\n ans = min(ans, abs(k - num))\n tmp = set()\n for m in memo:\n cur = m | num\n if cur < k:\n tmp.add(cur)\n ans = min(ans, abs(k - cur))\n memo = tmp\n return ans\n","runtime":"656"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n d = set()\n ans = float(\"inf\")\n for x in nums:\n d.add(x)\n ans = min(ans, abs(k - x))\n q = set()\n for y in d:\n v = y | x\n if v < k:\n q.add(v)\n ans = min(ans, abs(k - v))\n d = q\n return ans","runtime":"728"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n d = set()\n ans = float(\"inf\")\n for x in nums:\n d.add(x)\n ans = min(ans, abs(k - x))\n q = set()\n for y in d:\n v = y | x\n if v < k:\n q.add(v)\n ans = min(ans, abs(k - v))\n d = q\n return ans","runtime":"801"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = inf\n for i, x in enumerate(nums):\n res = min(res, abs(x - k))\n j = i - 1\n while j >= 0 and nums[j] | x != nums[j]:\n nums[j] |= x\n res = min(res, abs(nums[j] - k))\n j -= 1\n\n return res","runtime":"874"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = inf\n for i, x in enumerate(nums):\n ans = min(ans, abs(x - k))\n j = i - 1\n while j >= 0 and nums[j] | x != nums[j]:\n nums[j] |= x\n ans = min(ans, abs(nums[j] - k))\n j -= 1\n return ans","runtime":"946"},{"code":"class Solution:\n def minimumDifference(self, nums:List[int],k:int)-> int:\n ans = inf\n for i, x in enumerate(nums):\n ans =min(ans, abs(x-k))\n j=i-1\n while j>=0 and nums[j] | x != nums[j]:\n nums[j] |= x\n ans =min(ans,abs(nums[j]-k))\n j-= 1\n return ans\n","runtime":"1019"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = inf\n for i,x in enumerate(nums):\n ans = min(ans,abs(x-k))\n j=i-1\n while j>= 0 and nums[j]|x!= nums[j]:\n nums[j] |= x\n ans =min(ans,abs(nums[j]-k))\n j-=1\n return ans","runtime":"1091"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = inf\n for i, x in enumerate(nums):\n ans = min(ans, abs(x-k))\n j = i-1\n while j >= 0 and nums[j] | x != nums[j]:\n nums[j] |= x\n ans = min(ans, abs(nums[j] - k))\n j -= 1\n return ans\n \n \n ","runtime":"1091"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = inf\n for i, x in enumerate(nums):\n ans = min(ans, abs(x - k))\n j = i - 1\n while j >= 0 and nums[j] | x != nums[j]:\n nums[j] |= x\n ans = min(ans, abs(nums[j] - k))\n j -= 1\n return ans\n","runtime":"1164"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n dp = set()\n n = len(nums)\n\n # result: contains all subarray distinct OR values\n result = set()\n\n for i in range(n):\n new_dp = set()\n\n # single nums[i] can be a subarray\n new_dp.add(nums[i])\n\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n # update all possible subarray result\n result |= new_dp\n dp = new_dp\n \n return min(abs(val - k) for val in result)","runtime":"1164"},{"code":"class SegmentTree:\n def __init__(self, arr: List[int]):\n self.size = len(arr) + 1\n self.st = [0] * 2 * self.size\n\n for i, val in enumerate(arr):\n self.st[self.size + i] = val\n\n for i in range(self.size - 1, 0, -1):\n self.st[i] = self.st[2 * i] | self.st[2 * i + 1]\n\n def query(self, left: int, right: int):\n left += self.size\n right += self.size + 1\n res = 0\n\n while left < right:\n if left & 1:\n res |= self.st[left]\n left += 1\n\n if right & 1:\n right -= 1\n res |= self.st[right]\n\n left //= 2\n right //= 2\n\n return res\n\n\nclass Solution:\n # def minimumDifference(self, nums: List[int], k: int) -> int:\n # n = len(nums)\n # st = SegmentTree(nums)\n # ans = inf\n\n # for i in range(n):\n # ans = min(ans, abs(k - nums[i]))\n\n # left = 0\n # right = i - 1\n\n # while left + 1 < right:\n # mid = (left + right) // 2\n\n # or_sum = st.query(mid, i)\n\n # if or_sum <= k:\n # right = mid\n # else:\n # left = mid\n\n # ans = min(ans, abs(k - st.query(left, i)))\n # if right >= 0:\n # ans = min(ans, abs(k - st.query(right, i)))\n\n # return ans\n\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n = len(nums)\n ans = abs(k - nums[0])\n\n s = {nums[0]}\n\n for i in range(1, n):\n ans = min(ans, abs(k - nums[i]))\n\n new_s = {nums[i]}\n for t in s:\n temp = t | nums[i]\n ans = min(ans, abs(k - temp))\n new_s.add(temp)\n\n s = new_s\n\n return ans\n","runtime":"1237"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = float('inf')\n curr_or_set = set()\n for num in nums:\n next_or_set = set()\n next_or_set.add(num)\n ans = min(ans, abs(k - num))\n for prev_or in curr_or_set:\n new_or = prev_or | num # Corrected to use bitwise OR\n next_or_set.add(new_or)\n ans = min(ans, abs(k - new_or))\n curr_or_set = next_or_set\n return ans\n","runtime":"1237"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n l = len(nums)\n final = set()\n final.add(0)\n final.add(nums[0])\n mn = abs(k - nums[0])\n for i in range(1,l):\n lst = set()\n lst.add(0)\n for nm in final:\n cr = nm | nums[i]\n lst.add(cr)\n mn = min(mn,abs(k-cr))\n if(mn == 0):\n return 0\n final = lst\n return mn\n ","runtime":"1309"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n l = len(nums)\n final = set()\n final.add(0)\n final.add(nums[0])\n mn = abs(k - nums[0])\n for i in range(1,l):\n lst = set()\n lst.add(0)\n for nm in final:\n cr = nm | nums[i]\n lst.add(cr)\n mn = min(mn,abs(k-cr))\n if(mn == 0):\n return 0\n final = lst\n return mn","runtime":"1309"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = 10**10\n st = set()\n for num in nums:\n st = {num} | {num | i for i in st}\n res = min(res, min(abs(i - k) for i in st))\n return res\n","runtime":"1382"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ors = set()\n ans = inf\n \n for num in nums:\n # at most length 30, only unset bits can become set on adding an element, and set bits never become unset again.\n ors = set([x | num for x in ors] + [num])\n for x in ors: \n ans = min(ans, abs(x - k))\n \n return ans ","runtime":"1382"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)","runtime":"1455"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","runtime":"1527"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","runtime":"1600"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","runtime":"1673"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)","runtime":"1745"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","runtime":"1745"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n cur_or = [nums[0]]\n sum_or = nums[0]\n for num in nums[1:]:\n if num!=cur_or[-1]:\n cur_or.append(num)\n sum_or |= num\n diff = min([abs(or_-k) for or_ in cur_or])\n if min(cur_or)>k or min(cur_or)==sum_or:\n return diff\n\n \n for i in range(1, len(cur_or)):\n for l in range(len(cur_or)-1):\n cur_or[l] |= cur_or[l+1]\n cur_or = cur_or[:-1]\n diff_new = min([abs(or_-k) for or_ in cur_or])\n diff = min(diff_new,diff)\n # print(i, cur_or, diff, sum_or)\n if min(cur_or)>k or min(cur_or)==sum_or:\n return diff\n\n return diff\n \n\n\n","runtime":"1818"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n m = max(nums).bit_length()\n cnt = [0] * m\n s = i = 0\n ans = inf\n for j, x in enumerate(nums):\n s |= x\n ans = min(ans, abs(s - k))\n for h in range(m):\n if x >> h & 1:\n cnt[h] += 1\n while i < j and s > k:\n y = nums[i]\n for h in range(m):\n if y >> h & 1:\n cnt[h] -= 1\n if cnt[h] == 0:\n s ^= 1 << h\n i += 1\n ans = min(ans, abs(s - k))\n return ans","runtime":"1818"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n m = max(nums).bit_length()\n cnt = [0] * m\n s = i = 0\n ans = inf\n for j, x in enumerate(nums):\n s |= x\n ans = min(ans, abs(s - k))\n for h in range(m):\n if x >> h & 1:\n cnt[h] += 1\n while i < j and s > k:\n y = nums[i]\n for h in range(m):\n if y >> h & 1:\n cnt[h] -= 1\n if cnt[h] == 0:\n s ^= 1 << h\n i += 1\n ans = min(ans, abs(s - k))\n return ans","runtime":"1890"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n zeros = 0 in nums\n curr = 0\n M = max(nums)\n e = 1\n i = 0\n count = {}\n best = inf\n while e <= M:\n count[e] = 0\n e *= 2\n for n in nums:\n curr |= n\n for e in count:\n if n&e: count[e] += 1\n best = min(abs(k-curr), best)\n while curr > k and i < len(nums):\n for e in count:\n if e&nums[i]:\n count[e] -= 1\n if not count[e]: curr -= e\n if curr or zeros:\n best = min(abs(k-curr), best)\n i += 1\n return best\n","runtime":"1963"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n zeros = 0 in nums\n curr = 0\n M = max(nums)\n e = 1\n i = 0\n count = {}\n best = abs(k-nums[0])\n while e <= M:\n count[e] = 0\n e *= 2\n for n in nums:\n curr |= n\n for e in count:\n if n&e: count[e] += 1\n best = min(abs(k-curr), best)\n while curr > k and i < len(nums):\n for e in count:\n if e&nums[i]:\n count[e] -= 1\n if not count[e]: curr -= e\n if curr or zeros:\n best = min(abs(k-curr), best)\n i += 1\n return best\n","runtime":"2036"},{"code":"from functools import cache\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n # Recursive funtion with the current index and past bitwise AND value \n @cache\n def solve(idx, curr_and):\n # If index reached at the end simply pass inf\n if idx >= n:\n return inf\n \n # No need to check the other case since if we include curr_and it will always give us 0 value\n if curr_and | nums[idx] == 0:\n return min(abs(0-k), abs(nums[idx]-k), solve(idx+1, nums[idx]))\n \n return min(abs((curr_and | nums[idx]) - k), abs(nums[idx]-k), solve(idx+1, nums[idx]), solve(idx+1, curr_and|nums[idx]))\n \n return solve(0, nums[0])","runtime":"2254"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n @cache\n def get_minimum_difference(index, or_value):\n if index >= len(nums):\n return inf\n\n return min(\n abs(k - nums[index]),\n abs(k - (nums[index] | or_value)),\n get_minimum_difference(index + 1, nums[index]),\n get_minimum_difference(index + 1, nums[index] | or_value)\n )\n\n return get_minimum_difference(0, 0)","runtime":"2326"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n maxbit = 0\n bits = [[] for i in range(len(nums))]\n for i in range(len(nums)):\n num = nums[i]\n bit = 0\n while num:\n if num & 1 > 0:\n bits[i].append(bit)\n bit += 1\n num >>= 1\n maxbit = max(bit, maxbit)\n \n left = 0\n right = 0\n minDiff = abs(nums[0]-k)\n cur_num = 0\n cur_bits = [set() for i in range(maxbit)]\n while right < len(nums):\n cur_num |= nums[right]\n for bit in bits[right]:\n cur_bits[bit].add(right)\n\n minDiff = min(minDiff, abs(k-cur_num))\n while cur_num > k and left <= right:\n for bit in bits[left]:\n cur_bits[bit].remove(left)\n if len(cur_bits[bit]) == 0:\n cur_num ^= (1<<bit)\n\n if left < right:\n minDiff = min(minDiff, abs(k-cur_num))\n left += 1\n \n right += 1\n return minDiff\n\n\n\n\n \n \n ","runtime":"2399"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n maxbit = 0\n bits = [set() for i in range(len(nums))]\n for i in range(len(nums)):\n num = nums[i]\n bit = 0\n while num:\n if num & 1 > 0:\n bits[i].add(bit)\n bit += 1\n num >>= 1\n maxbit = max(bit, maxbit)\n \n left = 0\n right = 0\n minDiff = abs(nums[0]-k)\n cur_num = 0\n cur_bits = [[] for i in range(maxbit)]\n while right < len(nums):\n cur_num |= nums[right]\n for bit in bits[right]:\n cur_bits[bit].append(right)\n\n minDiff = min(minDiff, abs(k-cur_num))\n while cur_num > k and left <= right:\n for bit in bits[left]:\n cur_bits[bit].pop(0)\n if len(cur_bits[bit]) == 0:\n cur_num ^= (1<<bit)\n\n if left < right:\n minDiff = min(minDiff, abs(k-cur_num))\n left += 1\n \n right += 1\n return minDiff\n\n\n\n\n \n \n ","runtime":"2472"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n best_seen = 10**12\n n = len(nums)\n N_BITS = (10**9).bit_length() + 1\n bit_counts = [0 for _ in range(N_BITS)]\n powers = [pow(2,i) for i in range(N_BITS)]\n curr_bit_or = 0\n \n def get_bit_indices(x: int) -> list[int]:\n bits = bin(x)\n ans = []\n for i in reversed(range(2, len(bits))):\n if bits[i] == \"1\":\n ans.append(len(bits)-i-1)\n return ans\n \n left_index_incl = 0\n right_index_incl = 0\n bits_first = get_bit_indices(nums[0])\n for i in bits_first:\n bit_counts[i] = 1\n curr_bit_or += powers[i]\n best_seen = min(best_seen, abs(k-curr_bit_or))\n\n \n while right_index_incl < n:\n if best_seen == 0:\n return 0\n if curr_bit_or <= k or left_index_incl >= right_index_incl:\n right_index_incl += 1\n if right_index_incl >= n:\n break\n bits_here = get_bit_indices(nums[right_index_incl])\n for i in bits_here:\n bit_counts[i] += 1\n if bit_counts[i] == 1:\n curr_bit_or += powers[i]\n else:\n\n bits_here = get_bit_indices(nums[left_index_incl])\n for i in bits_here:\n bit_counts[i] -= 1\n if bit_counts[i] == 0:\n curr_bit_or -= powers[i]\n \n left_index_incl += 1\n \n best_seen = min(best_seen, abs(k-curr_bit_or))\n \n \n \n \n \n \n return best_seen","runtime":"2544"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n @cache\n def solve(i: int, curr_or: int) -> int:\n if i >= n:\n return math.inf\n\n return min(\n abs((curr_or | nums[i]) - k), \n abs(nums[i] - k), \n solve(i + 1, 0), \n solve(i + 1, curr_or | nums[i]))\n \n \n return solve(0, nums[0])","runtime":"2617"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = float('inf')\n l = 0\n curr = 0\n curr_freqs = [0] * 32\n for r in range(len(nums)):\n curr |= nums[r]\n for i in range(32):\n if (1 << i) & nums[r]: curr_freqs[i] += 1\n \n \n res = min(res, abs(k - curr))\n while l < r and k < curr:\n for i in range(32):\n if (1 << i) & nums[l]: \n curr_freqs[i] -= 1\n if curr_freqs[i] == 0:\n curr ^= (1 << i)\n l += 1\n res = min(res, abs(k - curr))\n \n return res","runtime":"2689"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n best_seen = 10**12\n n = len(nums)\n N_BITS = (10**9).bit_length() + 1\n bit_counts = [0 for _ in range(N_BITS)]\n powers = [pow(2,i) for i in range(N_BITS)]\n curr_bit_or = 0\n \n def get_bit_indices(x: int) -> list[int]:\n return [i for i,y in enumerate(powers) if x&y != 0]\n bits = bin(x)\n ans = []\n for i in reversed(range(2, len(bits))):\n if bits[i] == \"1\":\n ans.append(len(bits)-i-1)\n return ans\n \n left_index_incl = 0\n right_index_incl = 0\n bits_first = get_bit_indices(nums[0])\n for i in bits_first:\n bit_counts[i] = 1\n curr_bit_or += powers[i]\n best_seen = min(best_seen, abs(k-curr_bit_or))\n\n \n while right_index_incl < n:\n if best_seen == 0:\n return 0\n if curr_bit_or <= k or left_index_incl >= right_index_incl:\n right_index_incl += 1\n if right_index_incl >= n:\n break\n bits_here = get_bit_indices(nums[right_index_incl])\n for i in bits_here:\n bit_counts[i] += 1\n if bit_counts[i] == 1:\n curr_bit_or += powers[i]\n else:\n\n bits_here = get_bit_indices(nums[left_index_incl])\n for i in bits_here:\n bit_counts[i] -= 1\n if bit_counts[i] == 0:\n curr_bit_or -= powers[i]\n \n left_index_incl += 1\n \n best_seen = min(best_seen, abs(k-curr_bit_or))\n \n \n \n \n \n \n return best_seen","runtime":"2762"},{"code":"def add(M,num):\n j=0\n while num!=0:\n M[j]=M[j]+(num&1)\n num=num>>1\n j=j+1\n\ndef remove(M,num):\n j=0\n while num!=0:\n M[j]=M[j]-(num&1)\n num=num>>1\n j=j+1\n\ndef get_num(M):\n ans=0\n for j in range (0,len(M)):\n if M[j]>0:\n ans=ans|(1<<j)\n\n return ans\n\nclass Solution:\n def minimumDifference(self, L: List[int], k: int) -> int:\n l=0\n ans=2**31-1\n M=[0]*32\n for r in range (0,len(L)):\n add(M,L[r])\n count=get_num(M)\n while l<=r and count>k:\n ans=min(ans,abs(count-k))\n remove(M,L[l])\n count=get_num(M)\n l=l+1\n if count!=0:\n ans=min(ans,abs(count-k))\n return ans\n \n\n ","runtime":"2835"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n bitCount = [0] * 30\n curOr = 0\n i = 0\n res = inf\n for j, x in enumerate(nums):\n for b in range(30):\n if (x >> b) & 1 == 1:\n bitCount[b] += 1\n curOr = 0\n for b in range(30):\n if bitCount[b] >= 1:\n curOr |= (1 << b)\n res = min(res, abs(curOr - k))\n while curOr >= k:\n x = nums[i]\n for b in range(30):\n if (x >> b) & 1 == 1:\n bitCount[b] -= 1\n i += 1\n curOr = 0\n for b in range(30):\n if bitCount[b] >= 1:\n curOr |= (1 << b)\n \n curOr = 0\n for b in range(30):\n if bitCount[b] >= 1:\n curOr |= (1 << b)\n if curOr != 0:\n res = min(res, abs(curOr - k))\n \n return res","runtime":"2907"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n return TreeNode(start, end, nums[start], None, None)\n\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val = left.val | right.val\n return TreeNode(start, end, val, left, right)\n self.root = build(nums, 0, len(nums)-1)\n\n def range_or(self, start, end):\n def query(node, start, end):\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return query(node.right, start, end)\n elif mid >= end:\n return query(node.left, start, end)\n else:\n return query(node.left, start, mid) | query(node.right, mid+1, end)\n\n return query(self.root, start, end)\n\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n tree = SegmentTree(nums)\n N = len(nums)\n res = float(inf)\n left, right = 0, 0\n while right < N:\n while right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur > k:\n break\n right += 1\n\n left += 1\n while left <= right and right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur < k:\n break\n left += 1\n\n right = max(right, left)\n\n return res\n","runtime":"2980"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n M = max(nums)\n m = math.floor(math.log(M,2))+1\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*m for _ in range(n)]\n for i in range(n):\n for j in range(m):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(m):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*m\n i = 0\n j = 0\n t = 0\n while i<n:\n # t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1\n else:\n if t<k:\n for l in range(m):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1 \n return res\n ","runtime":"3053"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ORs = set()\n max_bits = max(int(log(n, 2)) + 1 if n > 0 else 1 for n in nums)\n bits = defaultdict(list)\n last_index = {}\n \n for j, n in enumerate(nums):\n OR = 0\n if n == 0:\n ORs.add(0)\n for b in range(max_bits):\n if (n >> b) & 1:\n if b in last_index:\n i = last_index[b]\n bits[i].remove(b)\n if not bits[i]:\n del bits[i]\n bits[j].append(b)\n last_index[b] = j\n for i in reversed(sorted(bits)):\n for b in bits[i]:\n OR |= 1 << b\n ORs.add(OR)\n\n OR = min(ORs, key=lambda x: abs(x - k))\n \n return abs(OR - k)","runtime":"3125"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n M = max(nums)\n m = math.floor(math.log(M,2))+1\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*m for _ in range(n)]\n for i in range(n):\n for j in range(m):\n if nums[i]&1<<j:\n dp[i][j] += 1\n r = [0]*m\n i = 0\n j = 0\n t = 0\n while i<n:\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1\n else:\n if t<k:\n for l in range(m):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1 \n return res\n ","runtime":"3198"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n return TreeNode(start, end, nums[start], None, None)\n\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val = left.val | right.val\n return TreeNode(start, end, val, left, right)\n self.root = build(nums, 0, len(nums)-1)\n\n def range_or(self, start, end):\n def query(node, start, end):\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return query(node.right, start, end)\n elif mid >= end:\n return query(node.left, start, end)\n else:\n return query(node.left, start, mid) | query(node.right, mid+1, end)\n\n return query(self.root, start, end)\n\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n tree = SegmentTree(nums)\n N = len(nums)\n res = float(inf)\n left, right = 0, 0\n while right < N:\n while right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur > k:\n break\n\n right += 1\n\n left += 1\n while left <= right and right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur < k:\n break\n\n left += 1\n\n right = max(right, left)\n\n return res\n","runtime":"3271"},{"code":"class Solution:\n \n \n def __init__(self):\n self.table = []\n self.n = 0\n \n def buildSparseTable(self, arr): \n for i in range(self.n): \n self.table[i][0] = arr[i] \n j = 1\n while (1 << j) <= self.n: \n i = 0\n while i <= self.n - (1 << j): \n self.table[i][j] = (self.table[i][j - 1] | self.table[i + (1 << (j - 1))][j - 1]) \n i += 1\n j += 1\n \n def query1(self, i, j): \n import math\n k = int(math.log2(j - i + 1)) \n return (self.table[i][k] | self.table[j - (1 << k) + 1][k]) \n \n def minimumDifference(self, nums, k) -> int:\n import math\n target = k\n self.n = len(nums)\n k = int(math.log2(self.n)) + 1\n self.table = [[0]*k for i in range(self.n)]\n self.buildSparseTable(nums)\n vals = [2**61]*self.n\n for m in range(self.n):\n i, j = m, self.n - 1\n while i <= j:\n a = self.query1(m, i)\n b = self.query1(m, j)\n if a - target >= 0 and b - target >= 0:\n if abs(target - a) < abs(target - vals[m]):\n vals[m] = a\n break\n elif a - target <= 0 and b - target <= 0:\n if abs(target - b) < abs(target - vals[m]):\n vals[m] = b\n break\n k = (i+j)>>1\n f = self.query1(m, k)\n vals[m] = f\n if f - target <= 0:\n i = k + 1\n else:\n j = k - 1\n return min([abs(x - target) for x in vals]) \n ","runtime":"3343"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n while i<n:\n t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n # print(t,res)\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n # if i<j: \n # res = min(res, abs(k-getInt(r)))\n \n return res\n ","runtime":"3416"},{"code":"import math\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n #Count how many ones at each bit location\n bits_array = [0]*32\n res = math.inf\n left,right = 0,0\n def product():\n result = 0\n for (i,count) in enumerate(bits_array):\n result += pow(2,i) if count > 0 else 0\n return result\n def orr(x):\n i = 0\n while x > 0:\n if x & 1 == 1:\n bits_array[i] += 1\n x = x >> 1\n i += 1\n def invorr(x):\n i = 0\n while x > 0:\n if x & 1 == 1:\n bits_array[i] -= 1\n x = x >> 1\n i += 1\n while right <= len(nums):\n while right < len(nums) and (nums[right] | product()) < k:\n orr(nums[right])\n right += 1\n lower = product() if left != right else math.inf\n if right < len(nums):\n orr(nums[right])\n while left <= right and product() >= k:\n invorr(nums[left])\n left += 1\n higher = nums[left-1] | product() if right < len(nums) else math.inf\n res = min(res,abs(k - lower),abs(higher - k))\n right += 1\n return res\n ","runtime":"3489"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n while i<n:\n t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n # print(t,res)\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n if i<j: \n res = min(res, abs(k-getInt(r)))\n \n return res\n ","runtime":"3561"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n left, right = 0, (1 << 32) - 1\n n = len(nums)\n\n orr = 0\n for num in nums:\n orr |= num\n\n def checkSmaller():\n res = 0\n minResult = float('inf')\n right = 0\n\n # store for each column a counter\n cnt = Counter()\n\n for i in range(n):\n while right < n and res < k:\n res = res | nums[right]\n for b in range(32):\n if (1 << b) & nums[right]:\n cnt[b] += 1\n minResult = min(minResult, abs(k - res))\n right += 1\n \n # remove the beginning of the window\n for b in range(32):\n if (1 << b) & nums[i]:\n cnt[b] -= 1\n if cnt[b] == 0:\n res = res ^ (1 << b)\n if right - (i+1) > 0:\n minResult = min(minResult, abs(k - res))\n return minResult\n return checkSmaller()\n","runtime":"3634"},{"code":"class RangeORQuery:\n def __init__(self, nums):\n self.n = len(nums)\n self.log = [0] * (self.n + 1)\n self.precompute_logs()\n self.build_sparse_table(nums)\n\n def precompute_logs(self):\n for i in range(2, self.n + 1):\n self.log[i] = self.log[i // 2] + 1\n\n def build_sparse_table(self, nums):\n self.K = self.log[self.n] + 1\n self.st = [[0] * self.K for _ in range(self.n)]\n for i in range(self.n):\n self.st[i][0] = nums[i]\n j = 1\n while (1 << j) <= self.n:\n i = 0\n while (i + (1 << j) - 1) < self.n:\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\n i += 1\n j += 1\n\n def range_or(self, L, R):\n j = self.log[R - L + 1]\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n roq = RangeORQuery(nums)\n N = len(nums)\n res = float(inf)\n for i in range(len(nums)):\n left, right = i, N-1\n while left < right:\n mid = left + (right - left) // 2\n if roq.range_or(i, mid) < k:\n left = mid + 1\n else:\n right = mid\n cur = roq.range_or(i, left)\n if cur == k:\n return 0\n if cur > k:\n res = min(res, cur - k)\n if left - 1 >= i:\n res = min(res, k - roq.range_or(i, left-1))\n else:\n res = min(res, k - cur)\n if left + 1 < N:\n res = min(res, roq.range_or(i, left+1) - k)\n return res\n","runtime":"3706"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n t = 0\n while i<n:\n # t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1 \n return res\n ","runtime":"3779"},{"code":"class RangeORQuery:\n def __init__(self, nums):\n self.n = len(nums)\n self.log = [0] * (self.n + 1)\n self.precompute_logs()\n self.build_sparse_table(nums)\n\n def precompute_logs(self):\n for i in range(2, self.n + 1):\n self.log[i] = self.log[i // 2] + 1\n\n def build_sparse_table(self, nums):\n self.K = self.log[self.n] + 1\n self.st = [[0] * self.K for _ in range(self.n)]\n for i in range(self.n):\n self.st[i][0] = nums[i]\n j = 1\n while (1 << j) <= self.n:\n i = 0\n while (i + (1 << j) - 1) < self.n:\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\n i += 1\n j += 1\n\n def range_or(self, L, R):\n j = self.log[R - L + 1]\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n roq = RangeORQuery(nums)\n N = len(nums)\n res = float(inf)\n for i in range(len(nums)):\n left, right = i, N-1\n while left < right:\n mid = left + (right - left) // 2\n if roq.range_or(i, mid) < k:\n left = mid + 1\n else:\n right = mid\n cur = roq.range_or(i, left)\n if cur == k:\n return 0\n if cur > k:\n res = min(res, cur - k)\n if left - 1 >= i:\n res = min(res, k - roq.range_or(i, left-1))\n else:\n res = min(res, k - cur)\n if left + 1 < N:\n res = min(res, roq.range_or(i, left+1) - k)\n return res ","runtime":"3852"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n t = 0\n while i<n:\n # t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n q = 2**33-1-q\n t &= q\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n q = 2**33-1-q\n t &= q\n i += 1 \n return res\n ","runtime":"3924"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n def binToInt(bitset):\n setbit = 1\n res = 0\n for i in range(32):\n if bitset[i]:\n res |= setbit\n setbit <<= 1\n return res\n\n def update(num, bitset, diff):\n tmp = num\n i = 0\n while tmp:\n bitset[i] += diff * (tmp % 2)\n tmp >>= 1\n i += 1\n return bitset\n\n N = len(nums)\n right = -1\n curr = 0\n bitset = [0] * 32\n res = float('inf')\n for left in range(N):\n while right < (N - 1) and curr <= k:\n right += 1\n curr |= nums[right]\n update(nums[right], bitset, 1)\n\n bestFromLeft = abs(k - curr)\n if right > left:\n bestFromLeft = min(bestFromLeft, abs(k - binToInt(update(nums[right], bitset.copy(), -1))))\n res = min(res, bestFromLeft)\n\n curr = binToInt(update(nums[left], bitset, -1))\n return res\n ","runtime":"3997"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n while i<n:\n t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n print(t,res)\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n if i<j: \n res = min(res, abs(k-getInt(r)))\n \n return res\n ","runtime":"4070"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n # do I find a subarray with the result mid-k or mid+k?\n left, right = 0, (1 << 32) - 1\n n = len(nums)\n\n orr = 0\n for num in nums:\n orr |= num\n\n def checkSmaller():\n res = 0\n minResult = float('inf')\n right = 0\n\n # store for each column a counter\n cnt = Counter()\n\n for i in range(n):\n while right < n and res < k:\n res = res | nums[right]\n for b in range(32):\n if (1 << b) & nums[right]:\n cnt[b] += 1\n minResult = min(minResult, abs(k - res))\n right += 1\n \n # remove the beginning of the window\n for b in range(32):\n if (1 << b) & nums[i]:\n cnt[b] -= 1\n if cnt[b] == 0:\n res = res ^ (1 << b)\n if right - (i+1) > 0:\n minResult = min(minResult, abs(k - res))\n return minResult\n return checkSmaller()\n","runtime":"4142"},{"code":"class Solution:\n def getOr(self, dp, l, r):\n \"\"\"\n The getAnd method calculates the bitwise AND of the subarray\n defined by indices l and r using the precomputed counts of set\n bits in the dp array.\n \"\"\"\n\n n = len(dp)\n ans = 0\n for i in range(self.MAX_BITS):\n if dp[r + 1][i] - dp[l][i] != (r - l + 1):\n ans |= (1 << i)\n return ans\n\n def minimumDifference(self, nums: List[int], k: int) -> int:\n self.MAX_BITS = 32\n n = len(nums)\n dp = [[0] * self.MAX_BITS for _ in range(n + 1)]\n\n \"\"\"\n Storing the cumulative sum of set bits.\n So suppose, [2, 3, 4]\n dp = [[0, 0, 0]\n [0, 1, 0] ==> 2\n [1, 2, 0] ==> 3\n [1, 2, 1]] ==> 4\n \n This will be useful in computing the AND value\n between any two numbers [left, right]\n \"\"\"\n for i in range(n):\n for j in range(self.MAX_BITS):\n dp[i + 1][j] = dp[i][j] + ((1 << j) & nums[i] == 0)\n\n start, end = 0, 0\n ans = float('inf')\n\n \"\"\"\n Idea behind sliding window:\n --------------------------------------------------------------------\n Keep sliding the window until the and value of window goes below k.\n\n When it goes below k there is no point in further increasing the\n size of the window as Bitwise AND always reduces the value and\n the absolute difference will keep increasing.\n\n At this point start reducing the size of the window till the\n value of the window goes above k.\n \"\"\"\n while end < n:\n currentOr = self.getOr(dp, start, end)\n ans = min(ans, abs(k - currentOr))\n while start < end and currentOr > k:\n start += 1\n currentOr = self.getOr(dp, start, end)\n ans = min(ans, abs(k - currentOr))\n end += 1\n return ans\n\n\"\"\"\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n min_diff = float('inf')\n n = len(nums)\n\n # Precompute bitwise AND values for each starting index i\n bitwise_and = [[0] * n for _ in range(n)]\n for i in range(n):\n bitwise_and[i][i] = nums[i]\n for j in range(i + 1, n):\n bitwise_and[i][j] = bitwise_and[i][j - 1] & nums[j]\n\n # Iterate over all possible subarrays\n for i in range(n):\n for j in range(i, n):\n # Use precomputed bitwise AND value for subarray i to j\n current_and = bitwise_and[i][j]\n\n # Update the minimum absolute difference\n min_diff = min(min_diff, abs(k - current_and))\n\n return min_diff\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n min_diff = float('inf')\n prefix = nums[0]\n left = 0\n\n for right in range(len(nums)):\n prefix &= nums[right]\n\n # Shrink the window from the left side while prefix exceeds k\n while prefix > k and left <= right:\n prefix &= ~nums[left]\n left += 1\n\n min_diff = min(min_diff, abs(k - prefix))\n\n if min_diff == 0:\n break\n\n return min_diff\n\"\"\"","runtime":"4215"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n=len(nums)\n b=bin(n)[2:]\n log=len(b)\n jump=[[i+1 for j in range(log)] for i in range(n)]\n dp=[[nums[i] for j in range(log)] for i in range(n)]\n res=float('inf')\n for j in range(1,log):\n for i in range(n-(1<<j)+1):\n jump[i][j]=jump[jump[i][j-1]][j-1]\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\n lo=0\n for hi in range(n):\n while lo<=hi:\n l=hi-lo+1\n cur=lo\n val=0\n for i in range(log):\n if l&(1<<i):\n val|=dp[cur][i]\n cur=jump[cur][i]\n if val<=k:\n res=min(res,k-val)\n break\n res=min(res,val-k)\n lo+=1\n return res\n","runtime":"4288"},{"code":"class SegmentTree:\n def __init__(self, arr: List[int]):\n self.n = len(arr)\n self.tree = [0] * (4 * self.n)\n self.build(arr, 0, 0, self.n - 1)\n\n def build(self, arr: List[int], node: int, start: int, end: int):\n if start == end:\n self.tree[node] = arr[start]\n else:\n mid = (start + end) // 2\n self.build(arr, 2 * node + 1, start, mid)\n self.build(arr, 2 * node + 2, mid + 1, end)\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\n\n def query(self, node: int, start: int, end: int, left: int, right: int) -> int:\n if left > end or right < start:\n return 0\n if left <= start and end <= right:\n return self.tree[node]\n mid = (start + end) // 2\n left_or = self.query(2 * node + 1, start, mid, left, right)\n right_or = self.query(2 * node + 2, mid + 1, end, left, right)\n return left_or | right_or\n\n def range_query(self, left: int, right: int) -> int:\n return self.query(0, 0, self.n - 1, left, right)\n\n def update(self, node: int, start: int, end: int, index: int, value: int):\n if start == end:\n self.tree[node] = value\n else:\n mid = (start + end) // 2\n if index <= mid:\n self.update(2 * node + 1, start, mid, index, value)\n else:\n self.update(2 * node + 2, mid + 1, end, index, value)\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\n\n def point_update(self, index: int, value: int):\n self.update(0, 0, self.n - 1, index, value)\n\nclass Solution:\n # Time: O()\n # Space: O(), where n = len(nums)\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n segment_tree = SegmentTree(nums)\n\n res = float('inf')\n\n # Sliding window approach\n l = 0\n for r in range(n):\n while r >= l:\n curr_or = segment_tree.range_query(l, r)\n res = min(res, abs(curr_or-k))\n if curr_or > k:\n break\n l += 1\n l = 0\n for r in range(n):\n while r >= l:\n curr_or = segment_tree.range_query(l, r)\n res = min(res, abs(curr_or-k))\n if curr_or <= k:\n break\n l += 1\n return res\n","runtime":"4360"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n=len(nums)\n b=bin(n)[2:]\n log=len(b)\n jump=[[i+1 for j in range(log)] for i in range(n)]\n dp=[[nums[i] for j in range(log)] for i in range(n)]\n res=float('inf')\n for j in range(1,log):\n for i in range(n-(1<<j)+1):\n jump[i][j]=jump[jump[i][j-1]][j-1]\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\n lo=0\n for hi in range(n):\n while lo<=hi:\n l=hi-lo+1\n cur=lo\n val=0\n for i in range(log):\n if l&(1<<i):\n val|=dp[cur][i]\n cur=jump[cur][i]\n if val<=k:\n res=min(res,k-val)\n break\n res=min(res,val-k)\n lo+=1\n return res\n\n","runtime":"4433"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n def binary_ones_positions(n):\n positions = set() # 创建一个空的集合来存储位置信息\n position = 0 # 初始化位的位置，从0开始\n\n # 当 n 不为0时，逐位检查\n while n > 0:\n if n & 1: # 检查当前位是否为1\n positions.add(position)\n n >>= 1 # 右移一位\n position += 1 # 位置加1\n\n return positions\n \n def getnum(cnt):\n res=0\n for i, c in enumerate(cnt):\n if c>0:\n res |= (1<<i)\n return res\n\n \n cnt = [0] * 32\n start = 0\n res = float(\"inf\")\n for i, num in enumerate(nums):\n pos = binary_ones_positions(num)\n for p in pos:\n cnt[p]+=1\n res = min(res, abs(getnum(cnt)-k))\n \n while getnum(cnt)>k and start<i:\n pos = binary_ones_positions(nums[start])\n for p in pos:\n cnt[p]-=1\n res = min(res, abs(getnum(cnt)-k))\n start+=1\n \n return res\n \n \n \n ","runtime":"4505"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n = len(nums) \n bitCount = [0] * 32 # frequency of each bit being set to 1\n \n def getRes():\n res = 0\n for i in range(32):\n if bitCount[i] > 0: \n res |= 1 << i\n return res\n \n def addNum(left, right, num): \n for i in range(32):\n if (num >> i) & 1:\n bitCount[i] += 1 \n return getRes()\n \n def removeNum(num):\n for i in range(32):\n if (num >> i) & 1: \n bitCount[i] -= 1 \n \n res = float('inf')\n right = 0\n \n for left in range(n): \n while right < n: \n if addNum(left, right, nums[right]) < k: \n right += 1\n else: \n break\n\n\n # get diff when bit result >= k \n if right < n: \n res = min(res, getRes() - k)\n removeNum(nums[right]) # remove nums[right]\n \n # get diff when bit result < k\n if right > left: \n res = min(res, k - getRes()) # excluding nums[right]\n \n removeNum(nums[left])\n # print(bitCount)\n \n return res\n\n# class Solution:\n# def minimumDifference(self, nums: List[int], k: int) -> int:\n# n = len(nums)\n# current_or = 0\n# res = float('inf')\n# right = 0\n\n# def addNum(num):\n# nonlocal current_or\n# current_or |= num\n\n# def removeNum(left, right):\n# nonlocal current_or\n# # Recalculate the OR for the current window\n# current_or = 0\n# for i in range(left, right + 1):\n# current_or |= nums[i]\n\n# for left in range(n):\n# while right < n:\n# addNum(nums[right])\n# if current_or > k:\n# right += 1\n# else:\n# # If the current OR <= k, we stop extending the window\n# break\n \n# if right < n:\n# res = min(res, abs(k - current_or))\n \n# if right > left:\n# res = min(res, abs(current_or - k))\n \n# removeNum(left + 1, right)\n# if right == left:\n# right += 1\n\n# return res","runtime":"4578"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = abs(nums[0] - k)\\n for n in nums[1:]:\\n res = min(res, abs(n-k))\\n if res == 0: return 0\\n \\n temp = []\\n for i in range(len(nums)):\\n if nums[i] < k:\\n if len(temp) == 0 or temp[-1] != nums[i]:\\n temp.append(nums[i])\\n elif len(temp) != 0:\\n for j, n in enumerate(temp):\\n local_res = n\\n index = j + 1\\n while index < len(temp):\\n local_res |= temp[index]\\n if abs(local_res - k) < res:\\n res = abs(local_res - k)\\n if res == 0: return 0\\n elif local_res > k:\\n break\\n index += 1\\n if local_res < k:\\n break\\n temp = []\\n for j, n in enumerate(temp):\\n local_res = n\\n index = j + 1\\n while index < len(temp):\\n local_res |= temp[index]\\n if abs(local_res - k) < res:\\n res = abs(local_res - k)\\n if res == 0: return 0\\n elif local_res > k:\\n break\\n index += 1\\n if local_res < k:\\n break\\n return res\\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = abs(nums[0] - k)\\n for n in nums[1:]:\\n res = min(res, abs(n-k))\\n if res == 0: return 0\\n \\n temp = []\\n for i in range(len(nums)):\\n if nums[i] < k:\\n if len(temp) == 0 or temp[-1] != nums[i]:\\n temp.append(nums[i])\\n elif len(temp) != 0:\\n for j, n in enumerate(temp):\\n local_res = n\\n index = j + 1\\n while index < len(temp):\\n local_res |= temp[index]\\n if abs(local_res - k) < res:\\n res = abs(local_res - k)\\n elif local_res > k:\\n break\\n index += 1\\n if local_res < k:\\n break\\n temp = []\\n for j, n in enumerate(temp):\\n local_res = n\\n index = j + 1\\n while index < len(temp):\\n local_res |= temp[index]\\n if abs(local_res - k) < res:\\n res = abs(local_res - k)\\n elif local_res > k:\\n break\\n index += 1\\n if local_res < k:\\n break\\n return res\\n \\n \\n \\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"365\"\n },\n {\n \"code\": \"class Solution:\\n def bitwise_or(self, nums: List[int]) -> int:\\n answer = 0\\n for num in nums:\\n answer = answer | num\\n \\n return answer\\n\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n best_difference = float(\\\"inf\\\")\\n left_index = 0\\n right_index = 0\\n use_prev = False\\n while True:\\n if use_prev:\\n current = current | nums[right_index]\\n else:\\n current = self.bitwise_or(nums[left_index:right_index+1])\\n if k == current:\\n return 0\\n elif k > current:\\n best_difference = min(best_difference, k-current)\\n # too small - increase right.\\n right_index += 1\\n if right_index >= len(nums):\\n return best_difference\\n use_prev = True\\n else:\\n best_difference = min(best_difference, current-k)\\n # too big - increase left.\\n left_index += 1\\n # make sure we don't go past right.\\n if left_index > right_index:\\n right_index = left_index\\n if left_index >= len(nums):\\n return best_difference\\n use_prev = False\\n\",\n \"runtime\": \"438\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n#kartikdevsharmaa\",\n \"runtime\": \"510\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n best = 10**9\\n p = []\\n for v in nums:\\n q = [v]\\n best = min(best,abs(k-q[-1]))\\n for x in p:\\n if q[-1]>k: break\\n x |= q[-1]\\n if x != q[-1]: \\n q.append(x)\\n best = min(best,abs(k-x))\\n p = q\\n #\\n return best\\n\\n\\n\\n\\n \",\n \"runtime\": \"583\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n memo = set()\\n ans = float(\\\"inf\\\")\\n for num in nums:\\n memo.add(num)\\n ans = min(ans, abs(k - num))\\n tmp = set()\\n for m in memo:\\n cur = m | num\\n if cur < k:\\n tmp.add(cur)\\n ans = min(ans, abs(k - cur))\\n memo = tmp\\n return ans\\n\",\n \"runtime\": \"656\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n d = set()\\n ans = float(\\\"inf\\\")\\n for x in nums:\\n d.add(x)\\n ans = min(ans, abs(k - x))\\n q = set()\\n for y in d:\\n v = y | x\\n if v < k:\\n q.add(v)\\n ans = min(ans, abs(k - v))\\n d = q\\n return ans\",\n \"runtime\": \"728\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n d = set()\\n ans = float(\\\"inf\\\")\\n for x in nums:\\n d.add(x)\\n ans = min(ans, abs(k - x))\\n q = set()\\n for y in d:\\n v = y | x\\n if v < k:\\n q.add(v)\\n ans = min(ans, abs(k - v))\\n d = q\\n return ans\",\n \"runtime\": \"801\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = inf\\n for i, x in enumerate(nums):\\n res = min(res, abs(x - k))\\n j = i - 1\\n while j >= 0 and nums[j] | x != nums[j]:\\n nums[j] |= x\\n res = min(res, abs(nums[j] - k))\\n j -= 1\\n\\n return res\",\n \"runtime\": \"874\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = inf\\n for i, x in enumerate(nums):\\n ans = min(ans, abs(x - k))\\n j = i - 1\\n while j >= 0 and nums[j] | x != nums[j]:\\n nums[j] |= x\\n ans = min(ans, abs(nums[j] - k))\\n j -= 1\\n return ans\",\n \"runtime\": \"946\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums:List[int],k:int)-> int:\\n ans = inf\\n for i, x in enumerate(nums):\\n ans =min(ans, abs(x-k))\\n j=i-1\\n while j>=0 and nums[j] | x != nums[j]:\\n nums[j] |= x\\n ans =min(ans,abs(nums[j]-k))\\n j-= 1\\n return ans\\n\",\n \"runtime\": \"1019\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = inf\\n for i,x in enumerate(nums):\\n ans = min(ans,abs(x-k))\\n j=i-1\\n while j>= 0 and nums[j]|x!= nums[j]:\\n nums[j] |= x\\n ans =min(ans,abs(nums[j]-k))\\n j-=1\\n return ans\",\n \"runtime\": \"1091\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = inf\\n for i, x in enumerate(nums):\\n ans = min(ans, abs(x-k))\\n j = i-1\\n while j >= 0 and nums[j] | x != nums[j]:\\n nums[j] |= x\\n ans = min(ans, abs(nums[j] - k))\\n j -= 1\\n return ans\\n \\n \\n \",\n \"runtime\": \"1091\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = inf\\n for i, x in enumerate(nums):\\n ans = min(ans, abs(x - k))\\n j = i - 1\\n while j >= 0 and nums[j] | x != nums[j]:\\n nums[j] |= x\\n ans = min(ans, abs(nums[j] - k))\\n j -= 1\\n return ans\\n\",\n \"runtime\": \"1164\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n dp = set()\\n n = len(nums)\\n\\n # result: contains all subarray distinct OR values\\n result = set()\\n\\n for i in range(n):\\n new_dp = set()\\n\\n # single nums[i] can be a subarray\\n new_dp.add(nums[i])\\n\\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n # update all possible subarray result\\n result |= new_dp\\n dp = new_dp\\n \\n return min(abs(val - k) for val in result)\",\n \"runtime\": \"1164\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, arr: List[int]):\\n self.size = len(arr) + 1\\n self.st = [0] * 2 * self.size\\n\\n for i, val in enumerate(arr):\\n self.st[self.size + i] = val\\n\\n for i in range(self.size - 1, 0, -1):\\n self.st[i] = self.st[2 * i] | self.st[2 * i + 1]\\n\\n def query(self, left: int, right: int):\\n left += self.size\\n right += self.size + 1\\n res = 0\\n\\n while left < right:\\n if left & 1:\\n res |= self.st[left]\\n left += 1\\n\\n if right & 1:\\n right -= 1\\n res |= self.st[right]\\n\\n left //= 2\\n right //= 2\\n\\n return res\\n\\n\\nclass Solution:\\n # def minimumDifference(self, nums: List[int], k: int) -> int:\\n # n = len(nums)\\n # st = SegmentTree(nums)\\n # ans = inf\\n\\n # for i in range(n):\\n # ans = min(ans, abs(k - nums[i]))\\n\\n # left = 0\\n # right = i - 1\\n\\n # while left + 1 < right:\\n # mid = (left + right) // 2\\n\\n # or_sum = st.query(mid, i)\\n\\n # if or_sum <= k:\\n # right = mid\\n # else:\\n # left = mid\\n\\n # ans = min(ans, abs(k - st.query(left, i)))\\n # if right >= 0:\\n # ans = min(ans, abs(k - st.query(right, i)))\\n\\n # return ans\\n\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n ans = abs(k - nums[0])\\n\\n s = {nums[0]}\\n\\n for i in range(1, n):\\n ans = min(ans, abs(k - nums[i]))\\n\\n new_s = {nums[i]}\\n for t in s:\\n temp = t | nums[i]\\n ans = min(ans, abs(k - temp))\\n new_s.add(temp)\\n\\n s = new_s\\n\\n return ans\\n\",\n \"runtime\": \"1237\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = float('inf')\\n curr_or_set = set()\\n for num in nums:\\n next_or_set = set()\\n next_or_set.add(num)\\n ans = min(ans, abs(k - num))\\n for prev_or in curr_or_set:\\n new_or = prev_or | num # Corrected to use bitwise OR\\n next_or_set.add(new_or)\\n ans = min(ans, abs(k - new_or))\\n curr_or_set = next_or_set\\n return ans\\n\",\n \"runtime\": \"1237\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n l = len(nums)\\n final = set()\\n final.add(0)\\n final.add(nums[0])\\n mn = abs(k - nums[0])\\n for i in range(1,l):\\n lst = set()\\n lst.add(0)\\n for nm in final:\\n cr = nm | nums[i]\\n lst.add(cr)\\n mn = min(mn,abs(k-cr))\\n if(mn == 0):\\n return 0\\n final = lst\\n return mn\\n \",\n \"runtime\": \"1309\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n l = len(nums)\\n final = set()\\n final.add(0)\\n final.add(nums[0])\\n mn = abs(k - nums[0])\\n for i in range(1,l):\\n lst = set()\\n lst.add(0)\\n for nm in final:\\n cr = nm | nums[i]\\n lst.add(cr)\\n mn = min(mn,abs(k-cr))\\n if(mn == 0):\\n return 0\\n final = lst\\n return mn\",\n \"runtime\": \"1309\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = 10**10\\n st = set()\\n for num in nums:\\n st = {num} | {num | i for i in st}\\n res = min(res, min(abs(i - k) for i in st))\\n return res\\n\",\n \"runtime\": \"1382\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ors = set()\\n ans = inf\\n \\n for num in nums:\\n # at most length 30, only unset bits can become set on adding an element, and set bits never become unset again.\\n ors = set([x | num for x in ors] + [num])\\n for x in ors: \\n ans = min(ans, abs(x - k))\\n \\n return ans \",\n \"runtime\": \"1382\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\",\n \"runtime\": \"1455\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"runtime\": \"1527\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"runtime\": \"1600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"runtime\": \"1673\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\",\n \"runtime\": \"1745\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"runtime\": \"1745\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n cur_or = [nums[0]]\\n sum_or = nums[0]\\n for num in nums[1:]:\\n if num!=cur_or[-1]:\\n cur_or.append(num)\\n sum_or |= num\\n diff = min([abs(or_-k) for or_ in cur_or])\\n if min(cur_or)>k or min(cur_or)==sum_or:\\n return diff\\n\\n \\n for i in range(1, len(cur_or)):\\n for l in range(len(cur_or)-1):\\n cur_or[l] |= cur_or[l+1]\\n cur_or = cur_or[:-1]\\n diff_new = min([abs(or_-k) for or_ in cur_or])\\n diff = min(diff_new,diff)\\n # print(i, cur_or, diff, sum_or)\\n if min(cur_or)>k or min(cur_or)==sum_or:\\n return diff\\n\\n return diff\\n \\n\\n\\n\",\n \"runtime\": \"1818\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n m = max(nums).bit_length()\\n cnt = [0] * m\\n s = i = 0\\n ans = inf\\n for j, x in enumerate(nums):\\n s |= x\\n ans = min(ans, abs(s - k))\\n for h in range(m):\\n if x >> h & 1:\\n cnt[h] += 1\\n while i < j and s > k:\\n y = nums[i]\\n for h in range(m):\\n if y >> h & 1:\\n cnt[h] -= 1\\n if cnt[h] == 0:\\n s ^= 1 << h\\n i += 1\\n ans = min(ans, abs(s - k))\\n return ans\",\n \"runtime\": \"1818\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n m = max(nums).bit_length()\\n cnt = [0] * m\\n s = i = 0\\n ans = inf\\n for j, x in enumerate(nums):\\n s |= x\\n ans = min(ans, abs(s - k))\\n for h in range(m):\\n if x >> h & 1:\\n cnt[h] += 1\\n while i < j and s > k:\\n y = nums[i]\\n for h in range(m):\\n if y >> h & 1:\\n cnt[h] -= 1\\n if cnt[h] == 0:\\n s ^= 1 << h\\n i += 1\\n ans = min(ans, abs(s - k))\\n return ans\",\n \"runtime\": \"1890\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n zeros = 0 in nums\\n curr = 0\\n M = max(nums)\\n e = 1\\n i = 0\\n count = {}\\n best = inf\\n while e <= M:\\n count[e] = 0\\n e *= 2\\n for n in nums:\\n curr |= n\\n for e in count:\\n if n&e: count[e] += 1\\n best = min(abs(k-curr), best)\\n while curr > k and i < len(nums):\\n for e in count:\\n if e&nums[i]:\\n count[e] -= 1\\n if not count[e]: curr -= e\\n if curr or zeros:\\n best = min(abs(k-curr), best)\\n i += 1\\n return best\\n\",\n \"runtime\": \"1963\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n zeros = 0 in nums\\n curr = 0\\n M = max(nums)\\n e = 1\\n i = 0\\n count = {}\\n best = abs(k-nums[0])\\n while e <= M:\\n count[e] = 0\\n e *= 2\\n for n in nums:\\n curr |= n\\n for e in count:\\n if n&e: count[e] += 1\\n best = min(abs(k-curr), best)\\n while curr > k and i < len(nums):\\n for e in count:\\n if e&nums[i]:\\n count[e] -= 1\\n if not count[e]: curr -= e\\n if curr or zeros:\\n best = min(abs(k-curr), best)\\n i += 1\\n return best\\n\",\n \"runtime\": \"2036\"\n },\n {\n \"code\": \"from functools import cache\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n # Recursive funtion with the current index and past bitwise AND value \\n @cache\\n def solve(idx, curr_and):\\n # If index reached at the end simply pass inf\\n if idx >= n:\\n return inf\\n \\n # No need to check the other case since if we include curr_and it will always give us 0 value\\n if curr_and | nums[idx] == 0:\\n return min(abs(0-k), abs(nums[idx]-k), solve(idx+1, nums[idx]))\\n \\n return min(abs((curr_and | nums[idx]) - k), abs(nums[idx]-k), solve(idx+1, nums[idx]), solve(idx+1, curr_and|nums[idx]))\\n \\n return solve(0, nums[0])\",\n \"runtime\": \"2254\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n @cache\\n def get_minimum_difference(index, or_value):\\n if index >= len(nums):\\n return inf\\n\\n return min(\\n abs(k - nums[index]),\\n abs(k - (nums[index] | or_value)),\\n get_minimum_difference(index + 1, nums[index]),\\n get_minimum_difference(index + 1, nums[index] | or_value)\\n )\\n\\n return get_minimum_difference(0, 0)\",\n \"runtime\": \"2326\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n maxbit = 0\\n bits = [[] for i in range(len(nums))]\\n for i in range(len(nums)):\\n num = nums[i]\\n bit = 0\\n while num:\\n if num & 1 > 0:\\n bits[i].append(bit)\\n bit += 1\\n num >>= 1\\n maxbit = max(bit, maxbit)\\n \\n left = 0\\n right = 0\\n minDiff = abs(nums[0]-k)\\n cur_num = 0\\n cur_bits = [set() for i in range(maxbit)]\\n while right < len(nums):\\n cur_num |= nums[right]\\n for bit in bits[right]:\\n cur_bits[bit].add(right)\\n\\n minDiff = min(minDiff, abs(k-cur_num))\\n while cur_num > k and left <= right:\\n for bit in bits[left]:\\n cur_bits[bit].remove(left)\\n if len(cur_bits[bit]) == 0:\\n cur_num ^= (1<<bit)\\n\\n if left < right:\\n minDiff = min(minDiff, abs(k-cur_num))\\n left += 1\\n \\n right += 1\\n return minDiff\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2399\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n maxbit = 0\\n bits = [set() for i in range(len(nums))]\\n for i in range(len(nums)):\\n num = nums[i]\\n bit = 0\\n while num:\\n if num & 1 > 0:\\n bits[i].add(bit)\\n bit += 1\\n num >>= 1\\n maxbit = max(bit, maxbit)\\n \\n left = 0\\n right = 0\\n minDiff = abs(nums[0]-k)\\n cur_num = 0\\n cur_bits = [[] for i in range(maxbit)]\\n while right < len(nums):\\n cur_num |= nums[right]\\n for bit in bits[right]:\\n cur_bits[bit].append(right)\\n\\n minDiff = min(minDiff, abs(k-cur_num))\\n while cur_num > k and left <= right:\\n for bit in bits[left]:\\n cur_bits[bit].pop(0)\\n if len(cur_bits[bit]) == 0:\\n cur_num ^= (1<<bit)\\n\\n if left < right:\\n minDiff = min(minDiff, abs(k-cur_num))\\n left += 1\\n \\n right += 1\\n return minDiff\\n\\n\\n\\n\\n \\n \\n \",\n \"runtime\": \"2472\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n best_seen = 10**12\\n n = len(nums)\\n N_BITS = (10**9).bit_length() + 1\\n bit_counts = [0 for _ in range(N_BITS)]\\n powers = [pow(2,i) for i in range(N_BITS)]\\n curr_bit_or = 0\\n \\n def get_bit_indices(x: int) -> list[int]:\\n bits = bin(x)\\n ans = []\\n for i in reversed(range(2, len(bits))):\\n if bits[i] == \\\"1\\\":\\n ans.append(len(bits)-i-1)\\n return ans\\n \\n left_index_incl = 0\\n right_index_incl = 0\\n bits_first = get_bit_indices(nums[0])\\n for i in bits_first:\\n bit_counts[i] = 1\\n curr_bit_or += powers[i]\\n best_seen = min(best_seen, abs(k-curr_bit_or))\\n\\n \\n while right_index_incl < n:\\n if best_seen == 0:\\n return 0\\n if curr_bit_or <= k or left_index_incl >= right_index_incl:\\n right_index_incl += 1\\n if right_index_incl >= n:\\n break\\n bits_here = get_bit_indices(nums[right_index_incl])\\n for i in bits_here:\\n bit_counts[i] += 1\\n if bit_counts[i] == 1:\\n curr_bit_or += powers[i]\\n else:\\n\\n bits_here = get_bit_indices(nums[left_index_incl])\\n for i in bits_here:\\n bit_counts[i] -= 1\\n if bit_counts[i] == 0:\\n curr_bit_or -= powers[i]\\n \\n left_index_incl += 1\\n \\n best_seen = min(best_seen, abs(k-curr_bit_or))\\n \\n \\n \\n \\n \\n \\n return best_seen\",\n \"runtime\": \"2544\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n @cache\\n def solve(i: int, curr_or: int) -> int:\\n if i >= n:\\n return math.inf\\n\\n return min(\\n abs((curr_or | nums[i]) - k), \\n abs(nums[i] - k), \\n solve(i + 1, 0), \\n solve(i + 1, curr_or | nums[i]))\\n \\n \\n return solve(0, nums[0])\",\n \"runtime\": \"2617\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = float('inf')\\n l = 0\\n curr = 0\\n curr_freqs = [0] * 32\\n for r in range(len(nums)):\\n curr |= nums[r]\\n for i in range(32):\\n if (1 << i) & nums[r]: curr_freqs[i] += 1\\n \\n \\n res = min(res, abs(k - curr))\\n while l < r and k < curr:\\n for i in range(32):\\n if (1 << i) & nums[l]: \\n curr_freqs[i] -= 1\\n if curr_freqs[i] == 0:\\n curr ^= (1 << i)\\n l += 1\\n res = min(res, abs(k - curr))\\n \\n return res\",\n \"runtime\": \"2689\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n best_seen = 10**12\\n n = len(nums)\\n N_BITS = (10**9).bit_length() + 1\\n bit_counts = [0 for _ in range(N_BITS)]\\n powers = [pow(2,i) for i in range(N_BITS)]\\n curr_bit_or = 0\\n \\n def get_bit_indices(x: int) -> list[int]:\\n return [i for i,y in enumerate(powers) if x&y != 0]\\n bits = bin(x)\\n ans = []\\n for i in reversed(range(2, len(bits))):\\n if bits[i] == \\\"1\\\":\\n ans.append(len(bits)-i-1)\\n return ans\\n \\n left_index_incl = 0\\n right_index_incl = 0\\n bits_first = get_bit_indices(nums[0])\\n for i in bits_first:\\n bit_counts[i] = 1\\n curr_bit_or += powers[i]\\n best_seen = min(best_seen, abs(k-curr_bit_or))\\n\\n \\n while right_index_incl < n:\\n if best_seen == 0:\\n return 0\\n if curr_bit_or <= k or left_index_incl >= right_index_incl:\\n right_index_incl += 1\\n if right_index_incl >= n:\\n break\\n bits_here = get_bit_indices(nums[right_index_incl])\\n for i in bits_here:\\n bit_counts[i] += 1\\n if bit_counts[i] == 1:\\n curr_bit_or += powers[i]\\n else:\\n\\n bits_here = get_bit_indices(nums[left_index_incl])\\n for i in bits_here:\\n bit_counts[i] -= 1\\n if bit_counts[i] == 0:\\n curr_bit_or -= powers[i]\\n \\n left_index_incl += 1\\n \\n best_seen = min(best_seen, abs(k-curr_bit_or))\\n \\n \\n \\n \\n \\n \\n return best_seen\",\n \"runtime\": \"2762\"\n },\n {\n \"code\": \"def add(M,num):\\n j=0\\n while num!=0:\\n M[j]=M[j]+(num&1)\\n num=num>>1\\n j=j+1\\n\\ndef remove(M,num):\\n j=0\\n while num!=0:\\n M[j]=M[j]-(num&1)\\n num=num>>1\\n j=j+1\\n\\ndef get_num(M):\\n ans=0\\n for j in range (0,len(M)):\\n if M[j]>0:\\n ans=ans|(1<<j)\\n\\n return ans\\n\\nclass Solution:\\n def minimumDifference(self, L: List[int], k: int) -> int:\\n l=0\\n ans=2**31-1\\n M=[0]*32\\n for r in range (0,len(L)):\\n add(M,L[r])\\n count=get_num(M)\\n while l<=r and count>k:\\n ans=min(ans,abs(count-k))\\n remove(M,L[l])\\n count=get_num(M)\\n l=l+1\\n if count!=0:\\n ans=min(ans,abs(count-k))\\n return ans\\n \\n\\n \",\n \"runtime\": \"2835\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n bitCount = [0] * 30\\n curOr = 0\\n i = 0\\n res = inf\\n for j, x in enumerate(nums):\\n for b in range(30):\\n if (x >> b) & 1 == 1:\\n bitCount[b] += 1\\n curOr = 0\\n for b in range(30):\\n if bitCount[b] >= 1:\\n curOr |= (1 << b)\\n res = min(res, abs(curOr - k))\\n while curOr >= k:\\n x = nums[i]\\n for b in range(30):\\n if (x >> b) & 1 == 1:\\n bitCount[b] -= 1\\n i += 1\\n curOr = 0\\n for b in range(30):\\n if bitCount[b] >= 1:\\n curOr |= (1 << b)\\n \\n curOr = 0\\n for b in range(30):\\n if bitCount[b] >= 1:\\n curOr |= (1 << b)\\n if curOr != 0:\\n res = min(res, abs(curOr - k))\\n \\n return res\",\n \"runtime\": \"2907\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n return TreeNode(start, end, nums[start], None, None)\\n\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val = left.val | right.val\\n return TreeNode(start, end, val, left, right)\\n self.root = build(nums, 0, len(nums)-1)\\n\\n def range_or(self, start, end):\\n def query(node, start, end):\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return query(node.right, start, end)\\n elif mid >= end:\\n return query(node.left, start, end)\\n else:\\n return query(node.left, start, mid) | query(node.right, mid+1, end)\\n\\n return query(self.root, start, end)\\n\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n tree = SegmentTree(nums)\\n N = len(nums)\\n res = float(inf)\\n left, right = 0, 0\\n while right < N:\\n while right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur > k:\\n break\\n right += 1\\n\\n left += 1\\n while left <= right and right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur < k:\\n break\\n left += 1\\n\\n right = max(right, left)\\n\\n return res\\n\",\n \"runtime\": \"2980\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n M = max(nums)\\n m = math.floor(math.log(M,2))+1\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*m for _ in range(n)]\\n for i in range(n):\\n for j in range(m):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(m):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*m\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n # t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1\\n else:\\n if t<k:\\n for l in range(m):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1 \\n return res\\n \",\n \"runtime\": \"3053\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ORs = set()\\n max_bits = max(int(log(n, 2)) + 1 if n > 0 else 1 for n in nums)\\n bits = defaultdict(list)\\n last_index = {}\\n \\n for j, n in enumerate(nums):\\n OR = 0\\n if n == 0:\\n ORs.add(0)\\n for b in range(max_bits):\\n if (n >> b) & 1:\\n if b in last_index:\\n i = last_index[b]\\n bits[i].remove(b)\\n if not bits[i]:\\n del bits[i]\\n bits[j].append(b)\\n last_index[b] = j\\n for i in reversed(sorted(bits)):\\n for b in bits[i]:\\n OR |= 1 << b\\n ORs.add(OR)\\n\\n OR = min(ORs, key=lambda x: abs(x - k))\\n \\n return abs(OR - k)\",\n \"runtime\": \"3125\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n M = max(nums)\\n m = math.floor(math.log(M,2))+1\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*m for _ in range(n)]\\n for i in range(n):\\n for j in range(m):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n r = [0]*m\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1\\n else:\\n if t<k:\\n for l in range(m):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1 \\n return res\\n \",\n \"runtime\": \"3198\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n return TreeNode(start, end, nums[start], None, None)\\n\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val = left.val | right.val\\n return TreeNode(start, end, val, left, right)\\n self.root = build(nums, 0, len(nums)-1)\\n\\n def range_or(self, start, end):\\n def query(node, start, end):\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return query(node.right, start, end)\\n elif mid >= end:\\n return query(node.left, start, end)\\n else:\\n return query(node.left, start, mid) | query(node.right, mid+1, end)\\n\\n return query(self.root, start, end)\\n\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n tree = SegmentTree(nums)\\n N = len(nums)\\n res = float(inf)\\n left, right = 0, 0\\n while right < N:\\n while right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur > k:\\n break\\n\\n right += 1\\n\\n left += 1\\n while left <= right and right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur < k:\\n break\\n\\n left += 1\\n\\n right = max(right, left)\\n\\n return res\\n\",\n \"runtime\": \"3271\"\n },\n {\n \"code\": \"class Solution:\\n \\n \\n def __init__(self):\\n self.table = []\\n self.n = 0\\n \\n def buildSparseTable(self, arr): \\n for i in range(self.n): \\n self.table[i][0] = arr[i] \\n j = 1\\n while (1 << j) <= self.n: \\n i = 0\\n while i <= self.n - (1 << j): \\n self.table[i][j] = (self.table[i][j - 1] | self.table[i + (1 << (j - 1))][j - 1]) \\n i += 1\\n j += 1\\n \\n def query1(self, i, j): \\n import math\\n k = int(math.log2(j - i + 1)) \\n return (self.table[i][k] | self.table[j - (1 << k) + 1][k]) \\n \\n def minimumDifference(self, nums, k) -> int:\\n import math\\n target = k\\n self.n = len(nums)\\n k = int(math.log2(self.n)) + 1\\n self.table = [[0]*k for i in range(self.n)]\\n self.buildSparseTable(nums)\\n vals = [2**61]*self.n\\n for m in range(self.n):\\n i, j = m, self.n - 1\\n while i <= j:\\n a = self.query1(m, i)\\n b = self.query1(m, j)\\n if a - target >= 0 and b - target >= 0:\\n if abs(target - a) < abs(target - vals[m]):\\n vals[m] = a\\n break\\n elif a - target <= 0 and b - target <= 0:\\n if abs(target - b) < abs(target - vals[m]):\\n vals[m] = b\\n break\\n k = (i+j)>>1\\n f = self.query1(m, k)\\n vals[m] = f\\n if f - target <= 0:\\n i = k + 1\\n else:\\n j = k - 1\\n return min([abs(x - target) for x in vals]) \\n \",\n \"runtime\": \"3343\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n while i<n:\\n t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n # print(t,res)\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n # if i<j: \\n # res = min(res, abs(k-getInt(r)))\\n \\n return res\\n \",\n \"runtime\": \"3416\"\n },\n {\n \"code\": \"import math\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n #Count how many ones at each bit location\\n bits_array = [0]*32\\n res = math.inf\\n left,right = 0,0\\n def product():\\n result = 0\\n for (i,count) in enumerate(bits_array):\\n result += pow(2,i) if count > 0 else 0\\n return result\\n def orr(x):\\n i = 0\\n while x > 0:\\n if x & 1 == 1:\\n bits_array[i] += 1\\n x = x >> 1\\n i += 1\\n def invorr(x):\\n i = 0\\n while x > 0:\\n if x & 1 == 1:\\n bits_array[i] -= 1\\n x = x >> 1\\n i += 1\\n while right <= len(nums):\\n while right < len(nums) and (nums[right] | product()) < k:\\n orr(nums[right])\\n right += 1\\n lower = product() if left != right else math.inf\\n if right < len(nums):\\n orr(nums[right])\\n while left <= right and product() >= k:\\n invorr(nums[left])\\n left += 1\\n higher = nums[left-1] | product() if right < len(nums) else math.inf\\n res = min(res,abs(k - lower),abs(higher - k))\\n right += 1\\n return res\\n \",\n \"runtime\": \"3489\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n while i<n:\\n t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n # print(t,res)\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n if i<j: \\n res = min(res, abs(k-getInt(r)))\\n \\n return res\\n \",\n \"runtime\": \"3561\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n left, right = 0, (1 << 32) - 1\\n n = len(nums)\\n\\n orr = 0\\n for num in nums:\\n orr |= num\\n\\n def checkSmaller():\\n res = 0\\n minResult = float('inf')\\n right = 0\\n\\n # store for each column a counter\\n cnt = Counter()\\n\\n for i in range(n):\\n while right < n and res < k:\\n res = res | nums[right]\\n for b in range(32):\\n if (1 << b) & nums[right]:\\n cnt[b] += 1\\n minResult = min(minResult, abs(k - res))\\n right += 1\\n \\n # remove the beginning of the window\\n for b in range(32):\\n if (1 << b) & nums[i]:\\n cnt[b] -= 1\\n if cnt[b] == 0:\\n res = res ^ (1 << b)\\n if right - (i+1) > 0:\\n minResult = min(minResult, abs(k - res))\\n return minResult\\n return checkSmaller()\\n\",\n \"runtime\": \"3634\"\n },\n {\n \"code\": \"class RangeORQuery:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.log = [0] * (self.n + 1)\\n self.precompute_logs()\\n self.build_sparse_table(nums)\\n\\n def precompute_logs(self):\\n for i in range(2, self.n + 1):\\n self.log[i] = self.log[i // 2] + 1\\n\\n def build_sparse_table(self, nums):\\n self.K = self.log[self.n] + 1\\n self.st = [[0] * self.K for _ in range(self.n)]\\n for i in range(self.n):\\n self.st[i][0] = nums[i]\\n j = 1\\n while (1 << j) <= self.n:\\n i = 0\\n while (i + (1 << j) - 1) < self.n:\\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\\n i += 1\\n j += 1\\n\\n def range_or(self, L, R):\\n j = self.log[R - L + 1]\\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n roq = RangeORQuery(nums)\\n N = len(nums)\\n res = float(inf)\\n for i in range(len(nums)):\\n left, right = i, N-1\\n while left < right:\\n mid = left + (right - left) // 2\\n if roq.range_or(i, mid) < k:\\n left = mid + 1\\n else:\\n right = mid\\n cur = roq.range_or(i, left)\\n if cur == k:\\n return 0\\n if cur > k:\\n res = min(res, cur - k)\\n if left - 1 >= i:\\n res = min(res, k - roq.range_or(i, left-1))\\n else:\\n res = min(res, k - cur)\\n if left + 1 < N:\\n res = min(res, roq.range_or(i, left+1) - k)\\n return res\\n\",\n \"runtime\": \"3706\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n # t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1 \\n return res\\n \",\n \"runtime\": \"3779\"\n },\n {\n \"code\": \"class RangeORQuery:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.log = [0] * (self.n + 1)\\n self.precompute_logs()\\n self.build_sparse_table(nums)\\n\\n def precompute_logs(self):\\n for i in range(2, self.n + 1):\\n self.log[i] = self.log[i // 2] + 1\\n\\n def build_sparse_table(self, nums):\\n self.K = self.log[self.n] + 1\\n self.st = [[0] * self.K for _ in range(self.n)]\\n for i in range(self.n):\\n self.st[i][0] = nums[i]\\n j = 1\\n while (1 << j) <= self.n:\\n i = 0\\n while (i + (1 << j) - 1) < self.n:\\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\\n i += 1\\n j += 1\\n\\n def range_or(self, L, R):\\n j = self.log[R - L + 1]\\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n roq = RangeORQuery(nums)\\n N = len(nums)\\n res = float(inf)\\n for i in range(len(nums)):\\n left, right = i, N-1\\n while left < right:\\n mid = left + (right - left) // 2\\n if roq.range_or(i, mid) < k:\\n left = mid + 1\\n else:\\n right = mid\\n cur = roq.range_or(i, left)\\n if cur == k:\\n return 0\\n if cur > k:\\n res = min(res, cur - k)\\n if left - 1 >= i:\\n res = min(res, k - roq.range_or(i, left-1))\\n else:\\n res = min(res, k - cur)\\n if left + 1 < N:\\n res = min(res, roq.range_or(i, left+1) - k)\\n return res \",\n \"runtime\": \"3852\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n # t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n q = 2**33-1-q\\n t &= q\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n q = 2**33-1-q\\n t &= q\\n i += 1 \\n return res\\n \",\n \"runtime\": \"3924\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n def binToInt(bitset):\\n setbit = 1\\n res = 0\\n for i in range(32):\\n if bitset[i]:\\n res |= setbit\\n setbit <<= 1\\n return res\\n\\n def update(num, bitset, diff):\\n tmp = num\\n i = 0\\n while tmp:\\n bitset[i] += diff * (tmp % 2)\\n tmp >>= 1\\n i += 1\\n return bitset\\n\\n N = len(nums)\\n right = -1\\n curr = 0\\n bitset = [0] * 32\\n res = float('inf')\\n for left in range(N):\\n while right < (N - 1) and curr <= k:\\n right += 1\\n curr |= nums[right]\\n update(nums[right], bitset, 1)\\n\\n bestFromLeft = abs(k - curr)\\n if right > left:\\n bestFromLeft = min(bestFromLeft, abs(k - binToInt(update(nums[right], bitset.copy(), -1))))\\n res = min(res, bestFromLeft)\\n\\n curr = binToInt(update(nums[left], bitset, -1))\\n return res\\n \",\n \"runtime\": \"3997\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n while i<n:\\n t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n print(t,res)\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n if i<j: \\n res = min(res, abs(k-getInt(r)))\\n \\n return res\\n \",\n \"runtime\": \"4070\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n # do I find a subarray with the result mid-k or mid+k?\\n left, right = 0, (1 << 32) - 1\\n n = len(nums)\\n\\n orr = 0\\n for num in nums:\\n orr |= num\\n\\n def checkSmaller():\\n res = 0\\n minResult = float('inf')\\n right = 0\\n\\n # store for each column a counter\\n cnt = Counter()\\n\\n for i in range(n):\\n while right < n and res < k:\\n res = res | nums[right]\\n for b in range(32):\\n if (1 << b) & nums[right]:\\n cnt[b] += 1\\n minResult = min(minResult, abs(k - res))\\n right += 1\\n \\n # remove the beginning of the window\\n for b in range(32):\\n if (1 << b) & nums[i]:\\n cnt[b] -= 1\\n if cnt[b] == 0:\\n res = res ^ (1 << b)\\n if right - (i+1) > 0:\\n minResult = min(minResult, abs(k - res))\\n return minResult\\n return checkSmaller()\\n\",\n \"runtime\": \"4142\"\n },\n {\n \"code\": \"class Solution:\\n def getOr(self, dp, l, r):\\n \\\"\\\"\\\"\\n The getAnd method calculates the bitwise AND of the subarray\\n defined by indices l and r using the precomputed counts of set\\n bits in the dp array.\\n \\\"\\\"\\\"\\n\\n n = len(dp)\\n ans = 0\\n for i in range(self.MAX_BITS):\\n if dp[r + 1][i] - dp[l][i] != (r - l + 1):\\n ans |= (1 << i)\\n return ans\\n\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n self.MAX_BITS = 32\\n n = len(nums)\\n dp = [[0] * self.MAX_BITS for _ in range(n + 1)]\\n\\n \\\"\\\"\\\"\\n Storing the cumulative sum of set bits.\\n So suppose, [2, 3, 4]\\n dp = [[0, 0, 0]\\n [0, 1, 0] ==> 2\\n [1, 2, 0] ==> 3\\n [1, 2, 1]] ==> 4\\n \\n This will be useful in computing the AND value\\n between any two numbers [left, right]\\n \\\"\\\"\\\"\\n for i in range(n):\\n for j in range(self.MAX_BITS):\\n dp[i + 1][j] = dp[i][j] + ((1 << j) & nums[i] == 0)\\n\\n start, end = 0, 0\\n ans = float('inf')\\n\\n \\\"\\\"\\\"\\n Idea behind sliding window:\\n --------------------------------------------------------------------\\n Keep sliding the window until the and value of window goes below k.\\n\\n When it goes below k there is no point in further increasing the\\n size of the window as Bitwise AND always reduces the value and\\n the absolute difference will keep increasing.\\n\\n At this point start reducing the size of the window till the\\n value of the window goes above k.\\n \\\"\\\"\\\"\\n while end < n:\\n currentOr = self.getOr(dp, start, end)\\n ans = min(ans, abs(k - currentOr))\\n while start < end and currentOr > k:\\n start += 1\\n currentOr = self.getOr(dp, start, end)\\n ans = min(ans, abs(k - currentOr))\\n end += 1\\n return ans\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n min_diff = float('inf')\\n n = len(nums)\\n\\n # Precompute bitwise AND values for each starting index i\\n bitwise_and = [[0] * n for _ in range(n)]\\n for i in range(n):\\n bitwise_and[i][i] = nums[i]\\n for j in range(i + 1, n):\\n bitwise_and[i][j] = bitwise_and[i][j - 1] & nums[j]\\n\\n # Iterate over all possible subarrays\\n for i in range(n):\\n for j in range(i, n):\\n # Use precomputed bitwise AND value for subarray i to j\\n current_and = bitwise_and[i][j]\\n\\n # Update the minimum absolute difference\\n min_diff = min(min_diff, abs(k - current_and))\\n\\n return min_diff\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n min_diff = float('inf')\\n prefix = nums[0]\\n left = 0\\n\\n for right in range(len(nums)):\\n prefix &= nums[right]\\n\\n # Shrink the window from the left side while prefix exceeds k\\n while prefix > k and left <= right:\\n prefix &= ~nums[left]\\n left += 1\\n\\n min_diff = min(min_diff, abs(k - prefix))\\n\\n if min_diff == 0:\\n break\\n\\n return min_diff\\n\\\"\\\"\\\"\",\n \"runtime\": \"4215\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n b=bin(n)[2:]\\n log=len(b)\\n jump=[[i+1 for j in range(log)] for i in range(n)]\\n dp=[[nums[i] for j in range(log)] for i in range(n)]\\n res=float('inf')\\n for j in range(1,log):\\n for i in range(n-(1<<j)+1):\\n jump[i][j]=jump[jump[i][j-1]][j-1]\\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\\n lo=0\\n for hi in range(n):\\n while lo<=hi:\\n l=hi-lo+1\\n cur=lo\\n val=0\\n for i in range(log):\\n if l&(1<<i):\\n val|=dp[cur][i]\\n cur=jump[cur][i]\\n if val<=k:\\n res=min(res,k-val)\\n break\\n res=min(res,val-k)\\n lo+=1\\n return res\\n\",\n \"runtime\": \"4288\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, arr: List[int]):\\n self.n = len(arr)\\n self.tree = [0] * (4 * self.n)\\n self.build(arr, 0, 0, self.n - 1)\\n\\n def build(self, arr: List[int], node: int, start: int, end: int):\\n if start == end:\\n self.tree[node] = arr[start]\\n else:\\n mid = (start + end) // 2\\n self.build(arr, 2 * node + 1, start, mid)\\n self.build(arr, 2 * node + 2, mid + 1, end)\\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\\n\\n def query(self, node: int, start: int, end: int, left: int, right: int) -> int:\\n if left > end or right < start:\\n return 0\\n if left <= start and end <= right:\\n return self.tree[node]\\n mid = (start + end) // 2\\n left_or = self.query(2 * node + 1, start, mid, left, right)\\n right_or = self.query(2 * node + 2, mid + 1, end, left, right)\\n return left_or | right_or\\n\\n def range_query(self, left: int, right: int) -> int:\\n return self.query(0, 0, self.n - 1, left, right)\\n\\n def update(self, node: int, start: int, end: int, index: int, value: int):\\n if start == end:\\n self.tree[node] = value\\n else:\\n mid = (start + end) // 2\\n if index <= mid:\\n self.update(2 * node + 1, start, mid, index, value)\\n else:\\n self.update(2 * node + 2, mid + 1, end, index, value)\\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\\n\\n def point_update(self, index: int, value: int):\\n self.update(0, 0, self.n - 1, index, value)\\n\\nclass Solution:\\n # Time: O()\\n # Space: O(), where n = len(nums)\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n segment_tree = SegmentTree(nums)\\n\\n res = float('inf')\\n\\n # Sliding window approach\\n l = 0\\n for r in range(n):\\n while r >= l:\\n curr_or = segment_tree.range_query(l, r)\\n res = min(res, abs(curr_or-k))\\n if curr_or > k:\\n break\\n l += 1\\n l = 0\\n for r in range(n):\\n while r >= l:\\n curr_or = segment_tree.range_query(l, r)\\n res = min(res, abs(curr_or-k))\\n if curr_or <= k:\\n break\\n l += 1\\n return res\\n\",\n \"runtime\": \"4360\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n b=bin(n)[2:]\\n log=len(b)\\n jump=[[i+1 for j in range(log)] for i in range(n)]\\n dp=[[nums[i] for j in range(log)] for i in range(n)]\\n res=float('inf')\\n for j in range(1,log):\\n for i in range(n-(1<<j)+1):\\n jump[i][j]=jump[jump[i][j-1]][j-1]\\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\\n lo=0\\n for hi in range(n):\\n while lo<=hi:\\n l=hi-lo+1\\n cur=lo\\n val=0\\n for i in range(log):\\n if l&(1<<i):\\n val|=dp[cur][i]\\n cur=jump[cur][i]\\n if val<=k:\\n res=min(res,k-val)\\n break\\n res=min(res,val-k)\\n lo+=1\\n return res\\n\\n\",\n \"runtime\": \"4433\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n def binary_ones_positions(n):\\n positions = set() # 创建一个空的集合来存储位置信息\\n position = 0 # 初始化位的位置，从0开始\\n\\n # 当 n 不为0时，逐位检查\\n while n > 0:\\n if n & 1: # 检查当前位是否为1\\n positions.add(position)\\n n >>= 1 # 右移一位\\n position += 1 # 位置加1\\n\\n return positions\\n \\n def getnum(cnt):\\n res=0\\n for i, c in enumerate(cnt):\\n if c>0:\\n res |= (1<<i)\\n return res\\n\\n \\n cnt = [0] * 32\\n start = 0\\n res = float(\\\"inf\\\")\\n for i, num in enumerate(nums):\\n pos = binary_ones_positions(num)\\n for p in pos:\\n cnt[p]+=1\\n res = min(res, abs(getnum(cnt)-k))\\n \\n while getnum(cnt)>k and start<i:\\n pos = binary_ones_positions(nums[start])\\n for p in pos:\\n cnt[p]-=1\\n res = min(res, abs(getnum(cnt)-k))\\n start+=1\\n \\n return res\\n \\n \\n \\n \",\n \"runtime\": \"4505\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n = len(nums) \\n bitCount = [0] * 32 # frequency of each bit being set to 1\\n \\n def getRes():\\n res = 0\\n for i in range(32):\\n if bitCount[i] > 0: \\n res |= 1 << i\\n return res\\n \\n def addNum(left, right, num): \\n for i in range(32):\\n if (num >> i) & 1:\\n bitCount[i] += 1 \\n return getRes()\\n \\n def removeNum(num):\\n for i in range(32):\\n if (num >> i) & 1: \\n bitCount[i] -= 1 \\n \\n res = float('inf')\\n right = 0\\n \\n for left in range(n): \\n while right < n: \\n if addNum(left, right, nums[right]) < k: \\n right += 1\\n else: \\n break\\n\\n\\n # get diff when bit result >= k \\n if right < n: \\n res = min(res, getRes() - k)\\n removeNum(nums[right]) # remove nums[right]\\n \\n # get diff when bit result < k\\n if right > left: \\n res = min(res, k - getRes()) # excluding nums[right]\\n \\n removeNum(nums[left])\\n # print(bitCount)\\n \\n return res\\n\\n# class Solution:\\n# def minimumDifference(self, nums: List[int], k: int) -> int:\\n# n = len(nums)\\n# current_or = 0\\n# res = float('inf')\\n# right = 0\\n\\n# def addNum(num):\\n# nonlocal current_or\\n# current_or |= num\\n\\n# def removeNum(left, right):\\n# nonlocal current_or\\n# # Recalculate the OR for the current window\\n# current_or = 0\\n# for i in range(left, right + 1):\\n# current_or |= nums[i]\\n\\n# for left in range(n):\\n# while right < n:\\n# addNum(nums[right])\\n# if current_or > k:\\n# right += 1\\n# else:\\n# # If the current OR <= k, we stop extending the window\\n# break\\n \\n# if right < n:\\n# res = min(res, abs(k - current_or))\\n \\n# if right > left:\\n# res = min(res, abs(current_or - k))\\n \\n# removeNum(left + 1, right)\\n# if right == left:\\n# right += 1\\n\\n# return res\",\n \"runtime\": \"4578\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":67,"string":"67"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ans = float('inf')\n curr_or_set = set()\n for num in nums:\n next_or_set = set()\n next_or_set.add(num)\n ans = min(ans, abs(k - num))\n for prev_or in curr_or_set:\n new_or = prev_or | num # Corrected to use bitwise OR\n next_or_set.add(new_or)\n ans = min(ans, abs(k - new_or))\n curr_or_set = next_or_set\n return ans\n","memory":"30600"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n s1 = set()\n mini = float('inf')\n\n for num in nums:\n s2 = {num}\n for it in s1:\n s2.add(it | num)\n \n for it in s2:\n mini = min(mini, abs(k - it))\n \n s1 = s2\n\n return mini","memory":"30700"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n l = len(nums)\n final = set()\n final.add(0)\n final.add(nums[0])\n mn = abs(k - nums[0])\n for i in range(1,l):\n lst = set()\n lst.add(0)\n for nm in final:\n cr = nm | nums[i]\n lst.add(cr)\n mn = min(mn,abs(k-cr))\n if(mn == 0):\n return 0\n final = lst\n return mn","memory":"30800"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n def binToInt(bitset):\n setbit = 1\n res = 0\n for i in range(32):\n if bitset[i]:\n res |= setbit\n setbit <<= 1\n return res\n\n def update(num, bitset, diff):\n tmp = num\n i = 0\n while tmp:\n bitset[i] += diff * (tmp % 2)\n tmp >>= 1\n i += 1\n return bitset\n\n N = len(nums)\n right = -1\n curr = 0\n bitset = [0] * 32\n res = float('inf')\n for left in range(N):\n while right < (N - 1) and curr <= k:\n right += 1\n curr |= nums[right]\n update(nums[right], bitset, 1)\n\n bestFromLeft = abs(k - curr)\n if right > left:\n bestFromLeft = min(bestFromLeft, abs(k - binToInt(update(nums[right], bitset.copy(), -1))))\n res = min(res, bestFromLeft)\n\n curr = binToInt(update(nums[left], bitset, -1))\n return res\n ","memory":"30900"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n = len(nums)\n sub_res = [0] * n\n res = float('inf')\n for i in range(n):\n sub_res[i] = nums[i]\n res = min(res, abs(k - sub_res[i]))\n for j in range(i - 1, -1, -1):\n if sub_res[j] | nums[i] == sub_res[j]:\n break\n sub_res[j] = sub_res[j] | nums[i]\n res = min(res, abs(k - sub_res[j]))\n return res\n ","memory":"31500"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n def binary_ones_positions(n):\n positions = set() # 创建一个空的集合来存储位置信息\n position = 0 # 初始化位的位置，从0开始\n\n # 当 n 不为0时，逐位检查\n while n > 0:\n if n & 1: # 检查当前位是否为1\n positions.add(position)\n n >>= 1 # 右移一位\n position += 1 # 位置加1\n\n return positions\n \n def getnum(cnt):\n res=0\n for i, c in enumerate(cnt):\n if c>0:\n res |= (1<<i)\n return res\n\n \n cnt = [0] * 32\n start = 0\n res = float(\"inf\")\n for i, num in enumerate(nums):\n pos = binary_ones_positions(num)\n for p in pos:\n cnt[p]+=1\n res = min(res, abs(getnum(cnt)-k))\n \n while getnum(cnt)>k and start<i:\n pos = binary_ones_positions(nums[start])\n for p in pos:\n cnt[p]-=1\n res = min(res, abs(getnum(cnt)-k))\n start+=1\n \n return res\n \n \n \n ","memory":"31600"},{"code":"class SegmentTree:\n def __init__(self, arr: List[int]):\n self.n = len(arr)\n self.tree = [0] * (4 * self.n)\n self.build(arr, 0, 0, self.n - 1)\n\n def build(self, arr: List[int], node: int, start: int, end: int):\n if start == end:\n self.tree[node] = arr[start]\n else:\n mid = (start + end) // 2\n self.build(arr, 2 * node + 1, start, mid)\n self.build(arr, 2 * node + 2, mid + 1, end)\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\n\n def query(self, node: int, start: int, end: int, left: int, right: int) -> int:\n if left > end or right < start:\n return 0\n if left <= start and end <= right:\n return self.tree[node]\n mid = (start + end) // 2\n left_or = self.query(2 * node + 1, start, mid, left, right)\n right_or = self.query(2 * node + 2, mid + 1, end, left, right)\n return left_or | right_or\n\n def range_query(self, left: int, right: int) -> int:\n return self.query(0, 0, self.n - 1, left, right)\n\n def update(self, node: int, start: int, end: int, index: int, value: int):\n if start == end:\n self.tree[node] = value\n else:\n mid = (start + end) // 2\n if index <= mid:\n self.update(2 * node + 1, start, mid, index, value)\n else:\n self.update(2 * node + 2, mid + 1, end, index, value)\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\n\n def point_update(self, index: int, value: int):\n self.update(0, 0, self.n - 1, index, value)\n\nclass Solution:\n # Time: O()\n # Space: O(), where n = len(nums)\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n segment_tree = SegmentTree(nums)\n\n res = float('inf')\n\n # Sliding window approach\n l = 0\n for r in range(n):\n while r >= l:\n curr_or = segment_tree.range_query(l, r)\n res = min(res, abs(curr_or-k))\n if curr_or > k:\n break\n l += 1\n l = 0\n for r in range(n):\n while r >= l:\n curr_or = segment_tree.range_query(l, r)\n res = min(res, abs(curr_or-k))\n if curr_or <= k:\n break\n l += 1\n return res\n","memory":"32800"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","memory":"34600"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","memory":"34600"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","memory":"34700"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","memory":"34700"},{"code":"class Solution:\n def minimumDifference(self, array, target):\n array_length = len(array)\n start_index = -1\n current_result = abs(array[0] - target)\n or_accumulator = 0\n\n for end_index in range(array_length):\n or_accumulator |= array[end_index]\n \n if or_accumulator > target:\n or_accumulator = 0\n start_index = end_index\n while (or_accumulator | array[start_index]) <= target:\n or_accumulator |= array[start_index]\n start_index -= 1\n \n if start_index != end_index:\n current_result = min(current_result, abs(or_accumulator - target))\n \n if start_index >= 0:\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\n \n return current_result\n\ndef kdsmain():\n input_data = sys.stdin.read().strip()\n lines = input_data.splitlines()\n \n num_test_cases = len(lines) // 2\n results = []\n\n for i in range(num_test_cases):\n array = json.loads(lines[i*2])\n target = int(lines[i*2 + 1])\n \n result = Solution().minimumDifference(array, target)\n results.append(str(result))\n\n with open('user.out', 'w') as f:\n for result in results:\n f.write(f\"{result}\\n\")\n\nif __name__ == \"__main__\":\n kdsmain()\n exit(0)\n\n#kartikdevsharmaa","memory":"34800"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n dp = set()\n n = len(nums)\n\n # result: contains all subarray distinct OR values\n result = set()\n\n for i in range(n):\n new_dp = set()\n\n # single nums[i] can be a subarray\n new_dp.add(nums[i])\n\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n # update all possible subarray result\n result |= new_dp\n dp = new_dp\n \n return min(abs(val - k) for val in result)","memory":"43200"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n\n # record all subarray OR values that is ending with nums[i - 1]\n # then these OR values can OR with nums[i] can get all subarray OR values that is ending with nums[i]\n\n # dp: contains all OR values that is ending with nums[i]\n dp = set()\n n = len(nums)\n\n # result: contains all subarray distinct OR values\n result = set()\n\n for i in range(n):\n new_dp = set()\n\n # single nums[i] can be a subarray\n new_dp.add(nums[i])\n\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n # update all possible subarray result\n result |= new_dp\n dp = new_dp\n \n return min(abs(val - k) for val in result)\n","memory":"43300"},{"code":"class Solution:\n # https://leetcode.com/problems/find-subarray-with-bitwise-or-closest-to-k/solutions/5243284/updated-logtrick-o-30n-include-similar-questions\n def minimumDifference(self, nums: List[int], k: int) -> int:\n\n # record all subarray OR values that is ending with nums[i - 1]\n # then these OR values can OR with nums[i] can get all subarray OR values that is ending with nums[i]\n\n # dp: contains all OR values that is ending with nums[i]\n dp = set()\n n = len(nums)\n\n # result: contains all subarray distinct OR values\n result = set()\n\n for i in range(n):\n new_dp = set()\n\n # single nums[i] can be a subarray\n new_dp.add(nums[i])\n\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n # update all possible subarray result\n result |= new_dp\n dp = new_dp\n \n return min(abs(val - k) for val in result)\n","memory":"43300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n dp = set()\n n = len(nums)\n\n result = set()\n for i in range(n):\n new_dp = set()\n\n new_dp.add(nums[i])\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n result |= new_dp\n dp = new_dp\n \n return min(abs(val - k) for val in result)","memory":"43400"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n dp = set()\n n = len(nums)\n\n result = set()\n\n for i in range(n):\n current = set()\n current.add(nums[i])\n\n for mask in dp:\n current.add(mask | nums[i])\n \n result |= current\n dp = current\n \n return min(abs(val - k) for val in result)","memory":"43500"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n sumOR = set()\n tmp = set()\n\n for num in nums:\n tmp = {num | n for n in tmp} | {num}\n sumOR |= tmp\n \n return min(abs(val - k) for val in sumOR)","memory":"43600"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n \"\"\"\n Brute force:\n get rolling OR for each start (O(N^2))\n\n Overlapping subproblems, recurrent substructure:\n dp[i] = all OR values ending with nums[i-1]\n \"\"\"\n N = len(nums)\n\n dp = set() # all subarray OR vals ending w/ nums[i]\n res = set() # all subarray OR vals\n\n for i in range(N):\n new_dp = set()\n new_dp.add(nums[i]) # [i:i+1]\n\n # [<partial>:i+1]\n for mask in dp:\n new_dp.add(mask | nums[i])\n \n res |= new_dp # setwise OR!\n dp = new_dp\n \n return min(abs(val - k) for val in res)\n","memory":"43700"},{"code":"class Solution:\n\n\n def minimumDifference(self, nums: List[int], k: int) -> int:\n # awice: Set + Math - https://leetcode.com/problems/find-subarray-with-bitwise-or-closest-to-k/solutions/5248558/python3-set/\n\n A = nums\n S = set()\n T = set()\n\n for x in A:\n S = {y | x for y in S} | {x}\n T |= S\n \n return min(abs(x - k) for x in T)","memory":"43900"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ors, s = set(), set()\n for x in nums:\n s = set(x|y for y in s)\n s.add(x)\n ors |= s\n return min(abs(x-k) for x in ors)","memory":"44000"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n ORs = set()\n max_bits = max(int(log(n, 2)) + 1 if n > 0 else 1 for n in nums)\n bits = defaultdict(list)\n last_index = {}\n \n for j, n in enumerate(nums):\n OR = 0\n if n == 0:\n ORs.add(0)\n for b in range(max_bits):\n if (n >> b) & 1:\n if b in last_index:\n i = last_index[b]\n bits[i].remove(b)\n if not bits[i]:\n del bits[i]\n bits[j].append(b)\n last_index[b] = j\n for i in reversed(sorted(bits)):\n for b in bits[i]:\n OR |= 1 << b\n ORs.add(OR)\n\n OR = min(ORs, key=lambda x: abs(x - k))\n \n return abs(OR - k)","memory":"45300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n maxbit = 0\n bits = [[] for i in range(len(nums))]\n for i in range(len(nums)):\n num = nums[i]\n bit = 0\n while num:\n if num & 1 > 0:\n bits[i].append(bit)\n bit += 1\n num >>= 1\n maxbit = max(bit, maxbit)\n \n left = 0\n right = 0\n minDiff = abs(nums[0]-k)\n cur_num = 0\n cur_bits = [[] for i in range(maxbit)]\n while right < len(nums):\n cur_num |= nums[right]\n for bit in bits[right]:\n cur_bits[bit].append(right)\n\n minDiff = min(minDiff, abs(k-cur_num))\n while cur_num > k and left <= right:\n for bit in bits[left]:\n cur_bits[bit].pop(0)\n if len(cur_bits[bit]) == 0:\n cur_num ^= (1<<bit)\n\n if left < right:\n minDiff = min(minDiff, abs(k-cur_num))\n left += 1\n \n right += 1\n return minDiff\n\n\n\n\n \n \n ","memory":"53400"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n M = max(nums)\n m = math.floor(math.log(M,2))+1\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*m for _ in range(n)]\n for i in range(n):\n for j in range(m):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(m):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*m\n i = 0\n j = 0\n t = 0\n while i<n:\n # t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1\n else:\n if t<k:\n for l in range(m):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1 \n return res\n ","memory":"54700"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n M = max(nums)\n m = math.floor(math.log(M,2))+1\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*m for _ in range(n)]\n for i in range(n):\n for j in range(m):\n if nums[i]&1<<j:\n dp[i][j] += 1\n r = [0]*m\n i = 0\n j = 0\n t = 0\n while i<n:\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1\n else:\n if t<k:\n for l in range(m):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(m):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n t &= ~q\n i += 1 \n return res\n ","memory":"54800"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n while i<n:\n t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n print(t,res)\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n if i<j: \n res = min(res, abs(k-getInt(r)))\n \n return res\n ","memory":"56400"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n t = 0\n while i<n:\n # t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n q = 2**33-1-q\n t &= q\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n if r[l] == 1:\n q = 1<<l\n t |= q\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n if r[l] == 0:\n q = 1<<l\n q = 2**33-1-q\n t &= q\n i += 1 \n return res\n ","memory":"56400"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n if k in nums:\n return 0\n if len(nums) == 1:\n return abs(k-nums[0])\n n = len(nums)\n r = 0\n res = float(\"inf\")\n dp = [[0]*32 for _ in range(n)]\n for i in range(n):\n for j in range(32):\n if nums[i]&1<<j:\n dp[i][j] += 1\n def getInt(l):\n r = 0\n for i in range(32):\n if l[i] > 0:\n r |= 1<<i\n return r\n r = [0]*32\n i = 0\n j = 0\n while i<n:\n t = getInt(r)\n if i<j:\n res = min(res, abs(t-k))\n # print(t,res)\n if j == n:\n if t<k:\n break\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n else:\n if t<k:\n for l in range(32):\n r[l] += dp[j][l]\n j += 1\n elif t== k:\n return 0\n else:\n for l in range(32):\n r[l] -= dp[i][l]\n i += 1\n if i<j: \n res = min(res, abs(k-getInt(r)))\n \n return res\n ","memory":"56800"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)","memory":"58300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)","memory":"58500"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","memory":"58600"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n or_cache = [0] * len(nums)\n \n def divide_and_conquer(left: int, right: int) -> int:\n if left == right:\n return abs(nums[left] - k)\n \n mid = left + (right - left) // 2\n left_result = divide_and_conquer(left, mid)\n right_result = divide_and_conquer(mid + 1, right)\n \n combined_or = nums[mid] | nums[mid + 1]\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\n \n # Early stopping condition\n if combined_or >= k:\n return current_min_diff\n \n or_cache[mid] = combined_or\n or_cache[mid + 1] = combined_or\n \n left_bound = left\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\n for i in range(mid - 1, left - 1, -1):\n or_cache[i] = or_cache[i + 1] | nums[i]\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\n # Early stopping condition\n if or_cache[i] >= k:\n left_bound = i + 1\n break\n \n # Sliding window to find the minimum difference\n for right_bound in range(mid + 1, right + 1):\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n while left_bound < mid and combined_or > k:\n left_bound += 1\n combined_or = or_cache[left_bound] | or_cache[right_bound]\n current_min_diff = min(current_min_diff, abs(combined_or - k))\n \n # Early stopping condition\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\n return current_min_diff\n \n return current_min_diff\n \n return divide_and_conquer(0, len(nums) - 1)\n ","memory":"58600"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n return TreeNode(start, end, nums[start], None, None)\n\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val = left.val | right.val\n return TreeNode(start, end, val, left, right)\n self.root = build(nums, 0, len(nums)-1)\n\n def range_or(self, start, end):\n def query(node, start, end):\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return query(node.right, start, end)\n elif mid >= end:\n return query(node.left, start, end)\n else:\n return query(node.left, start, mid) | query(node.right, mid+1, end)\n\n return query(self.root, start, end)\n\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n tree = SegmentTree(nums)\n N = len(nums)\n res = float(inf)\n left, right = 0, 0\n while right < N:\n while right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur > k:\n break\n right += 1\n\n left += 1\n while left <= right and right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur < k:\n break\n left += 1\n\n right = max(right, left)\n\n return res\n","memory":"59200"},{"code":"class TreeNode:\n def __init__(self, start, end, val, left, right):\n self.start = start\n self.end = end\n self.val = val\n self.left = left\n self.right = right\nclass SegmentTree:\n def __init__(self, nums):\n def build(nums, start, end):\n if start == end:\n return TreeNode(start, end, nums[start], None, None)\n\n mid = start + (end - start) // 2\n left = build(nums, start, mid)\n right = build(nums, mid+1, end)\n val = left.val | right.val\n return TreeNode(start, end, val, left, right)\n self.root = build(nums, 0, len(nums)-1)\n\n def range_or(self, start, end):\n def query(node, start, end):\n if node.start == start and node.end == end:\n return node.val\n\n mid = node.start + (node.end - node.start) // 2\n if mid < start:\n return query(node.right, start, end)\n elif mid >= end:\n return query(node.left, start, end)\n else:\n return query(node.left, start, mid) | query(node.right, mid+1, end)\n\n return query(self.root, start, end)\n\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n tree = SegmentTree(nums)\n N = len(nums)\n res = float(inf)\n left, right = 0, 0\n while right < N:\n while right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur > k:\n break\n\n right += 1\n\n left += 1\n while left <= right and right < N:\n cur = tree.range_or(left, right)\n res = min(res, abs(cur-k))\n if cur == k:\n return 0\n if cur < k:\n break\n\n left += 1\n\n right = max(right, left)\n\n return res\n","memory":"59300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n maxbit = 0\n bits = [[] for i in range(len(nums))]\n for i in range(len(nums)):\n num = nums[i]\n bit = 0\n while num:\n if num & 1 > 0:\n bits[i].append(bit)\n bit += 1\n num >>= 1\n maxbit = max(bit, maxbit)\n \n left = 0\n right = 0\n minDiff = abs(nums[0]-k)\n cur_num = 0\n cur_bits = [set() for i in range(maxbit)]\n while right < len(nums):\n cur_num |= nums[right]\n for bit in bits[right]:\n cur_bits[bit].add(right)\n\n minDiff = min(minDiff, abs(k-cur_num))\n while cur_num > k and left <= right:\n for bit in bits[left]:\n cur_bits[bit].remove(left)\n if len(cur_bits[bit]) == 0:\n cur_num ^= (1<<bit)\n\n if left < right:\n minDiff = min(minDiff, abs(k-cur_num))\n left += 1\n \n right += 1\n return minDiff\n\n\n\n\n \n \n ","memory":"86000"},{"code":"class RangeORQuery:\n def __init__(self, nums):\n self.n = len(nums)\n self.log = [0] * (self.n + 1)\n self.precompute_logs()\n self.build_sparse_table(nums)\n\n def precompute_logs(self):\n for i in range(2, self.n + 1):\n self.log[i] = self.log[i // 2] + 1\n\n def build_sparse_table(self, nums):\n self.K = self.log[self.n] + 1\n self.st = [[0] * self.K for _ in range(self.n)]\n for i in range(self.n):\n self.st[i][0] = nums[i]\n j = 1\n while (1 << j) <= self.n:\n i = 0\n while (i + (1 << j) - 1) < self.n:\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\n i += 1\n j += 1\n\n def range_or(self, L, R):\n j = self.log[R - L + 1]\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n roq = RangeORQuery(nums)\n N = len(nums)\n res = float(inf)\n for i in range(len(nums)):\n left, right = i, N-1\n while left < right:\n mid = left + (right - left) // 2\n if roq.range_or(i, mid) < k:\n left = mid + 1\n else:\n right = mid\n cur = roq.range_or(i, left)\n if cur == k:\n return 0\n if cur > k:\n res = min(res, cur - k)\n if left - 1 >= i:\n res = min(res, k - roq.range_or(i, left-1))\n else:\n res = min(res, k - cur)\n if left + 1 < N:\n res = min(res, roq.range_or(i, left+1) - k)\n return res\n","memory":"91500"},{"code":"class RangeORQuery:\n def __init__(self, nums):\n self.n = len(nums)\n self.log = [0] * (self.n + 1)\n self.precompute_logs()\n self.build_sparse_table(nums)\n\n def precompute_logs(self):\n for i in range(2, self.n + 1):\n self.log[i] = self.log[i // 2] + 1\n\n def build_sparse_table(self, nums):\n self.K = self.log[self.n] + 1\n self.st = [[0] * self.K for _ in range(self.n)]\n for i in range(self.n):\n self.st[i][0] = nums[i]\n j = 1\n while (1 << j) <= self.n:\n i = 0\n while (i + (1 << j) - 1) < self.n:\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\n i += 1\n j += 1\n\n def range_or(self, L, R):\n j = self.log[R - L + 1]\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\n\nclass Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n roq = RangeORQuery(nums)\n N = len(nums)\n res = float(inf)\n for i in range(len(nums)):\n left, right = i, N-1\n while left < right:\n mid = left + (right - left) // 2\n if roq.range_or(i, mid) < k:\n left = mid + 1\n else:\n right = mid\n cur = roq.range_or(i, left)\n if cur == k:\n return 0\n if cur > k:\n res = min(res, cur - k)\n if left - 1 >= i:\n res = min(res, k - roq.range_or(i, left-1))\n else:\n res = min(res, k - cur)\n if left + 1 < N:\n res = min(res, roq.range_or(i, left+1) - k)\n return res ","memory":"91600"},{"code":"class Solution:\n \n \n def __init__(self):\n self.table = []\n self.n = 0\n \n def buildSparseTable(self, arr): \n for i in range(self.n): \n self.table[i][0] = arr[i] \n j = 1\n while (1 << j) <= self.n: \n i = 0\n while i <= self.n - (1 << j): \n self.table[i][j] = (self.table[i][j - 1] | self.table[i + (1 << (j - 1))][j - 1]) \n i += 1\n j += 1\n \n def query1(self, i, j): \n import math\n k = int(math.log2(j - i + 1)) \n return (self.table[i][k] | self.table[j - (1 << k) + 1][k]) \n \n def minimumDifference(self, nums, k) -> int:\n import math\n target = k\n self.n = len(nums)\n k = int(math.log2(self.n)) + 1\n self.table = [[0]*k for i in range(self.n)]\n self.buildSparseTable(nums)\n vals = [2**61]*self.n\n for m in range(self.n):\n i, j = m, self.n - 1\n while i <= j:\n a = self.query1(m, i)\n b = self.query1(m, j)\n if a - target >= 0 and b - target >= 0:\n if abs(target - a) < abs(target - vals[m]):\n vals[m] = a\n break\n elif a - target <= 0 and b - target <= 0:\n if abs(target - b) < abs(target - vals[m]):\n vals[m] = b\n break\n k = (i+j)>>1\n f = self.query1(m, k)\n vals[m] = f\n if f - target <= 0:\n i = k + 1\n else:\n j = k - 1\n return min([abs(x - target) for x in vals]) \n ","memory":"97800"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n res = float('inf')\n dp = [set() for i in range(len(nums))]\n dp[0].add(nums[0])\n res = abs(nums[0]-k)\n \n for i in range(1, len(nums)):\n curr = nums[i]\n dp[i].add(nums[i])\n for num in dp[i-1]:\n dp[i].add(num|curr)\n for e in dp[i]:\n res = min(res, abs(e-k))\n\n return res","memory":"102500"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n maxbit = 0\n bits = [set() for i in range(len(nums))]\n for i in range(len(nums)):\n num = nums[i]\n bit = 0\n while num:\n if num & 1 > 0:\n bits[i].add(bit)\n bit += 1\n num >>= 1\n maxbit = max(bit, maxbit)\n \n left = 0\n right = 0\n minDiff = abs(nums[0]-k)\n cur_num = 0\n cur_bits = [[] for i in range(maxbit)]\n while right < len(nums):\n cur_num |= nums[right]\n for bit in bits[right]:\n cur_bits[bit].append(right)\n\n minDiff = min(minDiff, abs(k-cur_num))\n while cur_num > k and left <= right:\n for bit in bits[left]:\n cur_bits[bit].pop(0)\n if len(cur_bits[bit]) == 0:\n cur_num ^= (1<<bit)\n\n if left < right:\n minDiff = min(minDiff, abs(k-cur_num))\n left += 1\n \n right += 1\n return minDiff\n\n\n\n\n \n \n ","memory":"109300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n=len(nums)\n b=bin(n)[2:]\n log=len(b)\n jump=[[i+1 for j in range(log)] for i in range(n)]\n dp=[[nums[i] for j in range(log)] for i in range(n)]\n res=float('inf')\n for j in range(1,log):\n for i in range(n-(1<<j)+1):\n jump[i][j]=jump[jump[i][j-1]][j-1]\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\n lo=0\n for hi in range(n):\n while lo<=hi:\n l=hi-lo+1\n cur=lo\n val=0\n for i in range(log):\n if l&(1<<i):\n val|=dp[cur][i]\n cur=jump[cur][i]\n if val<=k:\n res=min(res,k-val)\n break\n res=min(res,val-k)\n lo+=1\n return res\n\n","memory":"127300"},{"code":"class Solution:\n def minimumDifference(self, nums: List[int], k: int) -> int:\n n=len(nums)\n b=bin(n)[2:]\n log=len(b)\n jump=[[i+1 for j in range(log)] for i in range(n)]\n dp=[[nums[i] for j in range(log)] for i in range(n)]\n res=float('inf')\n for j in range(1,log):\n for i in range(n-(1<<j)+1):\n jump[i][j]=jump[jump[i][j-1]][j-1]\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\n lo=0\n for hi in range(n):\n while lo<=hi:\n l=hi-lo+1\n cur=lo\n val=0\n for i in range(log):\n if l&(1<<i):\n val|=dp[cur][i]\n cur=jump[cur][i]\n if val<=k:\n res=min(res,k-val)\n break\n res=min(res,val-k)\n lo+=1\n return res\n","memory":"128300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ans = float('inf')\\n curr_or_set = set()\\n for num in nums:\\n next_or_set = set()\\n next_or_set.add(num)\\n ans = min(ans, abs(k - num))\\n for prev_or in curr_or_set:\\n new_or = prev_or | num # Corrected to use bitwise OR\\n next_or_set.add(new_or)\\n ans = min(ans, abs(k - new_or))\\n curr_or_set = next_or_set\\n return ans\\n\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n s1 = set()\\n mini = float('inf')\\n\\n for num in nums:\\n s2 = {num}\\n for it in s1:\\n s2.add(it | num)\\n \\n for it in s2:\\n mini = min(mini, abs(k - it))\\n \\n s1 = s2\\n\\n return mini\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n l = len(nums)\\n final = set()\\n final.add(0)\\n final.add(nums[0])\\n mn = abs(k - nums[0])\\n for i in range(1,l):\\n lst = set()\\n lst.add(0)\\n for nm in final:\\n cr = nm | nums[i]\\n lst.add(cr)\\n mn = min(mn,abs(k-cr))\\n if(mn == 0):\\n return 0\\n final = lst\\n return mn\",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n def binToInt(bitset):\\n setbit = 1\\n res = 0\\n for i in range(32):\\n if bitset[i]:\\n res |= setbit\\n setbit <<= 1\\n return res\\n\\n def update(num, bitset, diff):\\n tmp = num\\n i = 0\\n while tmp:\\n bitset[i] += diff * (tmp % 2)\\n tmp >>= 1\\n i += 1\\n return bitset\\n\\n N = len(nums)\\n right = -1\\n curr = 0\\n bitset = [0] * 32\\n res = float('inf')\\n for left in range(N):\\n while right < (N - 1) and curr <= k:\\n right += 1\\n curr |= nums[right]\\n update(nums[right], bitset, 1)\\n\\n bestFromLeft = abs(k - curr)\\n if right > left:\\n bestFromLeft = min(bestFromLeft, abs(k - binToInt(update(nums[right], bitset.copy(), -1))))\\n res = min(res, bestFromLeft)\\n\\n curr = binToInt(update(nums[left], bitset, -1))\\n return res\\n \",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n sub_res = [0] * n\\n res = float('inf')\\n for i in range(n):\\n sub_res[i] = nums[i]\\n res = min(res, abs(k - sub_res[i]))\\n for j in range(i - 1, -1, -1):\\n if sub_res[j] | nums[i] == sub_res[j]:\\n break\\n sub_res[j] = sub_res[j] | nums[i]\\n res = min(res, abs(k - sub_res[j]))\\n return res\\n \",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n def binary_ones_positions(n):\\n positions = set() # 创建一个空的集合来存储位置信息\\n position = 0 # 初始化位的位置，从0开始\\n\\n # 当 n 不为0时，逐位检查\\n while n > 0:\\n if n & 1: # 检查当前位是否为1\\n positions.add(position)\\n n >>= 1 # 右移一位\\n position += 1 # 位置加1\\n\\n return positions\\n \\n def getnum(cnt):\\n res=0\\n for i, c in enumerate(cnt):\\n if c>0:\\n res |= (1<<i)\\n return res\\n\\n \\n cnt = [0] * 32\\n start = 0\\n res = float(\\\"inf\\\")\\n for i, num in enumerate(nums):\\n pos = binary_ones_positions(num)\\n for p in pos:\\n cnt[p]+=1\\n res = min(res, abs(getnum(cnt)-k))\\n \\n while getnum(cnt)>k and start<i:\\n pos = binary_ones_positions(nums[start])\\n for p in pos:\\n cnt[p]-=1\\n res = min(res, abs(getnum(cnt)-k))\\n start+=1\\n \\n return res\\n \\n \\n \\n \",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"class SegmentTree:\\n def __init__(self, arr: List[int]):\\n self.n = len(arr)\\n self.tree = [0] * (4 * self.n)\\n self.build(arr, 0, 0, self.n - 1)\\n\\n def build(self, arr: List[int], node: int, start: int, end: int):\\n if start == end:\\n self.tree[node] = arr[start]\\n else:\\n mid = (start + end) // 2\\n self.build(arr, 2 * node + 1, start, mid)\\n self.build(arr, 2 * node + 2, mid + 1, end)\\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\\n\\n def query(self, node: int, start: int, end: int, left: int, right: int) -> int:\\n if left > end or right < start:\\n return 0\\n if left <= start and end <= right:\\n return self.tree[node]\\n mid = (start + end) // 2\\n left_or = self.query(2 * node + 1, start, mid, left, right)\\n right_or = self.query(2 * node + 2, mid + 1, end, left, right)\\n return left_or | right_or\\n\\n def range_query(self, left: int, right: int) -> int:\\n return self.query(0, 0, self.n - 1, left, right)\\n\\n def update(self, node: int, start: int, end: int, index: int, value: int):\\n if start == end:\\n self.tree[node] = value\\n else:\\n mid = (start + end) // 2\\n if index <= mid:\\n self.update(2 * node + 1, start, mid, index, value)\\n else:\\n self.update(2 * node + 2, mid + 1, end, index, value)\\n self.tree[node] = self.tree[2 * node + 1] | self.tree[2 * node + 2]\\n\\n def point_update(self, index: int, value: int):\\n self.update(0, 0, self.n - 1, index, value)\\n\\nclass Solution:\\n # Time: O()\\n # Space: O(), where n = len(nums)\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n segment_tree = SegmentTree(nums)\\n\\n res = float('inf')\\n\\n # Sliding window approach\\n l = 0\\n for r in range(n):\\n while r >= l:\\n curr_or = segment_tree.range_query(l, r)\\n res = min(res, abs(curr_or-k))\\n if curr_or > k:\\n break\\n l += 1\\n l = 0\\n for r in range(n):\\n while r >= l:\\n curr_or = segment_tree.range_query(l, r)\\n res = min(res, abs(curr_or-k))\\n if curr_or <= k:\\n break\\n l += 1\\n return res\\n\",\n \"memory\": \"32800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"memory\": \"34600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"memory\": \"34700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, array, target):\\n array_length = len(array)\\n start_index = -1\\n current_result = abs(array[0] - target)\\n or_accumulator = 0\\n\\n for end_index in range(array_length):\\n or_accumulator |= array[end_index]\\n \\n if or_accumulator > target:\\n or_accumulator = 0\\n start_index = end_index\\n while (or_accumulator | array[start_index]) <= target:\\n or_accumulator |= array[start_index]\\n start_index -= 1\\n \\n if start_index != end_index:\\n current_result = min(current_result, abs(or_accumulator - target))\\n \\n if start_index >= 0:\\n current_result = min(current_result, abs(target - (or_accumulator | array[start_index])))\\n \\n return current_result\\n\\ndef kdsmain():\\n input_data = sys.stdin.read().strip()\\n lines = input_data.splitlines()\\n \\n num_test_cases = len(lines) // 2\\n results = []\\n\\n for i in range(num_test_cases):\\n array = json.loads(lines[i*2])\\n target = int(lines[i*2 + 1])\\n \\n result = Solution().minimumDifference(array, target)\\n results.append(str(result))\\n\\n with open('user.out', 'w') as f:\\n for result in results:\\n f.write(f\\\"{result}\\\\n\\\")\\n\\nif __name__ == \\\"__main__\\\":\\n kdsmain()\\n exit(0)\\n\\n#kartikdevsharmaa\",\n \"memory\": \"34800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n dp = set()\\n n = len(nums)\\n\\n # result: contains all subarray distinct OR values\\n result = set()\\n\\n for i in range(n):\\n new_dp = set()\\n\\n # single nums[i] can be a subarray\\n new_dp.add(nums[i])\\n\\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n # update all possible subarray result\\n result |= new_dp\\n dp = new_dp\\n \\n return min(abs(val - k) for val in result)\",\n \"memory\": \"43200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n\\n # record all subarray OR values that is ending with nums[i - 1]\\n # then these OR values can OR with nums[i] can get all subarray OR values that is ending with nums[i]\\n\\n # dp: contains all OR values that is ending with nums[i]\\n dp = set()\\n n = len(nums)\\n\\n # result: contains all subarray distinct OR values\\n result = set()\\n\\n for i in range(n):\\n new_dp = set()\\n\\n # single nums[i] can be a subarray\\n new_dp.add(nums[i])\\n\\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n # update all possible subarray result\\n result |= new_dp\\n dp = new_dp\\n \\n return min(abs(val - k) for val in result)\\n\",\n \"memory\": \"43300\"\n },\n {\n \"code\": \"class Solution:\\n # https://leetcode.com/problems/find-subarray-with-bitwise-or-closest-to-k/solutions/5243284/updated-logtrick-o-30n-include-similar-questions\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n\\n # record all subarray OR values that is ending with nums[i - 1]\\n # then these OR values can OR with nums[i] can get all subarray OR values that is ending with nums[i]\\n\\n # dp: contains all OR values that is ending with nums[i]\\n dp = set()\\n n = len(nums)\\n\\n # result: contains all subarray distinct OR values\\n result = set()\\n\\n for i in range(n):\\n new_dp = set()\\n\\n # single nums[i] can be a subarray\\n new_dp.add(nums[i])\\n\\n # using nums[i] to update all subarray OR values ending with nums[i - 1] to the subarray ending with nums[i]\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n # update all possible subarray result\\n result |= new_dp\\n dp = new_dp\\n \\n return min(abs(val - k) for val in result)\\n\",\n \"memory\": \"43300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n dp = set()\\n n = len(nums)\\n\\n result = set()\\n for i in range(n):\\n new_dp = set()\\n\\n new_dp.add(nums[i])\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n result |= new_dp\\n dp = new_dp\\n \\n return min(abs(val - k) for val in result)\",\n \"memory\": \"43400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n dp = set()\\n n = len(nums)\\n\\n result = set()\\n\\n for i in range(n):\\n current = set()\\n current.add(nums[i])\\n\\n for mask in dp:\\n current.add(mask | nums[i])\\n \\n result |= current\\n dp = current\\n \\n return min(abs(val - k) for val in result)\",\n \"memory\": \"43500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n sumOR = set()\\n tmp = set()\\n\\n for num in nums:\\n tmp = {num | n for n in tmp} | {num}\\n sumOR |= tmp\\n \\n return min(abs(val - k) for val in sumOR)\",\n \"memory\": \"43600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n Brute force:\\n get rolling OR for each start (O(N^2))\\n\\n Overlapping subproblems, recurrent substructure:\\n dp[i] = all OR values ending with nums[i-1]\\n \\\"\\\"\\\"\\n N = len(nums)\\n\\n dp = set() # all subarray OR vals ending w/ nums[i]\\n res = set() # all subarray OR vals\\n\\n for i in range(N):\\n new_dp = set()\\n new_dp.add(nums[i]) # [i:i+1]\\n\\n # [<partial>:i+1]\\n for mask in dp:\\n new_dp.add(mask | nums[i])\\n \\n res |= new_dp # setwise OR!\\n dp = new_dp\\n \\n return min(abs(val - k) for val in res)\\n\",\n \"memory\": \"43700\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n # awice: Set + Math - https://leetcode.com/problems/find-subarray-with-bitwise-or-closest-to-k/solutions/5248558/python3-set/\\n\\n A = nums\\n S = set()\\n T = set()\\n\\n for x in A:\\n S = {y | x for y in S} | {x}\\n T |= S\\n \\n return min(abs(x - k) for x in T)\",\n \"memory\": \"43900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ors, s = set(), set()\\n for x in nums:\\n s = set(x|y for y in s)\\n s.add(x)\\n ors |= s\\n return min(abs(x-k) for x in ors)\",\n \"memory\": \"44000\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n ORs = set()\\n max_bits = max(int(log(n, 2)) + 1 if n > 0 else 1 for n in nums)\\n bits = defaultdict(list)\\n last_index = {}\\n \\n for j, n in enumerate(nums):\\n OR = 0\\n if n == 0:\\n ORs.add(0)\\n for b in range(max_bits):\\n if (n >> b) & 1:\\n if b in last_index:\\n i = last_index[b]\\n bits[i].remove(b)\\n if not bits[i]:\\n del bits[i]\\n bits[j].append(b)\\n last_index[b] = j\\n for i in reversed(sorted(bits)):\\n for b in bits[i]:\\n OR |= 1 << b\\n ORs.add(OR)\\n\\n OR = min(ORs, key=lambda x: abs(x - k))\\n \\n return abs(OR - k)\",\n \"memory\": \"45300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n maxbit = 0\\n bits = [[] for i in range(len(nums))]\\n for i in range(len(nums)):\\n num = nums[i]\\n bit = 0\\n while num:\\n if num & 1 > 0:\\n bits[i].append(bit)\\n bit += 1\\n num >>= 1\\n maxbit = max(bit, maxbit)\\n \\n left = 0\\n right = 0\\n minDiff = abs(nums[0]-k)\\n cur_num = 0\\n cur_bits = [[] for i in range(maxbit)]\\n while right < len(nums):\\n cur_num |= nums[right]\\n for bit in bits[right]:\\n cur_bits[bit].append(right)\\n\\n minDiff = min(minDiff, abs(k-cur_num))\\n while cur_num > k and left <= right:\\n for bit in bits[left]:\\n cur_bits[bit].pop(0)\\n if len(cur_bits[bit]) == 0:\\n cur_num ^= (1<<bit)\\n\\n if left < right:\\n minDiff = min(minDiff, abs(k-cur_num))\\n left += 1\\n \\n right += 1\\n return minDiff\\n\\n\\n\\n\\n \\n \\n \",\n \"memory\": \"53400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n M = max(nums)\\n m = math.floor(math.log(M,2))+1\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*m for _ in range(n)]\\n for i in range(n):\\n for j in range(m):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(m):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*m\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n # t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1\\n else:\\n if t<k:\\n for l in range(m):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1 \\n return res\\n \",\n \"memory\": \"54700\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n M = max(nums)\\n m = math.floor(math.log(M,2))+1\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*m for _ in range(n)]\\n for i in range(n):\\n for j in range(m):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n r = [0]*m\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1\\n else:\\n if t<k:\\n for l in range(m):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(m):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n t &= ~q\\n i += 1 \\n return res\\n \",\n \"memory\": \"54800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n while i<n:\\n t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n print(t,res)\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n if i<j: \\n res = min(res, abs(k-getInt(r)))\\n \\n return res\\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n t = 0\\n while i<n:\\n # t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n q = 2**33-1-q\\n t &= q\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n if r[l] == 1:\\n q = 1<<l\\n t |= q\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n if r[l] == 0:\\n q = 1<<l\\n q = 2**33-1-q\\n t &= q\\n i += 1 \\n return res\\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n if k in nums:\\n return 0\\n if len(nums) == 1:\\n return abs(k-nums[0])\\n n = len(nums)\\n r = 0\\n res = float(\\\"inf\\\")\\n dp = [[0]*32 for _ in range(n)]\\n for i in range(n):\\n for j in range(32):\\n if nums[i]&1<<j:\\n dp[i][j] += 1\\n def getInt(l):\\n r = 0\\n for i in range(32):\\n if l[i] > 0:\\n r |= 1<<i\\n return r\\n r = [0]*32\\n i = 0\\n j = 0\\n while i<n:\\n t = getInt(r)\\n if i<j:\\n res = min(res, abs(t-k))\\n # print(t,res)\\n if j == n:\\n if t<k:\\n break\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n else:\\n if t<k:\\n for l in range(32):\\n r[l] += dp[j][l]\\n j += 1\\n elif t== k:\\n return 0\\n else:\\n for l in range(32):\\n r[l] -= dp[i][l]\\n i += 1\\n if i<j: \\n res = min(res, abs(k-getInt(r)))\\n \\n return res\\n \",\n \"memory\": \"56800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\",\n \"memory\": \"58300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\",\n \"memory\": \"58500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"memory\": \"58600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n or_cache = [0] * len(nums)\\n \\n def divide_and_conquer(left: int, right: int) -> int:\\n if left == right:\\n return abs(nums[left] - k)\\n \\n mid = left + (right - left) // 2\\n left_result = divide_and_conquer(left, mid)\\n right_result = divide_and_conquer(mid + 1, right)\\n \\n combined_or = nums[mid] | nums[mid + 1]\\n current_min_diff = min(abs(combined_or - k), left_result, right_result)\\n \\n # Early stopping condition\\n if combined_or >= k:\\n return current_min_diff\\n \\n or_cache[mid] = combined_or\\n or_cache[mid + 1] = combined_or\\n \\n left_bound = left\\n # Calculate leftmost index where the OR value with nums[mid+1] is less than k\\n for i in range(mid - 1, left - 1, -1):\\n or_cache[i] = or_cache[i + 1] | nums[i]\\n current_min_diff = min(current_min_diff, abs(or_cache[i] - k))\\n # Early stopping condition\\n if or_cache[i] >= k:\\n left_bound = i + 1\\n break\\n \\n # Sliding window to find the minimum difference\\n for right_bound in range(mid + 1, right + 1):\\n or_cache[right_bound] = or_cache[right_bound - 1] | nums[right_bound]\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n while left_bound < mid and combined_or > k:\\n left_bound += 1\\n combined_or = or_cache[left_bound] | or_cache[right_bound]\\n current_min_diff = min(current_min_diff, abs(combined_or - k))\\n \\n # Early stopping condition\\n if current_min_diff == 0 or (left_bound == mid and combined_or > k):\\n return current_min_diff\\n \\n return current_min_diff\\n \\n return divide_and_conquer(0, len(nums) - 1)\\n \",\n \"memory\": \"58600\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n return TreeNode(start, end, nums[start], None, None)\\n\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val = left.val | right.val\\n return TreeNode(start, end, val, left, right)\\n self.root = build(nums, 0, len(nums)-1)\\n\\n def range_or(self, start, end):\\n def query(node, start, end):\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return query(node.right, start, end)\\n elif mid >= end:\\n return query(node.left, start, end)\\n else:\\n return query(node.left, start, mid) | query(node.right, mid+1, end)\\n\\n return query(self.root, start, end)\\n\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n tree = SegmentTree(nums)\\n N = len(nums)\\n res = float(inf)\\n left, right = 0, 0\\n while right < N:\\n while right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur > k:\\n break\\n right += 1\\n\\n left += 1\\n while left <= right and right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur < k:\\n break\\n left += 1\\n\\n right = max(right, left)\\n\\n return res\\n\",\n \"memory\": \"59200\"\n },\n {\n \"code\": \"class TreeNode:\\n def __init__(self, start, end, val, left, right):\\n self.start = start\\n self.end = end\\n self.val = val\\n self.left = left\\n self.right = right\\nclass SegmentTree:\\n def __init__(self, nums):\\n def build(nums, start, end):\\n if start == end:\\n return TreeNode(start, end, nums[start], None, None)\\n\\n mid = start + (end - start) // 2\\n left = build(nums, start, mid)\\n right = build(nums, mid+1, end)\\n val = left.val | right.val\\n return TreeNode(start, end, val, left, right)\\n self.root = build(nums, 0, len(nums)-1)\\n\\n def range_or(self, start, end):\\n def query(node, start, end):\\n if node.start == start and node.end == end:\\n return node.val\\n\\n mid = node.start + (node.end - node.start) // 2\\n if mid < start:\\n return query(node.right, start, end)\\n elif mid >= end:\\n return query(node.left, start, end)\\n else:\\n return query(node.left, start, mid) | query(node.right, mid+1, end)\\n\\n return query(self.root, start, end)\\n\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n tree = SegmentTree(nums)\\n N = len(nums)\\n res = float(inf)\\n left, right = 0, 0\\n while right < N:\\n while right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur > k:\\n break\\n\\n right += 1\\n\\n left += 1\\n while left <= right and right < N:\\n cur = tree.range_or(left, right)\\n res = min(res, abs(cur-k))\\n if cur == k:\\n return 0\\n if cur < k:\\n break\\n\\n left += 1\\n\\n right = max(right, left)\\n\\n return res\\n\",\n \"memory\": \"59300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n maxbit = 0\\n bits = [[] for i in range(len(nums))]\\n for i in range(len(nums)):\\n num = nums[i]\\n bit = 0\\n while num:\\n if num & 1 > 0:\\n bits[i].append(bit)\\n bit += 1\\n num >>= 1\\n maxbit = max(bit, maxbit)\\n \\n left = 0\\n right = 0\\n minDiff = abs(nums[0]-k)\\n cur_num = 0\\n cur_bits = [set() for i in range(maxbit)]\\n while right < len(nums):\\n cur_num |= nums[right]\\n for bit in bits[right]:\\n cur_bits[bit].add(right)\\n\\n minDiff = min(minDiff, abs(k-cur_num))\\n while cur_num > k and left <= right:\\n for bit in bits[left]:\\n cur_bits[bit].remove(left)\\n if len(cur_bits[bit]) == 0:\\n cur_num ^= (1<<bit)\\n\\n if left < right:\\n minDiff = min(minDiff, abs(k-cur_num))\\n left += 1\\n \\n right += 1\\n return minDiff\\n\\n\\n\\n\\n \\n \\n \",\n \"memory\": \"86000\"\n },\n {\n \"code\": \"class RangeORQuery:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.log = [0] * (self.n + 1)\\n self.precompute_logs()\\n self.build_sparse_table(nums)\\n\\n def precompute_logs(self):\\n for i in range(2, self.n + 1):\\n self.log[i] = self.log[i // 2] + 1\\n\\n def build_sparse_table(self, nums):\\n self.K = self.log[self.n] + 1\\n self.st = [[0] * self.K for _ in range(self.n)]\\n for i in range(self.n):\\n self.st[i][0] = nums[i]\\n j = 1\\n while (1 << j) <= self.n:\\n i = 0\\n while (i + (1 << j) - 1) < self.n:\\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\\n i += 1\\n j += 1\\n\\n def range_or(self, L, R):\\n j = self.log[R - L + 1]\\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n roq = RangeORQuery(nums)\\n N = len(nums)\\n res = float(inf)\\n for i in range(len(nums)):\\n left, right = i, N-1\\n while left < right:\\n mid = left + (right - left) // 2\\n if roq.range_or(i, mid) < k:\\n left = mid + 1\\n else:\\n right = mid\\n cur = roq.range_or(i, left)\\n if cur == k:\\n return 0\\n if cur > k:\\n res = min(res, cur - k)\\n if left - 1 >= i:\\n res = min(res, k - roq.range_or(i, left-1))\\n else:\\n res = min(res, k - cur)\\n if left + 1 < N:\\n res = min(res, roq.range_or(i, left+1) - k)\\n return res\\n\",\n \"memory\": \"91500\"\n },\n {\n \"code\": \"class RangeORQuery:\\n def __init__(self, nums):\\n self.n = len(nums)\\n self.log = [0] * (self.n + 1)\\n self.precompute_logs()\\n self.build_sparse_table(nums)\\n\\n def precompute_logs(self):\\n for i in range(2, self.n + 1):\\n self.log[i] = self.log[i // 2] + 1\\n\\n def build_sparse_table(self, nums):\\n self.K = self.log[self.n] + 1\\n self.st = [[0] * self.K for _ in range(self.n)]\\n for i in range(self.n):\\n self.st[i][0] = nums[i]\\n j = 1\\n while (1 << j) <= self.n:\\n i = 0\\n while (i + (1 << j) - 1) < self.n:\\n self.st[i][j] = self.st[i][j - 1] | self.st[i + (1 << (j - 1))][j - 1]\\n i += 1\\n j += 1\\n\\n def range_or(self, L, R):\\n j = self.log[R - L + 1]\\n return self.st[L][j] | self.st[R - (1 << j) + 1][j]\\n\\nclass Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n roq = RangeORQuery(nums)\\n N = len(nums)\\n res = float(inf)\\n for i in range(len(nums)):\\n left, right = i, N-1\\n while left < right:\\n mid = left + (right - left) // 2\\n if roq.range_or(i, mid) < k:\\n left = mid + 1\\n else:\\n right = mid\\n cur = roq.range_or(i, left)\\n if cur == k:\\n return 0\\n if cur > k:\\n res = min(res, cur - k)\\n if left - 1 >= i:\\n res = min(res, k - roq.range_or(i, left-1))\\n else:\\n res = min(res, k - cur)\\n if left + 1 < N:\\n res = min(res, roq.range_or(i, left+1) - k)\\n return res \",\n \"memory\": \"91600\"\n },\n {\n \"code\": \"class Solution:\\n \\n \\n def __init__(self):\\n self.table = []\\n self.n = 0\\n \\n def buildSparseTable(self, arr): \\n for i in range(self.n): \\n self.table[i][0] = arr[i] \\n j = 1\\n while (1 << j) <= self.n: \\n i = 0\\n while i <= self.n - (1 << j): \\n self.table[i][j] = (self.table[i][j - 1] | self.table[i + (1 << (j - 1))][j - 1]) \\n i += 1\\n j += 1\\n \\n def query1(self, i, j): \\n import math\\n k = int(math.log2(j - i + 1)) \\n return (self.table[i][k] | self.table[j - (1 << k) + 1][k]) \\n \\n def minimumDifference(self, nums, k) -> int:\\n import math\\n target = k\\n self.n = len(nums)\\n k = int(math.log2(self.n)) + 1\\n self.table = [[0]*k for i in range(self.n)]\\n self.buildSparseTable(nums)\\n vals = [2**61]*self.n\\n for m in range(self.n):\\n i, j = m, self.n - 1\\n while i <= j:\\n a = self.query1(m, i)\\n b = self.query1(m, j)\\n if a - target >= 0 and b - target >= 0:\\n if abs(target - a) < abs(target - vals[m]):\\n vals[m] = a\\n break\\n elif a - target <= 0 and b - target <= 0:\\n if abs(target - b) < abs(target - vals[m]):\\n vals[m] = b\\n break\\n k = (i+j)>>1\\n f = self.query1(m, k)\\n vals[m] = f\\n if f - target <= 0:\\n i = k + 1\\n else:\\n j = k - 1\\n return min([abs(x - target) for x in vals]) \\n \",\n \"memory\": \"97800\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n res = float('inf')\\n dp = [set() for i in range(len(nums))]\\n dp[0].add(nums[0])\\n res = abs(nums[0]-k)\\n \\n for i in range(1, len(nums)):\\n curr = nums[i]\\n dp[i].add(nums[i])\\n for num in dp[i-1]:\\n dp[i].add(num|curr)\\n for e in dp[i]:\\n res = min(res, abs(e-k))\\n\\n return res\",\n \"memory\": \"102500\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n maxbit = 0\\n bits = [set() for i in range(len(nums))]\\n for i in range(len(nums)):\\n num = nums[i]\\n bit = 0\\n while num:\\n if num & 1 > 0:\\n bits[i].add(bit)\\n bit += 1\\n num >>= 1\\n maxbit = max(bit, maxbit)\\n \\n left = 0\\n right = 0\\n minDiff = abs(nums[0]-k)\\n cur_num = 0\\n cur_bits = [[] for i in range(maxbit)]\\n while right < len(nums):\\n cur_num |= nums[right]\\n for bit in bits[right]:\\n cur_bits[bit].append(right)\\n\\n minDiff = min(minDiff, abs(k-cur_num))\\n while cur_num > k and left <= right:\\n for bit in bits[left]:\\n cur_bits[bit].pop(0)\\n if len(cur_bits[bit]) == 0:\\n cur_num ^= (1<<bit)\\n\\n if left < right:\\n minDiff = min(minDiff, abs(k-cur_num))\\n left += 1\\n \\n right += 1\\n return minDiff\\n\\n\\n\\n\\n \\n \\n \",\n \"memory\": \"109300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n b=bin(n)[2:]\\n log=len(b)\\n jump=[[i+1 for j in range(log)] for i in range(n)]\\n dp=[[nums[i] for j in range(log)] for i in range(n)]\\n res=float('inf')\\n for j in range(1,log):\\n for i in range(n-(1<<j)+1):\\n jump[i][j]=jump[jump[i][j-1]][j-1]\\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\\n lo=0\\n for hi in range(n):\\n while lo<=hi:\\n l=hi-lo+1\\n cur=lo\\n val=0\\n for i in range(log):\\n if l&(1<<i):\\n val|=dp[cur][i]\\n cur=jump[cur][i]\\n if val<=k:\\n res=min(res,k-val)\\n break\\n res=min(res,val-k)\\n lo+=1\\n return res\\n\\n\",\n \"memory\": \"127300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDifference(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n b=bin(n)[2:]\\n log=len(b)\\n jump=[[i+1 for j in range(log)] for i in range(n)]\\n dp=[[nums[i] for j in range(log)] for i in range(n)]\\n res=float('inf')\\n for j in range(1,log):\\n for i in range(n-(1<<j)+1):\\n jump[i][j]=jump[jump[i][j-1]][j-1]\\n dp[i][j]=dp[i][j-1]|dp[jump[i][j-1]][j-1]\\n lo=0\\n for hi in range(n):\\n while lo<=hi:\\n l=hi-lo+1\\n cur=lo\\n val=0\\n for i in range(log):\\n if l&(1<<i):\\n val|=dp[cur][i]\\n cur=jump[cur][i]\\n if val<=k:\\n res=min(res,k-val)\\n break\\n res=min(res,val-k)\\n lo+=1\\n return res\\n\",\n \"memory\": \"128300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":42,"string":"42"}}},{"rowIdx":2460,"cells":{"question_id":{"kind":"number","value":3456,"string":"3,456"},"name":{"kind":"string","value":"find-the-maximum-length-of-a-good-subsequence-i"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code> and a <strong>non-negative</strong> integer <code>k</code>. A sequence of integers <code>seq</code> is called <strong>good</strong> if there are <strong>at most</strong> <code>k</code> indices <code>i</code> in the range <code>[0, seq.length - 2]</code> such that <code>seq[i] != seq[i + 1]</code>.</p>\n\n<p>Return the <strong>maximum</strong> possible length of a <strong>good</strong> <span data-keyword=\"subsequence-array\">subsequence</span> of <code>nums</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,1,1,3], k = 2</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The maximum length subsequence is <code>[<u>1</u>,<u>2</u>,<u>1</u>,<u>1</u>,3]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,4,5,1], k = 0</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The maximum length subsequence is <code>[<u>1</u>,2,3,4,5,<u>1</u>]</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 500</code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>0 <= k <= min(nums.length, 25)</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":30.70263637757971,"string":"30.702636"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","hash-table","dynamic-programming"],"string":"[\n \"array\",\n \"hash-table\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"140\", 37.30589999999997], [\"254\", 0.5181], [\"368\", 2.0726000000000004], [\"482\", 0.2591], [\"596\", 0.5182], [\"710\", 0.2591], [\"824\", 0.2591], [\"938\", 0.2591], [\"1052\", 0.2591], [\"1166\", 0.2591], [\"1280\", 0.2591], [\"1394\", 0.5181], [\"1508\", 0.2591], [\"1623\", 0.2591], [\"1737\", 0.2591], [\"1851\", 0.2591], [\"1965\", 0.2591], [\"2079\", 0.2591], [\"2193\", 0.2591], [\"2307\", 0.2591], [\"2421\", 0.2591], [\"2535\", 0.2591], [\"2649\", 0.2591], [\"2763\", 0.2591], [\"2877\", 0.2591], [\"2991\", 0.2591], [\"3105\", 0.2591], [\"3220\", 0.2591], [\"3334\", 0.2591], [\"3448\", 0.2591], [\"3562\", 0.2591], [\"3676\", 0.2591], [\"3790\", 0.2591], [\"3904\", 0.2591], [\"4018\", 0.2591], [\"4132\", 0.2591], [\"4246\", 0.2591], [\"4360\", 0.2591], [\"4474\", 0.2591], [\"4588\", 0.2591], [\"4703\", 0.2591], [\"4817\", 0.2591], [\"4931\", 0.2591], [\"5045\", 0.2591], [\"5159\", 0.7773], [\"5273\", 0.7773], [\"5387\", 0.7773], [\"5501\", 2.5910000000000006], [\"5615\", 3.6272000000000006], [\"5729\", 4.922700000000001], [\"5843\", 5.181800000000001], [\"5957\", 0.7773], [\"6071\", 1.0364], [\"6186\", 0.7773], [\"6300\", 1.0364], [\"6414\", 0.5182], [\"6528\", 4.145300000000001], [\"6642\", 1.8137000000000003], [\"6756\", 3.109200000000001], [\"6870\", 3.109200000000001], [\"6984\", 1.2955], [\"7098\", 0.5182], [\"7212\", 1.2955], [\"7326\", 0.2591], [\"7440\", 0.7773], [\"7554\", 0.2591], [\"7668\", 0.2591], [\"7783\", 0.2591], [\"7897\", 0.2591], [\"8011\", 0.2591], [\"8125\", 0.2591], [\"8239\", 0.5182], [\"8353\", 0.2591], [\"8467\", 0.2591], [\"8581\", 0.2591], [\"8695\", 0.5182], [\"8809\", 0.2591], [\"8923\", 0.5182], [\"9037\", 0.2591], [\"9151\", 0.2591]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 1.0363], [\"16500\", 4.1451], [\"16600\", 6.2176], [\"16700\", 11.9171], [\"16800\", 24.0933], [\"16900\", 17.3575], [\"17000\", 8.0311], [\"17100\", 3.6269], [\"17200\", 0.2591], [\"17700\", 0.2591], [\"17800\", 0.2591], [\"17900\", 0.5181], [\"18400\", 0.2591], [\"18500\", 0.2591], [\"18600\", 0.2591], [\"18700\", 0.5181], [\"18800\", 0.2591], [\"20500\", 0.2591], [\"25100\", 0.2591], [\"25700\", 0.2591], [\"28000\", 0.2591], [\"28100\", 0.2591], [\"28500\", 0.2591], [\"28600\", 0.2591], [\"28800\", 0.2591], [\"28900\", 0.2591], [\"29100\", 0.7772], [\"29200\", 0.2591], [\"29300\", 0.2591], [\"29500\", 0.2591], [\"29700\", 1.8135], [\"29800\", 1.0363], [\"29900\", 0.2591], [\"31000\", 0.2591], [\"31300\", 0.2591], [\"31400\", 1.2953], [\"31500\", 1.2953], [\"31600\", 2.8497], [\"31700\", 1.8135]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n dp = [defaultdict(int) for i in range(k + 1)]\n res = [0] * (k + 1)\n for a in A:\n for i in range(k, -1, -1):\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\n res[i] = max(res[i], dp[i][a])\n return res[k]","runtime":"140"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n fs = {}\n records = [[0] * 3 for _ in range(k + 1)]\n for x in nums:\n if x not in fs:\n fs[x] = [0] * (k + 1)\n f = fs[x]\n for j in range(k, -1, -1):\n f[j] += 1\n if j > 0:\n mx, mx2, num = records[j - 1]\n f[j] = max(f[j], (mx if x != num else mx2) + 1)\n\n # records[j] 维护 fs[.][j] 的 mx, mx2, num\n v = f[j]\n p = records[j]\n if v > p[0]:\n if x != p[2]:\n p[2] = x\n p[1] = p[0]\n p[0] = v\n elif x != p[2] and v > p[1]:\n p[1] = v\n return records[k][0]\n","runtime":"140"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n # dp_prev = dp[:]\n # dp = [0] * (last_index + 1)\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n if dp[j][n] != 0:\n dp[j][n] += 1\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if prev != 0:\n dp[j][n] = max(dp[j][n], prev + 1)\n # dp[j][n] = max(max(dp[j - 1][:n] + dp[j - 1][n + 1:]) + 1, dp[j][n] + 1)\n\n # max([max(dp_elem) for dp_elem in dp])\n\n # out = max([max(dp_elem)])\n\n print(dp)\n\n\n return max([max(dp_elem) for dp_elem in dp])\n ","runtime":"254"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if dp[j][n] != 0:\n dp[j][n] += 1\n if prev != 0:\n dp[j][n] = max(dp[j][n], prev + 1)\n\n return max([max(dp_elem) for dp_elem in dp])\n ","runtime":"254"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n if dp[j][n] != 0:\n dp[j][n] += 1\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if prev != 0:\n dp[j][n] = max(dp[j][n], prev + 1)\n\n return max([max(dp_elem) for dp_elem in dp])\n ","runtime":"368"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if dp[j][n] != 0:\n dp[j][n] += 1\n if prev != 0:\n dp[j][n] = max(dp[j][n], prev + 1)\n\n return max([max(dp_elem) for dp_elem in dp])\n ","runtime":"368"},{"code":"class Solution:\n # dp[k][i] = max(dp[k][s], max(dp[k-1][j<i])+1, nums[s]=nums[i]\n # O(n^2) implementation\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n d = [0]*(n+1) # 0 is sentinel\n # p is dp[k], d is dp[k-1]\n for it in range(k+1):\n p = [0]*(n+1)\n prev = Counter()\n for i,v in enumerate(nums,start=1):\n p[i] = max(prev[v], max(d[:i]))+1\n prev[v] = p[i]\n d = p\n #\n return max(d) \n ","runtime":"482"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = {}\n n = len(nums)\n for x in nums:\n if not x in dp:\n dp[x]=[0]*(k+1)\n xr = dp[x]\n for r in range(0,k+1):\n if xr[r] > 0 or r == 0:\n xr[r] += 1\n for y in dp:\n if y != x:\n for r in range(0,k):\n if dp[y][r]>=xr[r+1]:\n xr[r+1] = dp[y][r]+1\n maxlen = 0\n for x in dp:\n m = max(dp[x])\n if m>maxlen:\n maxlen = m\n\n print(dp)\n return maxlen\n","runtime":"596"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = defaultdict(lambda:(defaultdict(lambda:0)))\n if len(nums) == 1: return 1\n for x in nums:\n for i in range(k+1):\n d = dp[i]\n d[x] += 1\n v = max([d[y] for y in d if y != x], default=0)\n dp[i+1][x] = max(dp[i+1][x], v)\n return max(max(dp[i].values()) for i in range(k+1) if dp[i])","runtime":"596"},{"code":"class Solution:\n\n\n '''\n * * * * \n [1, 2, 1, 1, 3], if k = 2\n j i\n x x x x x \n\n dp[i][t] = the maximum possible length of a good subsequenc of nums[0:i] and t imes on such that seq[j] != seq[j + 1]\n\n if nums[i] == nums[j]\n = max(, dp[j][t] + 1) \n else:\n max(, dp[j][t-1] + 1)\n\n ---\n i\n x x x x x \n dfs(i) = dfs(i-1, t) + dfs(i-1, t-1) + 1\n\n '''\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k + 1) for _ in range(n)]\n last_seen = {}\n\n for i in range(n):\n for t in range(k + 1):\n dp[i][t] = 1\n if nums[i] in last_seen:\n j = last_seen[nums[i]]\n dp[i][t] = max(dp[i][t], dp[j][t] + 1)\n for prev_num, j in last_seen.items():\n if prev_num != nums[i] and t > 0:\n dp[i][t] = max(dp[i][t], dp[j][t - 1] + 1)\n last_seen[nums[i]] = i\n\n return max(max(row) for row in dp)\n\n \n\n\n\n\n\n\n\n ","runtime":"710"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k + 1) for _ in range(n + 1)]\n for i in range(n - 1, -1, -1):\n for j in range(k + 1):\n dp[i][j] = 1\n for i0 in range(i + 1, n):\n if nums[i0] == nums[i]:\n dp[i][j] = max(dp[i][j], dp[i0][j] + 1)\n break\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[i0][j - 1] + 1)\n return max(dp[i][k] for i in range(n))","runtime":"824"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n mp = {}\n dp = [[0 for _ in range(k+1)] for _ in range(n)]\n\n for i in range(n):\n for j in range(k+1):\n for v in mp:\n if j == 0 and v != nums[i]: continue\n if v == nums[i]: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j])\n else: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j-1])\n mp[nums[i]] = i\n \n res = 0\n for i in range(n):\n res = max(max(dp[i]), res)\n return res+1","runtime":"938"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n mp = {}\n dp = [[0 for _ in range(k+1)] for _ in range(n)]\n\n for i in range(n):\n for j in range(k+1):\n dp[i][j] = 1\n for v in mp:\n if j == 0 and v != nums[i]: continue\n if v == nums[i]: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j])\n else: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j-1])\n mp[nums[i]] = i\n \n res = 0\n for i in range(n):\n res = max(max(dp[i]), res)\n return res","runtime":"1052"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n #print(n)\n dp_el = [[0 for j in range(k+1)] for i in range(n)]\n dp = [[0 for j in range(k+1)] for i in range(n)]\n nmap = {}\n for i in range(n):\n for j in range(k+1):\n if i == 0:\n dp[i][j] = 1\n dp_el[i][j] = 1\n elif j == 0:\n dp[i][j] = max([nums[:i+1].count(x) for x in set(nums[:i+1])])\n dp_el[i][j] = nums[:i+1].count(nums[i])\n else:\n dp_el[i][j] = dp[i-1][j-1] + 1\n if nums[i] in nmap:\n dp_el[i][j] = max(dp_el[nmap[nums[i]]][j] + 1, dp_el[i][j])\n dp[i][j] = max(dp_el[i][j], dp[i-1][j])\n nmap[nums[i]] = i\n return dp[n-1][k]","runtime":"1166"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1 for _ in nums]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp[idx] = sub + 1\n return max(dp)","runtime":"1280"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n dp.extend(\n 1 + max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n for idx in range(1, len(nums))\n )\n \n return max(dp)","runtime":"1394"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n for idx in range(1, len(nums)):\n ans = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n ) + 1\n dp.append(ans)\n return max(dp)","runtime":"1394"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n for idx in range(1, len(nums)):\n ans = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n ) + 1\n dp.append(ans)\n \n return max(dp)","runtime":"1508"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1 for _ in nums]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp[idx] = sub + 1\n return max(dp)","runtime":"1623"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n for idx in range(1, len(nums)):\n ans = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n ) + 1\n dp.append(ans)\n \n return max(dp)","runtime":"1737"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1 for _ in nums]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp[idx] = sub + 1\n return max(dp)","runtime":"1851"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1 for _ in nums]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp[idx] = sub + 1\n return max(dp)","runtime":"1965"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp.append(sub + 1)\n return max(dp)","runtime":"2079"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1 for _ in nums]\n for idx in range(1, len(nums)):\n sub = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n )\n dp[idx] = sub + 1\n return max(dp)","runtime":"2193"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[j, k_left] = max(dp[j], if nums[j] == nums[prev]: dp[prev, k_left] + 1 else max(dp[prev, k_left - 1] + 1 for each prev)\n \n dp = [0 for i in range(len(nums))] # dp[j] = maximum length for k-1 including nums[j]\n for k_left in range(k+1):\n prevDP = dp[:]\n for i in range(len(nums)):\n if i == 0:\n dp[0] = 1\n else:\n dp[i] = max(dp[i], max(1 + dp[j] if nums[i] == nums[j] else prevDP[j] + 1 for j in range(i)))\n return max(dp)","runtime":"2307"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[j, k_left] = max length ending (and including) nums[j] of nums[0..j] with k_left differences \n # dp[j, k_left] = max(dp[j], if nums[j] == nums[prev]: dp[prev, k_left] + 1 else max(dp[prev, k_left - 1] + 1 for each prev)\n # ans = max(dp[-1, k])\n dp = [0 for i in range(len(nums))] # dp[j] = maximum length for k-1 including nums[j]\n for k_left in range(k+1):\n prevDP = dp[:]\n for i in range(len(nums)):\n if i == 0:\n dp[0] = 1\n else:\n dp[i] = max(dp[i], max(1 + dp[j] if nums[i] == nums[j] else prevDP[j] + 1 for j in range(i)))\n return max(dp)","runtime":"2421"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def findPre(idx):\n search = nums[idx]\n while idx:\n idx -= 1\n if nums[idx] == search: return idx\n return 0\n @cache\n def maxLength(diff,idx):\n if idx == 0: return 1\n ans = 1\n for i in range(findPre(idx),idx):\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\n choice2 = maxLength(diff-1,i) if diff else 0\n ans = max(ans,1+max(choice1,choice2))\n return ans\n return max(maxLength(k,i) for i in range(len(nums)))","runtime":"2535"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n cnt1 = Counter(nums)\n res = max(cnt1.values())\n \n d = collections.defaultdict(dict)\n d[nums[0]][k] = 1\n for i in range(1, len(nums)):\n if nums[i] in d:\n for cnt in d[nums[i]]:\n d[nums[i]][cnt] += 1\n res = max(res, d[nums[i]][cnt])\n else:\n d[nums[i]][k] = 1\n \n for num in d:\n if num != nums[i]:\n for cnt in d[num]:\n if cnt:\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), d[num][cnt]+1)\n \n res = max(res, d[nums[i]][cnt-1])\n \n # print(d, nums[i], res)\n return res\n \n \n ","runtime":"2649"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\n # print(dp)\n # for k == 0:\n for i in range(1, n):\n for j in range(i):\n if nums[i] == nums[j]:\n dp[i] = (dp[j][0] + 1, 0)\n # print(0, dp)\n\n for tmpk in range(1, k+1):\n tmpDP = [(0, 0) for _ in range(n)]\n tmpDP[0] = (1, 0)\n for i in range(1, n):\n for j in range(i):\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\n dp = tmpDP\n # print(tmpk, dp)\n \n return max(dp)[0]","runtime":"2763"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\n # print(dp)\n # for k == 0:\n for i in range(1, n):\n for j in range(i):\n if nums[i] == nums[j]:\n dp[i] = (dp[j][0] + 1, 0)\n # print(0, dp)\n\n for tmpk in range(1, k+1):\n tmpDP = [(0, 0) for _ in range(n)]\n tmpDP[0] = (1, 0)\n for i in range(1, n):\n for j in range(i):\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\n dp = tmpDP\n # print(tmpk, dp)\n \n return max(dp)[0]","runtime":"2877"},{"code":"from collections import defaultdict\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''\n subsequence, at most k pairs (i,i+1) are not equal\n DP[i,k] = for each j < i, for each level of k\n if j==i, DP[j]\n if j!=i, we will use up a k\n '''\n\n # k == 0\n DP = [1]*len(nums)\n counter = defaultdict(int)\n for i in range(len(nums)): # longest subsequence with duplicates => we could use counter too\n counter[nums[i]] += 1\n DP[i] = counter[nums[i]]\n\n for _ in range(min(k,len(nums))):\n # compute DP[i], LS with k pairs of non equal\n DP_next = [1]\n for i in range(1, len(nums)):\n DP_next_i = 1\n for j in range(i):\n if nums[j] == nums[i]:\n DP_next_i = max(DP_next_i, DP_next[j]+1)\n else:\n DP_next_i = max(DP_next_i, DP[j]+1)\n DP_next.append(DP_next_i)\n DP = DP_next\n\n return max(DP)","runtime":"2991"},{"code":"from collections import defaultdict\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''\n subsequence, at most k pairs (i,i+1) are not equal\n DP[i,k] = for each j < i, for each level of k\n if j==i, DP[j]\n if j!=i, we will use up a k\n '''\n\n # k == 0\n DP = [1]*len(nums)\n counter = defaultdict(int)\n for i in range(len(nums)): # longest subsequence with duplicates => we could use counter too\n counter[nums[i]] += 1\n DP[i] = counter[nums[i]]\n\n for _ in range(k):\n # compute DP[i], LS with k pairs of non equal\n DP_next = [1]\n for i in range(1, len(nums)):\n DP_next_i = 1\n for j in range(i):\n if nums[j] == nums[i]:\n DP_next_i = max(DP_next_i, DP_next[j]+1)\n else:\n DP_next_i = max(DP_next_i, DP[j]+1)\n DP_next.append(DP_next_i)\n DP = DP_next\n\n return max(DP)","runtime":"3105"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [1 for j in range(n)]\n for j in range(1, n):\n for h in range(j):\n if nums[h] == nums[j]:\n dp[j] = dp[h] + 1\n for i in range(1, k + 1):\n temp = dp.copy()\n for j in range(1, n):\n for h in range(j):\n if nums[h] == nums[j]:\n dp[j] = max(dp[j], dp[h] + 1)\n else:\n dp[j] = max(dp[j], temp[h] + 1)\n return max(dp)\n","runtime":"3220"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = []\n for idx in range(len(nums)):\n ans = 1\n for j in range(idx):\n if nums[j] == nums[idx]:\n ans = max(ans, dp[j] + 1)\n else:\n ans = max(ans, prev[j] + 1)\n dp.append(ans)\n \n return max(dp)","runtime":"3334"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # convert to at most n\n mapping = dict()\n next_index = 0 # mapped as 0<-n-1\n for i, v in enumerate(nums):\n if v not in mapping:\n mapping[v] = next_index\n next_index += 1 \n \n nums[i] = mapping[v]\n # print(nums)\n max_val = next_index-1\n dp = [[0]*(k+1) for _ in range(max_val+1)]\n # dp[index][last_value < (max_val)][current_k <= k] => current longest length\n ans = 0\n for i, v in enumerate(nums):\n # continues value case\n ndp = [list(v) for v in dp]\n for nk in range(k+1):\n for last_v in range(max_val+1):\n if v==last_v:\n ndp[v][nk] = max(\n ndp[v][nk],\n dp[v][nk] + 1 # as same as last value\n )\n elif nk >0 :\n ndp[v][nk] = max(\n ndp[v][nk],\n dp[last_v][nk-1] + 1 # nk will be increase and length is also increased\n )\n ans = max(ans, ndp[v][nk])\n #print(dp)\n dp = ndp\n return ans\n\n \n\n\n \n\n\n\n\n \n def wrong(self):\n # nums\n # k>=0\n # seq is good-> mat most k has\n # nums[left] to nums[right]\n left = 0\n right = 0 # if left=0, right=0, only 1 elements\n not_same_count = 0 # seq[i] != seq[i+1] count in [left:right+1] \n ans = 1\n while right < len(nums)-1 and left < len(nums) - 1:\n print(left, right)\n right_next_is_same = (nums[right] == nums[right+1])\n left_next_is_same = (nums[left] == nums[left+1])\n if not_same_count + int(not right_next_is_same) <= k :\n right +=1\n not_same_count += int(not right_next_is_same)\n ans = max(ans, right-left+1)\n else:\n left += 1\n not_same_count -= int(not right_next_is_same)\n # ans will not be updated...\n return ans\n\n \n\n\n\n","runtime":"3448"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n - dp[k][i] = max length of good subsequence from nums[i : ] \n with k indices left\n \"\"\"\n n = len(nums)\n prev = [0] * n\n for _ in range(k + 1):\n cur = [1] * n\n for i in range(n - 1, -1, -1):\n for j in range(i + 1, n):\n if nums[i] == nums[j]:\n cur[i] = max(cur[i], 1 + cur[j])\n else:\n cur[i] = max(cur[i], 1 + prev[j])\n prev = cur\n return max(prev)","runtime":"3562"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], max_k: int) -> int:\n\n n = len(nums)\n\n dp = [1 for i in range(n)]\n\n\n\n for k in range(0,max_k + 1):\n dp2 = [1 for i in range(n)]\n for i in range(n):\n for j in range(i - 1,-1,-1):\n if k != 0 and nums[i] != nums[j]:\n dp2[i] = max(dp2[i], dp[j] + 1)\n elif nums[i] == nums[j]:\n dp2[i] = max(dp2[i], dp2[j] + 1) \n dp = dp2\n return max(dp2)\n ","runtime":"3676"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n\n dp = [[0] * (k + 1) for _ in range(n)]\n ret = 0\n for i in range(n):\n for t in range(k + 1):\n ans = 1\n for j in range(i):\n if nums[j] == nums[i]:\n ans = max(ans, dp[j][t] + 1)\n elif t >= 1:\n ans = max(ans, dp[j][t - 1] + 1)\n dp[i][t] = ans\n ret = max(ret, ans)\n return ret","runtime":"3790"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[i][j] -> max length of subsequence that ends\n at index i with and has j neighbouring elements\n with different charactes\n dp[i][j] = 1 + max(dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j-1 >= 0\n for 0<=l<i)\n dp[0][0] = 1\n dp[0][i] = 0 for i > 0\n dp[i][j] = 0 for j > i\n \"\"\"\n n = len(nums)\n dp = [[0] * (k + 1) for _ in range(n)]\n dp[0][0] = 1\n res_max = 1\n # for i in range(1, n):\n # for j in range(min(i+1, k+1)):\n for j in range(k+1):\n for i in range(1, n):\n res = 0\n for l in range(i):\n res = max(res, dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j - 1 >= 0 else 0)\n\n dp[i][j] = res + 1\n res_max = max(res_max, dp[i][j])\n\n return res_max\n","runtime":"3904"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n tracked = [[0 for j in range(len(nums))] for i in range(k+1)]\n\n for i in range(k+1):\n tracked[i][0] = 1\n\n for i in range(1,len(nums)):\n tracked[0][i] = 1\n for j in range(i):\n #print(\"num1\",i, \"num2\",j)\n if nums[i] == nums[j]:\n #print(\"here\")\n for v in range(k+1):\n tracked[v][i] = max(tracked[v][i], tracked[v][j]+1)\n #print(tracked[v][i])\n else:\n for v in range(1, k+1):\n tracked[v][i] = max(tracked[v][i], tracked[v-1][j]+1)\n #print(tracked)\n return max(tracked[-1])","runtime":"4018"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for _ in range(k+1)] for __ in range(len(nums))]\n for i in range(len(nums)):\n dp[i][0] = 1\n for i in range(1,len(nums)):\n for j in range(0,i):\n if nums[i] == nums[j]:\n for kk in range(k+1):\n dp[i][kk] = max(dp[i][kk], dp[j][kk] + 1)\n else:\n for kk in range(1,k+1):\n dp[i][kk] = max(dp[i][kk], dp[j][kk-1] + 1)\n # print(dp)\n return max(max(dp[i]) for i in range(len(dp)))","runtime":"4132"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[1 for _ in range(k+1)] for _ in range(len(nums))]\n\n max_len = 1\n for i in range(1, len(nums)):\n for j in range(i):\n if nums[i] == nums[j]:\n for l in range(k+1):\n dp[i][l] = max(dp[i][l], dp[j][l]+1)\n else:\n for l in range(k):\n dp[i][l+1] = max(dp[i][l+1], dp[j][l]+1)\n max_len = max(max(dp[i]), max_len)\n return max_len\n ","runtime":"4246"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\n\n for idx in range(n - 1, -1, -1):\n for j in range(k + 1):\n if idx == n - 1:\n dp[idx][j] = 1\n else:\n ans = -float(\"inf\")\n for ptr in range(idx + 1, n):\n if nums[idx] != nums[ptr]:\n ans = max(1 + (dp[ptr][j - 1] if j >= 1 else 0), ans)\n else:\n ans = max(1 + dp[ptr][j], ans)\n \n dp[idx][j] = ans\n \n return max(map(max, dp))","runtime":"4360"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[i][j] -> max length of subsequence that ends\n at index i with and has j neighbouring elements\n with different charactes\n dp[i][j] = 1 + max(dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j-1 >= 0\n for 0<=l<i)\n dp[0][0] = 1\n dp[0][i] = 0 for i > 0\n dp[i][j] = 0 for j > i\n \"\"\"\n n = len(nums)\n dp = [[0] * (k + 1) for _ in range(n)]\n dp[0][0] = 1\n res_max = 1\n for i in range(1, n):\n for j in range(min(i+1, k+1)):\n res = 0\n for l in range(i):\n res = max(res, dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j - 1 >= 0 else 0)\n\n dp[i][j] = res + 1\n res_max = max(res_max, dp[i][j])\n\n return res_max\n","runtime":"4474"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n dp = [[0] * (k + 1) for _ in range(N + 1)]\n max_len = 0\n for i in reversed(range(N)):\n for g in range(k + 1):\n res = 1\n for j in range(i + 1, N):\n if nums[i] == nums[j]:\n res = max(res, 1 + dp[j][g])\n elif g + 1 <= k:\n res = max(res, 1 + dp[j][g + 1])\n dp[i][g] = res\n max_len = max(max_len, dp[i][g])\n return max_len\n\n @cache\n def dfs(i, g):\n res = 1\n for j in range(i + 1, N):\n if nums[i] == nums[j]:\n res = max(res, 1 + dfs(j, g))\n elif g + 1 <= k:\n res = max(res, 1 + dfs(j, g + 1))\n return res \n N = len(nums)\n return max(dfs(i, 0) for i in range(N))","runtime":"4817"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1 for _ in range(n)] for _ in range(k + 1)]\n for i in range(n - 2, -1, -1):\n for j in range(i + 1, n):\n if nums[i] == nums[j]:\n dp[0][i] = max(dp[0][i], 1 + dp[0][j])\n for l in range(1, k + 1):\n for i in range(n - 2, -1, -1):\n for j in range(i + 1, n):\n if nums[i] == nums[j]:\n dp[l][i] = max(dp[l][i], 1 + dp[l][j])\n else:\n dp[l][i] = max(dp[l][i], 1 + dp[l - 1][j])\n \n return max(map(max, dp))\n","runtime":"4931"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1 for _ in range(k + 1)] for _ in range(n)]\n for i in range(1, n):\n num = nums[i]\n for j in range(i):\n if num == nums[j]:\n for p in range(k + 1):\n dp[i][p] = max(dp[i][p], dp[j][p] + 1)\n else:\n for p in range(k):\n dp[i][p + 1] = max(dp[i][p + 1], dp[j][p] + 1)\n # for line in dp:\n # print(line)\n return max(dp[i][k] for i in range(n))\n","runtime":"5045"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n dp= [[1]* (k+1) for _ in range(len(nums))]\n\n maxl=1\n for i in range(len(nums)):\n for j in range(i):\n if nums[i]==nums[j]:\n for l in range(k+1):\n dp[i][l]=dp[j][l]+1\n else:\n for l in range(k):\n dp[i][l+1]=max(dp[i][l+1], dp[j][l]+1) \n maxl=max(maxl,max(dp[i]))\n return maxl\n \n \n\n\n \n # @cache\n # def func(idx,d):\n # if idx==len(nums):\n # return 0\n # if d>k:\n # return float('-inf')\n # v=0 \n # for j in range(idx+1,len(nums)):\n # if nums[j]!=nums[idx]: \n # v= max(v,1+func(j,d+1))\n # else:\n # v=max(v,1+func(j,d))\n # return v\n\n # res=0\n\n # for i in range(len(nums)):\n # res=max(res, func(i,0)+1)\n # return res\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n dp= [[1]*(k+1) for _ in range(len(nums))]\n \n maxl=1\n for i in range(len(nums)-1):\n for j in range(i+1, len(nums)):\n if nums[j]==nums[i]:\n for n in range(k+1):\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\n maxl=max(maxl,dp[j][n])\n if nums[j] !=nums[i]:\n for n in range(k):\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\n maxl=max(maxl,dp[j][n+1])\n return maxl\n","runtime":"5159"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n dp= [[1]* (k+1) for _ in range(len(nums))]\n\n maxl=1\n for i in range(len(nums)):\n for j in range(i):\n if nums[i]==nums[j]:\n for l in range(k+1):\n dp[i][l]=dp[j][l]+1\n else:\n for l in range(k):\n dp[i][l+1]=max(dp[i][l+1], dp[j][l]+1) \n maxl=max(maxl,max(dp[i]))\n return maxl\n \n \n\n\n \n # @cache\n # def func(idx,d):\n # if idx==len(nums):\n # return 0\n # if d>k:\n # return float('-inf')\n # v=0 \n # for j in range(idx+1,len(nums)):\n # if nums[j]!=nums[idx]: \n # v= max(v,1+func(j,d+1))\n # else:\n # v=max(v,1+func(j,d))\n # return v\n\n # res=0\n\n # for i in range(len(nums)):\n # res=max(res, func(i,0)+1)\n # return res\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n dp= [[1]*(k+1) for _ in range(len(nums))]\n \n maxl=1\n for i in range(len(nums)-1):\n for j in range(i+1, len(nums)):\n if nums[j]==nums[i]:\n for n in range(k+1):\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\n maxl=max(maxl,dp[j][n])\n if nums[j] !=nums[i]:\n for n in range(k):\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\n maxl=max(maxl,dp[j][n+1])\n return maxl\n","runtime":"5159"},{"code":"from functools import cache\nfrom collections import Counter\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n nextd = [n]*n\n counter = Counter()\n for i in range(n-2,-1,-1):\n if nums[i] != nums[i+1]:\n nextd[i] = i+1\n else:\n nextd[i] = nextd[i+1]\n nextcnt = [1]*n\n for i in range(n-1,-1,-1):\n counter[nums[i]] += 1\n nextcnt[i] = counter[nums[i]]\n @cache\n def dfs(i,k):\n if k == 0:\n return nextcnt[i]\n if i == n-1: return 1\n res = 0\n j = nextd[i]\n while j < n:\n if nums[i] != nums[j]:\n res = max(res, dfs(j,k-1))\n else:\n res = max(res, dfs(j,k))\n j = nextd[j]\n return res + nextd[i] - i\n return max([dfs(i,k) for i in range(n)])","runtime":"5273"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k + 1) for i in range(n)]\n dp[0][0] = 1\n for i in range(1, n):\n dp[i][0] = 1\n for j in range(0, i):\n if nums[i] == nums[j]:\n for l in range(k+1):\n if dp[j][l] != 0:\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\n else:\n for l in range(k):\n if dp[j][l] != 0:\n dp[i][l+1] = max(dp[i][l+1], dp[j][l] + 1)\n return max([max(row) for row in dp])\n ","runtime":"5273"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n n = len(nums)\n if n == 0:\n return 0\n \n dp = [[1] * (k + 1) for _ in range(n)]\n print(dp)\n \n for i in range(n):\n for j in range(k + 1):\n for l in range(i):\n if nums[i] == nums[l]:\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\n \n return max(max(row) for row in dp)","runtime":"5387"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[-inf] * (k + 1) for _ in range(n)]\n f[0][0] = 1\n res = 1\n\n for i in range(1, n):\n for u in range(0, k + 1):\n f[i][u] = 1\n for j in range(i - 1, -1, -1):\n if nums[i] != nums[j]:\n if u > 0:\n f[i][u] = max(f[i][u], f[j][u - 1] + 1)\n else:\n f[i][u] = max(f[i][u], f[j][u] + 1)\n res = max(res, f[i][u])\n return res\n ","runtime":"5387"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[i][j]: length of the longest subseq ending at index i with at most j places where adjacent elements are not equal\n \"\"\"\n dp = [[1] * (k+1) for _ in range(len(nums))]\n\n # if we consider just the one element at index i in the subseq, ans = 1 -> base case\n\n for i in range(len(nums)):\n for j in range(i):\n for l in range(k+1):\n if nums[i] == nums[j]:\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\n elif l > 0: # consider the one with l-1\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\n\n # max value in the dp is the ans\n return max(max(row) for row in dp)","runtime":"5501"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # ans = 0\n # n = len(nums)\n\n # @cache\n # def helper(k, i):\n # if i >=n or k <0:\n # return 0\n # mx = 0\n # for j in range(i+1, n):\n # if nums[j] == nums[i]:\n # mx = max(mx, helper(k, j))\n # else:\n # mx = max(mx, helper(k-1, j))\n # return 1 + mx\n\n # for i in range(n):\n # ans = max(ans, helper(k, i))\n # return ans\n \n \n n, k = len(nums), k+1\n\n dp = [[1] * k for _ in range(n)] # 1)\n \n for p, q in product(range(n), range(k)): # 2)\n for r in range(p):\n\n if nums[p] == nums[r]:\n dp[p][q] = max(dp[p][q], dp[r][q] + 1)\n elif q:\n dp[p][q] = max(dp[p][q], dp[r][q - 1] + 1)\n\n return max(chain(*dp)) \n ","runtime":"5501"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[i][j] = max good subsequence of nums including i such that at most j possible skips\n # dp[i][j] = max(dp[a][j] + 1 if nums[i] == nums[a] else dp[a][j - 1] + 1), 0 <= a < i\n\n dp = [[1 for i in range(k + 1)] for i in range(len(nums))]\n mx = 1\n for i in range(len(nums)):\n for j in range(k + 1):\n if i <= j:\n dp[i][j] = i + 1\n else:\n for a in range(0, i):\n if nums[i] == nums[a]:\n dp[i][j] = max(dp[i][j], dp[a][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[a][j - 1] + 1)\n mx = max(mx, dp[i][j])\n return mx","runtime":"5615"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n \n dp = [[1]*(k+1) for _ in range(n)]\n\n for i in range(n):\n for j in range(k+1):\n for l in range(i):\n if nums[i] == nums[l]:\n dp[i][j]=max(dp[i][j], dp[l][j]+1)\n elif j>0:\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\n \n return max(max(row) for row in dp)","runtime":"5615"},{"code":"\"\"\"\ndp[i][k] -> until index i, with k the length of the valid sequence\n\nfor j in range(i+1, len(nums))\n\n\"\"\"\nimport collections\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n res = 0\n dp = [[1 for _ in range(k + 1)] for _ in range(len(nums))]\n # dp = collections.defaultdict(dict)\n # for i in range(len(nums)):\n # for j in range(k+1):\n # dp[i][j] = 1\n # print(dp)\n for i in range(len(nums)):\n n = nums[i]\n for v in range(k+1):\n for j in range(i+1, len(nums)):\n if nums[j] == n:\n dp[j][v] = max(dp[j][v], dp[i][v] + 1)\n elif v > 0:\n dp[j][v-1] = max(dp[j][v-1], dp[i][v] + 1)\n print(dp)\n for i in range(len(nums)):\n for j in range(k+1):\n res = max(res, dp[i][j])\n return res\n\n # def helper(index, remaining, path):\n # nonlocal res\n # if index >= len(nums):\n # res = max(res, len(path))\n # return\n \n # helper(index+1, remaining, path)\n # if not path or nums[index] == path[-1]:\n # helper(index+1, remaining, path + [nums[index]])\n # else:\n # if remaining > 0:\n # helper(index+1, remaining-1, path + [nums[index]])\n # return\n \n # helper(0, k, [])\n # return res","runtime":"5729"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[1] * (k + 1) for _ in range(n)]\n ans = 0\n for i, x in enumerate(nums):\n for h in range(k + 1):\n for j, y in enumerate(nums[:i]):\n if x == y:\n f[i][h] = max(f[i][h], f[j][h] + 1)\n elif h:\n f[i][h] = max(f[i][h], f[j][h - 1] + 1)\n ans = max(ans, f[i][k])\n return ans ","runtime":"5729"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n \n dp = [[1] * (k + 1) for _ in range(n)]\n \n for i in range(n):\n for j in range(k + 1):\n for l in range(i):\n if nums[i] == nums[l]:\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\n \n return max(max(row) for row in dp)\n ","runtime":"5843"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1] * (k + 1) for _ in range(n)]\n\n answer = 1\n \n for i in range(1, n):\n for j in range(min(k + 1, n)):\n for m in range(i):\n if nums[m] == nums[i]:\n dp[i][j] = max(dp[i][j], dp[m][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[m][j - 1] + 1)\n \n answer = max(answer, dp[i][j])\n \n return answer\n\n ","runtime":"5843"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[1 for _ in range(k + 1)] for _ in range(len(nums))]\n for i in range(len(nums) - 2, -1, -1):\n for j in range(k + 1):\n for l in range(i + 1, len(nums)):\n if nums[i] == nums[l]:\n dp[i][j] = max(dp[i][j], 1 + dp[l][j])\n else:\n if j - 1 >= 0:dp[i][j] = max(dp[i][j], 1 + dp[l][j - 1])\n mx = 1\n for i in range(len(nums)):\n mx = max(mx, dp[i][k])\n return mx","runtime":"5957"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if len(nums)==0:\n return 0\n\n dp = [[1]*(k+1) for i in range(len(nums))]\n\n for i in range(len(nums)):\n for j in range(k+1):\n for t in range(i):\n if nums[i]==nums[t]:\n dp[i][j] = max(dp[i][j], dp[t][j]+1)\n elif j>0:\n dp[i][j] = max(dp[i][j], dp[t][j-1]+1)\n return max(max(row) for row in dp)","runtime":"5957"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1] * (k+1) for _ in range(n)]\n for y in range(k+1):\n for i in range(n):\n for j in range(i):\n if nums[i] == nums[j]:\n dp[i][y] = max(dp[i][y],dp[j][y]+1)\n elif y:\n dp[i][y] = max(dp[i][y],dp[j][y-1]+1)\n return max([dp[i][k] for i in range(n)])\n","runtime":"6071"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # ans = 0\n # n = len(nums)\n\n # @cache\n # def helper(k, i):\n # if i >=n or k <0:\n # return 0\n # mx = 0\n # for j in range(i+1, n):\n # if nums[j] == nums[i]:\n # mx = max(mx, helper(k, j))\n # else:\n # mx = max(mx, helper(k-1, j))\n # return 1 + mx\n\n # for i in range(n):\n # ans = max(ans, helper(k, i))\n # return ans\n\n n=len(nums)\n #dp=[[1 for i in range(k+1)] for j in range(n)]\n dp = [[1]*(k+1) for _ in range(n)]\n for i in range(n):\n for j in range(k+1):\n for p in range(0,i):\n if(nums[i]==nums[p]):\n dp[i][j]=max(dp[i][j],1+dp[p][j])\n elif(nums[i]!=nums[p]):\n if(j>0):\n dp[i][j]=max(dp[i][j],1+dp[p][j-1])\n # print(dp)\n ans=0\n for i in range(n):\n for j in range(k+1):\n ans=max(ans,dp[i][j])\n return ans\n \n \n ","runtime":"6071"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1 for j in range(n)] for i in range(k + 1)]\n for j in range(1, n):\n for h in range(j):\n if nums[h] == nums[j]:\n dp[0][j] = dp[0][h] + 1\n for i in range(1, k + 1):\n for j in range(1, n):\n for h in range(j):\n if nums[h] == nums[j]:\n dp[i][j] = max(dp[i][j], dp[i - 1][j], dp[i][h] + 1)\n else:\n dp[i][j] = max(dp[i][j], dp[i - 1][j], dp[i - 1][h] + 1)\n return max(dp[k])\n","runtime":"6186"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nums += [-1]\n n = len(nums)\n f = [[-inf]*(k+2) for _ in range(n)]\n for i in range(n):\n f[i][0] = 1\n for j in range(i):\n for t in range(min(i,k+1)+1): \n if nums[i]==nums[j]:\n f[i][t] = max(f[i][t], 1+f[j][t])\n elif t>0:\n f[i][t] = max(f[i][t], 1+f[j][t-1])\n return max(f[-1])-1\n","runtime":"6186"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0 for i in range(k + 1)] for j in range(n)]\n dp[0][0] = 1\n for i in range(1, n):\n dp[i][0] = 1\n for j in range(0, i):\n for m in range(k + 1):\n if nums[i] == nums[j]:\n if dp[j][m] != 0:\n dp[i][m] = max(dp[i][m], dp[j][m] + 1)\n elif m > 0 and dp[j][m-1] != 0:\n dp[i][m] = max(dp[i][m], dp[j][m-1] + 1)\n return max([max(dp[i]) for i in range(n)])\n","runtime":"6300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0]*(k+1) for _ in range(len(nums))]\n ans = 1\n for i in range(len(nums)):\n f[i][0] = 1\n for j in range(k+1):\n for l in range(i):\n if nums[l] == nums[i]:\n f[i][j] = max(f[i][j], f[l][j]+1)\n if j > 0:\n f[i][j] = max(f[i][j], f[l][j-1]+1)\n ans = max(ans, f[i][j])\n return ans\n","runtime":"6300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n vals = set(nums)\n d = {}\n for x in vals:\n d[x] = len(d)\n tmp = []\n for x in nums:\n tmp.append(d[x])\n n = max(tmp)\n dp = [[0] * (k + 1) for _ in range(n + 1)]\n x = tmp[0]\n dp[x][0] = 1\n #print(tmp)\n for x in tmp[1:]:\n ndp = copy.deepcopy(dp)\n #print(dp)\n for y in range(n + 1):\n for used in range(k):\n if y != x:\n ndp[x][used + 1] = max(ndp[x][used + 1], dp[y][used] + 1)\n else:\n ndp[x][used] = max(ndp[x][used], dp[y][used] + 1)\n ndp[x][k] = max(ndp[x][k], dp[y][k] + 1 if y == x else 0)\n dp = ndp\n \n #print(dp)\n ans = 0\n for _, row in enumerate(dp):\n for __, val in enumerate(row):\n ans = max(ans, val)\n return ans","runtime":"6414"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 0\n n = len(nums)\n\n @cache\n def helper(k, i):\n if i >=n or k <0:\n return 0\n mx = 0\n for j in range(i+1, n):\n if nums[j] == nums[i]:\n mx = max(mx, helper(k, j))\n else:\n mx = max(mx, helper(k-1, j))\n return 1 + mx\n\n for i in range(n):\n ans = max(ans, helper(k, i))\n return ans","runtime":"6414"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n vals = set(nums)\n d = {}\n for x in vals:\n d[x] = len(d)\n tmp = []\n for x in nums:\n tmp.append(d[x])\n n = max(tmp)\n dp = [[0] * (k + 1) for _ in range(n + 1)]\n x = tmp[0]\n dp[x][0] = 1\n #print(tmp)\n for x in tmp[1:]:\n ndp = copy.deepcopy(dp)\n #print(dp)\n for y in range(n + 1):\n for used in range(k):\n if y != x:\n ndp[x][used + 1] = max(ndp[x][used + 1], dp[y][used] + 1)\n else:\n ndp[x][used] = max(ndp[x][used], dp[y][used] + 1)\n ndp[x][k] = max(ndp[x][k], dp[y][k] + 1 if y == x else 0)\n dp = ndp\n \n #print(dp)\n ans = 0\n for _, row in enumerate(dp):\n for __, val in enumerate(row):\n ans = max(ans, val)\n return ans","runtime":"6528"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 0\n n = len(nums)\n\n @cache\n def helper(k, i):\n if i >=n or k <0:\n return 0\n mx = 0\n for j in range(i+1, n):\n if nums[j] == nums[i]:\n mx = max(mx, helper(k, j))\n else:\n mx = max(mx, helper(k-1, j))\n return 1 + mx\n\n for i in range(n):\n ans = max(ans, helper(k, i))\n return ans","runtime":"6528"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 0\n n = len(nums)\n\n @cache\n def helper(k, i):\n if i >=n or k <0:\n return 0\n mx = 0\n for j in range(i+1, n):\n if nums[j] == nums[i]:\n mx = max(mx, helper(k, j))\n else:\n mx = max(mx, helper(k-1, j))\n return 1 + mx\n\n for i in range(n):\n ans = max(ans, helper(k, i))\n return ans","runtime":"6642"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n \n @cache\n def fn(i, k):\n \"\"\"Return \"\"\"\n # if k < 0: return -inf \n if i == n: return 0 \n ans = 1\n for j in range(i+1, n): \n if nums[i] == nums[j]: ans = max(ans, 1 + fn(j, k))\n elif k > 0: ans = max(ans, 1 + fn(j, k-1))\n return ans \n \n return max(fn(i, k) for i in range(n))","runtime":"6642"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * (k + 1) for i in nums]\n dp[0][0] = 1\n n = len(nums)\n for i in range(1, n):\n dp[i][0] = 1\n for j in range(k + 1):\n for l in range(i):\n if nums[l] == nums[i] and dp[l][j] != 0:\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\n elif nums[l] != nums[i] and j > 0 and dp[l][j-1] != 0:\n dp[i][j] = max(dp[i][j], dp[l][j-1] + 1)\n return max([max(row) for row in dp])","runtime":"6756"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n @cache\n def dfs(i,s):\n if i==n:\n return 0\n res=0\n for j in range(i+1,n):\n if nums[i]==nums[j]:\n res=max(res,1+dfs(j,s))\n else :\n if s>0:\n res=max(res,1+dfs(j,s-1))\n return res\n return max(dfs(i,k) for i in range(n))+1\n","runtime":"6756"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def fn(idx, diffs):\n if diffs < 0:\n return 0\n ans = 1\n for j in range(idx):\n if nums[j] == nums[idx]:\n ans = max(ans, fn(j, diffs) + 1)\n else:\n ans = max(ans, fn(j, diffs-1) + 1)\n return ans\n \n return max(fn(i, k) for i in range(len(nums)))","runtime":"6870"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n ret = 0\n\n @cache\n def dfs(i: int, diff_cnt: int) -> int:\n nonlocal ret\n if i == 0:\n return 1\n ans = 1\n # ans = max(1, dfs(i - 1, diff_cnt))\n for pos in range(i):\n if nums[pos] == nums[i]:\n ans = max(ans, dfs(pos, diff_cnt) + 1)\n else:\n if diff_cnt >= 1:\n ans = max(ans, dfs(pos, diff_cnt - 1) + 1)\n return ans\n\n # dfs(N - 1, k)\n for i in range(N):\n ret = max(ret, dfs(i, k))\n return ret","runtime":"6870"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[-1] * 51 for _ in range(n)]\n ans = 0\n\n for i in range(n):\n dp[i][0] = 1\n for l in range(k + 1):\n for j in range(i):\n add = 1 if nums[i] != nums[j] else 0\n if l - add >= 0 and dp[j][l - add] != -1:\n dp[i][l] = max(dp[i][l], dp[j][l - add] + 1)\n ans = max(ans, dp[i][l])\n \n return ans","runtime":"6984"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def f(end, k):\n if(k < 0): return 0\n if(end == 0): return 1\n take = 1\n for i in range(end-1, -1, -1):\n if(nums[i] != nums[end]):\n if(k > 0):\n currLen = 1 + f(i, k-1)\n take = max(currLen, take)\n else:\n currLen = 1 + f(i, k)\n take = max(currLen, take)\n return take\n\n ret = 0\n for i in range(0, len(nums)):\n ret = max(ret, f(i,k))\n\n\n return ret\n ","runtime":"6984"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n mx = 0\n for p in range(i):\n if nums[p] == nums[i]:\n mx = max(dfs(p, j), mx)\n elif j and nums[p] != nums[i]:\n mx = max(dfs(p, j - 1), mx) \n return mx + 1\n\n return max(dfs(i, k) for i in range(n - 1, -1, -1))\n ","runtime":"7098"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def f(i, k):\n # print(i, k)\n if i >= n: return 0\n\n pick = 1\n for j in range(i + 1, n):\n good = nums[i] != nums[j]\n if not good:\n pick = max(pick, 1 + f(j, k))\n # print(\"not good\", i, j, pick)\n\n elif k:\n pick = max(pick, 1 + f(j, k - 1))\n # print(\"good\", i, j, pick)\n \n \n # print(i, k, \"pick\", pick)\n return pick\n\n n = len(nums)\n \n return max(f(i, k) for i in range(n))\n","runtime":"7098"},{"code":"from collections import Counter\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # O(n*n*k)\n n = len(nums)\n dp = [[-1]*(k+1) for _ in range(n+1)]\n \n def solve(i, remk):\n if i == -1: return 0\n if dp[i][remk] != -1: return dp[i][remk]\n\n maxLen = 1\n for j in range(i-1, -1, -1):\n if nums[i] == nums[j]:\n maxLen = max(maxLen, 1 + solve(j, remk))\n elif nums[i] != nums[j] and remk > 0:\n maxLen = max(maxLen, 1+solve(j, remk-1))\n\n dp[i][remk] = maxLen\n return maxLen\n\n ans = 0\n for i in range(n):\n ans = max(ans, solve(i, k))\n # imaging every i is end of sub sequence\n # print(dp)\n return ans","runtime":"7212"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def helper(i,n):\n curr = 1\n for j in range(i+1,len(nums)):\n ch = 1\n if nums[i] == nums[j]:\n ch = 0\n if n + ch <= k:\n curr = max(curr, helper(j, n+ch)+1)\n return curr\n ans = 0\n for i in range(len(nums)):\n ans = max(ans, helper(i,0)) \n return ans\n\n\n\n\n\n \n","runtime":"7212"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def dfs(ptr, left):\n nonlocal nums\n if left < 0:\n return 0\n ans = 1\n for i in range(ptr+1, len(nums)):\n ans = max(ans, 1 + dfs(i, left - (nums[i]!=nums[ptr])))\n return ans\n \n return max([dfs(i, k) for i in range(len(nums))])","runtime":"7326"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def rec(i, k_inner):\n if k_inner == -1:\n return -inf\n if i == len(nums):\n return 0\n\n max_r = 0\n for j in range(i+1, len(nums)):\n max_r = max(max_r, 1 + rec(j, k_inner-(nums[i]!=nums[j])))\n\n return max_r\n\n m = 0\n for j in range(len(nums)):\n m = max(m, rec(j, k))\n return m + 1\n","runtime":"7440"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n @lru_cache(None)\n def dfs(i: int, pre: int, rest: int) -> int:\n if i == n:\n return 0\n res = dfs(i + 1, pre, rest)\n if pre == 0:\n # 第一个数\n res = max(res, 1 + dfs(i + 1, nums[i], rest))\n else:\n if pre != nums[i]:\n if rest >= 1:\n res = max(res, 1 + dfs(i + 1, nums[i], rest - 1))\n else:\n res = max(res, 1 + dfs(i + 1, pre, rest))\n return res\n \n ans = dfs(0, 0, k)\n dfs.cache_clear()\n return ans","runtime":"7440"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def f(i, k):\n # print(i, k)\n if i >= n: return 0\n\n pick = 1\n for j in range(i + 1, n):\n good = nums[i] != nums[j]\n if not good:\n pick = max(pick, 1 + f(j, k))\n # print(\"not good\", i, j, pick)\n\n if k:\n pick = max(pick, 1 + f(j, k - 1))\n # print(\"good\", i, j, pick)\n \n \n # print(i, k, \"pick\", pick)\n return pick\n\n n = len(nums)\n \n return max(f(i, k) for i in range(n))\n","runtime":"7554"},{"code":"\ndef get_dp(dp, k, n, m):\n if k >= len(dp):\n return 0\n if n >= len(dp[0]):\n return 0\n if m >= len(dp[0][0]):\n return 0\n \n return dp[k][n][m]\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if not nums:\n return 0\n # k inequalities\n # starting from index n\n # being m the current active number\n unique_nums = list(set(nums))\n reverse_lookup = {num: idx for idx, num in enumerate(unique_nums)}\n # dp: k x n x m\n n = len(nums)\n dp = [[[0] * len(unique_nums) for _ in range(n)] for _ in range(k + 1)]\n\n for curr_k in range(k + 1):\n for idx in reversed(range(n)):\n for m_idx in range(len(unique_nums)):\n # taking the current number\n curr_num = unique_nums[m_idx]\n next_k = curr_k - 1 if nums[idx] != curr_num else curr_k\n # if k would become negative, we cannot chose the current element\n taking = 0\n if next_k >= 0:\n taking = 1 + get_dp(dp, next_k, idx + 1, reverse_lookup[nums[idx]])\n\n # not taking\n not_taking = get_dp(dp, curr_k, idx + 1, m_idx)\n # print(len(dp), len(dp[0]), len(dp[0][0]), curr_k, idx, m_idx)\n dp[curr_k][idx][m_idx] = max(taking, not_taking)\n \n\n best = 0\n\n for start in range(len(unique_nums)):\n best = max(dp[k][0][start], best)\n\n return best\n","runtime":"7668"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n @cache\n def dp(currentIdx: int, lastChosen: int, remaining: int) -> int:\n if remaining < 0:\n # because you have chosen a forbidden item\n return -1\n if currentIdx >= n:\n return 0\n\n notChoose = dp(currentIdx + 1, lastChosen, remaining)\n choose = 1 + dp(currentIdx + 1, nums[currentIdx], remaining - (1 if nums[currentIdx] != lastChosen else 0))\n\n return max(notChoose, choose)\n \n # if remaining is equal to k, then lastChosen should not matter\n res = dp(0, float('inf'), k+1)\n dp.cache_clear()\n return res","runtime":"7783"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n @cache\n def f(i, j):\n max_len = 1\n for m in range(i + 1, n):\n nj = j + int(nums[m] != nums[i])\n if nj <= k:\n max_len = max(max_len, f(m, nj) + 1)\n return max_len\n\n return max(f(l, 0) for l in range(n))","runtime":"7897"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n @cache\n def dp(index, rem):\n if rem < 0: return -math.inf\n if index == n - 1: return 1\n res = 1\n for j in range(index + 1, n):\n res = max(res, 1 + dp(j, rem - int(nums[index] != nums[j])))\n return res\n res = 1\n for i in range(n):\n res = max(res, dp(i, k))\n return res\n ","runtime":"8011"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def f(i, j):\n n = 1\n for m in range(i+1, len(nums)):\n nj = j+int(nums[m] != nums[i])\n if nj <= k:\n n = max(n, f(m, nj) + 1)\n return n\n return max(f(l, 0) for l in range(len(nums)))","runtime":"8125"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\n self.helper(nums, 0, k, dp)\n return max([l[k] for l in dp])\n \n def helper(self, nums, index, k, dp):\n if index >= len(nums) or k <= -1:\n return 0\n if dp[index][k] != -1:\n return dp[index][k]\n output = 0\n for i in range(index+1, len(nums)):\n if nums[index] != nums[i] and k > 0:\n self.helper(nums, i, k-1, dp)\n output = max(output, dp[i][k-1])\n elif nums[index] == nums[i]:\n self.helper(nums, i, k, dp)\n output = max(output, dp[i][k])\n # print(index, k, output)\n output += 1\n dp[index][k] = output\n # for i in range(0, k+1):\n # if dp[index][i] == -1 or dp[index][i] < output:\n # dp[index][i] = output\n return max(output, self.helper(nums, index+1, k, dp))","runtime":"8239"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\n self.helper(nums, 0, k, dp)\n return max([l[k] for l in dp])\n \n def helper(self, nums, index, k, dp):\n if index >= len(nums) or k <= -1:\n return 0\n if dp[index][k] != -1:\n return dp[index][k]\n output = 0\n for i in range(index+1, len(nums)):\n if nums[index] != nums[i] and k > 0:\n self.helper(nums, i, k-1, dp)\n output = max(output, dp[i][k-1])\n elif nums[index] == nums[i]:\n self.helper(nums, i, k, dp)\n output = max(output, dp[i][k])\n # print(index, k, output)\n output += 1\n dp[index][k] = output\n # for i in range(0, k+1):\n # if dp[index][i] == -1 or dp[index][i] < output:\n # dp[index][i] = output\n return max(output, self.helper(nums, index+1, k, dp))","runtime":"8239"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n dp= [[1]*(k+1) for _ in range(len(nums))]\n \n maxl=1\n for i in range(len(nums)-1):\n for j in range(i+1, len(nums)):\n if nums[j]==nums[i]:\n for n in range(k+1):\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\n maxl=max(maxl,dp[j][n])\n if nums[j] !=nums[i]:\n for n in range(k):\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\n maxl=max(maxl,dp[j][n+1])\n return maxl\n","runtime":"8353"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ck = set(nums)\n d = {}\n ct = 0\n for i in sorted(ck):\n d[i] = ct\n ct += 1\n n = len(nums)\n nums = [d[i] for i in nums]\n print(nums)\n dp = [[[-float('inf')]*(k+1) for _ in range(ct)] for _ in range(n + 1)] \n dp[0][nums[0]][0] = 0\n ans = 0\n for i in range(1, n+1):\n dp[i][nums[i-1]][0] = 1\n for j in range(ct):\n for kk in range(k+1):\n dp[i][j][kk] = max(dp[i-1][j][kk], dp[i][j][kk])\n if nums[i-1] == j:\n dp[i][nums[i-1]][kk] = max(dp[i][nums[i-1]][kk], 1 + dp[i-1][j][kk])\n elif kk + 1 <= k:\n dp[i][nums[i-1]][kk + 1] = max(dp[i][nums[i-1]][kk + 1], 1 + dp[i-1][j][kk])\n ans = max(ans, dp[i][nums[i-1]][kk])\n # for i in dp:\n # print('-'*19)\n # print(i)\n return ans","runtime":"8467"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[1]*(k+1) for _ in range(len(nums))]\n ans= 1\n for i in range(len(nums)):\n for j in range(k+1):\n for l in range(i):\n if nums[l] == nums[i]:\n dp[i][j] = max(dp[i][j], dp[l][j]+1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\n ans = max(ans, dp[i][j])\n\n\n\n return ans","runtime":"8581"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[i][j]: length of the longest subseq ending at index i with at most j places where adjacent elements are not equal\n \"\"\"\n dp = [[1] * (k+1) for _ in range(len(nums))]\n\n # if we consider just the one element at index i in the subseq, ans = 1 -> base case\n\n max_len = 1\n\n for i in range(len(nums)):\n for j in range(i):\n for l in range(k+1):\n if nums[i] == nums[j]:\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\n elif l > 0: # consider the one with l-1\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\n max_len = max(max_len, dp[i][l])\n\n # max value in the dp is the ans\n return max_len","runtime":"8695"},{"code":"class Solution:\n def __init__(self):\n self.a1=[]\n self.res=0\n def dp(self,a,i,k):\n if i==len(a)-1:\n self.a1[i][k]=1\n # self.res=max(self.res,self.a1[str(i)+' '+str(k)])\n return\n elif self.a1[i][k]!=-1:\n return\n else:\n o=1\n for j in range(i+1,len(a)):\n if i==-1:\n self.dp(a,j,k)\n o=max(o,self.a1[j][k]+1)\n continue\n if a[j]!=a[i] and k>0:\n self.dp(a,j,k-1)\n o=max(o,self.a1[j][k-1]+1)\n if a[j]==a[i]:\n self.dp(a,j,k)\n o=max(o,self.a1[j][k]+1)\n if i==-1:\n o-=1\n self.a1[i][k]=o\n # self.res=max(self.res,o)\n def maximumLength(self, nums: List[int], k: int) -> int:\n for i in range(len(nums)):\n e=[]\n for j in range(k+1):\n e.append(-1)\n self.a1.append(e)\n self.dp(nums,-1,k)\n s1=0\n for i in range(len(nums)):\n s1=max(s1,self.a1[i][k])\n return s1\n","runtime":"8695"},{"code":"import collections\nfrom typing import List\n\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = collections.defaultdict(int)\n\n def dfs(total_diff_count, _i):\n key = (total_diff_count, _i)\n if key in dp:\n return dp[key]\n result = 1\n previous = nums[_i]\n for next_i in range(_i + 1, len(nums)):\n if nums[next_i] == previous:\n result = max(result, 1 + dfs(total_diff_count, next_i))\n else:\n if total_diff_count < k:\n result = max(result, 1 + dfs(total_diff_count + 1, next_i))\n\n dp[key] = result\n return result\n\n return max(dfs(0, i) for i in range(len(nums)))","runtime":"8809"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if k >= len(nums) - 1:\n return len(nums)\n elif k == 0:\n return max(v for k, v in Counter(nums).items())\n \n dp = [[float('-inf')] * (k + 1) for _ in range(len(nums))]\n res = 0\n for i in range(len(dp)):\n dp[i][0] = 1\n for i in range(1, len(nums)):\n for l in range(k + 1): # Can reduce\n for j in range(i):\n if nums[j] != nums[i] and l > 0:\n # transition case\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\n elif nums[j] == nums[i]:\n # No transition\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\n res = max(res, dp[i][l])\n return res","runtime":"8923"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n ans = 0\n # dp[i][j] means the longest subsequence ending at index i with at most j changes\n dp = [[1] * (k + 1) for _ in range(n)]\n \n for i in range(n):\n for j in range(k + 1):\n for l in range(i):\n if nums[i] == nums[l]:\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\n ans = max(ans, dp[i][j])\n print(ans)\n \n return max(max(row) for row in dp)\n ","runtime":"8923"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n dp = [defaultdict(int) for i in range(k + 1)]\\n res = [0] * (k + 1)\\n for a in A:\\n for i in range(k, -1, -1):\\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\\n res[i] = max(res[i], dp[i][a])\\n return res[k]\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n fs = {}\\n records = [[0] * 3 for _ in range(k + 1)]\\n for x in nums:\\n if x not in fs:\\n fs[x] = [0] * (k + 1)\\n f = fs[x]\\n for j in range(k, -1, -1):\\n f[j] += 1\\n if j > 0:\\n mx, mx2, num = records[j - 1]\\n f[j] = max(f[j], (mx if x != num else mx2) + 1)\\n\\n # records[j] 维护 fs[.][j] 的 mx, mx2, num\\n v = f[j]\\n p = records[j]\\n if v > p[0]:\\n if x != p[2]:\\n p[2] = x\\n p[1] = p[0]\\n p[0] = v\\n elif x != p[2] and v > p[1]:\\n p[1] = v\\n return records[k][0]\\n\",\n \"runtime\": \"140\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n # dp_prev = dp[:]\\n # dp = [0] * (last_index + 1)\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if prev != 0:\\n dp[j][n] = max(dp[j][n], prev + 1)\\n # dp[j][n] = max(max(dp[j - 1][:n] + dp[j - 1][n + 1:]) + 1, dp[j][n] + 1)\\n\\n # max([max(dp_elem) for dp_elem in dp])\\n\\n # out = max([max(dp_elem)])\\n\\n print(dp)\\n\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n \",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n if prev != 0:\\n dp[j][n] = max(dp[j][n], prev + 1)\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n \",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if prev != 0:\\n dp[j][n] = max(dp[j][n], prev + 1)\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n \",\n \"runtime\": \"368\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n if prev != 0:\\n dp[j][n] = max(dp[j][n], prev + 1)\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n \",\n \"runtime\": \"368\"\n },\n {\n \"code\": \"class Solution:\\n # dp[k][i] = max(dp[k][s], max(dp[k-1][j<i])+1, nums[s]=nums[i]\\n # O(n^2) implementation\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n d = [0]*(n+1) # 0 is sentinel\\n # p is dp[k], d is dp[k-1]\\n for it in range(k+1):\\n p = [0]*(n+1)\\n prev = Counter()\\n for i,v in enumerate(nums,start=1):\\n p[i] = max(prev[v], max(d[:i]))+1\\n prev[v] = p[i]\\n d = p\\n #\\n return max(d) \\n \",\n \"runtime\": \"482\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = {}\\n n = len(nums)\\n for x in nums:\\n if not x in dp:\\n dp[x]=[0]*(k+1)\\n xr = dp[x]\\n for r in range(0,k+1):\\n if xr[r] > 0 or r == 0:\\n xr[r] += 1\\n for y in dp:\\n if y != x:\\n for r in range(0,k):\\n if dp[y][r]>=xr[r+1]:\\n xr[r+1] = dp[y][r]+1\\n maxlen = 0\\n for x in dp:\\n m = max(dp[x])\\n if m>maxlen:\\n maxlen = m\\n\\n print(dp)\\n return maxlen\\n\",\n \"runtime\": \"596\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = defaultdict(lambda:(defaultdict(lambda:0)))\\n if len(nums) == 1: return 1\\n for x in nums:\\n for i in range(k+1):\\n d = dp[i]\\n d[x] += 1\\n v = max([d[y] for y in d if y != x], default=0)\\n dp[i+1][x] = max(dp[i+1][x], v)\\n return max(max(dp[i].values()) for i in range(k+1) if dp[i])\",\n \"runtime\": \"596\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n '''\\n * * * * \\n [1, 2, 1, 1, 3], if k = 2\\n j i\\n x x x x x \\n\\n dp[i][t] = the maximum possible length of a good subsequenc of nums[0:i] and t imes on such that seq[j] != seq[j + 1]\\n\\n if nums[i] == nums[j]\\n = max(, dp[j][t] + 1) \\n else:\\n max(, dp[j][t-1] + 1)\\n\\n ---\\n i\\n x x x x x \\n dfs(i) = dfs(i-1, t) + dfs(i-1, t-1) + 1\\n\\n '''\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k + 1) for _ in range(n)]\\n last_seen = {}\\n\\n for i in range(n):\\n for t in range(k + 1):\\n dp[i][t] = 1\\n if nums[i] in last_seen:\\n j = last_seen[nums[i]]\\n dp[i][t] = max(dp[i][t], dp[j][t] + 1)\\n for prev_num, j in last_seen.items():\\n if prev_num != nums[i] and t > 0:\\n dp[i][t] = max(dp[i][t], dp[j][t - 1] + 1)\\n last_seen[nums[i]] = i\\n\\n return max(max(row) for row in dp)\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"710\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k + 1) for _ in range(n + 1)]\\n for i in range(n - 1, -1, -1):\\n for j in range(k + 1):\\n dp[i][j] = 1\\n for i0 in range(i + 1, n):\\n if nums[i0] == nums[i]:\\n dp[i][j] = max(dp[i][j], dp[i0][j] + 1)\\n break\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[i0][j - 1] + 1)\\n return max(dp[i][k] for i in range(n))\",\n \"runtime\": \"824\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n mp = {}\\n dp = [[0 for _ in range(k+1)] for _ in range(n)]\\n\\n for i in range(n):\\n for j in range(k+1):\\n for v in mp:\\n if j == 0 and v != nums[i]: continue\\n if v == nums[i]: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j])\\n else: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j-1])\\n mp[nums[i]] = i\\n \\n res = 0\\n for i in range(n):\\n res = max(max(dp[i]), res)\\n return res+1\",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n mp = {}\\n dp = [[0 for _ in range(k+1)] for _ in range(n)]\\n\\n for i in range(n):\\n for j in range(k+1):\\n dp[i][j] = 1\\n for v in mp:\\n if j == 0 and v != nums[i]: continue\\n if v == nums[i]: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j])\\n else: dp[i][j] = max(dp[i][j], 1+dp[mp[v]][j-1])\\n mp[nums[i]] = i\\n \\n res = 0\\n for i in range(n):\\n res = max(max(dp[i]), res)\\n return res\",\n \"runtime\": \"1052\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n #print(n)\\n dp_el = [[0 for j in range(k+1)] for i in range(n)]\\n dp = [[0 for j in range(k+1)] for i in range(n)]\\n nmap = {}\\n for i in range(n):\\n for j in range(k+1):\\n if i == 0:\\n dp[i][j] = 1\\n dp_el[i][j] = 1\\n elif j == 0:\\n dp[i][j] = max([nums[:i+1].count(x) for x in set(nums[:i+1])])\\n dp_el[i][j] = nums[:i+1].count(nums[i])\\n else:\\n dp_el[i][j] = dp[i-1][j-1] + 1\\n if nums[i] in nmap:\\n dp_el[i][j] = max(dp_el[nmap[nums[i]]][j] + 1, dp_el[i][j])\\n dp[i][j] = max(dp_el[i][j], dp[i-1][j])\\n nmap[nums[i]] = i\\n return dp[n-1][k]\",\n \"runtime\": \"1166\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1 for _ in nums]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp[idx] = sub + 1\\n return max(dp)\",\n \"runtime\": \"1280\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n dp.extend(\\n 1 + max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n for idx in range(1, len(nums))\\n )\\n \\n return max(dp)\",\n \"runtime\": \"1394\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n for idx in range(1, len(nums)):\\n ans = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n ) + 1\\n dp.append(ans)\\n return max(dp)\",\n \"runtime\": \"1394\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n for idx in range(1, len(nums)):\\n ans = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n ) + 1\\n dp.append(ans)\\n \\n return max(dp)\",\n \"runtime\": \"1508\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1 for _ in nums]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp[idx] = sub + 1\\n return max(dp)\",\n \"runtime\": \"1623\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n for idx in range(1, len(nums)):\\n ans = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n ) + 1\\n dp.append(ans)\\n \\n return max(dp)\",\n \"runtime\": \"1737\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1 for _ in nums]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp[idx] = sub + 1\\n return max(dp)\",\n \"runtime\": \"1851\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1 for _ in nums]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp[idx] = sub + 1\\n return max(dp)\",\n \"runtime\": \"1965\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp.append(sub + 1)\\n return max(dp)\",\n \"runtime\": \"2079\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1 for _ in nums]\\n for idx in range(1, len(nums)):\\n sub = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n )\\n dp[idx] = sub + 1\\n return max(dp)\",\n \"runtime\": \"2193\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[j, k_left] = max(dp[j], if nums[j] == nums[prev]: dp[prev, k_left] + 1 else max(dp[prev, k_left - 1] + 1 for each prev)\\n \\n dp = [0 for i in range(len(nums))] # dp[j] = maximum length for k-1 including nums[j]\\n for k_left in range(k+1):\\n prevDP = dp[:]\\n for i in range(len(nums)):\\n if i == 0:\\n dp[0] = 1\\n else:\\n dp[i] = max(dp[i], max(1 + dp[j] if nums[i] == nums[j] else prevDP[j] + 1 for j in range(i)))\\n return max(dp)\",\n \"runtime\": \"2307\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[j, k_left] = max length ending (and including) nums[j] of nums[0..j] with k_left differences \\n # dp[j, k_left] = max(dp[j], if nums[j] == nums[prev]: dp[prev, k_left] + 1 else max(dp[prev, k_left - 1] + 1 for each prev)\\n # ans = max(dp[-1, k])\\n dp = [0 for i in range(len(nums))] # dp[j] = maximum length for k-1 including nums[j]\\n for k_left in range(k+1):\\n prevDP = dp[:]\\n for i in range(len(nums)):\\n if i == 0:\\n dp[0] = 1\\n else:\\n dp[i] = max(dp[i], max(1 + dp[j] if nums[i] == nums[j] else prevDP[j] + 1 for j in range(i)))\\n return max(dp)\",\n \"runtime\": \"2421\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def findPre(idx):\\n search = nums[idx]\\n while idx:\\n idx -= 1\\n if nums[idx] == search: return idx\\n return 0\\n @cache\\n def maxLength(diff,idx):\\n if idx == 0: return 1\\n ans = 1\\n for i in range(findPre(idx),idx):\\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\\n choice2 = maxLength(diff-1,i) if diff else 0\\n ans = max(ans,1+max(choice1,choice2))\\n return ans\\n return max(maxLength(k,i) for i in range(len(nums)))\",\n \"runtime\": \"2535\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n cnt1 = Counter(nums)\\n res = max(cnt1.values())\\n \\n d = collections.defaultdict(dict)\\n d[nums[0]][k] = 1\\n for i in range(1, len(nums)):\\n if nums[i] in d:\\n for cnt in d[nums[i]]:\\n d[nums[i]][cnt] += 1\\n res = max(res, d[nums[i]][cnt])\\n else:\\n d[nums[i]][k] = 1\\n \\n for num in d:\\n if num != nums[i]:\\n for cnt in d[num]:\\n if cnt:\\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), d[num][cnt]+1)\\n \\n res = max(res, d[nums[i]][cnt-1])\\n \\n # print(d, nums[i], res)\\n return res\\n \\n \\n \",\n \"runtime\": \"2649\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\\n # print(dp)\\n # for k == 0:\\n for i in range(1, n):\\n for j in range(i):\\n if nums[i] == nums[j]:\\n dp[i] = (dp[j][0] + 1, 0)\\n # print(0, dp)\\n\\n for tmpk in range(1, k+1):\\n tmpDP = [(0, 0) for _ in range(n)]\\n tmpDP[0] = (1, 0)\\n for i in range(1, n):\\n for j in range(i):\\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\\n dp = tmpDP\\n # print(tmpk, dp)\\n \\n return max(dp)[0]\",\n \"runtime\": \"2763\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\\n # print(dp)\\n # for k == 0:\\n for i in range(1, n):\\n for j in range(i):\\n if nums[i] == nums[j]:\\n dp[i] = (dp[j][0] + 1, 0)\\n # print(0, dp)\\n\\n for tmpk in range(1, k+1):\\n tmpDP = [(0, 0) for _ in range(n)]\\n tmpDP[0] = (1, 0)\\n for i in range(1, n):\\n for j in range(i):\\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\\n dp = tmpDP\\n # print(tmpk, dp)\\n \\n return max(dp)[0]\",\n \"runtime\": \"2877\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''\\n subsequence, at most k pairs (i,i+1) are not equal\\n DP[i,k] = for each j < i, for each level of k\\n if j==i, DP[j]\\n if j!=i, we will use up a k\\n '''\\n\\n # k == 0\\n DP = [1]*len(nums)\\n counter = defaultdict(int)\\n for i in range(len(nums)): # longest subsequence with duplicates => we could use counter too\\n counter[nums[i]] += 1\\n DP[i] = counter[nums[i]]\\n\\n for _ in range(min(k,len(nums))):\\n # compute DP[i], LS with k pairs of non equal\\n DP_next = [1]\\n for i in range(1, len(nums)):\\n DP_next_i = 1\\n for j in range(i):\\n if nums[j] == nums[i]:\\n DP_next_i = max(DP_next_i, DP_next[j]+1)\\n else:\\n DP_next_i = max(DP_next_i, DP[j]+1)\\n DP_next.append(DP_next_i)\\n DP = DP_next\\n\\n return max(DP)\",\n \"runtime\": \"2991\"\n },\n {\n \"code\": \"from collections import defaultdict\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''\\n subsequence, at most k pairs (i,i+1) are not equal\\n DP[i,k] = for each j < i, for each level of k\\n if j==i, DP[j]\\n if j!=i, we will use up a k\\n '''\\n\\n # k == 0\\n DP = [1]*len(nums)\\n counter = defaultdict(int)\\n for i in range(len(nums)): # longest subsequence with duplicates => we could use counter too\\n counter[nums[i]] += 1\\n DP[i] = counter[nums[i]]\\n\\n for _ in range(k):\\n # compute DP[i], LS with k pairs of non equal\\n DP_next = [1]\\n for i in range(1, len(nums)):\\n DP_next_i = 1\\n for j in range(i):\\n if nums[j] == nums[i]:\\n DP_next_i = max(DP_next_i, DP_next[j]+1)\\n else:\\n DP_next_i = max(DP_next_i, DP[j]+1)\\n DP_next.append(DP_next_i)\\n DP = DP_next\\n\\n return max(DP)\",\n \"runtime\": \"3105\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [1 for j in range(n)]\\n for j in range(1, n):\\n for h in range(j):\\n if nums[h] == nums[j]:\\n dp[j] = dp[h] + 1\\n for i in range(1, k + 1):\\n temp = dp.copy()\\n for j in range(1, n):\\n for h in range(j):\\n if nums[h] == nums[j]:\\n dp[j] = max(dp[j], dp[h] + 1)\\n else:\\n dp[j] = max(dp[j], temp[h] + 1)\\n return max(dp)\\n\",\n \"runtime\": \"3220\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = []\\n for idx in range(len(nums)):\\n ans = 1\\n for j in range(idx):\\n if nums[j] == nums[idx]:\\n ans = max(ans, dp[j] + 1)\\n else:\\n ans = max(ans, prev[j] + 1)\\n dp.append(ans)\\n \\n return max(dp)\",\n \"runtime\": \"3334\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # convert to at most n\\n mapping = dict()\\n next_index = 0 # mapped as 0<-n-1\\n for i, v in enumerate(nums):\\n if v not in mapping:\\n mapping[v] = next_index\\n next_index += 1 \\n \\n nums[i] = mapping[v]\\n # print(nums)\\n max_val = next_index-1\\n dp = [[0]*(k+1) for _ in range(max_val+1)]\\n # dp[index][last_value < (max_val)][current_k <= k] => current longest length\\n ans = 0\\n for i, v in enumerate(nums):\\n # continues value case\\n ndp = [list(v) for v in dp]\\n for nk in range(k+1):\\n for last_v in range(max_val+1):\\n if v==last_v:\\n ndp[v][nk] = max(\\n ndp[v][nk],\\n dp[v][nk] + 1 # as same as last value\\n )\\n elif nk >0 :\\n ndp[v][nk] = max(\\n ndp[v][nk],\\n dp[last_v][nk-1] + 1 # nk will be increase and length is also increased\\n )\\n ans = max(ans, ndp[v][nk])\\n #print(dp)\\n dp = ndp\\n return ans\\n\\n \\n\\n\\n \\n\\n\\n\\n\\n \\n def wrong(self):\\n # nums\\n # k>=0\\n # seq is good-> mat most k has\\n # nums[left] to nums[right]\\n left = 0\\n right = 0 # if left=0, right=0, only 1 elements\\n not_same_count = 0 # seq[i] != seq[i+1] count in [left:right+1] \\n ans = 1\\n while right < len(nums)-1 and left < len(nums) - 1:\\n print(left, right)\\n right_next_is_same = (nums[right] == nums[right+1])\\n left_next_is_same = (nums[left] == nums[left+1])\\n if not_same_count + int(not right_next_is_same) <= k :\\n right +=1\\n not_same_count += int(not right_next_is_same)\\n ans = max(ans, right-left+1)\\n else:\\n left += 1\\n not_same_count -= int(not right_next_is_same)\\n # ans will not be updated...\\n return ans\\n\\n \\n\\n\\n\\n\",\n \"runtime\": \"3448\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n - dp[k][i] = max length of good subsequence from nums[i : ] \\n with k indices left\\n \\\"\\\"\\\"\\n n = len(nums)\\n prev = [0] * n\\n for _ in range(k + 1):\\n cur = [1] * n\\n for i in range(n - 1, -1, -1):\\n for j in range(i + 1, n):\\n if nums[i] == nums[j]:\\n cur[i] = max(cur[i], 1 + cur[j])\\n else:\\n cur[i] = max(cur[i], 1 + prev[j])\\n prev = cur\\n return max(prev)\",\n \"runtime\": \"3562\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], max_k: int) -> int:\\n\\n n = len(nums)\\n\\n dp = [1 for i in range(n)]\\n\\n\\n\\n for k in range(0,max_k + 1):\\n dp2 = [1 for i in range(n)]\\n for i in range(n):\\n for j in range(i - 1,-1,-1):\\n if k != 0 and nums[i] != nums[j]:\\n dp2[i] = max(dp2[i], dp[j] + 1)\\n elif nums[i] == nums[j]:\\n dp2[i] = max(dp2[i], dp2[j] + 1) \\n dp = dp2\\n return max(dp2)\\n \",\n \"runtime\": \"3676\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n\\n dp = [[0] * (k + 1) for _ in range(n)]\\n ret = 0\\n for i in range(n):\\n for t in range(k + 1):\\n ans = 1\\n for j in range(i):\\n if nums[j] == nums[i]:\\n ans = max(ans, dp[j][t] + 1)\\n elif t >= 1:\\n ans = max(ans, dp[j][t - 1] + 1)\\n dp[i][t] = ans\\n ret = max(ret, ans)\\n return ret\",\n \"runtime\": \"3790\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[i][j] -> max length of subsequence that ends\\n at index i with and has j neighbouring elements\\n with different charactes\\n dp[i][j] = 1 + max(dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j-1 >= 0\\n for 0<=l<i)\\n dp[0][0] = 1\\n dp[0][i] = 0 for i > 0\\n dp[i][j] = 0 for j > i\\n \\\"\\\"\\\"\\n n = len(nums)\\n dp = [[0] * (k + 1) for _ in range(n)]\\n dp[0][0] = 1\\n res_max = 1\\n # for i in range(1, n):\\n # for j in range(min(i+1, k+1)):\\n for j in range(k+1):\\n for i in range(1, n):\\n res = 0\\n for l in range(i):\\n res = max(res, dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j - 1 >= 0 else 0)\\n\\n dp[i][j] = res + 1\\n res_max = max(res_max, dp[i][j])\\n\\n return res_max\\n\",\n \"runtime\": \"3904\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n tracked = [[0 for j in range(len(nums))] for i in range(k+1)]\\n\\n for i in range(k+1):\\n tracked[i][0] = 1\\n\\n for i in range(1,len(nums)):\\n tracked[0][i] = 1\\n for j in range(i):\\n #print(\\\"num1\\\",i, \\\"num2\\\",j)\\n if nums[i] == nums[j]:\\n #print(\\\"here\\\")\\n for v in range(k+1):\\n tracked[v][i] = max(tracked[v][i], tracked[v][j]+1)\\n #print(tracked[v][i])\\n else:\\n for v in range(1, k+1):\\n tracked[v][i] = max(tracked[v][i], tracked[v-1][j]+1)\\n #print(tracked)\\n return max(tracked[-1])\",\n \"runtime\": \"4018\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for _ in range(k+1)] for __ in range(len(nums))]\\n for i in range(len(nums)):\\n dp[i][0] = 1\\n for i in range(1,len(nums)):\\n for j in range(0,i):\\n if nums[i] == nums[j]:\\n for kk in range(k+1):\\n dp[i][kk] = max(dp[i][kk], dp[j][kk] + 1)\\n else:\\n for kk in range(1,k+1):\\n dp[i][kk] = max(dp[i][kk], dp[j][kk-1] + 1)\\n # print(dp)\\n return max(max(dp[i]) for i in range(len(dp)))\",\n \"runtime\": \"4132\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[1 for _ in range(k+1)] for _ in range(len(nums))]\\n\\n max_len = 1\\n for i in range(1, len(nums)):\\n for j in range(i):\\n if nums[i] == nums[j]:\\n for l in range(k+1):\\n dp[i][l] = max(dp[i][l], dp[j][l]+1)\\n else:\\n for l in range(k):\\n dp[i][l+1] = max(dp[i][l+1], dp[j][l]+1)\\n max_len = max(max(dp[i]), max_len)\\n return max_len\\n \",\n \"runtime\": \"4246\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\\n\\n for idx in range(n - 1, -1, -1):\\n for j in range(k + 1):\\n if idx == n - 1:\\n dp[idx][j] = 1\\n else:\\n ans = -float(\\\"inf\\\")\\n for ptr in range(idx + 1, n):\\n if nums[idx] != nums[ptr]:\\n ans = max(1 + (dp[ptr][j - 1] if j >= 1 else 0), ans)\\n else:\\n ans = max(1 + dp[ptr][j], ans)\\n \\n dp[idx][j] = ans\\n \\n return max(map(max, dp))\",\n \"runtime\": \"4360\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[i][j] -> max length of subsequence that ends\\n at index i with and has j neighbouring elements\\n with different charactes\\n dp[i][j] = 1 + max(dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j-1 >= 0\\n for 0<=l<i)\\n dp[0][0] = 1\\n dp[0][i] = 0 for i > 0\\n dp[i][j] = 0 for j > i\\n \\\"\\\"\\\"\\n n = len(nums)\\n dp = [[0] * (k + 1) for _ in range(n)]\\n dp[0][0] = 1\\n res_max = 1\\n for i in range(1, n):\\n for j in range(min(i+1, k+1)):\\n res = 0\\n for l in range(i):\\n res = max(res, dp[l][j] if nums[l] == nums[i] else dp[l][j-1] if j - 1 >= 0 else 0)\\n\\n dp[i][j] = res + 1\\n res_max = max(res_max, dp[i][j])\\n\\n return res_max\\n\",\n \"runtime\": \"4474\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n dp = [[0] * (k + 1) for _ in range(N + 1)]\\n max_len = 0\\n for i in reversed(range(N)):\\n for g in range(k + 1):\\n res = 1\\n for j in range(i + 1, N):\\n if nums[i] == nums[j]:\\n res = max(res, 1 + dp[j][g])\\n elif g + 1 <= k:\\n res = max(res, 1 + dp[j][g + 1])\\n dp[i][g] = res\\n max_len = max(max_len, dp[i][g])\\n return max_len\\n\\n @cache\\n def dfs(i, g):\\n res = 1\\n for j in range(i + 1, N):\\n if nums[i] == nums[j]:\\n res = max(res, 1 + dfs(j, g))\\n elif g + 1 <= k:\\n res = max(res, 1 + dfs(j, g + 1))\\n return res \\n N = len(nums)\\n return max(dfs(i, 0) for i in range(N))\",\n \"runtime\": \"4817\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1 for _ in range(n)] for _ in range(k + 1)]\\n for i in range(n - 2, -1, -1):\\n for j in range(i + 1, n):\\n if nums[i] == nums[j]:\\n dp[0][i] = max(dp[0][i], 1 + dp[0][j])\\n for l in range(1, k + 1):\\n for i in range(n - 2, -1, -1):\\n for j in range(i + 1, n):\\n if nums[i] == nums[j]:\\n dp[l][i] = max(dp[l][i], 1 + dp[l][j])\\n else:\\n dp[l][i] = max(dp[l][i], 1 + dp[l - 1][j])\\n \\n return max(map(max, dp))\\n\",\n \"runtime\": \"4931\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1 for _ in range(k + 1)] for _ in range(n)]\\n for i in range(1, n):\\n num = nums[i]\\n for j in range(i):\\n if num == nums[j]:\\n for p in range(k + 1):\\n dp[i][p] = max(dp[i][p], dp[j][p] + 1)\\n else:\\n for p in range(k):\\n dp[i][p + 1] = max(dp[i][p + 1], dp[j][p] + 1)\\n # for line in dp:\\n # print(line)\\n return max(dp[i][k] for i in range(n))\\n\",\n \"runtime\": \"5045\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n dp= [[1]* (k+1) for _ in range(len(nums))]\\n\\n maxl=1\\n for i in range(len(nums)):\\n for j in range(i):\\n if nums[i]==nums[j]:\\n for l in range(k+1):\\n dp[i][l]=dp[j][l]+1\\n else:\\n for l in range(k):\\n dp[i][l+1]=max(dp[i][l+1], dp[j][l]+1) \\n maxl=max(maxl,max(dp[i]))\\n return maxl\\n \\n \\n\\n\\n \\n # @cache\\n # def func(idx,d):\\n # if idx==len(nums):\\n # return 0\\n # if d>k:\\n # return float('-inf')\\n # v=0 \\n # for j in range(idx+1,len(nums)):\\n # if nums[j]!=nums[idx]: \\n # v= max(v,1+func(j,d+1))\\n # else:\\n # v=max(v,1+func(j,d))\\n # return v\\n\\n # res=0\\n\\n # for i in range(len(nums)):\\n # res=max(res, func(i,0)+1)\\n # return res\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n dp= [[1]*(k+1) for _ in range(len(nums))]\\n \\n maxl=1\\n for i in range(len(nums)-1):\\n for j in range(i+1, len(nums)):\\n if nums[j]==nums[i]:\\n for n in range(k+1):\\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\\n maxl=max(maxl,dp[j][n])\\n if nums[j] !=nums[i]:\\n for n in range(k):\\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\\n maxl=max(maxl,dp[j][n+1])\\n return maxl\\n\",\n \"runtime\": \"5159\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n dp= [[1]* (k+1) for _ in range(len(nums))]\\n\\n maxl=1\\n for i in range(len(nums)):\\n for j in range(i):\\n if nums[i]==nums[j]:\\n for l in range(k+1):\\n dp[i][l]=dp[j][l]+1\\n else:\\n for l in range(k):\\n dp[i][l+1]=max(dp[i][l+1], dp[j][l]+1) \\n maxl=max(maxl,max(dp[i]))\\n return maxl\\n \\n \\n\\n\\n \\n # @cache\\n # def func(idx,d):\\n # if idx==len(nums):\\n # return 0\\n # if d>k:\\n # return float('-inf')\\n # v=0 \\n # for j in range(idx+1,len(nums)):\\n # if nums[j]!=nums[idx]: \\n # v= max(v,1+func(j,d+1))\\n # else:\\n # v=max(v,1+func(j,d))\\n # return v\\n\\n # res=0\\n\\n # for i in range(len(nums)):\\n # res=max(res, func(i,0)+1)\\n # return res\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n dp= [[1]*(k+1) for _ in range(len(nums))]\\n \\n maxl=1\\n for i in range(len(nums)-1):\\n for j in range(i+1, len(nums)):\\n if nums[j]==nums[i]:\\n for n in range(k+1):\\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\\n maxl=max(maxl,dp[j][n])\\n if nums[j] !=nums[i]:\\n for n in range(k):\\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\\n maxl=max(maxl,dp[j][n+1])\\n return maxl\\n\",\n \"runtime\": \"5159\"\n },\n {\n \"code\": \"from functools import cache\\nfrom collections import Counter\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n nextd = [n]*n\\n counter = Counter()\\n for i in range(n-2,-1,-1):\\n if nums[i] != nums[i+1]:\\n nextd[i] = i+1\\n else:\\n nextd[i] = nextd[i+1]\\n nextcnt = [1]*n\\n for i in range(n-1,-1,-1):\\n counter[nums[i]] += 1\\n nextcnt[i] = counter[nums[i]]\\n @cache\\n def dfs(i,k):\\n if k == 0:\\n return nextcnt[i]\\n if i == n-1: return 1\\n res = 0\\n j = nextd[i]\\n while j < n:\\n if nums[i] != nums[j]:\\n res = max(res, dfs(j,k-1))\\n else:\\n res = max(res, dfs(j,k))\\n j = nextd[j]\\n return res + nextd[i] - i\\n return max([dfs(i,k) for i in range(n)])\",\n \"runtime\": \"5273\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k + 1) for i in range(n)]\\n dp[0][0] = 1\\n for i in range(1, n):\\n dp[i][0] = 1\\n for j in range(0, i):\\n if nums[i] == nums[j]:\\n for l in range(k+1):\\n if dp[j][l] != 0:\\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\\n else:\\n for l in range(k):\\n if dp[j][l] != 0:\\n dp[i][l+1] = max(dp[i][l+1], dp[j][l] + 1)\\n return max([max(row) for row in dp])\\n \",\n \"runtime\": \"5273\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n n = len(nums)\\n if n == 0:\\n return 0\\n \\n dp = [[1] * (k + 1) for _ in range(n)]\\n print(dp)\\n \\n for i in range(n):\\n for j in range(k + 1):\\n for l in range(i):\\n if nums[i] == nums[l]:\\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\\n \\n return max(max(row) for row in dp)\",\n \"runtime\": \"5387\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[-inf] * (k + 1) for _ in range(n)]\\n f[0][0] = 1\\n res = 1\\n\\n for i in range(1, n):\\n for u in range(0, k + 1):\\n f[i][u] = 1\\n for j in range(i - 1, -1, -1):\\n if nums[i] != nums[j]:\\n if u > 0:\\n f[i][u] = max(f[i][u], f[j][u - 1] + 1)\\n else:\\n f[i][u] = max(f[i][u], f[j][u] + 1)\\n res = max(res, f[i][u])\\n return res\\n \",\n \"runtime\": \"5387\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[i][j]: length of the longest subseq ending at index i with at most j places where adjacent elements are not equal\\n \\\"\\\"\\\"\\n dp = [[1] * (k+1) for _ in range(len(nums))]\\n\\n # if we consider just the one element at index i in the subseq, ans = 1 -> base case\\n\\n for i in range(len(nums)):\\n for j in range(i):\\n for l in range(k+1):\\n if nums[i] == nums[j]:\\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\\n elif l > 0: # consider the one with l-1\\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\\n\\n # max value in the dp is the ans\\n return max(max(row) for row in dp)\",\n \"runtime\": \"5501\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # ans = 0\\n # n = len(nums)\\n\\n # @cache\\n # def helper(k, i):\\n # if i >=n or k <0:\\n # return 0\\n # mx = 0\\n # for j in range(i+1, n):\\n # if nums[j] == nums[i]:\\n # mx = max(mx, helper(k, j))\\n # else:\\n # mx = max(mx, helper(k-1, j))\\n # return 1 + mx\\n\\n # for i in range(n):\\n # ans = max(ans, helper(k, i))\\n # return ans\\n \\n \\n n, k = len(nums), k+1\\n\\n dp = [[1] * k for _ in range(n)] # 1)\\n \\n for p, q in product(range(n), range(k)): # 2)\\n for r in range(p):\\n\\n if nums[p] == nums[r]:\\n dp[p][q] = max(dp[p][q], dp[r][q] + 1)\\n elif q:\\n dp[p][q] = max(dp[p][q], dp[r][q - 1] + 1)\\n\\n return max(chain(*dp)) \\n \",\n \"runtime\": \"5501\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[i][j] = max good subsequence of nums including i such that at most j possible skips\\n # dp[i][j] = max(dp[a][j] + 1 if nums[i] == nums[a] else dp[a][j - 1] + 1), 0 <= a < i\\n\\n dp = [[1 for i in range(k + 1)] for i in range(len(nums))]\\n mx = 1\\n for i in range(len(nums)):\\n for j in range(k + 1):\\n if i <= j:\\n dp[i][j] = i + 1\\n else:\\n for a in range(0, i):\\n if nums[i] == nums[a]:\\n dp[i][j] = max(dp[i][j], dp[a][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[a][j - 1] + 1)\\n mx = max(mx, dp[i][j])\\n return mx\",\n \"runtime\": \"5615\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n \\n dp = [[1]*(k+1) for _ in range(n)]\\n\\n for i in range(n):\\n for j in range(k+1):\\n for l in range(i):\\n if nums[i] == nums[l]:\\n dp[i][j]=max(dp[i][j], dp[l][j]+1)\\n elif j>0:\\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\\n \\n return max(max(row) for row in dp)\",\n \"runtime\": \"5615\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\ndp[i][k] -> until index i, with k the length of the valid sequence\\n\\nfor j in range(i+1, len(nums))\\n\\n\\\"\\\"\\\"\\nimport collections\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n res = 0\\n dp = [[1 for _ in range(k + 1)] for _ in range(len(nums))]\\n # dp = collections.defaultdict(dict)\\n # for i in range(len(nums)):\\n # for j in range(k+1):\\n # dp[i][j] = 1\\n # print(dp)\\n for i in range(len(nums)):\\n n = nums[i]\\n for v in range(k+1):\\n for j in range(i+1, len(nums)):\\n if nums[j] == n:\\n dp[j][v] = max(dp[j][v], dp[i][v] + 1)\\n elif v > 0:\\n dp[j][v-1] = max(dp[j][v-1], dp[i][v] + 1)\\n print(dp)\\n for i in range(len(nums)):\\n for j in range(k+1):\\n res = max(res, dp[i][j])\\n return res\\n\\n # def helper(index, remaining, path):\\n # nonlocal res\\n # if index >= len(nums):\\n # res = max(res, len(path))\\n # return\\n \\n # helper(index+1, remaining, path)\\n # if not path or nums[index] == path[-1]:\\n # helper(index+1, remaining, path + [nums[index]])\\n # else:\\n # if remaining > 0:\\n # helper(index+1, remaining-1, path + [nums[index]])\\n # return\\n \\n # helper(0, k, [])\\n # return res\",\n \"runtime\": \"5729\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[1] * (k + 1) for _ in range(n)]\\n ans = 0\\n for i, x in enumerate(nums):\\n for h in range(k + 1):\\n for j, y in enumerate(nums[:i]):\\n if x == y:\\n f[i][h] = max(f[i][h], f[j][h] + 1)\\n elif h:\\n f[i][h] = max(f[i][h], f[j][h - 1] + 1)\\n ans = max(ans, f[i][k])\\n return ans \",\n \"runtime\": \"5729\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n \\n dp = [[1] * (k + 1) for _ in range(n)]\\n \\n for i in range(n):\\n for j in range(k + 1):\\n for l in range(i):\\n if nums[i] == nums[l]:\\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\\n \\n return max(max(row) for row in dp)\\n \",\n \"runtime\": \"5843\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1] * (k + 1) for _ in range(n)]\\n\\n answer = 1\\n \\n for i in range(1, n):\\n for j in range(min(k + 1, n)):\\n for m in range(i):\\n if nums[m] == nums[i]:\\n dp[i][j] = max(dp[i][j], dp[m][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[m][j - 1] + 1)\\n \\n answer = max(answer, dp[i][j])\\n \\n return answer\\n\\n \",\n \"runtime\": \"5843\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[1 for _ in range(k + 1)] for _ in range(len(nums))]\\n for i in range(len(nums) - 2, -1, -1):\\n for j in range(k + 1):\\n for l in range(i + 1, len(nums)):\\n if nums[i] == nums[l]:\\n dp[i][j] = max(dp[i][j], 1 + dp[l][j])\\n else:\\n if j - 1 >= 0:dp[i][j] = max(dp[i][j], 1 + dp[l][j - 1])\\n mx = 1\\n for i in range(len(nums)):\\n mx = max(mx, dp[i][k])\\n return mx\",\n \"runtime\": \"5957\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if len(nums)==0:\\n return 0\\n\\n dp = [[1]*(k+1) for i in range(len(nums))]\\n\\n for i in range(len(nums)):\\n for j in range(k+1):\\n for t in range(i):\\n if nums[i]==nums[t]:\\n dp[i][j] = max(dp[i][j], dp[t][j]+1)\\n elif j>0:\\n dp[i][j] = max(dp[i][j], dp[t][j-1]+1)\\n return max(max(row) for row in dp)\",\n \"runtime\": \"5957\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1] * (k+1) for _ in range(n)]\\n for y in range(k+1):\\n for i in range(n):\\n for j in range(i):\\n if nums[i] == nums[j]:\\n dp[i][y] = max(dp[i][y],dp[j][y]+1)\\n elif y:\\n dp[i][y] = max(dp[i][y],dp[j][y-1]+1)\\n return max([dp[i][k] for i in range(n)])\\n\",\n \"runtime\": \"6071\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # ans = 0\\n # n = len(nums)\\n\\n # @cache\\n # def helper(k, i):\\n # if i >=n or k <0:\\n # return 0\\n # mx = 0\\n # for j in range(i+1, n):\\n # if nums[j] == nums[i]:\\n # mx = max(mx, helper(k, j))\\n # else:\\n # mx = max(mx, helper(k-1, j))\\n # return 1 + mx\\n\\n # for i in range(n):\\n # ans = max(ans, helper(k, i))\\n # return ans\\n\\n n=len(nums)\\n #dp=[[1 for i in range(k+1)] for j in range(n)]\\n dp = [[1]*(k+1) for _ in range(n)]\\n for i in range(n):\\n for j in range(k+1):\\n for p in range(0,i):\\n if(nums[i]==nums[p]):\\n dp[i][j]=max(dp[i][j],1+dp[p][j])\\n elif(nums[i]!=nums[p]):\\n if(j>0):\\n dp[i][j]=max(dp[i][j],1+dp[p][j-1])\\n # print(dp)\\n ans=0\\n for i in range(n):\\n for j in range(k+1):\\n ans=max(ans,dp[i][j])\\n return ans\\n \\n \\n \",\n \"runtime\": \"6071\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1 for j in range(n)] for i in range(k + 1)]\\n for j in range(1, n):\\n for h in range(j):\\n if nums[h] == nums[j]:\\n dp[0][j] = dp[0][h] + 1\\n for i in range(1, k + 1):\\n for j in range(1, n):\\n for h in range(j):\\n if nums[h] == nums[j]:\\n dp[i][j] = max(dp[i][j], dp[i - 1][j], dp[i][h] + 1)\\n else:\\n dp[i][j] = max(dp[i][j], dp[i - 1][j], dp[i - 1][h] + 1)\\n return max(dp[k])\\n\",\n \"runtime\": \"6186\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nums += [-1]\\n n = len(nums)\\n f = [[-inf]*(k+2) for _ in range(n)]\\n for i in range(n):\\n f[i][0] = 1\\n for j in range(i):\\n for t in range(min(i,k+1)+1): \\n if nums[i]==nums[j]:\\n f[i][t] = max(f[i][t], 1+f[j][t])\\n elif t>0:\\n f[i][t] = max(f[i][t], 1+f[j][t-1])\\n return max(f[-1])-1\\n\",\n \"runtime\": \"6186\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0 for i in range(k + 1)] for j in range(n)]\\n dp[0][0] = 1\\n for i in range(1, n):\\n dp[i][0] = 1\\n for j in range(0, i):\\n for m in range(k + 1):\\n if nums[i] == nums[j]:\\n if dp[j][m] != 0:\\n dp[i][m] = max(dp[i][m], dp[j][m] + 1)\\n elif m > 0 and dp[j][m-1] != 0:\\n dp[i][m] = max(dp[i][m], dp[j][m-1] + 1)\\n return max([max(dp[i]) for i in range(n)])\\n\",\n \"runtime\": \"6300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0]*(k+1) for _ in range(len(nums))]\\n ans = 1\\n for i in range(len(nums)):\\n f[i][0] = 1\\n for j in range(k+1):\\n for l in range(i):\\n if nums[l] == nums[i]:\\n f[i][j] = max(f[i][j], f[l][j]+1)\\n if j > 0:\\n f[i][j] = max(f[i][j], f[l][j-1]+1)\\n ans = max(ans, f[i][j])\\n return ans\\n\",\n \"runtime\": \"6300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n vals = set(nums)\\n d = {}\\n for x in vals:\\n d[x] = len(d)\\n tmp = []\\n for x in nums:\\n tmp.append(d[x])\\n n = max(tmp)\\n dp = [[0] * (k + 1) for _ in range(n + 1)]\\n x = tmp[0]\\n dp[x][0] = 1\\n #print(tmp)\\n for x in tmp[1:]:\\n ndp = copy.deepcopy(dp)\\n #print(dp)\\n for y in range(n + 1):\\n for used in range(k):\\n if y != x:\\n ndp[x][used + 1] = max(ndp[x][used + 1], dp[y][used] + 1)\\n else:\\n ndp[x][used] = max(ndp[x][used], dp[y][used] + 1)\\n ndp[x][k] = max(ndp[x][k], dp[y][k] + 1 if y == x else 0)\\n dp = ndp\\n \\n #print(dp)\\n ans = 0\\n for _, row in enumerate(dp):\\n for __, val in enumerate(row):\\n ans = max(ans, val)\\n return ans\",\n \"runtime\": \"6414\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 0\\n n = len(nums)\\n\\n @cache\\n def helper(k, i):\\n if i >=n or k <0:\\n return 0\\n mx = 0\\n for j in range(i+1, n):\\n if nums[j] == nums[i]:\\n mx = max(mx, helper(k, j))\\n else:\\n mx = max(mx, helper(k-1, j))\\n return 1 + mx\\n\\n for i in range(n):\\n ans = max(ans, helper(k, i))\\n return ans\",\n \"runtime\": \"6414\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n vals = set(nums)\\n d = {}\\n for x in vals:\\n d[x] = len(d)\\n tmp = []\\n for x in nums:\\n tmp.append(d[x])\\n n = max(tmp)\\n dp = [[0] * (k + 1) for _ in range(n + 1)]\\n x = tmp[0]\\n dp[x][0] = 1\\n #print(tmp)\\n for x in tmp[1:]:\\n ndp = copy.deepcopy(dp)\\n #print(dp)\\n for y in range(n + 1):\\n for used in range(k):\\n if y != x:\\n ndp[x][used + 1] = max(ndp[x][used + 1], dp[y][used] + 1)\\n else:\\n ndp[x][used] = max(ndp[x][used], dp[y][used] + 1)\\n ndp[x][k] = max(ndp[x][k], dp[y][k] + 1 if y == x else 0)\\n dp = ndp\\n \\n #print(dp)\\n ans = 0\\n for _, row in enumerate(dp):\\n for __, val in enumerate(row):\\n ans = max(ans, val)\\n return ans\",\n \"runtime\": \"6528\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 0\\n n = len(nums)\\n\\n @cache\\n def helper(k, i):\\n if i >=n or k <0:\\n return 0\\n mx = 0\\n for j in range(i+1, n):\\n if nums[j] == nums[i]:\\n mx = max(mx, helper(k, j))\\n else:\\n mx = max(mx, helper(k-1, j))\\n return 1 + mx\\n\\n for i in range(n):\\n ans = max(ans, helper(k, i))\\n return ans\",\n \"runtime\": \"6528\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 0\\n n = len(nums)\\n\\n @cache\\n def helper(k, i):\\n if i >=n or k <0:\\n return 0\\n mx = 0\\n for j in range(i+1, n):\\n if nums[j] == nums[i]:\\n mx = max(mx, helper(k, j))\\n else:\\n mx = max(mx, helper(k-1, j))\\n return 1 + mx\\n\\n for i in range(n):\\n ans = max(ans, helper(k, i))\\n return ans\",\n \"runtime\": \"6642\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n \\n @cache\\n def fn(i, k):\\n \\\"\\\"\\\"Return \\\"\\\"\\\"\\n # if k < 0: return -inf \\n if i == n: return 0 \\n ans = 1\\n for j in range(i+1, n): \\n if nums[i] == nums[j]: ans = max(ans, 1 + fn(j, k))\\n elif k > 0: ans = max(ans, 1 + fn(j, k-1))\\n return ans \\n \\n return max(fn(i, k) for i in range(n))\",\n \"runtime\": \"6642\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * (k + 1) for i in nums]\\n dp[0][0] = 1\\n n = len(nums)\\n for i in range(1, n):\\n dp[i][0] = 1\\n for j in range(k + 1):\\n for l in range(i):\\n if nums[l] == nums[i] and dp[l][j] != 0:\\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\\n elif nums[l] != nums[i] and j > 0 and dp[l][j-1] != 0:\\n dp[i][j] = max(dp[i][j], dp[l][j-1] + 1)\\n return max([max(row) for row in dp])\",\n \"runtime\": \"6756\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n @cache\\n def dfs(i,s):\\n if i==n:\\n return 0\\n res=0\\n for j in range(i+1,n):\\n if nums[i]==nums[j]:\\n res=max(res,1+dfs(j,s))\\n else :\\n if s>0:\\n res=max(res,1+dfs(j,s-1))\\n return res\\n return max(dfs(i,k) for i in range(n))+1\\n\",\n \"runtime\": \"6756\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def fn(idx, diffs):\\n if diffs < 0:\\n return 0\\n ans = 1\\n for j in range(idx):\\n if nums[j] == nums[idx]:\\n ans = max(ans, fn(j, diffs) + 1)\\n else:\\n ans = max(ans, fn(j, diffs-1) + 1)\\n return ans\\n \\n return max(fn(i, k) for i in range(len(nums)))\",\n \"runtime\": \"6870\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n ret = 0\\n\\n @cache\\n def dfs(i: int, diff_cnt: int) -> int:\\n nonlocal ret\\n if i == 0:\\n return 1\\n ans = 1\\n # ans = max(1, dfs(i - 1, diff_cnt))\\n for pos in range(i):\\n if nums[pos] == nums[i]:\\n ans = max(ans, dfs(pos, diff_cnt) + 1)\\n else:\\n if diff_cnt >= 1:\\n ans = max(ans, dfs(pos, diff_cnt - 1) + 1)\\n return ans\\n\\n # dfs(N - 1, k)\\n for i in range(N):\\n ret = max(ret, dfs(i, k))\\n return ret\",\n \"runtime\": \"6870\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[-1] * 51 for _ in range(n)]\\n ans = 0\\n\\n for i in range(n):\\n dp[i][0] = 1\\n for l in range(k + 1):\\n for j in range(i):\\n add = 1 if nums[i] != nums[j] else 0\\n if l - add >= 0 and dp[j][l - add] != -1:\\n dp[i][l] = max(dp[i][l], dp[j][l - add] + 1)\\n ans = max(ans, dp[i][l])\\n \\n return ans\",\n \"runtime\": \"6984\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def f(end, k):\\n if(k < 0): return 0\\n if(end == 0): return 1\\n take = 1\\n for i in range(end-1, -1, -1):\\n if(nums[i] != nums[end]):\\n if(k > 0):\\n currLen = 1 + f(i, k-1)\\n take = max(currLen, take)\\n else:\\n currLen = 1 + f(i, k)\\n take = max(currLen, take)\\n return take\\n\\n ret = 0\\n for i in range(0, len(nums)):\\n ret = max(ret, f(i,k))\\n\\n\\n return ret\\n \",\n \"runtime\": \"6984\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n mx = 0\\n for p in range(i):\\n if nums[p] == nums[i]:\\n mx = max(dfs(p, j), mx)\\n elif j and nums[p] != nums[i]:\\n mx = max(dfs(p, j - 1), mx) \\n return mx + 1\\n\\n return max(dfs(i, k) for i in range(n - 1, -1, -1))\\n \",\n \"runtime\": \"7098\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def f(i, k):\\n # print(i, k)\\n if i >= n: return 0\\n\\n pick = 1\\n for j in range(i + 1, n):\\n good = nums[i] != nums[j]\\n if not good:\\n pick = max(pick, 1 + f(j, k))\\n # print(\\\"not good\\\", i, j, pick)\\n\\n elif k:\\n pick = max(pick, 1 + f(j, k - 1))\\n # print(\\\"good\\\", i, j, pick)\\n \\n \\n # print(i, k, \\\"pick\\\", pick)\\n return pick\\n\\n n = len(nums)\\n \\n return max(f(i, k) for i in range(n))\\n\",\n \"runtime\": \"7098\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # O(n*n*k)\\n n = len(nums)\\n dp = [[-1]*(k+1) for _ in range(n+1)]\\n \\n def solve(i, remk):\\n if i == -1: return 0\\n if dp[i][remk] != -1: return dp[i][remk]\\n\\n maxLen = 1\\n for j in range(i-1, -1, -1):\\n if nums[i] == nums[j]:\\n maxLen = max(maxLen, 1 + solve(j, remk))\\n elif nums[i] != nums[j] and remk > 0:\\n maxLen = max(maxLen, 1+solve(j, remk-1))\\n\\n dp[i][remk] = maxLen\\n return maxLen\\n\\n ans = 0\\n for i in range(n):\\n ans = max(ans, solve(i, k))\\n # imaging every i is end of sub sequence\\n # print(dp)\\n return ans\",\n \"runtime\": \"7212\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def helper(i,n):\\n curr = 1\\n for j in range(i+1,len(nums)):\\n ch = 1\\n if nums[i] == nums[j]:\\n ch = 0\\n if n + ch <= k:\\n curr = max(curr, helper(j, n+ch)+1)\\n return curr\\n ans = 0\\n for i in range(len(nums)):\\n ans = max(ans, helper(i,0)) \\n return ans\\n\\n\\n\\n\\n\\n \\n\",\n \"runtime\": \"7212\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def dfs(ptr, left):\\n nonlocal nums\\n if left < 0:\\n return 0\\n ans = 1\\n for i in range(ptr+1, len(nums)):\\n ans = max(ans, 1 + dfs(i, left - (nums[i]!=nums[ptr])))\\n return ans\\n \\n return max([dfs(i, k) for i in range(len(nums))])\",\n \"runtime\": \"7326\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def rec(i, k_inner):\\n if k_inner == -1:\\n return -inf\\n if i == len(nums):\\n return 0\\n\\n max_r = 0\\n for j in range(i+1, len(nums)):\\n max_r = max(max_r, 1 + rec(j, k_inner-(nums[i]!=nums[j])))\\n\\n return max_r\\n\\n m = 0\\n for j in range(len(nums)):\\n m = max(m, rec(j, k))\\n return m + 1\\n\",\n \"runtime\": \"7440\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n @lru_cache(None)\\n def dfs(i: int, pre: int, rest: int) -> int:\\n if i == n:\\n return 0\\n res = dfs(i + 1, pre, rest)\\n if pre == 0:\\n # 第一个数\\n res = max(res, 1 + dfs(i + 1, nums[i], rest))\\n else:\\n if pre != nums[i]:\\n if rest >= 1:\\n res = max(res, 1 + dfs(i + 1, nums[i], rest - 1))\\n else:\\n res = max(res, 1 + dfs(i + 1, pre, rest))\\n return res\\n \\n ans = dfs(0, 0, k)\\n dfs.cache_clear()\\n return ans\",\n \"runtime\": \"7440\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def f(i, k):\\n # print(i, k)\\n if i >= n: return 0\\n\\n pick = 1\\n for j in range(i + 1, n):\\n good = nums[i] != nums[j]\\n if not good:\\n pick = max(pick, 1 + f(j, k))\\n # print(\\\"not good\\\", i, j, pick)\\n\\n if k:\\n pick = max(pick, 1 + f(j, k - 1))\\n # print(\\\"good\\\", i, j, pick)\\n \\n \\n # print(i, k, \\\"pick\\\", pick)\\n return pick\\n\\n n = len(nums)\\n \\n return max(f(i, k) for i in range(n))\\n\",\n \"runtime\": \"7554\"\n },\n {\n \"code\": \"\\ndef get_dp(dp, k, n, m):\\n if k >= len(dp):\\n return 0\\n if n >= len(dp[0]):\\n return 0\\n if m >= len(dp[0][0]):\\n return 0\\n \\n return dp[k][n][m]\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if not nums:\\n return 0\\n # k inequalities\\n # starting from index n\\n # being m the current active number\\n unique_nums = list(set(nums))\\n reverse_lookup = {num: idx for idx, num in enumerate(unique_nums)}\\n # dp: k x n x m\\n n = len(nums)\\n dp = [[[0] * len(unique_nums) for _ in range(n)] for _ in range(k + 1)]\\n\\n for curr_k in range(k + 1):\\n for idx in reversed(range(n)):\\n for m_idx in range(len(unique_nums)):\\n # taking the current number\\n curr_num = unique_nums[m_idx]\\n next_k = curr_k - 1 if nums[idx] != curr_num else curr_k\\n # if k would become negative, we cannot chose the current element\\n taking = 0\\n if next_k >= 0:\\n taking = 1 + get_dp(dp, next_k, idx + 1, reverse_lookup[nums[idx]])\\n\\n # not taking\\n not_taking = get_dp(dp, curr_k, idx + 1, m_idx)\\n # print(len(dp), len(dp[0]), len(dp[0][0]), curr_k, idx, m_idx)\\n dp[curr_k][idx][m_idx] = max(taking, not_taking)\\n \\n\\n best = 0\\n\\n for start in range(len(unique_nums)):\\n best = max(dp[k][0][start], best)\\n\\n return best\\n\",\n \"runtime\": \"7668\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n @cache\\n def dp(currentIdx: int, lastChosen: int, remaining: int) -> int:\\n if remaining < 0:\\n # because you have chosen a forbidden item\\n return -1\\n if currentIdx >= n:\\n return 0\\n\\n notChoose = dp(currentIdx + 1, lastChosen, remaining)\\n choose = 1 + dp(currentIdx + 1, nums[currentIdx], remaining - (1 if nums[currentIdx] != lastChosen else 0))\\n\\n return max(notChoose, choose)\\n \\n # if remaining is equal to k, then lastChosen should not matter\\n res = dp(0, float('inf'), k+1)\\n dp.cache_clear()\\n return res\",\n \"runtime\": \"7783\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n @cache\\n def f(i, j):\\n max_len = 1\\n for m in range(i + 1, n):\\n nj = j + int(nums[m] != nums[i])\\n if nj <= k:\\n max_len = max(max_len, f(m, nj) + 1)\\n return max_len\\n\\n return max(f(l, 0) for l in range(n))\",\n \"runtime\": \"7897\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n @cache\\n def dp(index, rem):\\n if rem < 0: return -math.inf\\n if index == n - 1: return 1\\n res = 1\\n for j in range(index + 1, n):\\n res = max(res, 1 + dp(j, rem - int(nums[index] != nums[j])))\\n return res\\n res = 1\\n for i in range(n):\\n res = max(res, dp(i, k))\\n return res\\n \",\n \"runtime\": \"8011\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def f(i, j):\\n n = 1\\n for m in range(i+1, len(nums)):\\n nj = j+int(nums[m] != nums[i])\\n if nj <= k:\\n n = max(n, f(m, nj) + 1)\\n return n\\n return max(f(l, 0) for l in range(len(nums)))\",\n \"runtime\": \"8125\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\\n self.helper(nums, 0, k, dp)\\n return max([l[k] for l in dp])\\n \\n def helper(self, nums, index, k, dp):\\n if index >= len(nums) or k <= -1:\\n return 0\\n if dp[index][k] != -1:\\n return dp[index][k]\\n output = 0\\n for i in range(index+1, len(nums)):\\n if nums[index] != nums[i] and k > 0:\\n self.helper(nums, i, k-1, dp)\\n output = max(output, dp[i][k-1])\\n elif nums[index] == nums[i]:\\n self.helper(nums, i, k, dp)\\n output = max(output, dp[i][k])\\n # print(index, k, output)\\n output += 1\\n dp[index][k] = output\\n # for i in range(0, k+1):\\n # if dp[index][i] == -1 or dp[index][i] < output:\\n # dp[index][i] = output\\n return max(output, self.helper(nums, index+1, k, dp))\",\n \"runtime\": \"8239\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\\n self.helper(nums, 0, k, dp)\\n return max([l[k] for l in dp])\\n \\n def helper(self, nums, index, k, dp):\\n if index >= len(nums) or k <= -1:\\n return 0\\n if dp[index][k] != -1:\\n return dp[index][k]\\n output = 0\\n for i in range(index+1, len(nums)):\\n if nums[index] != nums[i] and k > 0:\\n self.helper(nums, i, k-1, dp)\\n output = max(output, dp[i][k-1])\\n elif nums[index] == nums[i]:\\n self.helper(nums, i, k, dp)\\n output = max(output, dp[i][k])\\n # print(index, k, output)\\n output += 1\\n dp[index][k] = output\\n # for i in range(0, k+1):\\n # if dp[index][i] == -1 or dp[index][i] < output:\\n # dp[index][i] = output\\n return max(output, self.helper(nums, index+1, k, dp))\",\n \"runtime\": \"8239\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n dp= [[1]*(k+1) for _ in range(len(nums))]\\n \\n maxl=1\\n for i in range(len(nums)-1):\\n for j in range(i+1, len(nums)):\\n if nums[j]==nums[i]:\\n for n in range(k+1):\\n dp[j][n]=max(dp[j][n],dp[i][n]+1)\\n maxl=max(maxl,dp[j][n])\\n if nums[j] !=nums[i]:\\n for n in range(k):\\n dp[j][n+1]= max(dp[j][n+1] , dp[i][n]+1)\\n maxl=max(maxl,dp[j][n+1])\\n return maxl\\n\",\n \"runtime\": \"8353\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ck = set(nums)\\n d = {}\\n ct = 0\\n for i in sorted(ck):\\n d[i] = ct\\n ct += 1\\n n = len(nums)\\n nums = [d[i] for i in nums]\\n print(nums)\\n dp = [[[-float('inf')]*(k+1) for _ in range(ct)] for _ in range(n + 1)] \\n dp[0][nums[0]][0] = 0\\n ans = 0\\n for i in range(1, n+1):\\n dp[i][nums[i-1]][0] = 1\\n for j in range(ct):\\n for kk in range(k+1):\\n dp[i][j][kk] = max(dp[i-1][j][kk], dp[i][j][kk])\\n if nums[i-1] == j:\\n dp[i][nums[i-1]][kk] = max(dp[i][nums[i-1]][kk], 1 + dp[i-1][j][kk])\\n elif kk + 1 <= k:\\n dp[i][nums[i-1]][kk + 1] = max(dp[i][nums[i-1]][kk + 1], 1 + dp[i-1][j][kk])\\n ans = max(ans, dp[i][nums[i-1]][kk])\\n # for i in dp:\\n # print('-'*19)\\n # print(i)\\n return ans\",\n \"runtime\": \"8467\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[1]*(k+1) for _ in range(len(nums))]\\n ans= 1\\n for i in range(len(nums)):\\n for j in range(k+1):\\n for l in range(i):\\n if nums[l] == nums[i]:\\n dp[i][j] = max(dp[i][j], dp[l][j]+1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\\n ans = max(ans, dp[i][j])\\n\\n\\n\\n return ans\",\n \"runtime\": \"8581\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[i][j]: length of the longest subseq ending at index i with at most j places where adjacent elements are not equal\\n \\\"\\\"\\\"\\n dp = [[1] * (k+1) for _ in range(len(nums))]\\n\\n # if we consider just the one element at index i in the subseq, ans = 1 -> base case\\n\\n max_len = 1\\n\\n for i in range(len(nums)):\\n for j in range(i):\\n for l in range(k+1):\\n if nums[i] == nums[j]:\\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\\n elif l > 0: # consider the one with l-1\\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\\n max_len = max(max_len, dp[i][l])\\n\\n # max value in the dp is the ans\\n return max_len\",\n \"runtime\": \"8695\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.a1=[]\\n self.res=0\\n def dp(self,a,i,k):\\n if i==len(a)-1:\\n self.a1[i][k]=1\\n # self.res=max(self.res,self.a1[str(i)+' '+str(k)])\\n return\\n elif self.a1[i][k]!=-1:\\n return\\n else:\\n o=1\\n for j in range(i+1,len(a)):\\n if i==-1:\\n self.dp(a,j,k)\\n o=max(o,self.a1[j][k]+1)\\n continue\\n if a[j]!=a[i] and k>0:\\n self.dp(a,j,k-1)\\n o=max(o,self.a1[j][k-1]+1)\\n if a[j]==a[i]:\\n self.dp(a,j,k)\\n o=max(o,self.a1[j][k]+1)\\n if i==-1:\\n o-=1\\n self.a1[i][k]=o\\n # self.res=max(self.res,o)\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n for i in range(len(nums)):\\n e=[]\\n for j in range(k+1):\\n e.append(-1)\\n self.a1.append(e)\\n self.dp(nums,-1,k)\\n s1=0\\n for i in range(len(nums)):\\n s1=max(s1,self.a1[i][k])\\n return s1\\n\",\n \"runtime\": \"8695\"\n },\n {\n \"code\": \"import collections\\nfrom typing import List\\n\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = collections.defaultdict(int)\\n\\n def dfs(total_diff_count, _i):\\n key = (total_diff_count, _i)\\n if key in dp:\\n return dp[key]\\n result = 1\\n previous = nums[_i]\\n for next_i in range(_i + 1, len(nums)):\\n if nums[next_i] == previous:\\n result = max(result, 1 + dfs(total_diff_count, next_i))\\n else:\\n if total_diff_count < k:\\n result = max(result, 1 + dfs(total_diff_count + 1, next_i))\\n\\n dp[key] = result\\n return result\\n\\n return max(dfs(0, i) for i in range(len(nums)))\",\n \"runtime\": \"8809\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if k >= len(nums) - 1:\\n return len(nums)\\n elif k == 0:\\n return max(v for k, v in Counter(nums).items())\\n \\n dp = [[float('-inf')] * (k + 1) for _ in range(len(nums))]\\n res = 0\\n for i in range(len(dp)):\\n dp[i][0] = 1\\n for i in range(1, len(nums)):\\n for l in range(k + 1): # Can reduce\\n for j in range(i):\\n if nums[j] != nums[i] and l > 0:\\n # transition case\\n dp[i][l] = max(dp[i][l], dp[j][l-1] + 1)\\n elif nums[j] == nums[i]:\\n # No transition\\n dp[i][l] = max(dp[i][l], dp[j][l] + 1)\\n res = max(res, dp[i][l])\\n return res\",\n \"runtime\": \"8923\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n ans = 0\\n # dp[i][j] means the longest subsequence ending at index i with at most j changes\\n dp = [[1] * (k + 1) for _ in range(n)]\\n \\n for i in range(n):\\n for j in range(k + 1):\\n for l in range(i):\\n if nums[i] == nums[l]:\\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\\n ans = max(ans, dp[i][j])\\n print(ans)\\n \\n return max(max(row) for row in dp)\\n \",\n \"runtime\": \"8923\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":104,"string":"104"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0 for _ in nums]\n for _ in range(k+1):\n prev = dp\n dp = [1]\n for idx in range(1, len(nums)):\n ans = max(\n dp[j] if nums[j] == nums[idx] else prev[j]\n for j in range(idx)\n ) + 1\n dp.append(ans)\n return max(dp)","memory":"16400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[1]*(k+1) for _ in range(len(nums))]\n ans= 1\n for i in range(len(nums)):\n for j in range(k+1):\n for l in range(i):\n if nums[l] == nums[i]:\n dp[i][j] = max(dp[i][j], dp[l][j]+1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\n ans = max(ans, dp[i][j])\n\n\n\n return ans","memory":"16500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\n # print(dp)\n # for k == 0:\n for i in range(1, n):\n for j in range(i):\n if nums[i] == nums[j]:\n dp[i] = (dp[j][0] + 1, 0)\n # print(0, dp)\n\n for tmpk in range(1, k+1):\n tmpDP = [(0, 0) for _ in range(n)]\n tmpDP[0] = (1, 0)\n for i in range(1, n):\n for j in range(i):\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\n dp = tmpDP\n # print(tmpk, dp)\n \n return max(dp)[0]","memory":"16600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [defaultdict(int) for i in range(k + 1)]\n res = [0] * (k + 1)\n for a in nums:\n for i in range(k, -1, -1):\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\n res[i] = max(res[i], dp[i][a])\n return res[k]","memory":"16700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\n self.helper(nums, 0, k, dp)\n return max([l[k] for l in dp])\n \n def helper(self, nums, index, k, dp):\n if index >= len(nums) or k <= -1:\n return 0\n if dp[index][k] != -1:\n return dp[index][k]\n output = 0\n for i in range(index+1, len(nums)):\n if nums[index] != nums[i] and k > 0:\n self.helper(nums, i, k-1, dp)\n output = max(output, dp[i][k-1])\n elif nums[index] == nums[i]:\n self.helper(nums, i, k, dp)\n output = max(output, dp[i][k])\n # print(index, k, output)\n output += 1\n dp[index][k] = output\n # for i in range(0, k+1):\n # if dp[index][i] == -1 or dp[index][i] < output:\n # dp[index][i] = output\n return max(output, self.helper(nums, index+1, k, dp))","memory":"16800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[1]*min(k+1,51) for i in range(n)]\n print(dp)\n ans=1\n for i in range(1,n):\n for j in range(min(k,50)+1):\n for m in range(i):\n if nums[m]==nums[i]:\n dp[i][j]=max(dp[i][j],dp[m][j]+1)\n elif j>0:\n dp[i][j]=max(dp[i][j],dp[m][j-1]+1)\n ans=max(ans,dp[i][j]) \n return ans","memory":"16900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n \n\n dp = [[1] * (k + 1) for _ in range(n)]\n \n for i in range(n):\n for j in range(k + 1):\n for l in range(i):\n if nums[i] == nums[l]:\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\n elif j > 0:\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\n \n return max(max(row) for row in dp)","memory":"17000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0 for i in range(k+1)] for j in range(n)]\n maxi=[[0 for i in range(k+1)] for j in range(n)]\n mp={}\n for i in range(n):\n for j in range(k+1):\n if(i==0):\n dp[i][j]=1\n maxi[i][j]=max(maxi[i][j],dp[i][j])\n elif(j==0):\n dp[i][j]=1\n t=mp.get(nums[i],-1)\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\n else:\n dp[i][j]=maxi[i-1][j-1]+1\n t=mp.get(nums[i],-1)\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\n mp[nums[i]]=i\n return max(dp[n-1][k],maxi[n-1][k])","memory":"17100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k+1) for _ in range(n)]\n\n same = [defaultdict(int) for _ in range(k+1)]\n diff = [0 for _ in range(k+1)]\n\n ans = 0\n for i, num in enumerate(nums): \n dp[i][0] = 1\n for j in range(k+1): \n dp[i][j] = 1 + same[j][num]\n if j > 0:\n dp[i][j] = max(dp[i][j], diff[j-1] + 1)\n ans = max(ans, dp[i][j])\n for j in range(k+1): \n same[j][num] = max(same[j][num], dp[i][j])\n diff[j] = max(diff[j], dp[i][j])\n\n return ans","memory":"17200"},{"code":"from collections import Counter\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # O(n*n*k)\n n = len(nums)\n dp = [[-1]*(k+1) for _ in range(n+1)]\n \n def solve(i, remk):\n if i == -1: return 0\n if dp[i][remk] != -1: return dp[i][remk]\n\n maxLen = 1\n for j in range(i-1, -1, -1):\n if nums[i] == nums[j]:\n maxLen = max(maxLen, 1 + solve(j, remk))\n elif nums[i] != nums[j] and remk > 0:\n maxLen = max(maxLen, 1+solve(j, remk-1))\n\n dp[i][remk] = maxLen\n return maxLen\n\n ans = 0\n for i in range(n):\n ans = max(ans, solve(i, k))\n # imaging every i is end of sub sequence\n # print(dp)\n return ans","memory":"17700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n memo = [[0 for i in range(k+1)] for i in range(len(nums))]\n def r(n, k):\n if n == 0:\n return 1\n if memo[n][k]:\n return memo[n][k]\n m = 1\n for i in range(n):\n a = 0\n if nums[i] == nums[n]:\n a = r(i, k) + 1\n elif k > 0:\n a = r(i, k - 1) + 1\n m = max(m, a)\n memo[n][k] = m\n return m\n return max([r(i, k) for i in range(len(nums))])","memory":"17800"},{"code":"from collections import Counter\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # O(n*n*k)\n n = len(nums)\n dp = [[-1]*(min(n+1, 26)) for _ in range(n+1)]\n \n def solve(i, remk):\n if i == -1: return 0\n if dp[i][remk] != -1: return dp[i][remk]\n\n maxLen = 1\n for j in range(i-1, -1, -1):\n if nums[i] == nums[j]:\n maxLen = max(maxLen, 1 + solve(j, remk))\n elif nums[i] != nums[j] and remk > 0:\n maxLen = max(maxLen, 1+solve(j, remk-1))\n\n dp[i][remk] = maxLen\n return maxLen\n\n ans = 0\n for i in range(n):\n ans = max(ans, solve(i, k))\n # imaging every i is end of sub sequence\n # print(dp)\n return ans","memory":"17900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n heaps = [[] for _ in range(k+1)]\n mp = defaultdict(dict)\n for n in nums:\n for i in range(k, 0, -1):\n v = 1\n if i in mp and n in mp[i]:\n v = max(v, mp[i][n] + 1)\n if heaps[i-1]:\n v = max(v, -heaps[i-1][0][0] + 1)\n mp[i][n] = v\n heappush(heaps[i], (-v, n))\n if n in mp[0]:\n mp[0][n] += 1\n else:\n mp[0][n] = 1\n heappush(heaps[0], (-mp[0][n], n))\n return max(-heaps[i][0][0] for i in range(k+1))","memory":"18400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n def DP(i, num_remaining, memo):\n if num_remaining < 0:\n return 0\n \n if i < 0:\n return 0 \n \n if (i, num_remaining) in memo:\n return memo[(i, num_remaining)]\n \n max_length = 1\n for j in range(i):\n if nums[j] == nums[i]:\n max_length = max(max_length, 1 + DP(j, num_remaining, memo))\n else:\n max_length = max(max_length, 1 + DP(j, num_remaining-1, memo))\n \n memo[(i, num_remaining)] = max_length\n return max_length\n \n memo = {}\n max_length = 0\n for i in range(len(nums)):\n max_length = max(max_length, DP(i, k, memo))\n\n return max_length\n","memory":"18500"},{"code":"class Solution:\n def dp(self, i, k):\n if i == 0:\n return 1\n else:\n key = (i, k)\n if key in self.cache:\n return self.cache[key]\n ans = 1\n for j in range(0, i):\n if self.nums[j] == self.nums[i]:\n ans = max(ans, 1 + self.dp(j, k))\n else:\n if k > 0:\n ans = max(ans, 1 + self.dp(j, k - 1))\n self.cache[key] = ans\n return ans\n def maximumLength(self, nums: List[int], k: int) -> int:\n self.nums = nums\n self.cache = {}\n ans = 0\n n = len(nums)\n for i in range(n):\n ans = max(ans, self.dp(i, k))\n return ans","memory":"18600"},{"code":"class Solution:\n\n @cache\n def solve(self, i, k):\n if i == 0:\n if k == 0:\n return 1\n else:\n return 0\n if k < 0:\n return 0\n\n n = len(self.nums)\n n_i = self.nums[i]\n\n if k == 0:\n result = 1\n else:\n result = 0\n\n for j in range(i):\n n_j = self.nums[j]\n\n if n_i == n_j and self.solve(j, k) > 0:\n result = max(result, self.solve(j, k) + 1)\n continue\n\n if n_i != n_j and self.solve(j, k - 1) > 0:\n result = max(result, self.solve(j, k - 1) + 1)\n continue\n\n return result\n\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n self.solve.cache_clear()\n self.nums = nums\n n = len(nums)\n\n result = -math.inf\n for i in range(n):\n for max_diff in range(k + 1):\n this_result = self.solve(i, max_diff)\n result = max(result, this_result)\n\n return result","memory":"18700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n max_sub = 0\n cache = dict()\n for ind in range(len(nums)):\n\n curr_sub = self.dfs(\n ind=ind,\n curr_diff=0,\n nums=nums,\n k=k,\n cache=cache\n )\n max_sub = max(max_sub, curr_sub)\n\n return max_sub\n\n def dfs(self, ind: int, curr_diff: int, nums: list, k: int, cache:dict) -> int:\n\n if (ind, curr_diff) in cache:\n return cache[(ind, curr_diff)]\n\n if curr_diff>k:\n return 0\n\n max_sub = 1\n \n for i in range(ind+1, len(nums)):\n diff = curr_diff\n\n if nums[ind]!=nums[i]:\n diff+=1\n \n curr_sub = 1 + self.dfs(\n ind=i,\n curr_diff=diff,\n nums=nums,\n k=k,\n cache=cache)\n max_sub = max(curr_sub, max_sub)\n cache[(ind, curr_diff)] = max_sub\n return max_sub","memory":"18800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # [1,2,1,1,3]\n # k = 2\n # \n dp = {} # dp[i][j] is the max length of the subsequence with up to i changes ending in nums[j]\n max_so_far = {} # max_so_far[i][j] is the max length of the subsequence with up to i changes up to (nums[j] doesnt have to include it)\n for i in range(k+1):\n dp[i, 0] = 1\n max_so_far[i,0] = 1\n \n for i in range(k+1):\n last_appearance = {} # last_appearance[n] is the index of the last appearance of n in nums so far\n\n for j in range(len(nums)):\n\n \n max_i_j = 1 # min is 1\n if nums[j] in last_appearance:\n last_appearance_index = last_appearance[nums[j]]\n max_i_j = max(max_i_j, dp[i, last_appearance_index] + 1) # add 1 to last sequence of this number\n\n last_appearance[nums[j]] = j # update last seen index\n if j == 0:\n continue\n if i > 0:\n max_i_j = max(max_i_j, max_so_far[i-1, j-1] + 1)\n\n dp[i, j] = max_i_j\n max_so_far[i,j] = max(max_so_far[i, j-1], dp[i, j])\n return max_so_far[k, len(nums)-1]\n","memory":"20500"},{"code":"from functools import cache\nfrom collections import Counter\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n nextd = [n]*n\n counter = Counter()\n for i in range(n-2,-1,-1):\n if nums[i] != nums[i+1]:\n nextd[i] = i+1\n else:\n nextd[i] = nextd[i+1]\n nextcnt = [1]*n\n for i in range(n-1,-1,-1):\n counter[nums[i]] += 1\n nextcnt[i] = counter[nums[i]]\n @cache\n def dfs(i,k):\n if k == 0:\n return nextcnt[i]\n if i == n-1: return 1\n res = 0\n j = nextd[i]\n while j < n:\n if nums[i] != nums[j]:\n res = max(res, dfs(j,k-1))\n else:\n res = max(res, dfs(j,k))\n j = nextd[j]\n return res + nextd[i] - i\n return max([dfs(i,k) for i in range(n)])","memory":"25100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n possible = set()\n # possible = {(\n # 0, # length\n # 0, # errors\n # '', # last number used\n # # (), # entire subsequence\n # )}\n for N in nums:\n new_possible = {\n # each N can start its own, length-1, error-free sequence\n (\n 1,\n 0,\n N,\n # (N,),\n )\n }\n for P in possible:\n # or we can extend each other sequence with this N\n (\n prev_len,\n prev_err,\n prev_num,\n # prev_seq,\n ) = P\n new_len = prev_len + 1\n new_err = prev_err + (0 if (prev_num == N) else 1)\n new_num = N\n # new_seq = prev_seq + (N,)\n if new_err > k:\n continue\n new_possible.add(\n (\n new_len,\n new_err,\n new_num,\n # new_seq,\n )\n )\n possible |= new_possible\n \n print(f'{possible=}')\n\n return max([\n length\n for (length, errors, last_num) in possible\n ])\n","memory":"25700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = {} \n\n # def rec_helper(i, j, prev):\n # # print(i, j, prev)\n # # i is the index, j is number of switches left\n # if (i, j, prev) in dp:\n # return dp[(i, j, prev)] \n\n # if j < 0 or i == len(nums):\n # return 0\n\n # if nums[i] == prev:\n # # print('Here', i, prev)\n # res = 1 + rec_helper(i+1, j, prev) # Include no switch\n # elif j == 0:\n # res = rec_helper(i+1, j, prev) # Exclude\n # else:\n # res = max(\n # rec_helper(i+1, j, prev), # Exclude \n # 1 + rec_helper(i+1, j-1, nums[i]) # Include and switch\n # )\n \n # # print('Res', i, j, prev, res)\n # dp[(i, j, prev)] = res\n # return dp[(i, j, prev)]\n\n def rec_helper(i, j):\n # print(i, j, prev)\n # i is the index, j is number of switches left\n if (i, j) in dp:\n return dp[(i, j)] \n\n if j < 0 or i == len(nums):\n return 0\n\n res = 1 \n for k in range(i+1, len(nums)): # Next inclusion\n if nums[k] == nums[i]:\n res = max(res, 1 + rec_helper(k, j)) \n else:\n res = max(\n res, 1 + rec_helper(k, j-1)\n )\n \n # return res\n \n # print('Res', i, j, prev, res)\n dp[(i, j)] = res\n return dp[(i, j)]\n\n res = 0 \n for i in range(len(nums)):\n # res = max(res, 1 + rec_helper(i+1, k, nums[i]))\n res = max(res, rec_helper(i, k))\n return res","memory":"28000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n mem = {}\n # i - last elem of subsq\n # curk - k left\n def helper(i, curk):\n if (i, curk) in mem:\n return mem[(i, curk)]\n res = 1\n for j in range(i):\n if nums[i] == nums[j]:\n res = max(res, 1 + helper(j, curk))\n elif curk + 1 <= k:\n res = max(res, 1 + helper(j, curk + 1))\n mem[(i, curk)] = res\n return res\n \n res = 1\n for i in range(len(nums)):\n res = max(res, helper(i, 0))\n \n return res","memory":"28100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n #if you add a num and -1 in then good-1 or if or num+1 then good -=1\n # if num is seq.. nothing already taken care of\n # if num+1\n \n # is the number of indices where [i] != [i+1]\n #sliding window: K++ if nums[r] != nums[r-1] k++\n # if too many, reduce left. if nums[l] != nums[l+1]: k--\n\n #take/skip a number (i,unequal) n*k\n\n def dfs(i,unequal):\n if unequal > k: #remove previously added\n return -1\n if i == len(nums):\n return 0\n key = (i,unequal)\n if key in cache:\n return cache[key]\n longest = 0\n for j in range(i+1,len(nums)):\n longest = max(longest, 1+dfs(j,unequal + (nums[j] != nums[i]) ) )\n cache[key] = longest\n return longest\n\n cache = {}\n \n return max(1+dfs(i,0) for i in range(len(nums)))","memory":"28500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 0\n n = len(nums)\n memo = {}\n #@cache\n def helper(k,i):\n if i>=n or k<0:\n return 0\n if (k,i) in memo:\n return memo[(k,i)]\n mx = 0\n for j in range(i+1,n):\n if nums[j]== nums[i]:\n mx = max(mx,helper(k,j))\n else:\n mx = max(mx,helper(k-1,j))\n memo[(k,i)] = mx+1\n return 1 + mx\n\n\n for i in range(n):\n ans = max(ans,helper(k,i))\n return ans\n","memory":"28600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # if len(nums) == 0:\n # return 0\n \n # dp = [defaultdict(int) for _ in range(k + 1)]\n # res = [0] * (k + 1)\n\n # for n in nums:\n # for i in range(k, -1, -1):\n # dp[i][n] = max(dp[i][n] + 1, res[i - 1] + 1 if i > 0 else 0)\n # res[i] = max(res[i], dp[i][n])\n \n # return res[k]\n\n res = 0\n n = len(nums)\n\n memo = {}\n def dp(i, k):\n if i >= n or k < 0:\n return 0\n \n if (i, k) in memo:\n return memo[(i, k)]\n \n mx = 0\n for j in range(i + 1, n):\n if nums[j] == nums[i]:\n mx = max(mx, dp(j, k))\n else:\n mx = max(mx, dp(j, k - 1))\n \n memo[(i, k)] = mx + 1\n return 1 + mx\n \n for i in range(n):\n res = max(res, dp(i, k))\n return res","memory":"28800"},{"code":"import collections\nfrom typing import List\n\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = collections.defaultdict(int)\n\n def dfs(total_diff_count, _i):\n key = (total_diff_count, _i)\n if key in dp:\n return dp[key]\n result = 1\n previous = nums[_i]\n for next_i in range(_i + 1, len(nums)):\n if nums[next_i] == previous:\n result = max(result, 1 + dfs(total_diff_count, next_i))\n else:\n if total_diff_count < k:\n result = max(result, 1 + dfs(total_diff_count + 1, next_i))\n\n dp[key] = result\n return result\n\n return max(dfs(0, i) for i in range(len(nums)))","memory":"28900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n mx = 0\n for p in range(i):\n if nums[p] == nums[i]:\n mx = max(dfs(p, j), mx)\n elif j and nums[p] != nums[i]:\n mx = max(dfs(p, j - 1), mx) \n return mx + 1\n\n return max(dfs(i, k) for i in range(n - 1, -1, -1))\n ","memory":"29100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n ret = 0\n\n @cache\n def dfs(i: int, diff_cnt: int) -> int:\n nonlocal ret\n if i == 0:\n return 1\n ans = 1\n # ans = max(1, dfs(i - 1, diff_cnt))\n for pos in range(i):\n if nums[pos] == nums[i]:\n ans = max(ans, dfs(pos, diff_cnt) + 1)\n else:\n if diff_cnt >= 1:\n ans = max(ans, dfs(pos, diff_cnt - 1) + 1)\n return ans\n\n # dfs(N - 1, k)\n for i in range(N):\n ret = max(ret, dfs(i, k))\n return ret","memory":"29100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def findPre(idx):\n search = nums[idx]\n while idx:\n idx -= 1\n if nums[idx] == search: return idx\n return -1\n @cache\n def maxLength(diff,idx):\n if idx == 0: return 1\n ans = 1\n for i in range(idx):\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\n choice2 = maxLength(diff-1,i) if diff else 0\n ans = max(ans,1+max(choice1,choice2))\n return ans\n return max(maxLength(k,i) for i in range(len(nums)))","memory":"29200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def f(end, k):\n if(k < 0): return 0\n if(end == 0): return 1\n take = 1\n for i in range(end-1, -1, -1):\n if(nums[i] != nums[end]):\n if(k > 0):\n currLen = 1 + f(i, k-1)\n take = max(currLen, take)\n else:\n currLen = 1 + f(i, k)\n take = max(currLen, take)\n return take\n\n ret = 0\n for i in range(0, len(nums)):\n ret = max(ret, f(i,k))\n\n\n return ret\n ","memory":"29300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def f(i, k):\n # print(i, k)\n if i >= n: return 0\n\n pick = 1\n for j in range(i + 1, n):\n good = nums[i] != nums[j]\n if not good:\n pick = max(pick, 1 + f(j, k))\n # print(\"not good\", i, j, pick)\n\n if k:\n pick = max(pick, 1 + f(j, k - 1))\n # print(\"good\", i, j, pick)\n \n \n # print(i, k, \"pick\", pick)\n return pick\n\n n = len(nums)\n \n return max(f(i, k) for i in range(n))\n","memory":"29500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n\n @cache\n def go(idx, delta):\n res = 1\n\n for j in range(idx+1, N):\n\n inc = 1\n\n if nums[j] == nums[idx]:\n inc = 0\n\n if delta + inc <= k:\n res = max(res, go(j, delta+inc) + 1)\n\n return res\n\n res = 0\n for i in range(N):\n res = max(res, go(i, 0))\n return res","memory":"29700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def dp(i: int, k: int) -> int:\n if i == len(nums):\n return 0\n res = 0\n for j in range(i + 1, len(nums)):\n if nums[i] != nums[j]:\n if k > 0:\n res = max(res, 1 + dp(j, k - 1))\n else:\n res = max(res, 1 + dp(j, k))\n return res\n return max([1 + dp(i, k) for i in range(len(nums))])\n","memory":"29800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n memory = {}\n if len(nums)==1:\n return 1\n def DynamicProgramming(index,prevIndex,currK):\n if memory.get((index,prevIndex,currK))!=None:\n return memory[(index,prevIndex,currK)]\n if index==len(nums):\n return 0\n countSeq = 0\n for idx in range(index,len(nums)):\n temp=0\n if nums[idx]!=nums[prevIndex]:\n temp=1\n if (currK+temp)>k:\n continue\n else:\n \n countSeq=max(countSeq,DynamicProgramming(idx+1,idx,currK+temp)+1)\n memory[(index,prevIndex,currK)]=countSeq\n return memory[(index,prevIndex,currK)]\n maxi = 0\n for idx in range(1,len(nums)):\n maxi=max(DynamicProgramming(idx,idx-1,0)+1,maxi)\n return maxi","memory":"29900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def findPre(idx):\n search = nums[idx]\n while idx:\n idx -= 1\n if nums[idx] == search: return idx\n return 0\n @cache\n def maxLength(diff,idx):\n if idx == 0: return 1\n ans = 1\n for i in range(findPre(idx),idx):\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\n choice2 = maxLength(diff-1,i) if diff else 0\n ans = max(ans,1+max(choice1,choice2))\n return ans\n return max(maxLength(k,i) for i in range(len(nums)))","memory":"31000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n @cache\n def dfs(i,k):\n if k==-1:\n return 0\n res = 1\n for j in range(i):\n if nums[j]==nums[i]: res =max(res,dfs(j,k)+1)\n else: res =max(res,dfs(j,k-1)+1)\n return res\n return max(dfs(i,k) for i in range(n))\n ","memory":"31300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def fn(idx, diffs):\n if diffs < 0:\n return 0\n ans = 1\n for j in range(idx):\n if nums[j] == nums[idx]:\n ans = max(ans, fn(j, diffs) + 1)\n else:\n ans = max(ans, fn(j, diffs-1) + 1)\n return ans\n \n return max(fn(i, k) for i in range(len(nums)))","memory":"31400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n @cache\n def fn(idx, diffs):\n if diffs < 0:\n return 0\n ans = 1\n for j in range(idx):\n if nums[j] == nums[idx]:\n ans = max(ans, fn(j, diffs) + 1)\n else:\n ans = max(ans, fn(j, diffs-1) + 1)\n return ans\n \n return max(fn(i, k) for i in range(len(nums)))","memory":"31400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def dfs(i, k):\n if k < 0: return 0\n temp_res = 0\n for j in range(i+1, n):\n if nums[i] == nums[j]:\n temp_res = max(temp_res, dfs(j, k))\n else:\n temp_res = max(temp_res, dfs(j, k-1))\n return 1 + temp_res\n \n n = len(nums)\n if n <= k: return n\n res = 0\n for i in range(n):\n res = max(res, dfs(i, k))\n return res","memory":"31500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n @cache\n def dfs(i, cur_good):\n if cur_good > k or i >= len(nums):\n return 0\n\n max_subsequence = 0\n for j in range(i+1, len(nums)):\n if nums[i] == nums[j]:\n max_subsequence = max(max_subsequence, dfs(j, cur_good))\n else:\n max_subsequence = max(max_subsequence, dfs(j, cur_good + 1))\n return 1 + max_subsequence\n \n res = 0\n for i in range(len(nums)):\n res = max(res, dfs(i, 0))\n return res\n\n \n\n\n\n\n\n","memory":"31600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n @cache\n def dp(index, rem):\n if rem < 0: return -math.inf\n if index == n - 1: return 1\n res = 1\n for j in range(index + 1, n):\n res = max(res, 1 + dp(j, rem - int(nums[index] != nums[j])))\n return res\n res = 1\n for i in range(n):\n res = max(res, dp(i, k))\n return res\n ","memory":"31700"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0 for _ in nums]\\n for _ in range(k+1):\\n prev = dp\\n dp = [1]\\n for idx in range(1, len(nums)):\\n ans = max(\\n dp[j] if nums[j] == nums[idx] else prev[j]\\n for j in range(idx)\\n ) + 1\\n dp.append(ans)\\n return max(dp)\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[1]*(k+1) for _ in range(len(nums))]\\n ans= 1\\n for i in range(len(nums)):\\n for j in range(k+1):\\n for l in range(i):\\n if nums[l] == nums[i]:\\n dp[i][j] = max(dp[i][j], dp[l][j]+1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j-1]+1)\\n ans = max(ans, dp[i][j])\\n\\n\\n\\n return ans\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [(1, 0) for _ in range(n)] # dp[i][j] = (maxLength, k) for a sub sequence that ends at nums[j]\\n # print(dp)\\n # for k == 0:\\n for i in range(1, n):\\n for j in range(i):\\n if nums[i] == nums[j]:\\n dp[i] = (dp[j][0] + 1, 0)\\n # print(0, dp)\\n\\n for tmpk in range(1, k+1):\\n tmpDP = [(0, 0) for _ in range(n)]\\n tmpDP[0] = (1, 0)\\n for i in range(1, n):\\n for j in range(i):\\n if nums[j] == nums[i] and (tmpDP[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (tmpDP[j][0] + 1, tmpDP[j][1])\\n if nums[i] != nums[j] and (dp[j][0] + 1 > tmpDP[i][0]):\\n tmpDP[i] = (dp[j][0]+1, dp[j][1] + 1)\\n dp = tmpDP\\n # print(tmpk, dp)\\n \\n return max(dp)[0]\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [defaultdict(int) for i in range(k + 1)]\\n res = [0] * (k + 1)\\n for a in nums:\\n for i in range(k, -1, -1):\\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\\n res[i] = max(res[i], dp[i][a])\\n return res[k]\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[-1 for _ in range(k+1)] for _ in range(len(nums))]\\n self.helper(nums, 0, k, dp)\\n return max([l[k] for l in dp])\\n \\n def helper(self, nums, index, k, dp):\\n if index >= len(nums) or k <= -1:\\n return 0\\n if dp[index][k] != -1:\\n return dp[index][k]\\n output = 0\\n for i in range(index+1, len(nums)):\\n if nums[index] != nums[i] and k > 0:\\n self.helper(nums, i, k-1, dp)\\n output = max(output, dp[i][k-1])\\n elif nums[index] == nums[i]:\\n self.helper(nums, i, k, dp)\\n output = max(output, dp[i][k])\\n # print(index, k, output)\\n output += 1\\n dp[index][k] = output\\n # for i in range(0, k+1):\\n # if dp[index][i] == -1 or dp[index][i] < output:\\n # dp[index][i] = output\\n return max(output, self.helper(nums, index+1, k, dp))\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[1]*min(k+1,51) for i in range(n)]\\n print(dp)\\n ans=1\\n for i in range(1,n):\\n for j in range(min(k,50)+1):\\n for m in range(i):\\n if nums[m]==nums[i]:\\n dp[i][j]=max(dp[i][j],dp[m][j]+1)\\n elif j>0:\\n dp[i][j]=max(dp[i][j],dp[m][j-1]+1)\\n ans=max(ans,dp[i][j]) \\n return ans\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n \\n\\n dp = [[1] * (k + 1) for _ in range(n)]\\n \\n for i in range(n):\\n for j in range(k + 1):\\n for l in range(i):\\n if nums[i] == nums[l]:\\n dp[i][j] = max(dp[i][j], dp[l][j] + 1)\\n elif j > 0:\\n dp[i][j] = max(dp[i][j], dp[l][j - 1] + 1)\\n \\n return max(max(row) for row in dp)\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0 for i in range(k+1)] for j in range(n)]\\n maxi=[[0 for i in range(k+1)] for j in range(n)]\\n mp={}\\n for i in range(n):\\n for j in range(k+1):\\n if(i==0):\\n dp[i][j]=1\\n maxi[i][j]=max(maxi[i][j],dp[i][j])\\n elif(j==0):\\n dp[i][j]=1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n else:\\n dp[i][j]=maxi[i-1][j-1]+1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\\n mp[nums[i]]=i\\n return max(dp[n-1][k],maxi[n-1][k])\",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k+1) for _ in range(n)]\\n\\n same = [defaultdict(int) for _ in range(k+1)]\\n diff = [0 for _ in range(k+1)]\\n\\n ans = 0\\n for i, num in enumerate(nums): \\n dp[i][0] = 1\\n for j in range(k+1): \\n dp[i][j] = 1 + same[j][num]\\n if j > 0:\\n dp[i][j] = max(dp[i][j], diff[j-1] + 1)\\n ans = max(ans, dp[i][j])\\n for j in range(k+1): \\n same[j][num] = max(same[j][num], dp[i][j])\\n diff[j] = max(diff[j], dp[i][j])\\n\\n return ans\",\n \"memory\": \"17200\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # O(n*n*k)\\n n = len(nums)\\n dp = [[-1]*(k+1) for _ in range(n+1)]\\n \\n def solve(i, remk):\\n if i == -1: return 0\\n if dp[i][remk] != -1: return dp[i][remk]\\n\\n maxLen = 1\\n for j in range(i-1, -1, -1):\\n if nums[i] == nums[j]:\\n maxLen = max(maxLen, 1 + solve(j, remk))\\n elif nums[i] != nums[j] and remk > 0:\\n maxLen = max(maxLen, 1+solve(j, remk-1))\\n\\n dp[i][remk] = maxLen\\n return maxLen\\n\\n ans = 0\\n for i in range(n):\\n ans = max(ans, solve(i, k))\\n # imaging every i is end of sub sequence\\n # print(dp)\\n return ans\",\n \"memory\": \"17700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n memo = [[0 for i in range(k+1)] for i in range(len(nums))]\\n def r(n, k):\\n if n == 0:\\n return 1\\n if memo[n][k]:\\n return memo[n][k]\\n m = 1\\n for i in range(n):\\n a = 0\\n if nums[i] == nums[n]:\\n a = r(i, k) + 1\\n elif k > 0:\\n a = r(i, k - 1) + 1\\n m = max(m, a)\\n memo[n][k] = m\\n return m\\n return max([r(i, k) for i in range(len(nums))])\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"from collections import Counter\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # O(n*n*k)\\n n = len(nums)\\n dp = [[-1]*(min(n+1, 26)) for _ in range(n+1)]\\n \\n def solve(i, remk):\\n if i == -1: return 0\\n if dp[i][remk] != -1: return dp[i][remk]\\n\\n maxLen = 1\\n for j in range(i-1, -1, -1):\\n if nums[i] == nums[j]:\\n maxLen = max(maxLen, 1 + solve(j, remk))\\n elif nums[i] != nums[j] and remk > 0:\\n maxLen = max(maxLen, 1+solve(j, remk-1))\\n\\n dp[i][remk] = maxLen\\n return maxLen\\n\\n ans = 0\\n for i in range(n):\\n ans = max(ans, solve(i, k))\\n # imaging every i is end of sub sequence\\n # print(dp)\\n return ans\",\n \"memory\": \"17900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n heaps = [[] for _ in range(k+1)]\\n mp = defaultdict(dict)\\n for n in nums:\\n for i in range(k, 0, -1):\\n v = 1\\n if i in mp and n in mp[i]:\\n v = max(v, mp[i][n] + 1)\\n if heaps[i-1]:\\n v = max(v, -heaps[i-1][0][0] + 1)\\n mp[i][n] = v\\n heappush(heaps[i], (-v, n))\\n if n in mp[0]:\\n mp[0][n] += 1\\n else:\\n mp[0][n] = 1\\n heappush(heaps[0], (-mp[0][n], n))\\n return max(-heaps[i][0][0] for i in range(k+1))\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n def DP(i, num_remaining, memo):\\n if num_remaining < 0:\\n return 0\\n \\n if i < 0:\\n return 0 \\n \\n if (i, num_remaining) in memo:\\n return memo[(i, num_remaining)]\\n \\n max_length = 1\\n for j in range(i):\\n if nums[j] == nums[i]:\\n max_length = max(max_length, 1 + DP(j, num_remaining, memo))\\n else:\\n max_length = max(max_length, 1 + DP(j, num_remaining-1, memo))\\n \\n memo[(i, num_remaining)] = max_length\\n return max_length\\n \\n memo = {}\\n max_length = 0\\n for i in range(len(nums)):\\n max_length = max(max_length, DP(i, k, memo))\\n\\n return max_length\\n\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def dp(self, i, k):\\n if i == 0:\\n return 1\\n else:\\n key = (i, k)\\n if key in self.cache:\\n return self.cache[key]\\n ans = 1\\n for j in range(0, i):\\n if self.nums[j] == self.nums[i]:\\n ans = max(ans, 1 + self.dp(j, k))\\n else:\\n if k > 0:\\n ans = max(ans, 1 + self.dp(j, k - 1))\\n self.cache[key] = ans\\n return ans\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n self.nums = nums\\n self.cache = {}\\n ans = 0\\n n = len(nums)\\n for i in range(n):\\n ans = max(ans, self.dp(i, k))\\n return ans\",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n\\n @cache\\n def solve(self, i, k):\\n if i == 0:\\n if k == 0:\\n return 1\\n else:\\n return 0\\n if k < 0:\\n return 0\\n\\n n = len(self.nums)\\n n_i = self.nums[i]\\n\\n if k == 0:\\n result = 1\\n else:\\n result = 0\\n\\n for j in range(i):\\n n_j = self.nums[j]\\n\\n if n_i == n_j and self.solve(j, k) > 0:\\n result = max(result, self.solve(j, k) + 1)\\n continue\\n\\n if n_i != n_j and self.solve(j, k - 1) > 0:\\n result = max(result, self.solve(j, k - 1) + 1)\\n continue\\n\\n return result\\n\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n self.solve.cache_clear()\\n self.nums = nums\\n n = len(nums)\\n\\n result = -math.inf\\n for i in range(n):\\n for max_diff in range(k + 1):\\n this_result = self.solve(i, max_diff)\\n result = max(result, this_result)\\n\\n return result\",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n max_sub = 0\\n cache = dict()\\n for ind in range(len(nums)):\\n\\n curr_sub = self.dfs(\\n ind=ind,\\n curr_diff=0,\\n nums=nums,\\n k=k,\\n cache=cache\\n )\\n max_sub = max(max_sub, curr_sub)\\n\\n return max_sub\\n\\n def dfs(self, ind: int, curr_diff: int, nums: list, k: int, cache:dict) -> int:\\n\\n if (ind, curr_diff) in cache:\\n return cache[(ind, curr_diff)]\\n\\n if curr_diff>k:\\n return 0\\n\\n max_sub = 1\\n \\n for i in range(ind+1, len(nums)):\\n diff = curr_diff\\n\\n if nums[ind]!=nums[i]:\\n diff+=1\\n \\n curr_sub = 1 + self.dfs(\\n ind=i,\\n curr_diff=diff,\\n nums=nums,\\n k=k,\\n cache=cache)\\n max_sub = max(curr_sub, max_sub)\\n cache[(ind, curr_diff)] = max_sub\\n return max_sub\",\n \"memory\": \"18800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # [1,2,1,1,3]\\n # k = 2\\n # \\n dp = {} # dp[i][j] is the max length of the subsequence with up to i changes ending in nums[j]\\n max_so_far = {} # max_so_far[i][j] is the max length of the subsequence with up to i changes up to (nums[j] doesnt have to include it)\\n for i in range(k+1):\\n dp[i, 0] = 1\\n max_so_far[i,0] = 1\\n \\n for i in range(k+1):\\n last_appearance = {} # last_appearance[n] is the index of the last appearance of n in nums so far\\n\\n for j in range(len(nums)):\\n\\n \\n max_i_j = 1 # min is 1\\n if nums[j] in last_appearance:\\n last_appearance_index = last_appearance[nums[j]]\\n max_i_j = max(max_i_j, dp[i, last_appearance_index] + 1) # add 1 to last sequence of this number\\n\\n last_appearance[nums[j]] = j # update last seen index\\n if j == 0:\\n continue\\n if i > 0:\\n max_i_j = max(max_i_j, max_so_far[i-1, j-1] + 1)\\n\\n dp[i, j] = max_i_j\\n max_so_far[i,j] = max(max_so_far[i, j-1], dp[i, j])\\n return max_so_far[k, len(nums)-1]\\n\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"from functools import cache\\nfrom collections import Counter\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n nextd = [n]*n\\n counter = Counter()\\n for i in range(n-2,-1,-1):\\n if nums[i] != nums[i+1]:\\n nextd[i] = i+1\\n else:\\n nextd[i] = nextd[i+1]\\n nextcnt = [1]*n\\n for i in range(n-1,-1,-1):\\n counter[nums[i]] += 1\\n nextcnt[i] = counter[nums[i]]\\n @cache\\n def dfs(i,k):\\n if k == 0:\\n return nextcnt[i]\\n if i == n-1: return 1\\n res = 0\\n j = nextd[i]\\n while j < n:\\n if nums[i] != nums[j]:\\n res = max(res, dfs(j,k-1))\\n else:\\n res = max(res, dfs(j,k))\\n j = nextd[j]\\n return res + nextd[i] - i\\n return max([dfs(i,k) for i in range(n)])\",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n possible = set()\\n # possible = {(\\n # 0, # length\\n # 0, # errors\\n # '', # last number used\\n # # (), # entire subsequence\\n # )}\\n for N in nums:\\n new_possible = {\\n # each N can start its own, length-1, error-free sequence\\n (\\n 1,\\n 0,\\n N,\\n # (N,),\\n )\\n }\\n for P in possible:\\n # or we can extend each other sequence with this N\\n (\\n prev_len,\\n prev_err,\\n prev_num,\\n # prev_seq,\\n ) = P\\n new_len = prev_len + 1\\n new_err = prev_err + (0 if (prev_num == N) else 1)\\n new_num = N\\n # new_seq = prev_seq + (N,)\\n if new_err > k:\\n continue\\n new_possible.add(\\n (\\n new_len,\\n new_err,\\n new_num,\\n # new_seq,\\n )\\n )\\n possible |= new_possible\\n \\n print(f'{possible=}')\\n\\n return max([\\n length\\n for (length, errors, last_num) in possible\\n ])\\n\",\n \"memory\": \"25700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = {} \\n\\n # def rec_helper(i, j, prev):\\n # # print(i, j, prev)\\n # # i is the index, j is number of switches left\\n # if (i, j, prev) in dp:\\n # return dp[(i, j, prev)] \\n\\n # if j < 0 or i == len(nums):\\n # return 0\\n\\n # if nums[i] == prev:\\n # # print('Here', i, prev)\\n # res = 1 + rec_helper(i+1, j, prev) # Include no switch\\n # elif j == 0:\\n # res = rec_helper(i+1, j, prev) # Exclude\\n # else:\\n # res = max(\\n # rec_helper(i+1, j, prev), # Exclude \\n # 1 + rec_helper(i+1, j-1, nums[i]) # Include and switch\\n # )\\n \\n # # print('Res', i, j, prev, res)\\n # dp[(i, j, prev)] = res\\n # return dp[(i, j, prev)]\\n\\n def rec_helper(i, j):\\n # print(i, j, prev)\\n # i is the index, j is number of switches left\\n if (i, j) in dp:\\n return dp[(i, j)] \\n\\n if j < 0 or i == len(nums):\\n return 0\\n\\n res = 1 \\n for k in range(i+1, len(nums)): # Next inclusion\\n if nums[k] == nums[i]:\\n res = max(res, 1 + rec_helper(k, j)) \\n else:\\n res = max(\\n res, 1 + rec_helper(k, j-1)\\n )\\n \\n # return res\\n \\n # print('Res', i, j, prev, res)\\n dp[(i, j)] = res\\n return dp[(i, j)]\\n\\n res = 0 \\n for i in range(len(nums)):\\n # res = max(res, 1 + rec_helper(i+1, k, nums[i]))\\n res = max(res, rec_helper(i, k))\\n return res\",\n \"memory\": \"28000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n mem = {}\\n # i - last elem of subsq\\n # curk - k left\\n def helper(i, curk):\\n if (i, curk) in mem:\\n return mem[(i, curk)]\\n res = 1\\n for j in range(i):\\n if nums[i] == nums[j]:\\n res = max(res, 1 + helper(j, curk))\\n elif curk + 1 <= k:\\n res = max(res, 1 + helper(j, curk + 1))\\n mem[(i, curk)] = res\\n return res\\n \\n res = 1\\n for i in range(len(nums)):\\n res = max(res, helper(i, 0))\\n \\n return res\",\n \"memory\": \"28100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n #if you add a num and -1 in then good-1 or if or num+1 then good -=1\\n # if num is seq.. nothing already taken care of\\n # if num+1\\n \\n # is the number of indices where [i] != [i+1]\\n #sliding window: K++ if nums[r] != nums[r-1] k++\\n # if too many, reduce left. if nums[l] != nums[l+1]: k--\\n\\n #take/skip a number (i,unequal) n*k\\n\\n def dfs(i,unequal):\\n if unequal > k: #remove previously added\\n return -1\\n if i == len(nums):\\n return 0\\n key = (i,unequal)\\n if key in cache:\\n return cache[key]\\n longest = 0\\n for j in range(i+1,len(nums)):\\n longest = max(longest, 1+dfs(j,unequal + (nums[j] != nums[i]) ) )\\n cache[key] = longest\\n return longest\\n\\n cache = {}\\n \\n return max(1+dfs(i,0) for i in range(len(nums)))\",\n \"memory\": \"28500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 0\\n n = len(nums)\\n memo = {}\\n #@cache\\n def helper(k,i):\\n if i>=n or k<0:\\n return 0\\n if (k,i) in memo:\\n return memo[(k,i)]\\n mx = 0\\n for j in range(i+1,n):\\n if nums[j]== nums[i]:\\n mx = max(mx,helper(k,j))\\n else:\\n mx = max(mx,helper(k-1,j))\\n memo[(k,i)] = mx+1\\n return 1 + mx\\n\\n\\n for i in range(n):\\n ans = max(ans,helper(k,i))\\n return ans\\n\",\n \"memory\": \"28600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # if len(nums) == 0:\\n # return 0\\n \\n # dp = [defaultdict(int) for _ in range(k + 1)]\\n # res = [0] * (k + 1)\\n\\n # for n in nums:\\n # for i in range(k, -1, -1):\\n # dp[i][n] = max(dp[i][n] + 1, res[i - 1] + 1 if i > 0 else 0)\\n # res[i] = max(res[i], dp[i][n])\\n \\n # return res[k]\\n\\n res = 0\\n n = len(nums)\\n\\n memo = {}\\n def dp(i, k):\\n if i >= n or k < 0:\\n return 0\\n \\n if (i, k) in memo:\\n return memo[(i, k)]\\n \\n mx = 0\\n for j in range(i + 1, n):\\n if nums[j] == nums[i]:\\n mx = max(mx, dp(j, k))\\n else:\\n mx = max(mx, dp(j, k - 1))\\n \\n memo[(i, k)] = mx + 1\\n return 1 + mx\\n \\n for i in range(n):\\n res = max(res, dp(i, k))\\n return res\",\n \"memory\": \"28800\"\n },\n {\n \"code\": \"import collections\\nfrom typing import List\\n\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = collections.defaultdict(int)\\n\\n def dfs(total_diff_count, _i):\\n key = (total_diff_count, _i)\\n if key in dp:\\n return dp[key]\\n result = 1\\n previous = nums[_i]\\n for next_i in range(_i + 1, len(nums)):\\n if nums[next_i] == previous:\\n result = max(result, 1 + dfs(total_diff_count, next_i))\\n else:\\n if total_diff_count < k:\\n result = max(result, 1 + dfs(total_diff_count + 1, next_i))\\n\\n dp[key] = result\\n return result\\n\\n return max(dfs(0, i) for i in range(len(nums)))\",\n \"memory\": \"28900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n mx = 0\\n for p in range(i):\\n if nums[p] == nums[i]:\\n mx = max(dfs(p, j), mx)\\n elif j and nums[p] != nums[i]:\\n mx = max(dfs(p, j - 1), mx) \\n return mx + 1\\n\\n return max(dfs(i, k) for i in range(n - 1, -1, -1))\\n \",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n ret = 0\\n\\n @cache\\n def dfs(i: int, diff_cnt: int) -> int:\\n nonlocal ret\\n if i == 0:\\n return 1\\n ans = 1\\n # ans = max(1, dfs(i - 1, diff_cnt))\\n for pos in range(i):\\n if nums[pos] == nums[i]:\\n ans = max(ans, dfs(pos, diff_cnt) + 1)\\n else:\\n if diff_cnt >= 1:\\n ans = max(ans, dfs(pos, diff_cnt - 1) + 1)\\n return ans\\n\\n # dfs(N - 1, k)\\n for i in range(N):\\n ret = max(ret, dfs(i, k))\\n return ret\",\n \"memory\": \"29100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def findPre(idx):\\n search = nums[idx]\\n while idx:\\n idx -= 1\\n if nums[idx] == search: return idx\\n return -1\\n @cache\\n def maxLength(diff,idx):\\n if idx == 0: return 1\\n ans = 1\\n for i in range(idx):\\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\\n choice2 = maxLength(diff-1,i) if diff else 0\\n ans = max(ans,1+max(choice1,choice2))\\n return ans\\n return max(maxLength(k,i) for i in range(len(nums)))\",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def f(end, k):\\n if(k < 0): return 0\\n if(end == 0): return 1\\n take = 1\\n for i in range(end-1, -1, -1):\\n if(nums[i] != nums[end]):\\n if(k > 0):\\n currLen = 1 + f(i, k-1)\\n take = max(currLen, take)\\n else:\\n currLen = 1 + f(i, k)\\n take = max(currLen, take)\\n return take\\n\\n ret = 0\\n for i in range(0, len(nums)):\\n ret = max(ret, f(i,k))\\n\\n\\n return ret\\n \",\n \"memory\": \"29300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def f(i, k):\\n # print(i, k)\\n if i >= n: return 0\\n\\n pick = 1\\n for j in range(i + 1, n):\\n good = nums[i] != nums[j]\\n if not good:\\n pick = max(pick, 1 + f(j, k))\\n # print(\\\"not good\\\", i, j, pick)\\n\\n if k:\\n pick = max(pick, 1 + f(j, k - 1))\\n # print(\\\"good\\\", i, j, pick)\\n \\n \\n # print(i, k, \\\"pick\\\", pick)\\n return pick\\n\\n n = len(nums)\\n \\n return max(f(i, k) for i in range(n))\\n\",\n \"memory\": \"29500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n\\n @cache\\n def go(idx, delta):\\n res = 1\\n\\n for j in range(idx+1, N):\\n\\n inc = 1\\n\\n if nums[j] == nums[idx]:\\n inc = 0\\n\\n if delta + inc <= k:\\n res = max(res, go(j, delta+inc) + 1)\\n\\n return res\\n\\n res = 0\\n for i in range(N):\\n res = max(res, go(i, 0))\\n return res\",\n \"memory\": \"29700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def dp(i: int, k: int) -> int:\\n if i == len(nums):\\n return 0\\n res = 0\\n for j in range(i + 1, len(nums)):\\n if nums[i] != nums[j]:\\n if k > 0:\\n res = max(res, 1 + dp(j, k - 1))\\n else:\\n res = max(res, 1 + dp(j, k))\\n return res\\n return max([1 + dp(i, k) for i in range(len(nums))])\\n\",\n \"memory\": \"29800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n memory = {}\\n if len(nums)==1:\\n return 1\\n def DynamicProgramming(index,prevIndex,currK):\\n if memory.get((index,prevIndex,currK))!=None:\\n return memory[(index,prevIndex,currK)]\\n if index==len(nums):\\n return 0\\n countSeq = 0\\n for idx in range(index,len(nums)):\\n temp=0\\n if nums[idx]!=nums[prevIndex]:\\n temp=1\\n if (currK+temp)>k:\\n continue\\n else:\\n \\n countSeq=max(countSeq,DynamicProgramming(idx+1,idx,currK+temp)+1)\\n memory[(index,prevIndex,currK)]=countSeq\\n return memory[(index,prevIndex,currK)]\\n maxi = 0\\n for idx in range(1,len(nums)):\\n maxi=max(DynamicProgramming(idx,idx-1,0)+1,maxi)\\n return maxi\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def findPre(idx):\\n search = nums[idx]\\n while idx:\\n idx -= 1\\n if nums[idx] == search: return idx\\n return 0\\n @cache\\n def maxLength(diff,idx):\\n if idx == 0: return 1\\n ans = 1\\n for i in range(findPre(idx),idx):\\n choice1 = maxLength(diff,i) if nums[i] == nums[idx] else 0\\n choice2 = maxLength(diff-1,i) if diff else 0\\n ans = max(ans,1+max(choice1,choice2))\\n return ans\\n return max(maxLength(k,i) for i in range(len(nums)))\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i,k):\\n if k==-1:\\n return 0\\n res = 1\\n for j in range(i):\\n if nums[j]==nums[i]: res =max(res,dfs(j,k)+1)\\n else: res =max(res,dfs(j,k-1)+1)\\n return res\\n return max(dfs(i,k) for i in range(n))\\n \",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def fn(idx, diffs):\\n if diffs < 0:\\n return 0\\n ans = 1\\n for j in range(idx):\\n if nums[j] == nums[idx]:\\n ans = max(ans, fn(j, diffs) + 1)\\n else:\\n ans = max(ans, fn(j, diffs-1) + 1)\\n return ans\\n \\n return max(fn(i, k) for i in range(len(nums)))\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n @cache\\n def fn(idx, diffs):\\n if diffs < 0:\\n return 0\\n ans = 1\\n for j in range(idx):\\n if nums[j] == nums[idx]:\\n ans = max(ans, fn(j, diffs) + 1)\\n else:\\n ans = max(ans, fn(j, diffs-1) + 1)\\n return ans\\n \\n return max(fn(i, k) for i in range(len(nums)))\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def dfs(i, k):\\n if k < 0: return 0\\n temp_res = 0\\n for j in range(i+1, n):\\n if nums[i] == nums[j]:\\n temp_res = max(temp_res, dfs(j, k))\\n else:\\n temp_res = max(temp_res, dfs(j, k-1))\\n return 1 + temp_res\\n \\n n = len(nums)\\n if n <= k: return n\\n res = 0\\n for i in range(n):\\n res = max(res, dfs(i, k))\\n return res\",\n \"memory\": \"31500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n @cache\\n def dfs(i, cur_good):\\n if cur_good > k or i >= len(nums):\\n return 0\\n\\n max_subsequence = 0\\n for j in range(i+1, len(nums)):\\n if nums[i] == nums[j]:\\n max_subsequence = max(max_subsequence, dfs(j, cur_good))\\n else:\\n max_subsequence = max(max_subsequence, dfs(j, cur_good + 1))\\n return 1 + max_subsequence\\n \\n res = 0\\n for i in range(len(nums)):\\n res = max(res, dfs(i, 0))\\n return res\\n\\n \\n\\n\\n\\n\\n\\n\",\n \"memory\": \"31600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n @cache\\n def dp(index, rem):\\n if rem < 0: return -math.inf\\n if index == n - 1: return 1\\n res = 1\\n for j in range(index + 1, n):\\n res = max(res, 1 + dp(j, rem - int(nums[index] != nums[j])))\\n return res\\n res = 1\\n for i in range(n):\\n res = max(res, dp(i, k))\\n return res\\n \",\n \"memory\": \"31700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":41,"string":"41"}}},{"rowIdx":2461,"cells":{"question_id":{"kind":"number","value":3452,"string":"3,452"},"name":{"kind":"string","value":"find-the-maximum-length-of-a-good-subsequence-ii"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code> and a <strong>non-negative</strong> integer <code>k</code>. A sequence of integers <code>seq</code> is called <strong>good</strong> if there are <strong>at most</strong> <code>k</code> indices <code>i</code> in the range <code>[0, seq.length - 2]</code> such that <code>seq[i] != seq[i + 1]</code>.</p>\n\n<p>Return the <strong>maximum</strong> possible length of a <strong>good</strong> <span data-keyword=\"subsequence-array\">subsequence</span> of <code>nums</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,1,1,3], k = 2</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The maximum length subsequence is <code>[<u>1</u>,<u>2</u>,<u>1</u>,<u>1</u>,3]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,4,5,1], k = 0</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The maximum length subsequence is <code>[<u>1</u>,2,3,4,5,<u>1</u>]</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 5 * 10<sup>3</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>\n\t<li><code>0 <= k <= min(50, nums.length)</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":24.547925348795072,"string":"24.547925"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","hash-table","dynamic-programming"],"string":"[\n \"array\",\n \"hash-table\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"538\", 0.901], [\"658\", 0.901], [\"778\", 0.4505], [\"898\", 8.108699999999999], [\"1017\", 18.469900000000006], [\"1137\", 30.632500000000025], [\"1257\", 7.207999999999999], [\"1376\", 6.3069999999999995], [\"1496\", 0.901], [\"1616\", 1.3515000000000001], [\"1736\", 4.9555], [\"1855\", 4.054399999999999], [\"1975\", 0.901], [\"2095\", 1.3515000000000001], [\"2215\", 0.4505], [\"2334\", 1.802], [\"2454\", 0.901], [\"2574\", 0.4505], [\"2693\", 0.4505], [\"2813\", 0.4505], [\"2933\", 0.4505], [\"3053\", 0.4505], [\"3172\", 0.4505], [\"3292\", 0.4505], [\"3412\", 0.4505], [\"3531\", 0.4505], [\"3651\", 0.4505], [\"3771\", 0.4505]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17300\", 0.9009], [\"17400\", 3.6036], [\"19200\", 1.3514], [\"19300\", 2.2523], [\"19400\", 9.009], [\"19500\", 3.1532], [\"19600\", 0.4505], [\"19800\", 0.4505], [\"20000\", 0.4505], [\"20200\", 0.4505], [\"20300\", 2.2523], [\"20400\", 2.2523], [\"20500\", 0.4505], [\"22000\", 0.4505], [\"22100\", 0.4505], [\"22200\", 0.4505], [\"23500\", 0.4505], [\"23600\", 0.4505], [\"24100\", 0.4505], [\"24200\", 0.4505], [\"24500\", 0.4505], [\"24600\", 0.9009], [\"24700\", 13.964], [\"24800\", 7.6577], [\"24900\", 5.8559], [\"25000\", 6.3063], [\"25100\", 4.0541], [\"25200\", 1.3514], [\"25300\", 0.4505], [\"26000\", 0.4505], [\"26200\", 1.3514], [\"26500\", 1.3514], [\"26600\", 4.0541], [\"26700\", 1.8018], [\"27200\", 0.4505], [\"27500\", 0.4505], [\"27600\", 0.4505], [\"27700\", 0.4505], [\"27800\", 0.4505], [\"27900\", 1.8018], [\"28000\", 0.4505], [\"28900\", 0.4505], [\"29200\", 1.8018], [\"29300\", 1.8018], [\"29400\", 4.0541], [\"29500\", 1.8018]]}"},"rt_list":{"kind":"list like","value":[{"code":"from typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length_by_num = {-1: [0]*(k+1)}\n total_max_length = [0]*(k+1)\n for n in nums:\n n_max_length = [1] + [1+a for a in total_max_length[:-1]]\n if n in max_length_by_num:\n n_max_length = [a+1 if a >= b else b for a,b in zip(max_length_by_num[n], n_max_length)]\n max_length_by_num[n] = n_max_length\n total_max_length = [a if b < a else b for a,b in zip(n_max_length, total_max_length)]\n\n return max(total_max_length)","runtime":"538"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # ns = sorted(list(set(nums)))\n # m = len(ns)\n # df = {a:i for i,a in enumerate(ns)}\n # nums = [df[a] for a in nums]\n # dp = [[0 for j in range(m)] for i in range(k+1)]\n # prevmax = [0 for i in range(k+1)]\n # for i,a in enumerate(nums):\n # for j in range(k,-1,-1):\n # dp[j][a] += 1\n # if j>0:\n # dp[j][a] = max(dp[j][a],prevmax[j-1]+1)\n # prevmax[j] = max(prevmax[j],dp[j][a])\n # return max([max(a) for a in dp])\n\n # shortcut for k == 0\n if k == 0:\n cnt = Counter(nums)\n return cnt.most_common(1)[0][1]\n # dp[i] is a length of longest sequence where i switches are made\n dp = [0 for _ in range(k + 1)]\n # hmap[num] contains array like dp, but specifically for sequences ending with num\n hmap = {}\n for num in nums:\n if num not in hmap:\n hmap[num] = [0] * (k + 1)\n li = hmap[num]\n for i in range(k + 1):\n # update each length of sequence ending with num and using i switches\n # it is either li[i] + 1 or dp[i - 1] + 1\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\n # update dp\n for i in range(k + 1):\n if li[i] > dp[i]:\n dp[i] = li[i]\n return max(dp)","runtime":"538"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n if k == 0:\n cnt = Counter(nums)\n return cnt.most_common(1)[0][1]\n\n dp = [0 for _ in range(k + 1)]\n\n hmap = {}\n for num in nums:\n if num not in hmap:\n hmap[num] = [0] * (k + 1)\n li = hmap[num]\n for i in range(k + 1):\n\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\n\n for i in range(k + 1):\n if li[i] > dp[i]:\n dp[i] = li[i]\n return max(dp)","runtime":"658"},{"code":"class Solution:\n # dp[k][i] = max(dp[k][s], max(dp[k-1][j<i])+1, nums[s]=nums[i]\n def maximumLength(self, nums: List[int], k: int) -> int:\n # find prev and dp[k==0]\n n = len(nums)+1\n prev = [0]*n # 1-index, 0 = no prev\n last = Counter()\n d = [0]*n\n for i,v in enumerate(nums,start=1):\n prev[i] = last[v]\n d[i] = d[prev[i]]+1\n last[v] = i\n # p is dp[k], d is dp[k-1]\n for it in range(k):\n p = [0]*n\n imax = 0 # max(d[:i])\n for i,v in enumerate(nums,start=1):\n p[i] = max(p[prev[i]], imax)+1\n imax = max(imax, d[i])\n d = p\n #\n return max(d) \n ","runtime":"658"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n fs = {}\n mx = [0] * (k + 2)\n for x in nums:\n if x not in fs:\n fs[x] = [0] * (k + 1)\n f = fs[x]\n for j in range(k, -1, -1):\n f[j] = max(f[j], mx[j]) + 1\n mx[j + 1] = max(mx[j + 1], f[j])\n return mx[-1]\n\n\n","runtime":"778"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n fs = {}\n mx = [0] * (k + 2)\n for x in nums:\n if x not in fs:\n fs[x] = [0] * (k + 1)\n f = fs[x]\n for j in range(k, -1, -1):\n f[j] = max(f[j], mx[j]) + 1\n mx[j + 1] = max(mx[j + 1], f[j])\n return mx[-1]","runtime":"898"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n fs = {}\n mx = [0] * (k + 2)\n for x in nums:\n if x not in fs:\n fs[x] = [0] * (k + 1)\n f = fs[x]\n for j in range(k, -1, -1):\n f[j] = max(f[j], mx[j]) + 1\n mx[j + 1] = max(mx[j + 1], f[j])\n return mx[-1]","runtime":"898"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n runs = {} # Dictionary to store subsequences for each number\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\n\n for x in nums: # Iterate through each number in nums\n if x not in runs:\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\n else:\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\n \n # Update runs[x] for differences 1 to k\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\n\n # Update best subsequences\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best) # Return the length of the longest subsequence","runtime":"1017"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n runs = {} # Dictionary to store subsequences for each number\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\n\n for x in nums: # Iterate through each number in nums\n if x not in runs:\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\n else:\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\n \n # Update runs[x] for differences 1 to k\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\n\n # Update best subsequences\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best) # Return the length of the longest subsequence","runtime":"1017"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ns = sorted(list(set(nums)))\n m = len(ns)\n df = {a:i for i,a in enumerate(ns)}\n nums = [df[a] for a in nums]\n dp = [[0 for j in range(m)] for i in range(k+1)]\n prevmax = [0 for i in range(k+1)]\n for i,a in enumerate(nums):\n for j in range(k,-1,-1):\n dp[j][a] += 1\n if j>0:\n dp[j][a] = max(dp[j][a],prevmax[j-1]+1)\n prevmax[j] = max(prevmax[j],dp[j][a])\n return max([max(a) for a in dp])","runtime":"1137"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n previous = dict()\n dp = [[]] * len(nums)\n dpmax = [0] * (k+1)\n dpset = [set()] * (k+1)\n for i in range(0, len(nums)):\n dp[i] = [1]*(k+1)\n if nums[i] in previous:\n for ip, vp in enumerate(dp[previous[nums[i]]]):\n dp[i][ip] = vp+1\n for ik in range(0, k+1):\n if nums[i] in dpset[ik]:\n dp[i][ik] = max(dp[i][ik], dpmax[ik]+1)\n else:\n if ik != k:\n dp[i][ik+1] = max(dp[i][ik+1], dpmax[ik]+1)\n for ik in range(0, k+1):\n if dpmax[ik] < dp[i][ik]:\n dpmax[ik] = dp[i][ik]\n dpset[ik] = {nums[i]}\n elif dpmax[ik] == dp[i][ik]:\n dpset[ik].add(nums[i])\n previous[nums[i]] = i \n return max(dpmax)","runtime":"1137"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n Define dp[i][c] as max length of a good subsequence that ends with num=c\n with i different neighbors.\n \n dp[i][x] = max(dp[i][x]+1, dp[i-1][y] + 1]) where y != x\n To improve the performance, we can keep track of the result of \n the max length of a good subsequence in each i.\n \"\"\"\n dp = defaultdict(int)\n max_len = [0] * (len(nums))\n for i in range(k+1):\n next_max_len = [0] * (len(nums))\n dp = defaultdict(int)\n for j, num in enumerate(nums):\n if j == 0:\n dp[num] = 1\n else:\n dp[num] = max(dp[num]+1, max_len[j-1] + 1)\n next_max_len[j] = max(next_max_len[j-1], dp[num])\n max_len = next_max_len\n return max(max_len)","runtime":"1257"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (n + 1) for _ in range(k + 2)]\n memo = {}\n adj_same = []\n for i in range(n):\n if nums[i] not in memo:\n adj_same.append(0)\n else:\n adj_same.append(memo[nums[i]])\n memo[nums[i]] = i + 1\n for i in range(1, k + 2):\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same[j - 1]] + 1)\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\n return dp[k + 1][n]\n","runtime":"1257"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0 for i in range(k+1)] for j in range(n)]\n maxi=[[0 for i in range(k+1)] for j in range(n)]\n mp={}\n for i in range(n):\n for j in range(k+1):\n if(i==0):\n dp[i][j]=1\n maxi[i][j]=max(maxi[i][j],dp[i][j])\n elif(j==0):\n dp[i][j]=1\n t=mp.get(nums[i],-1)\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\n else:\n dp[i][j]=maxi[i-1][j-1]+1\n t=mp.get(nums[i],-1)\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\n mp[nums[i]]=i\n return max(dp[n-1][k],maxi[n-1][k])","runtime":"1376"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n # dp[num][j]: at most j diff\n dp = {num: [0 for i in range(k+1)] for num in nums}\n mx = [0 for i in range(k+1)]\n for i, num in enumerate(nums):\n for j in range(k, -1, -1):\n dp[num][j] = dp[num][j] + 1\n if j > 0:\n dp[num][j] = max(dp[num][j], mx[j-1] + 1)\n mx[j] = max(mx[j], dp[num][j])\n return max([dp[i][k] for i in dp.keys()])","runtime":"1376"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0] * len(nums)\n prev_max = [0] * len(nums)\n for j in range(k + 1):\n local_max = defaultdict(int)\n for i in range(len(nums)):\n dp[i] = max(prev_max[i-1] if i > 0 else 0, local_max[nums[i]]) + 1\n local_max[nums[i]] = max(local_max[nums[i]], dp[i])\n #print(dp)\n prev_max = max(local_max.values() or [0])\n prev_max = dp[:]\n for i in range(1, len(nums)):\n prev_max[i] = max(prev_max[i-1], prev_max[i])\n return prev_max[-1]\n","runtime":"1496"},{"code":"from functools import cache\nfrom collections import defaultdict\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * len(nums) for i in range(k + 1)]\n count = defaultdict(int)\n for j in range(len(nums)):\n count[nums[j]] += 1\n dp[0][j] = count[nums[j]]\n for i in range(1, k + 1):\n dp[i][0] = 1\n for i in range(1, k + 1):\n count_for_cur_k = defaultdict(int)\n count_for_cur_k[nums[0]] = 1\n max_for_prev_k = dp[i - 1][0]\n \n for j in range(1, len(nums)):\n \n dp[i][j] = max(max_for_prev_k + 1, count_for_cur_k[nums[j]] + 1)\n max_for_prev_k = max(max_for_prev_k, dp[i - 1][j])\n count_for_cur_k[nums[j]] = max(count_for_cur_k[nums[j]], dp[i][j])\n # for row in dp:\n # print(row)\n return max([max(row) for row in dp])\n\n\n\n\n\n\n ","runtime":"1496"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n memo = defaultdict(lambda:(defaultdict(lambda:0)))\n maxs = [[0] for i in range(k + 1)]\n \n if len(nums) == 1:\n return 1\n\n for i in nums:\n for j in range(k+1):\n m = memo[j]\n m[i] += 1\n\n if maxs[j][-1] <= m[i]:\n maxs[j] = [maxs[j][-1], m[i]]\n \n memo[j + 1][i] = max(memo[j + 1][i], maxs[j][-2] if m[i] == maxs[j][-1] else maxs[j][-1])\n\n return max(max(memo[i].values()) for i in range(k+1) if memo[i])","runtime":"1616"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k+1) for _ in range(n)]\n\n same = [defaultdict(int) for _ in range(k+1)]\n diff = [0 for _ in range(k+1)]\n\n ans = 0\n for i, num in enumerate(nums): \n dp[i][0] = 1\n for j in range(k+1): \n dp[i][j] = 1 + same[j][num]\n if j > 0:\n dp[i][j] = max(dp[i][j], diff[j-1] + 1)\n ans = max(ans, dp[i][j])\n for j in range(k+1): \n same[j][num] = max(same[j][num], dp[i][j])\n diff[j] = max(diff[j], dp[i][j])\n\n return ans","runtime":"1975"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n DP1 = { (nums[n-1],c):1 for c in range(k+1) }\n DP2 = [1] * (k+1)\n res = 1\n for i in reversed(range(n-1)):\n for c in range(k+1):\n mx = 1\n if c < k:\n mx = max(mx, 1 + DP2[c+1])\n mx = max(mx, 1 + DP1.get((nums[i],c),0) )\n\n DP2[c] = max(DP2[c], mx)\n DP1[nums[i],c] = max(DP1.get((nums[i],c), 0), mx)\n \n if c == 0:\n res = max(res, mx)\n\n return res ","runtime":"1975"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * (k + 1) for i in range(len(nums))]\n for i in range(len(nums)):\n f[i][0] = 1\n for l in range(k+1):\n max_same_value = defaultdict(int)\n max_different = 0\n for i in range(len(nums)):\n if l > 0:\n f[i][l] = max(f[i][l-1], f[i][l])\n f[i][l] = max(max_same_value[nums[i]]+1, max_different+1, f[i][l])\n max_same_value[nums[i]] = max(f[i][l], max_same_value[nums[i]])\n if l > 0:\n max_different = max(f[i][l-1], max_different)\n result = max(f[i][k] for i in range(len(nums)))\n return result\n","runtime":"2095"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (k + 1) for _ in range(n)]\n max_value = [{} for _ in range(k + 1)]\n max_all = [0] * (k + 1)\n ret = 1\n\n for i in range(n):\n for t in range(k + 1):\n dp[i][t] = 1\n if nums[i] in max_value[t]:\n dp[i][t] = max(dp[i][t], max_value[t][nums[i]] + 1)\n if t >= 1:\n dp[i][t] = max(dp[i][t], max_all[t - 1] + 1)\n # dp[i][t] = ans\n ret = max(ret, dp[i][t])\n \n for t in range(k + 1):\n if nums[i] not in max_value[t]:\n max_value[t][nums[i]] = dp[i][t]\n else:\n max_value[t][nums[i]] = max(max_value[t][nums[i]], dp[i][t])\n max_all[t] = max(max_all[t], dp[i][t])\n\n return ret","runtime":"2095"},{"code":"import collections\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[i, j] is answer for sequence starting with i and with at most j non-equal neighbors\n # res[j]: is answer for sequence with at most j non-equal neighbors\n # dp[i, j] = max(dp[i, j] + 1, res[j-1] + 1)\n dp = collections.defaultdict(int)\n res = collections.defaultdict(int)\n ans = 0\n for i in range(len(nums)-1, -1, -1):\n for j in range(k, -1, -1):\n if j >= 1:\n dp[nums[i], j] = max(dp[nums[i], j]+1, res[j-1]+1)\n else:\n dp[nums[i], j] = dp[nums[i], j]+1\n res[j] = max(res[j], dp[nums[i], j])\n ans = max(ans, dp[nums[i], j])\n return ans\n ","runtime":"2215"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[0] * (k + 1) for _ in range(n)]\n mp = [defaultdict(int) for _ in range(k + 1)]\n g = [[0] * 3 for _ in range(k + 1)]\n ans = 0\n for i, x in enumerate(nums):\n for h in range(k + 1):\n f[i][h] = mp[h][x]\n if h:\n if g[h - 1][0] != nums[i]:\n f[i][h] = max(f[i][h], g[h - 1][1])\n else:\n f[i][h] = max(f[i][h], g[h - 1][2])\n f[i][h] += 1\n mp[h][nums[i]] = max(mp[h][nums[i]], f[i][h])\n if g[h][0] != x:\n if f[i][h] >= g[h][1]:\n g[h][2] = g[h][1]\n g[h][1] = f[i][h]\n g[h][0] = x\n else:\n g[h][2] = max(g[h][2], f[i][h])\n else:\n g[h][1] = max(g[h][1], f[i][h])\n ans = max(ans, f[i][h])\n return ans\n ","runtime":"2334"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[0] * (k + 1) for _ in range(n)]\n mp = [defaultdict(int) for _ in range(k + 1)]\n g = [[0] * 3 for _ in range(k + 1)]\n ans = 0\n for i, x in enumerate(nums):\n for h in range(k + 1):\n f[i][h] = mp[h][x]\n if h:\n if g[h - 1][0] != nums[i]:\n f[i][h] = max(f[i][h], g[h - 1][1])\n else:\n f[i][h] = max(f[i][h], g[h - 1][2])\n f[i][h] += 1\n mp[h][nums[i]] = max(mp[h][nums[i]], f[i][h])\n if g[h][0] != x:\n if f[i][h] >= g[h][1]:\n g[h][2] = g[h][1]\n g[h][1] = f[i][h]\n g[h][0] = x\n else:\n g[h][2] = max(g[h][2], f[i][h])\n else:\n g[h][1] = max(g[h][1], f[i][h])\n ans = max(ans, f[i][h])\n return ans\n","runtime":"2334"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0]*(k+1) for _ in range(n+1)]\n curr = [defaultdict(int) for _ in range(k+1)]\n prev = [[[0, -1], [0, -1]] for _ in range(k+1)]\n for i in range(n-1, -1, -1): \n for j in range(k+1): \n if j > 0: \n if nums[i] != prev[j-1][0][1]: dp[i][j] = prev[j-1][0][0]\n else: dp[i][j] = prev[j-1][1][0]\n dp[i][j] = max(dp[i][j], curr[j][nums[i]])\n dp[i][j] += 1\n curr[j][nums[i]] = dp[i][j] \n if nums[i] == prev[j][0][1]: prev[j][0][0] = dp[i][j]\n else: \n insort(prev[j], [dp[i][j], nums[i]], key = lambda x: -x[0])\n prev[j].pop()\n return max(dp[i][k] for i in range(n))","runtime":"2454"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = {}\n n = len(nums)\n last = {}\n for i in range(n-1, -1, -1):\n cur = nums[i]\n if cur in last:\n dp[(i,0)] = dp[(last[cur], 0)] + 1\n else:\n dp[(i,0)] = 1\n last[cur] = i\n for i in range(n-2, -1, -1):\n dp[(i,0)] = max(dp[(i+1, 0)], dp[(i,0)])\n\n for kval in range(1, k+1):\n dp[(n-1,kval)] = 1\n\n\n for kval in range(1, k+1):\n last = {}\n for i in range(n-2, -1, -1):\n cur = nums[i]\n if cur in last:\n dp[(i,kval)] = max(dp[(last[cur], kval)],dp[i+1, kval-1]) + 1\n else:\n dp[(i,kval)] = dp[i+1, kval-1] + 1\n last[cur] = i\n for i in range(n-2, -1, -1):\n dp[(i,kval)] = max(dp[(i+1, kval)], dp[(i,kval)])\n #print(dp)\n return dp[(0,k)]\n\n","runtime":"2454"},{"code":"class DP:\n def __init__(self, k):\n self._k = k\n\n # dp[prev][k] = value\n self._dp = defaultdict(dict)\n\n # max_dp[k][elem] = value\n # but store max 2 best pairs (elem, value) for every k\n self._max_dp = defaultdict(dict)\n\n def update_for_elem(self, elem, current):\n dp_elem = self._dp[elem]\n\n # update dp_elem by dp_elem\n for k in dp_elem:\n dp_elem[k] += current\n if 0 not in dp_elem:\n dp_elem[0] = current\n\n # update dp_elem by another elems\n for k, bucket in self._max_dp.items():\n for prev, value in bucket.items():\n if prev != elem:\n dp_elem[k + 1] = max(\n dp_elem.get(k + 1, 0),\n value + current,\n )\n\n dp_elem.pop(self._k + 1, None)\n\n # update max_dp\n for k, value in dp_elem.items():\n max_dp_line = self._max_dp[k]\n if len(max_dp_line) < 2 or elem in max_dp_line:\n # update by elem\n max_dp_line[elem] = value\n else:\n min_pair = min(\n (value_, elem_)\n for elem_, value_ in max_dp_line.items()\n )\n if min_pair[0] < value:\n # replace bad pair (elem_, value_) for (elem, value)\n max_dp_line.pop(min_pair[1])\n max_dp_line[elem] = value\n\n def get_max(self):\n return max(\n max(bucket.values())\n for bucket in self._max_dp.values()\n )\n\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = DP(k)\n for elem, it in groupby(nums):\n current = sum(1 for _ in it)\n dp.update_for_elem(elem, current)\n return dp.get_max()","runtime":"2574"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n heaps = [[] for _ in range(k+1)]\n mp = defaultdict(dict)\n for n in nums:\n for i in range(k, 0, -1):\n v = 1\n if i in mp and n in mp[i]:\n v = max(v, mp[i][n] + 1)\n if heaps[i-1]:\n v = max(v, -heaps[i-1][0][0] + 1)\n mp[i][n] = v\n heappush(heaps[i], (-v, n))\n if n in mp[0]:\n mp[0][n] += 1\n else:\n mp[0][n] = 1\n heappush(heaps[0], (-mp[0][n], n))\n return max(-heaps[i][0][0] for i in range(k+1))","runtime":"2693"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp =[[0] * (k + 1) for _ in range(n)]\n dp[0][0] = 1\n max_k = [0] * (k + 1)\n max_k[0] = 1\n ans = 1\n\n for i in range(1, n):\n dp[i][0] = 1\n for t in range(1, k + 1):\n dp[i][t] = max(dp[i][t], max_k[t - 1] + 1)\n for j in range(i - 1, -1, -1):\n if nums[i] == nums[j]:\n for t in range(k + 1):\n dp[i][t] = max(dp[i][t], dp[j][t] + 1)\n break\n for t in range(k + 1):\n max_k[t] = max(max_k[t], dp[i][t])\n ans = max(ans, max(dp[i]))\n # print(dp)\n return ans","runtime":"2813"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n res = max(Counter(nums).values())\n d = collections.defaultdict(dict)\n k_length = collections.defaultdict(int)\n d[nums[0]][k] = 1\n k_length[k] = 1\n \n for i in range(1, len(nums)):\n tmp = collections.defaultdict(int)\n if nums[i] in d:\n for cnt in d[nums[i]]:\n d[nums[i]][cnt] += 1\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\n res = max(res, d[nums[i]][cnt])\n else:\n d[nums[i]][k] = 1\n \n for cnt in k_length:\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\n if cnt:\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\n res = max(res, d[nums[i]][cnt-1])\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1])\n k_length = tmp\n \n return res","runtime":"2933"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n cnt1 = Counter(nums)\n res = max(cnt1.values())\n d = collections.defaultdict(dict)\n k_length = collections.defaultdict(int)\n d[nums[0]][k] = 1\n k_length[k] = 1\n \n for i in range(1, len(nums)):\n tmp = collections.defaultdict(int)\n if nums[i] in d:\n for cnt in d[nums[i]]:\n d[nums[i]][cnt] += 1\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\n res = max(res, d[nums[i]][cnt])\n else:\n d[nums[i]][k] = 1\n \n for cnt in k_length:\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\n if cnt:\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\n res = max(res, d[nums[i]][cnt-1])\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1],tmp[cnt-1])\n \n # print(\"k_length\",k_length) \n k_length = tmp\n # print(d, nums[i], res)\n return res","runtime":"3053"},{"code":"class Solution:\n def __init__(self):\n self.dp = {}\n\n def solve(self, i, count, same, nums, mp):\n if i >= len(nums):\n return 0\n if (i, same, count) in self.dp:\n return self.dp[(i, same, count)]\n\n take = 0\n notake = 0\n v = mp[nums[i]]\n ind = bisect.bisect_right(v, i)\n\n if ind == len(v):\n take = 1\n else:\n take = 1 + self.solve(v[ind], count, True, nums, mp)\n\n if count > 0:\n take = max(take, 1 + self.solve(i + 1, count - 1, False, nums, mp))\n if not same:\n notake = self.solve(i + 1, count, False, nums, mp)\n\n self.dp[(i, same, count)] = max(take, notake)\n return self.dp[(i, same, count)]\n\n def maximumLength(self, nums: List[int], k: int) -> int:\n self.dp = {}\n mp = defaultdict(list)\n for i in range(len(nums)):\n mp[nums[i]].append(i)\n return self.solve(0, k, False, nums, mp)\n\n \"\"\"\n Intuition\n The idea is to go over all elements of the array, building all possible sequences along the way, keeping track of the best ones.\n\n We track the longest subsequence with given last element x and number of shifts q∈[0,…k] so far.\n\n At each iteration we update our knowledge of the best subsequences. This step is optimized by also keeping a separate subsequence category tracking the best subsequences for given q but without specifying x. This trick allows us at each step to only look at O(k) stored values, instead of the full O(Nk) memory.\n\n Approach\n The variable best stores k+1 numbers, where best[q] is the best (longest) sequence so far that has had q shifts.\n\n The variable runs is a dict which stores the same for subsequences with a specific last element. In particular, runs[y] is the array for subsequences ending in y, e.g. runs[y][0] is the longest subsequence with q=0 shifts (i.e. all elements equal y).\n\n Now consider an iteration step. Suppose the current element is x. If we take a subsequence and add the current element, it will now end in x. This means that only runs[x] and best need to be updated.\n\n First we update runs[x].\n\n Consider subsequences that already ended with x and add our new x to its end.\n If this is the first time we have encountered x in nums, then we simply set runs[x] = [1] * (k+1). [Sidenote: we could equally initiate with [1, 0, 0, ...]. As long as the array is non-increasing, only its front number matters (it represents a longer subsequence with less shifts and thus always outperforms the rest of subsequences represented by this array)].\n If runs[x] already existed, we simply update its value by incrementing all values in it by one.\n Consider subsequences that did not end with x and add x to their end. This again increments values by 1 but also increases q by 1. Thus, we take runs[x][i] and update its value with best[i-1] + 1, if the latter is larger.\n Finally we update best by comparing its values with the just updated runs[x] and choosing the larger.\n After iterating through nums, we just have to choose the best of best.\n\n Complexity\n Time complexity:\n O(Nk): N iteration steps, O(k) updates at each step\n\n Space complexity:\n O(Nk)\n \"\"\"\n \"\"\"\n runs = {}\n best = [0] * (k + 1)\n for x in nums:\n if x not in runs:\n runs[x] = [1] * (k + 1)\n else:\n runs[x] = [z + 1 for z in runs[x]]\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best)\n \"\"\"","runtime":"3172"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n ind = defaultdict(list)\n for i, x in enumerate(nums):\n ind[x].append(i + 1)\n\n def firstMatchBefore(x: int, i: int) -> int:\n l, r = -1, len(ind[x]) - 1\n while l < r:\n m = l + (r - l + 1) // 2\n if ind[x][m] < i:\n l = m\n else:\n r = m - 1\n return ind[x][l] if l >= 0 else 0\n \n # 1-index for simplicity\n @cache\n def maxEndingAt(i, k) -> int:\n if i == 0:\n return 0\n j = firstMatchBefore(nums[i - 1], i)\n assert(j < i)\n match = maxEndingAt(j, k) + 1\n dont_match = maxUpTo(i - 1, k - 1) + 1 if k else 0\n return max(match, dont_match)\n\n # 1-index for simplicity\n @cache\n def maxUpTo(i: int, k: int) -> int:\n if i == 0:\n return 0\n take = maxEndingAt(i, k)\n skip = maxUpTo(i - 1, k)\n return max(take, skip)\n\n return maxUpTo(n, k)","runtime":"3292"},{"code":"from sortedcontainers import SortedList\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*(k + 1) for i in range(len(nums))]\n longest = [SortedList() for d in range(k + 1)]\n longest_specific = [Counter() for d in range(k + 1)]\n dp[0][0] = 1\n longest[0].add([1, nums[0]])\n longest_specific[0][nums[0]] += 1\n\n for i in range(1, len(nums)):\n a = nums[i]\n for d in range(k + 1):\n dp[i][d] = max(dp[i][d], longest_specific[d][a] + 1)\n if d > 0:\n if longest[d - 1] and longest[d - 1][-1][1] != a:\n dp[i][d] = max(dp[i][d], longest[d - 1][-1][0] + 1)\n elif len(longest[d - 1]) > 1 and longest[d - 1][-1][1] == a:\n dp[i][d] = max(dp[i][d], longest[d - 1][-2][0] + 1)\n longest[d].discard([longest_specific[d][a], a])\n longest[d].add([dp[i][d], a])\n longest_specific[d][a] = dp[i][d]\n \n return max(max(dp[i]) for i in range(len(nums)))\n \n\n","runtime":"3412"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length ","runtime":"3531"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","runtime":"3651"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","runtime":"3771"}],"string":"[\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length_by_num = {-1: [0]*(k+1)}\\n total_max_length = [0]*(k+1)\\n for n in nums:\\n n_max_length = [1] + [1+a for a in total_max_length[:-1]]\\n if n in max_length_by_num:\\n n_max_length = [a+1 if a >= b else b for a,b in zip(max_length_by_num[n], n_max_length)]\\n max_length_by_num[n] = n_max_length\\n total_max_length = [a if b < a else b for a,b in zip(n_max_length, total_max_length)]\\n\\n return max(total_max_length)\",\n \"runtime\": \"538\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # ns = sorted(list(set(nums)))\\n # m = len(ns)\\n # df = {a:i for i,a in enumerate(ns)}\\n # nums = [df[a] for a in nums]\\n # dp = [[0 for j in range(m)] for i in range(k+1)]\\n # prevmax = [0 for i in range(k+1)]\\n # for i,a in enumerate(nums):\\n # for j in range(k,-1,-1):\\n # dp[j][a] += 1\\n # if j>0:\\n # dp[j][a] = max(dp[j][a],prevmax[j-1]+1)\\n # prevmax[j] = max(prevmax[j],dp[j][a])\\n # return max([max(a) for a in dp])\\n\\n # shortcut for k == 0\\n if k == 0:\\n cnt = Counter(nums)\\n return cnt.most_common(1)[0][1]\\n # dp[i] is a length of longest sequence where i switches are made\\n dp = [0 for _ in range(k + 1)]\\n # hmap[num] contains array like dp, but specifically for sequences ending with num\\n hmap = {}\\n for num in nums:\\n if num not in hmap:\\n hmap[num] = [0] * (k + 1)\\n li = hmap[num]\\n for i in range(k + 1):\\n # update each length of sequence ending with num and using i switches\\n # it is either li[i] + 1 or dp[i - 1] + 1\\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\\n # update dp\\n for i in range(k + 1):\\n if li[i] > dp[i]:\\n dp[i] = li[i]\\n return max(dp)\",\n \"runtime\": \"538\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n if k == 0:\\n cnt = Counter(nums)\\n return cnt.most_common(1)[0][1]\\n\\n dp = [0 for _ in range(k + 1)]\\n\\n hmap = {}\\n for num in nums:\\n if num not in hmap:\\n hmap[num] = [0] * (k + 1)\\n li = hmap[num]\\n for i in range(k + 1):\\n\\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\\n\\n for i in range(k + 1):\\n if li[i] > dp[i]:\\n dp[i] = li[i]\\n return max(dp)\",\n \"runtime\": \"658\"\n },\n {\n \"code\": \"class Solution:\\n # dp[k][i] = max(dp[k][s], max(dp[k-1][j<i])+1, nums[s]=nums[i]\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # find prev and dp[k==0]\\n n = len(nums)+1\\n prev = [0]*n # 1-index, 0 = no prev\\n last = Counter()\\n d = [0]*n\\n for i,v in enumerate(nums,start=1):\\n prev[i] = last[v]\\n d[i] = d[prev[i]]+1\\n last[v] = i\\n # p is dp[k], d is dp[k-1]\\n for it in range(k):\\n p = [0]*n\\n imax = 0 # max(d[:i])\\n for i,v in enumerate(nums,start=1):\\n p[i] = max(p[prev[i]], imax)+1\\n imax = max(imax, d[i])\\n d = p\\n #\\n return max(d) \\n \",\n \"runtime\": \"658\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n fs = {}\\n mx = [0] * (k + 2)\\n for x in nums:\\n if x not in fs:\\n fs[x] = [0] * (k + 1)\\n f = fs[x]\\n for j in range(k, -1, -1):\\n f[j] = max(f[j], mx[j]) + 1\\n mx[j + 1] = max(mx[j + 1], f[j])\\n return mx[-1]\\n\\n\\n\",\n \"runtime\": \"778\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n fs = {}\\n mx = [0] * (k + 2)\\n for x in nums:\\n if x not in fs:\\n fs[x] = [0] * (k + 1)\\n f = fs[x]\\n for j in range(k, -1, -1):\\n f[j] = max(f[j], mx[j]) + 1\\n mx[j + 1] = max(mx[j + 1], f[j])\\n return mx[-1]\",\n \"runtime\": \"898\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n fs = {}\\n mx = [0] * (k + 2)\\n for x in nums:\\n if x not in fs:\\n fs[x] = [0] * (k + 1)\\n f = fs[x]\\n for j in range(k, -1, -1):\\n f[j] = max(f[j], mx[j]) + 1\\n mx[j + 1] = max(mx[j + 1], f[j])\\n return mx[-1]\",\n \"runtime\": \"898\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n runs = {} # Dictionary to store subsequences for each number\\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\\n\\n for x in nums: # Iterate through each number in nums\\n if x not in runs:\\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\\n else:\\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\\n \\n # Update runs[x] for differences 1 to k\\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\\n\\n # Update best subsequences\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best) # Return the length of the longest subsequence\",\n \"runtime\": \"1017\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n runs = {} # Dictionary to store subsequences for each number\\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\\n\\n for x in nums: # Iterate through each number in nums\\n if x not in runs:\\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\\n else:\\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\\n \\n # Update runs[x] for differences 1 to k\\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\\n\\n # Update best subsequences\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best) # Return the length of the longest subsequence\",\n \"runtime\": \"1017\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ns = sorted(list(set(nums)))\\n m = len(ns)\\n df = {a:i for i,a in enumerate(ns)}\\n nums = [df[a] for a in nums]\\n dp = [[0 for j in range(m)] for i in range(k+1)]\\n prevmax = [0 for i in range(k+1)]\\n for i,a in enumerate(nums):\\n for j in range(k,-1,-1):\\n dp[j][a] += 1\\n if j>0:\\n dp[j][a] = max(dp[j][a],prevmax[j-1]+1)\\n prevmax[j] = max(prevmax[j],dp[j][a])\\n return max([max(a) for a in dp])\",\n \"runtime\": \"1137\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n previous = dict()\\n dp = [[]] * len(nums)\\n dpmax = [0] * (k+1)\\n dpset = [set()] * (k+1)\\n for i in range(0, len(nums)):\\n dp[i] = [1]*(k+1)\\n if nums[i] in previous:\\n for ip, vp in enumerate(dp[previous[nums[i]]]):\\n dp[i][ip] = vp+1\\n for ik in range(0, k+1):\\n if nums[i] in dpset[ik]:\\n dp[i][ik] = max(dp[i][ik], dpmax[ik]+1)\\n else:\\n if ik != k:\\n dp[i][ik+1] = max(dp[i][ik+1], dpmax[ik]+1)\\n for ik in range(0, k+1):\\n if dpmax[ik] < dp[i][ik]:\\n dpmax[ik] = dp[i][ik]\\n dpset[ik] = {nums[i]}\\n elif dpmax[ik] == dp[i][ik]:\\n dpset[ik].add(nums[i])\\n previous[nums[i]] = i \\n return max(dpmax)\",\n \"runtime\": \"1137\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n Define dp[i][c] as max length of a good subsequence that ends with num=c\\n with i different neighbors.\\n \\n dp[i][x] = max(dp[i][x]+1, dp[i-1][y] + 1]) where y != x\\n To improve the performance, we can keep track of the result of \\n the max length of a good subsequence in each i.\\n \\\"\\\"\\\"\\n dp = defaultdict(int)\\n max_len = [0] * (len(nums))\\n for i in range(k+1):\\n next_max_len = [0] * (len(nums))\\n dp = defaultdict(int)\\n for j, num in enumerate(nums):\\n if j == 0:\\n dp[num] = 1\\n else:\\n dp[num] = max(dp[num]+1, max_len[j-1] + 1)\\n next_max_len[j] = max(next_max_len[j-1], dp[num])\\n max_len = next_max_len\\n return max(max_len)\",\n \"runtime\": \"1257\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (n + 1) for _ in range(k + 2)]\\n memo = {}\\n adj_same = []\\n for i in range(n):\\n if nums[i] not in memo:\\n adj_same.append(0)\\n else:\\n adj_same.append(memo[nums[i]])\\n memo[nums[i]] = i + 1\\n for i in range(1, k + 2):\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same[j - 1]] + 1)\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\\n return dp[k + 1][n]\\n\",\n \"runtime\": \"1257\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0 for i in range(k+1)] for j in range(n)]\\n maxi=[[0 for i in range(k+1)] for j in range(n)]\\n mp={}\\n for i in range(n):\\n for j in range(k+1):\\n if(i==0):\\n dp[i][j]=1\\n maxi[i][j]=max(maxi[i][j],dp[i][j])\\n elif(j==0):\\n dp[i][j]=1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n else:\\n dp[i][j]=maxi[i-1][j-1]+1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\\n mp[nums[i]]=i\\n return max(dp[n-1][k],maxi[n-1][k])\",\n \"runtime\": \"1376\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n # dp[num][j]: at most j diff\\n dp = {num: [0 for i in range(k+1)] for num in nums}\\n mx = [0 for i in range(k+1)]\\n for i, num in enumerate(nums):\\n for j in range(k, -1, -1):\\n dp[num][j] = dp[num][j] + 1\\n if j > 0:\\n dp[num][j] = max(dp[num][j], mx[j-1] + 1)\\n mx[j] = max(mx[j], dp[num][j])\\n return max([dp[i][k] for i in dp.keys()])\",\n \"runtime\": \"1376\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0] * len(nums)\\n prev_max = [0] * len(nums)\\n for j in range(k + 1):\\n local_max = defaultdict(int)\\n for i in range(len(nums)):\\n dp[i] = max(prev_max[i-1] if i > 0 else 0, local_max[nums[i]]) + 1\\n local_max[nums[i]] = max(local_max[nums[i]], dp[i])\\n #print(dp)\\n prev_max = max(local_max.values() or [0])\\n prev_max = dp[:]\\n for i in range(1, len(nums)):\\n prev_max[i] = max(prev_max[i-1], prev_max[i])\\n return prev_max[-1]\\n\",\n \"runtime\": \"1496\"\n },\n {\n \"code\": \"from functools import cache\\nfrom collections import defaultdict\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * len(nums) for i in range(k + 1)]\\n count = defaultdict(int)\\n for j in range(len(nums)):\\n count[nums[j]] += 1\\n dp[0][j] = count[nums[j]]\\n for i in range(1, k + 1):\\n dp[i][0] = 1\\n for i in range(1, k + 1):\\n count_for_cur_k = defaultdict(int)\\n count_for_cur_k[nums[0]] = 1\\n max_for_prev_k = dp[i - 1][0]\\n \\n for j in range(1, len(nums)):\\n \\n dp[i][j] = max(max_for_prev_k + 1, count_for_cur_k[nums[j]] + 1)\\n max_for_prev_k = max(max_for_prev_k, dp[i - 1][j])\\n count_for_cur_k[nums[j]] = max(count_for_cur_k[nums[j]], dp[i][j])\\n # for row in dp:\\n # print(row)\\n return max([max(row) for row in dp])\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"1496\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n memo = defaultdict(lambda:(defaultdict(lambda:0)))\\n maxs = [[0] for i in range(k + 1)]\\n \\n if len(nums) == 1:\\n return 1\\n\\n for i in nums:\\n for j in range(k+1):\\n m = memo[j]\\n m[i] += 1\\n\\n if maxs[j][-1] <= m[i]:\\n maxs[j] = [maxs[j][-1], m[i]]\\n \\n memo[j + 1][i] = max(memo[j + 1][i], maxs[j][-2] if m[i] == maxs[j][-1] else maxs[j][-1])\\n\\n return max(max(memo[i].values()) for i in range(k+1) if memo[i])\",\n \"runtime\": \"1616\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k+1) for _ in range(n)]\\n\\n same = [defaultdict(int) for _ in range(k+1)]\\n diff = [0 for _ in range(k+1)]\\n\\n ans = 0\\n for i, num in enumerate(nums): \\n dp[i][0] = 1\\n for j in range(k+1): \\n dp[i][j] = 1 + same[j][num]\\n if j > 0:\\n dp[i][j] = max(dp[i][j], diff[j-1] + 1)\\n ans = max(ans, dp[i][j])\\n for j in range(k+1): \\n same[j][num] = max(same[j][num], dp[i][j])\\n diff[j] = max(diff[j], dp[i][j])\\n\\n return ans\",\n \"runtime\": \"1975\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n DP1 = { (nums[n-1],c):1 for c in range(k+1) }\\n DP2 = [1] * (k+1)\\n res = 1\\n for i in reversed(range(n-1)):\\n for c in range(k+1):\\n mx = 1\\n if c < k:\\n mx = max(mx, 1 + DP2[c+1])\\n mx = max(mx, 1 + DP1.get((nums[i],c),0) )\\n\\n DP2[c] = max(DP2[c], mx)\\n DP1[nums[i],c] = max(DP1.get((nums[i],c), 0), mx)\\n \\n if c == 0:\\n res = max(res, mx)\\n\\n return res \",\n \"runtime\": \"1975\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * (k + 1) for i in range(len(nums))]\\n for i in range(len(nums)):\\n f[i][0] = 1\\n for l in range(k+1):\\n max_same_value = defaultdict(int)\\n max_different = 0\\n for i in range(len(nums)):\\n if l > 0:\\n f[i][l] = max(f[i][l-1], f[i][l])\\n f[i][l] = max(max_same_value[nums[i]]+1, max_different+1, f[i][l])\\n max_same_value[nums[i]] = max(f[i][l], max_same_value[nums[i]])\\n if l > 0:\\n max_different = max(f[i][l-1], max_different)\\n result = max(f[i][k] for i in range(len(nums)))\\n return result\\n\",\n \"runtime\": \"2095\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (k + 1) for _ in range(n)]\\n max_value = [{} for _ in range(k + 1)]\\n max_all = [0] * (k + 1)\\n ret = 1\\n\\n for i in range(n):\\n for t in range(k + 1):\\n dp[i][t] = 1\\n if nums[i] in max_value[t]:\\n dp[i][t] = max(dp[i][t], max_value[t][nums[i]] + 1)\\n if t >= 1:\\n dp[i][t] = max(dp[i][t], max_all[t - 1] + 1)\\n # dp[i][t] = ans\\n ret = max(ret, dp[i][t])\\n \\n for t in range(k + 1):\\n if nums[i] not in max_value[t]:\\n max_value[t][nums[i]] = dp[i][t]\\n else:\\n max_value[t][nums[i]] = max(max_value[t][nums[i]], dp[i][t])\\n max_all[t] = max(max_all[t], dp[i][t])\\n\\n return ret\",\n \"runtime\": \"2095\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[i, j] is answer for sequence starting with i and with at most j non-equal neighbors\\n # res[j]: is answer for sequence with at most j non-equal neighbors\\n # dp[i, j] = max(dp[i, j] + 1, res[j-1] + 1)\\n dp = collections.defaultdict(int)\\n res = collections.defaultdict(int)\\n ans = 0\\n for i in range(len(nums)-1, -1, -1):\\n for j in range(k, -1, -1):\\n if j >= 1:\\n dp[nums[i], j] = max(dp[nums[i], j]+1, res[j-1]+1)\\n else:\\n dp[nums[i], j] = dp[nums[i], j]+1\\n res[j] = max(res[j], dp[nums[i], j])\\n ans = max(ans, dp[nums[i], j])\\n return ans\\n \",\n \"runtime\": \"2215\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[0] * (k + 1) for _ in range(n)]\\n mp = [defaultdict(int) for _ in range(k + 1)]\\n g = [[0] * 3 for _ in range(k + 1)]\\n ans = 0\\n for i, x in enumerate(nums):\\n for h in range(k + 1):\\n f[i][h] = mp[h][x]\\n if h:\\n if g[h - 1][0] != nums[i]:\\n f[i][h] = max(f[i][h], g[h - 1][1])\\n else:\\n f[i][h] = max(f[i][h], g[h - 1][2])\\n f[i][h] += 1\\n mp[h][nums[i]] = max(mp[h][nums[i]], f[i][h])\\n if g[h][0] != x:\\n if f[i][h] >= g[h][1]:\\n g[h][2] = g[h][1]\\n g[h][1] = f[i][h]\\n g[h][0] = x\\n else:\\n g[h][2] = max(g[h][2], f[i][h])\\n else:\\n g[h][1] = max(g[h][1], f[i][h])\\n ans = max(ans, f[i][h])\\n return ans\\n \",\n \"runtime\": \"2334\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[0] * (k + 1) for _ in range(n)]\\n mp = [defaultdict(int) for _ in range(k + 1)]\\n g = [[0] * 3 for _ in range(k + 1)]\\n ans = 0\\n for i, x in enumerate(nums):\\n for h in range(k + 1):\\n f[i][h] = mp[h][x]\\n if h:\\n if g[h - 1][0] != nums[i]:\\n f[i][h] = max(f[i][h], g[h - 1][1])\\n else:\\n f[i][h] = max(f[i][h], g[h - 1][2])\\n f[i][h] += 1\\n mp[h][nums[i]] = max(mp[h][nums[i]], f[i][h])\\n if g[h][0] != x:\\n if f[i][h] >= g[h][1]:\\n g[h][2] = g[h][1]\\n g[h][1] = f[i][h]\\n g[h][0] = x\\n else:\\n g[h][2] = max(g[h][2], f[i][h])\\n else:\\n g[h][1] = max(g[h][1], f[i][h])\\n ans = max(ans, f[i][h])\\n return ans\\n\",\n \"runtime\": \"2334\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0]*(k+1) for _ in range(n+1)]\\n curr = [defaultdict(int) for _ in range(k+1)]\\n prev = [[[0, -1], [0, -1]] for _ in range(k+1)]\\n for i in range(n-1, -1, -1): \\n for j in range(k+1): \\n if j > 0: \\n if nums[i] != prev[j-1][0][1]: dp[i][j] = prev[j-1][0][0]\\n else: dp[i][j] = prev[j-1][1][0]\\n dp[i][j] = max(dp[i][j], curr[j][nums[i]])\\n dp[i][j] += 1\\n curr[j][nums[i]] = dp[i][j] \\n if nums[i] == prev[j][0][1]: prev[j][0][0] = dp[i][j]\\n else: \\n insort(prev[j], [dp[i][j], nums[i]], key = lambda x: -x[0])\\n prev[j].pop()\\n return max(dp[i][k] for i in range(n))\",\n \"runtime\": \"2454\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = {}\\n n = len(nums)\\n last = {}\\n for i in range(n-1, -1, -1):\\n cur = nums[i]\\n if cur in last:\\n dp[(i,0)] = dp[(last[cur], 0)] + 1\\n else:\\n dp[(i,0)] = 1\\n last[cur] = i\\n for i in range(n-2, -1, -1):\\n dp[(i,0)] = max(dp[(i+1, 0)], dp[(i,0)])\\n\\n for kval in range(1, k+1):\\n dp[(n-1,kval)] = 1\\n\\n\\n for kval in range(1, k+1):\\n last = {}\\n for i in range(n-2, -1, -1):\\n cur = nums[i]\\n if cur in last:\\n dp[(i,kval)] = max(dp[(last[cur], kval)],dp[i+1, kval-1]) + 1\\n else:\\n dp[(i,kval)] = dp[i+1, kval-1] + 1\\n last[cur] = i\\n for i in range(n-2, -1, -1):\\n dp[(i,kval)] = max(dp[(i+1, kval)], dp[(i,kval)])\\n #print(dp)\\n return dp[(0,k)]\\n\\n\",\n \"runtime\": \"2454\"\n },\n {\n \"code\": \"class DP:\\n def __init__(self, k):\\n self._k = k\\n\\n # dp[prev][k] = value\\n self._dp = defaultdict(dict)\\n\\n # max_dp[k][elem] = value\\n # but store max 2 best pairs (elem, value) for every k\\n self._max_dp = defaultdict(dict)\\n\\n def update_for_elem(self, elem, current):\\n dp_elem = self._dp[elem]\\n\\n # update dp_elem by dp_elem\\n for k in dp_elem:\\n dp_elem[k] += current\\n if 0 not in dp_elem:\\n dp_elem[0] = current\\n\\n # update dp_elem by another elems\\n for k, bucket in self._max_dp.items():\\n for prev, value in bucket.items():\\n if prev != elem:\\n dp_elem[k + 1] = max(\\n dp_elem.get(k + 1, 0),\\n value + current,\\n )\\n\\n dp_elem.pop(self._k + 1, None)\\n\\n # update max_dp\\n for k, value in dp_elem.items():\\n max_dp_line = self._max_dp[k]\\n if len(max_dp_line) < 2 or elem in max_dp_line:\\n # update by elem\\n max_dp_line[elem] = value\\n else:\\n min_pair = min(\\n (value_, elem_)\\n for elem_, value_ in max_dp_line.items()\\n )\\n if min_pair[0] < value:\\n # replace bad pair (elem_, value_) for (elem, value)\\n max_dp_line.pop(min_pair[1])\\n max_dp_line[elem] = value\\n\\n def get_max(self):\\n return max(\\n max(bucket.values())\\n for bucket in self._max_dp.values()\\n )\\n\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = DP(k)\\n for elem, it in groupby(nums):\\n current = sum(1 for _ in it)\\n dp.update_for_elem(elem, current)\\n return dp.get_max()\",\n \"runtime\": \"2574\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n heaps = [[] for _ in range(k+1)]\\n mp = defaultdict(dict)\\n for n in nums:\\n for i in range(k, 0, -1):\\n v = 1\\n if i in mp and n in mp[i]:\\n v = max(v, mp[i][n] + 1)\\n if heaps[i-1]:\\n v = max(v, -heaps[i-1][0][0] + 1)\\n mp[i][n] = v\\n heappush(heaps[i], (-v, n))\\n if n in mp[0]:\\n mp[0][n] += 1\\n else:\\n mp[0][n] = 1\\n heappush(heaps[0], (-mp[0][n], n))\\n return max(-heaps[i][0][0] for i in range(k+1))\",\n \"runtime\": \"2693\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp =[[0] * (k + 1) for _ in range(n)]\\n dp[0][0] = 1\\n max_k = [0] * (k + 1)\\n max_k[0] = 1\\n ans = 1\\n\\n for i in range(1, n):\\n dp[i][0] = 1\\n for t in range(1, k + 1):\\n dp[i][t] = max(dp[i][t], max_k[t - 1] + 1)\\n for j in range(i - 1, -1, -1):\\n if nums[i] == nums[j]:\\n for t in range(k + 1):\\n dp[i][t] = max(dp[i][t], dp[j][t] + 1)\\n break\\n for t in range(k + 1):\\n max_k[t] = max(max_k[t], dp[i][t])\\n ans = max(ans, max(dp[i]))\\n # print(dp)\\n return ans\",\n \"runtime\": \"2813\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n res = max(Counter(nums).values())\\n d = collections.defaultdict(dict)\\n k_length = collections.defaultdict(int)\\n d[nums[0]][k] = 1\\n k_length[k] = 1\\n \\n for i in range(1, len(nums)):\\n tmp = collections.defaultdict(int)\\n if nums[i] in d:\\n for cnt in d[nums[i]]:\\n d[nums[i]][cnt] += 1\\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\\n res = max(res, d[nums[i]][cnt])\\n else:\\n d[nums[i]][k] = 1\\n \\n for cnt in k_length:\\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\\n if cnt:\\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\\n res = max(res, d[nums[i]][cnt-1])\\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1])\\n k_length = tmp\\n \\n return res\",\n \"runtime\": \"2933\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n cnt1 = Counter(nums)\\n res = max(cnt1.values())\\n d = collections.defaultdict(dict)\\n k_length = collections.defaultdict(int)\\n d[nums[0]][k] = 1\\n k_length[k] = 1\\n \\n for i in range(1, len(nums)):\\n tmp = collections.defaultdict(int)\\n if nums[i] in d:\\n for cnt in d[nums[i]]:\\n d[nums[i]][cnt] += 1\\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\\n res = max(res, d[nums[i]][cnt])\\n else:\\n d[nums[i]][k] = 1\\n \\n for cnt in k_length:\\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\\n if cnt:\\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\\n res = max(res, d[nums[i]][cnt-1])\\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1],tmp[cnt-1])\\n \\n # print(\\\"k_length\\\",k_length) \\n k_length = tmp\\n # print(d, nums[i], res)\\n return res\",\n \"runtime\": \"3053\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.dp = {}\\n\\n def solve(self, i, count, same, nums, mp):\\n if i >= len(nums):\\n return 0\\n if (i, same, count) in self.dp:\\n return self.dp[(i, same, count)]\\n\\n take = 0\\n notake = 0\\n v = mp[nums[i]]\\n ind = bisect.bisect_right(v, i)\\n\\n if ind == len(v):\\n take = 1\\n else:\\n take = 1 + self.solve(v[ind], count, True, nums, mp)\\n\\n if count > 0:\\n take = max(take, 1 + self.solve(i + 1, count - 1, False, nums, mp))\\n if not same:\\n notake = self.solve(i + 1, count, False, nums, mp)\\n\\n self.dp[(i, same, count)] = max(take, notake)\\n return self.dp[(i, same, count)]\\n\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n self.dp = {}\\n mp = defaultdict(list)\\n for i in range(len(nums)):\\n mp[nums[i]].append(i)\\n return self.solve(0, k, False, nums, mp)\\n\\n \\\"\\\"\\\"\\n Intuition\\n The idea is to go over all elements of the array, building all possible sequences along the way, keeping track of the best ones.\\n\\n We track the longest subsequence with given last element x and number of shifts q∈[0,…k] so far.\\n\\n At each iteration we update our knowledge of the best subsequences. This step is optimized by also keeping a separate subsequence category tracking the best subsequences for given q but without specifying x. This trick allows us at each step to only look at O(k) stored values, instead of the full O(Nk) memory.\\n\\n Approach\\n The variable best stores k+1 numbers, where best[q] is the best (longest) sequence so far that has had q shifts.\\n\\n The variable runs is a dict which stores the same for subsequences with a specific last element. In particular, runs[y] is the array for subsequences ending in y, e.g. runs[y][0] is the longest subsequence with q=0 shifts (i.e. all elements equal y).\\n\\n Now consider an iteration step. Suppose the current element is x. If we take a subsequence and add the current element, it will now end in x. This means that only runs[x] and best need to be updated.\\n\\n First we update runs[x].\\n\\n Consider subsequences that already ended with x and add our new x to its end.\\n If this is the first time we have encountered x in nums, then we simply set runs[x] = [1] * (k+1). [Sidenote: we could equally initiate with [1, 0, 0, ...]. As long as the array is non-increasing, only its front number matters (it represents a longer subsequence with less shifts and thus always outperforms the rest of subsequences represented by this array)].\\n If runs[x] already existed, we simply update its value by incrementing all values in it by one.\\n Consider subsequences that did not end with x and add x to their end. This again increments values by 1 but also increases q by 1. Thus, we take runs[x][i] and update its value with best[i-1] + 1, if the latter is larger.\\n Finally we update best by comparing its values with the just updated runs[x] and choosing the larger.\\n After iterating through nums, we just have to choose the best of best.\\n\\n Complexity\\n Time complexity:\\n O(Nk): N iteration steps, O(k) updates at each step\\n\\n Space complexity:\\n O(Nk)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n runs = {}\\n best = [0] * (k + 1)\\n for x in nums:\\n if x not in runs:\\n runs[x] = [1] * (k + 1)\\n else:\\n runs[x] = [z + 1 for z in runs[x]]\\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best)\\n \\\"\\\"\\\"\",\n \"runtime\": \"3172\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n ind = defaultdict(list)\\n for i, x in enumerate(nums):\\n ind[x].append(i + 1)\\n\\n def firstMatchBefore(x: int, i: int) -> int:\\n l, r = -1, len(ind[x]) - 1\\n while l < r:\\n m = l + (r - l + 1) // 2\\n if ind[x][m] < i:\\n l = m\\n else:\\n r = m - 1\\n return ind[x][l] if l >= 0 else 0\\n \\n # 1-index for simplicity\\n @cache\\n def maxEndingAt(i, k) -> int:\\n if i == 0:\\n return 0\\n j = firstMatchBefore(nums[i - 1], i)\\n assert(j < i)\\n match = maxEndingAt(j, k) + 1\\n dont_match = maxUpTo(i - 1, k - 1) + 1 if k else 0\\n return max(match, dont_match)\\n\\n # 1-index for simplicity\\n @cache\\n def maxUpTo(i: int, k: int) -> int:\\n if i == 0:\\n return 0\\n take = maxEndingAt(i, k)\\n skip = maxUpTo(i - 1, k)\\n return max(take, skip)\\n\\n return maxUpTo(n, k)\",\n \"runtime\": \"3292\"\n },\n {\n \"code\": \"from sortedcontainers import SortedList\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*(k + 1) for i in range(len(nums))]\\n longest = [SortedList() for d in range(k + 1)]\\n longest_specific = [Counter() for d in range(k + 1)]\\n dp[0][0] = 1\\n longest[0].add([1, nums[0]])\\n longest_specific[0][nums[0]] += 1\\n\\n for i in range(1, len(nums)):\\n a = nums[i]\\n for d in range(k + 1):\\n dp[i][d] = max(dp[i][d], longest_specific[d][a] + 1)\\n if d > 0:\\n if longest[d - 1] and longest[d - 1][-1][1] != a:\\n dp[i][d] = max(dp[i][d], longest[d - 1][-1][0] + 1)\\n elif len(longest[d - 1]) > 1 and longest[d - 1][-1][1] == a:\\n dp[i][d] = max(dp[i][d], longest[d - 1][-2][0] + 1)\\n longest[d].discard([longest_specific[d][a], a])\\n longest[d].add([dp[i][d], a])\\n longest_specific[d][a] = dp[i][d]\\n \\n return max(max(dp[i]) for i in range(len(nums)))\\n \\n\\n\",\n \"runtime\": \"3412\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length \",\n \"runtime\": \"3531\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"runtime\": \"3651\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"runtime\": \"3771\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":38,"string":"38"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = defaultdict(int)\n prev_max = [0] * n\n cur_max = [0] * n\n\n for _ in range(k + 1):\n for j in range(n - 1, -1, -1):\n dp[nums[j]] = max(\n dp[nums[j]] + 1,\n prev_max[j + 1] + 1 if j != n - 1 else 0\n )\n\n cur_max[j] = max(\n cur_max[j + 1] if j != n - 1 else 0,\n dp[nums[j]]\n )\n \n dp.clear()\n prev_max = cur_max[:]\n\n return max(cur_max)","memory":"17300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [0]*len(nums)\n for _ in range(k+1):\n new_dp, dic, max_len = [], {}, 0\n for i, num in enumerate(nums):\n new_dp.append(max(new_dp[dic[num]], max_len)+1 if num in dic else max_len+1)\n dic[num] = i\n max_len = max(dp[i], max_len)\n dp = new_dp\n return max(dp)","memory":"17400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n longest = [0] * (k)\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n if dp[j][n] != 0:\n dp[j][n] += 1\n # prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if longest[j - 1] != 0:\n dp[j][n] = max(dp[j][n], longest[j - 1] + 1)\n\n for j in range(k):\n longest[j] = max(longest[j], dp[j][n])\n\n return max([max(dp_elem) for dp_elem in dp])\n\n ","memory":"19200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_index = -1\n transformed_numbers = {}\n\n for j in range(len(nums)):\n n = nums[j]\n if n in transformed_numbers:\n nums[j] = transformed_numbers[n]\n else:\n last_index = last_index + 1\n nums[j] = last_index\n transformed_numbers[n] = last_index\n\n if last_index == 0:\n return len(nums)\n\n longest = [0] * (k)\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\n\n for n in nums:\n\n dp[0][n] += 1\n\n for j in range(1, k + 1):\n if dp[j][n] != 0:\n dp[j][n] += 1\n # prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\n if longest[j - 1] != 0:\n dp[j][n] = max(dp[j][n], longest[j - 1] + 1)\n\n for j in range(k):\n longest[j] = max(longest[j], dp[j][n])\n\n return max([max(dp_elem) for dp_elem in dp])\n\n ","memory":"19300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # make it more efficient by skipping the contiguous portions\n # having the same character (so instead of adding the character once,\n # add it the length of block times)\n res = [0 for _ in range(k + 1)]\n dp = {nums[i]: [0 for _ in range(k + 1)] for i in range(len(nums))}\n\n # try for each number to find the maximum length trying\n # all the possible remaining changes\n for num in nums:\n # this traversal is an optimization, to\n # reduce the number of dimensions needed for\n # dp, so you don't have to store the index\n # of the last used element\n for remainingK in reversed(range(k + 1)):\n dp[num][remainingK] = max(1 + dp[num][remainingK], (1 + res[remainingK - 1]) if remainingK - 1 >= 0 else 0)\n res[remainingK] = max(res[remainingK], dp[num][remainingK])\n\n return max(res)","memory":"19400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # make it more efficient by skipping the contiguous portions\n # having the same character (so instead of adding the character once,\n # add it the length of block times)\n res = [0 for _ in range(k + 1)]\n dp = {nums[i]: [0 for _ in range(k + 1)] for i in range(len(nums))}\n\n # try for each number to find the maximum length trying\n # all the possible remaining changes\n for num in nums:\n # this traversal is an optimization, to\n # reduce the number of dimensions needed for\n # dp, so you don't have to store the index\n # of the last used element\n for remainingK in reversed(range(k + 1)):\n dp[num][remainingK] = max(1 + dp[num][remainingK], (1 + res[remainingK - 1]) if remainingK - 1 >= 0 else 0)\n res[remainingK] = max(res[remainingK], dp[num][remainingK])\n\n return res[k]","memory":"19500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n if k == 0:\n cnt = Counter(nums)\n return cnt.most_common(1)[0][1]\n\n dp = [0 for _ in range(k + 1)]\n\n hmap = {}\n for num in nums:\n if num not in hmap:\n hmap[num] = [0] * (k + 1)\n li = hmap[num]\n for i in range(k + 1):\n\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\n\n for i in range(k + 1):\n if li[i] > dp[i]:\n dp[i] = li[i]\n return max(dp)","memory":"19600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n c = Counter(nums)\n if k == 0:\n return max(c.values())\n if max(c.values()) == 1:\n return min(k + 1, n)\n \n runs = {}\n best = [0] * (k + 1)\n for x in nums:\n if x not in runs:\n runs[x] = [1] * (k + 1)\n else:\n runs[x] = [z + 1 for z in runs[x]]\n runs[x][1:] = [max(lo + 1, xrun) for lo, xrun in zip(best, runs[x][1:])]\n best[1:] = [max(lo + 1, b) for lo, b in pairwise(best)]\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best)","memory":"19800"},{"code":"class Solution:\n\tdef maximumLength(self, nums: List[int], k: int) -> int:\n\t\td = defaultdict(list)\n\t\tfor i, x in enumerate(nums): d[x].append(i)\n\t\tm = {x: i for i, x in enumerate(sorted(d.keys()))}\n\t\ta = [m[x] for x in nums]\n\t\tdp, res = [[0] * len(d) for _ in range(k + 1)], [0] * (k + 1)\n\t\tfor x in a:\n\t\t\tfor i in range(k, -1, -1):\n\t\t\t\tdp[i][x] = max(dp[i][x] + 1, res[i - 1] + 1 if i > 0 else 0)\n\t\t\t\tres[i] = max(res[i], dp[i][x])\n\t\treturn res[k]","memory":"20000"},{"code":"from typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length_by_num = {-1: [0]*(k+1)}\n total_max_length = [0]*(k+1)\n for n in nums:\n n_max_length = [1] + [1+a for a in total_max_length[:-1]]\n if n in max_length_by_num:\n n_max_length = [a+1 if a >= b else b for a,b in zip(max_length_by_num[n], n_max_length)]\n max_length_by_num[n] = n_max_length\n total_max_length = [a if b < a else b for a,b in zip(n_max_length, total_max_length)]\n\n return max(total_max_length)","memory":"20200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n runs = {}\n best = [0] * (k + 1)\n for x in nums:\n if x not in runs:\n runs[x] = [1] * (k + 1)\n else:\n runs[x] = [z + 1 for z in runs[x]]\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best)\n ","memory":"20300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n runs = {} # Dictionary to store subsequences for each number\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\n\n for x in nums: # Iterate through each number in nums\n if x not in runs:\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\n else:\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\n \n # Update runs[x] for differences 1 to k\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\n\n # Update best subsequences\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\n \n return max(best) # Return the length of the longest subsequence","memory":"20400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n\n seq = {}\n best = [0] * (k+1)\n for n in nums:\n if n not in seq:\n seq[n] = [1] * (k+1)\n else:\n seq[n] = [l+1 for l in seq[n]]\n \n seq[n][1:] = [max(s, b+1) for b, s in zip(best, seq[n][1:])]\n best = [max(b, s) for b, s in zip(best, seq[n])]\n return best[-1]","memory":"20500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (n + 1) for _ in range(k + 2)]\n for i in range(1, k + 2):\n memo = {}\n for j in range(1, n + 1):\n adj_same = memo.get(nums[j - 1], 0)\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same] + 1)\n memo[nums[j - 1]] = j\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\n return dp[k + 1][n]\n","memory":"22000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (n + 1) for _ in range(k + 2)]\n for i in range(1, k + 2):\n memo = {}\n for j in range(1, n + 1):\n adj_same = memo.get(nums[j - 1], 0)\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same] + 1)\n memo[nums[j - 1]] = j\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\n return dp[k + 1][n]\n","memory":"22100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * (n + 1) for _ in range(k + 2)]\n memo = {}\n adj_same = []\n for i in range(n):\n if nums[i] not in memo:\n adj_same.append(0)\n else:\n adj_same.append(memo[nums[i]])\n memo[nums[i]] = i + 1\n for i in range(1, k + 2):\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same[j - 1]] + 1)\n for j in range(1, n + 1):\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\n return dp[k + 1][n]\n","memory":"22200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # Store elements and their counts in a list of lists\n a = [[nums[0], 1]]\n for x in nums[1:]:\n if a[-1][0] == x:\n a[-1][1] += 1\n else:\n a.append([x, 1])\n\n n = len(a)\n dp = [[0] * (k + 1) for _ in range(n)]\n bst = [0] * (k + 1)\n lastOcc = {}\n\n for i in range(n):\n current_val = a[i][0]\n current_count = a[i][1]\n t = lastOcc.get(current_val)\n\n for j in range(min(i + 1, k + 1)):\n dp[i][j] = current_count\n if j > 0:\n dp[i][j] += bst[j - 1]\n if t is not None:\n dp[i][j] = max(dp[i][j], dp[t][j] + current_count)\n\n for j in range(k + 1):\n bst[j] = max(bst[j], dp[i][j])\n\n lastOcc[current_val] = i\n\n return max(bst)\n","memory":"23500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n a = [[nums[0], 0]]\n for x in nums:\n if a[-1][0] == x:\n a[-1][1] += 1\n else:\n a.append([x, 1])\n\n n = len(a)\n ans = 0\n # print(a)\n # print()\n \n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\n bst = [0 for _ in range(k + 1)]\n lastOcc = {}\n\n for i in range(n):\n t = lastOcc.get(a[i][0], None)\n\n for j in range(min(i + 1, k + 1)):\n s = [ a[i][1] ]\n # if i > 0:\n # s.append(dp[i - 1][j])\n if j > 0 and i > 0:\n s[0] += bst[j - 1]\n if t is not None:\n s.append( dp[t][j] + a[i][1] ) \n \n dp[i][j] = max(s)\n \n for j in range(k + 1):\n bst[j] = max(bst[j], dp[i][j])\n\n lastOcc[a[i][0]] = i\n \n # print(*dp, sep='\\n')\n\n return max(bst)","memory":"23600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0]*(k+1) for i in range(n)]\n last=[0]*(k+1)\n d={}\n for i,val in enumerate(nums):\n for j in range(k,-1,-1):\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\n last[j]=max(last[j],dp[i][j])\n d[val]=i \n return last[k]","memory":"24100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0]*(k+1) for i in range(n)]\n last=[0]*(k+1)\n d={}\n for i,val in enumerate(nums):\n for j in range(k,-1,-1):\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\n last[j]=max(last[j],dp[i][j])\n d[val]=i \n return last[k]","memory":"24200"},{"code":"from functools import cache\nfrom collections import defaultdict\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * len(nums) for i in range(k + 1)]\n count = defaultdict(int)\n for j in range(len(nums)):\n count[nums[j]] += 1\n dp[0][j] = count[nums[j]]\n for i in range(1, k + 1):\n dp[i][0] = 1\n for i in range(1, k + 1):\n count_for_cur_k = defaultdict(int)\n count_for_cur_k[nums[0]] = 1\n max_for_prev_k = dp[i - 1][0]\n \n for j in range(1, len(nums)):\n \n dp[i][j] = max(max_for_prev_k + 1, count_for_cur_k[nums[j]] + 1)\n max_for_prev_k = max(max_for_prev_k, dp[i - 1][j])\n count_for_cur_k[nums[j]] = max(count_for_cur_k[nums[j]], dp[i][j])\n # for row in dp:\n # print(row)\n return max([max(row) for row in dp])\n\n\n\n\n\n\n ","memory":"24500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [defaultdict(int) for _ in range(k+1)]\n res = [0] * (k+1)\n\n for a in nums:\n for i in range(k, -1, -1):\n dp[i][a] = max(dp[i][a] + 1, res[i-1] + 1 if i else 0)\n res[i] = max(res[i], dp[i][a])\n \n return res[k]","memory":"24600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [defaultdict(int) for _ in range(k + 1)]\n res = [0] * (k + 1)\n for num in nums:\n for i in range(k, -1, -1):\n dp[i][num] = max(dp[i][num] + 1, res[i - 1] + 1 if i else 0)\n res[i] = max(res[i], dp[i][num])\n return res[k]","memory":"24700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [defaultdict(int) for _ in range(k+1)]\n mx = [0 for _ in range(k+1)]\n ans = 0\n for num in nums:\n for j in range(k, -1, -1):\n dp[j][num] = max(dp[j][num], mx[j-1] if j else 0)+1\n mx[j] = max(mx[j],dp[j][num])\n return mx[-1]","memory":"24700"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n dp = [defaultdict(int) for i in range(k + 1)]\n res = [0] * (k + 1)\n for a in A:\n for i in range(k, -1, -1):\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\n res[i] = max(res[i], dp[i][a])\n return res[k]","memory":"24800"},{"code":"from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # Initialize dp[c][num] = maximum length ending with num using c changes\n dp = [defaultdict(int) for _ in range(k + 1)]\n # Initialize max_dp[c] = maximum length over all nums with c changes\n max_dp = [0] * (k + 1)\n \n for num in nums:\n # We need to iterate c from high to low to avoid overwriting states\n for c in range(k, -1, -1):\n # Option 1: Start a new subsequence with num\n if dp[c][num] < 1:\n dp[c][num] = 1\n if max_dp[c] < dp[c][num]:\n max_dp[c] = dp[c][num]\n \n # Option 2: Extend existing subsequence ending with num (no change)\n if dp[c][num] > 0:\n extended_length = dp[c][num] + 1\n if dp[c][num] < extended_length:\n dp[c][num] = extended_length\n if max_dp[c] < dp[c][num]:\n max_dp[c] = dp[c][num]\n \n # Option 3: Change to num from any different last_num (increase c by 1)\n if c > 0:\n # max_dp[c-1] is the maximum length for c-1 changes\n potential_length = max_dp[c - 1] + 1\n if dp[c][num] < potential_length:\n dp[c][num] = potential_length\n if max_dp[c] < dp[c][num]:\n max_dp[c] = dp[c][num]\n \n # The answer is the maximum value in max_dp\n return max(max_dp) - 1\n","memory":"24800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if k >= len(nums) - 1:\n return len(nums)\n\n maxes = [[{}, 0] for _ in range(k + 1)]\n for num in nums:\n for i in range(k, -1, -1):\n answer = 1 + maxes[i][0].get(num, 0)\n if i > 0:\n answer = max(answer, 1 + maxes[i - 1][1])\n\n maxes[i][0][num] = answer\n maxes[i][1] = max(maxes[i][1], answer)\n\n return maxes[-1][1]","memory":"24900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 0:\n return 0\n\n dp = [[0] * (k + 1) for _ in range(n)]\n for i in range(n):\n dp[i][0] = 1\n\n res = 1\n for j in range(k + 1):\n max1 = 1\n num_map = {nums[0]: 0}\n\n for i in range(1, n):\n dp[i][j] = 1\n if i > 0 and j > 0:\n max1 = max(max1, dp[i - 1][j - 1] + 1)\n dp[i][j] = max(dp[i][j], max1)\n\n if nums[i] in num_map:\n dp[i][j] = max(dp[i][j], dp[num_map[nums[i]]][j] + 1)\n\n num_map[nums[i]] = i\n res = max(res, dp[i][j])\n\n return res","memory":"25000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n best = [0] * (k+1)\n last = {}\n dp = [[1] * (k+1) for _ in nums]\n \n for i, e in enumerate(nums):\n for x in range(k+1):\n if e in last:\n dp[i][x] = dp[last[e]][x] + 1\n if x < k:\n dp[i][x] = max(dp[i][x], best[x+1] + 1)\n \n best[x] = max(best[x], dp[i][x])\n last[e] = i\n \n #print(f\"best: {best}\")\n #print(dp)\n \n return max(best)\n ","memory":"25100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0]*(k+1) for i in range(n)]\n last=[0]*(k+1)\n d={}\n for i,val in enumerate(nums):\n for j in range(k,-1,-1):\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\n last[j]=max(last[j],dp[i][j])\n d[val]=i \n return last[k]","memory":"25200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0]*(k+1) for _ in range(n)]\n prevs = [-1]*n\n tmp_map = {}\n for i in range(n):\n if nums[i] not in tmp_map:\n tmp_map[nums[i]] = i\n else:\n prevs[i] = tmp_map[nums[i]]\n tmp_map[nums[i]] = i\n \n max_k_length = {}\n ans = 0\n \n for i in range(n):\n for j in range(k+1):\n if prevs[i] != -1:\n dp[i][j] = max(dp[i][j], dp[prevs[i]][j]+1)\n if j==0:\n dp[i][j] = max(dp[i][j], 1)\n if j-1 in max_k_length:\n dp[i][j] = max(dp[i][j], max_k_length[j-1]+1)\n ans = max(ans, dp[i][j])\n for j in range(min(i,k)+1):\n max_k_length[j] = max(max_k_length.get(j, 0), dp[i][j])\n \n return ans","memory":"25300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n k += 1\n dp = [[0] * n for _ in range(k)]\n\n for i in range(k):\n seen = defaultdict(int)\n best = 0\n for j in range(n - 1, -1, -1):\n dp[i][j] = max(seen[nums[j]], best) + 1\n seen[nums[j]] = dp[i][j]\n if i > 0:\n best = max(best, dp[i - 1][j])\n\n return max(dp[-1])","memory":"26000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0]*(n+1) for i in range(k+1)]\n max_dp = [[0]*(n+1) for i in range(k+1)]\n prev = defaultdict(int)\n for j in range(0, k+1):\n for i in range(1, n+1):\n p = prev[nums[i-1]]\n dp[j][i] = 1 + max(dp[j][p], max_dp[j-1][i-1] if j else 0)\n max_dp[j][i] = max(max_dp[j][i-1], dp[j][i])\n prev[nums[i-1]] = i\n return max_dp[k][-1]","memory":"26200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\n max_dp, prev = [0] * (k + 1), {}\n for i in range(len(nums) - 1, -1, -1):\n p = prev[nums[i]] if nums[i] in prev else 0\n for j in range(k, -1, -1):\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i\n return max(dp[i][k] for i in range(len(nums)))","memory":"26500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\n max_dp = [0] * (k + 1)\n prev = {}\n for i in range(len(nums) - 1, -1, -1):\n p = 0\n \n if nums[i] in prev:\n p = prev[nums[i]]\n \n for j in range(k, -1, -1):\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i\n return max(dp[i][k] for i in range(len(nums)))","memory":"26500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\n max_dp = [0] * (k + 1)\n prev = {}\n for i in range(len(nums) - 1, -1, -1):\n p = 0\n \n if nums[i] in prev:\n p = prev[nums[i]]\n \n for j in range(k, -1, -1):\n temp = 0\n if j != 0:\n temp = max_dp[j - 1]\n dp[i][j] = 1 + max(dp[p][j], temp)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i\n return max(dp[i][k] for i in range(len(nums)))","memory":"26600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\n max_dp = [0] * (k + 1)\n prev = {}\n for i in range(len(nums) - 1, -1, -1):\n p = 0\n \n if nums[i] in prev:\n p = prev[nums[i]]\n \n for j in range(k, -1, -1):\n prev_max = 0\n if j != 0:\n prev_max = max_dp[j - 1]\n dp[i][j] = 1 + max(dp[p][j], prev_max)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i\n return max(dp[i][k] for i in range(len(nums)))","memory":"26600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], max_k: int) -> int:\n n = len(nums)\n dp = [[0 for i in range(max_k+ 1)] for i in range(n)]\n max_dp,prev = [0]*(max_k + 1), dict()\n for i in range(len(nums) - 1, -1, -1):\n p = prev[nums[i]] if nums[i] in prev else 0 \n for j in range(max_k,-1,-1):\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i \n \n return max(dp[i][max_k] for i in range(n))\n \n \n \n \n \n \n \n \n \n \n \n #############\n \n dp = [[1 for i in range(n)] for i in range(max_k + 1)]\n\n last_seen = [0 for i in range(n)]\n prev = defaultdict(int)\n for idx,num in enumerate(nums):\n if num in prev:\n dp[0][idx] = dp[0][prev[num]] + 1\n last_seen[idx] = prev[num] \n prev[num] = idx \n \n # print(dp)\n\n max_dp = [1 for i in range(n)]\n for i in range(1,n):\n max_dp[i] = max(max_dp[i-1],dp[0][i])\n \n for k in range(1,max_k + 1):\n prev_max = copy.deepcopy(max_dp)\n for i in range(1,n):\n dp[k][i] = max(dp[k][last_seen[i]] + 1, prev_max[i - 1] + 1, max_dp[last_seen[i]] + 1)\n max_dp[i] = max(dp[k][i], max_dp[i])\n \n return max(max_dp)\n \n\n\n ","memory":"26700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], max_k: int) -> int:\n n = len(nums)\n ### Solution for Starts with approach (seq start at idx i) with k differences\n \n dp = [[0 for i in range(max_k+ 1)] for i in range(n)]\n max_dp,prev = [0]*(max_k + 1), dict()\n for i in range(len(nums) - 1, -1, -1):\n p = prev[nums[i]] if nums[i] in prev else 0 \n for j in range(max_k,-1,-1):\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\n max_dp[j] = max(max_dp[j], dp[i][j])\n prev[nums[i]] = i \n \n return max(dp[i][max_k] for i in range(n))\n \n \n \n \n \n \n \n \n \n \n \n ############# solution with seq ends with index i with k differences (Failed 20 test cases)\n \n dp = [[1 for i in range(n)] for i in range(max_k + 1)]\n\n last_seen = [0 for i in range(n)]\n prev = defaultdict(int)\n for idx,num in enumerate(nums):\n if num in prev:\n dp[0][idx] = dp[0][prev[num]] + 1\n last_seen[idx] = prev[num] \n prev[num] = idx \n \n # print(dp)\n\n max_dp = [1 for i in range(n)]\n for i in range(1,n):\n max_dp[i] = max(max_dp[i-1],dp[0][i])\n \n for k in range(1,max_k + 1):\n prev_max = copy.deepcopy(max_dp)\n for i in range(1,n):\n dp[k][i] = max(dp[k][last_seen[i]] + 1, prev_max[i - 1] + 1, max_dp[last_seen[i]] + 1)\n max_dp[i] = max(dp[k][i], max_dp[i])\n \n return max(max_dp)\n \n\n\n ","memory":"26700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n d = defaultdict(int)\n dp = [[0]*(k+1) for _ in range(n+1)]\n ps = [[0]*(k+1) for _ in range(n+1)]\n # for i in range(1,n+1):\n # dp[i][0] = 1\n # ps[i][0] = 1\n for i in range(1,n+1):\n dp[i][0] = dp[d[nums[i-1]]][0]+1\n ps[i][0] = max(ps[i-1][0],dp[i][0])\n for j in range(1,k+1):\n dp[i][j] = max(dp[d[nums[i-1]]][j],ps[i-1][j-1]) + 1\n ps[i][j] = max(ps[i-1][j],dp[i][j])\n d[nums[i-1]] = i\n res = 0\n for i in range(k+1):\n res = max(res,ps[n][i])\n return res\n ","memory":"27200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n res = max(Counter(nums).values())\n d = collections.defaultdict(dict)\n k_length = collections.defaultdict(int)\n d[nums[0]][k] = 1\n k_length[k] = 1\n \n for i in range(1, len(nums)):\n tmp = collections.defaultdict(int)\n if nums[i] in d:\n for cnt in d[nums[i]]:\n d[nums[i]][cnt] += 1\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\n res = max(res, d[nums[i]][cnt])\n else:\n d[nums[i]][k] = 1\n \n for cnt in k_length:\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\n if cnt:\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\n res = max(res, d[nums[i]][cnt-1])\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1])\n k_length = tmp\n \n return res","memory":"27700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\n maxi = [[0 for _ in range(k + 1)] for _ in range(n)]\n last_seen = {}\n for i in range(n):\n for j in range(k + 1):\n if i == 0:\n dp[i][j] = 1\n maxi[i][j] = dp[i][j]\n elif j == 0:\n dp[i][j] = 1\n if nums[i] in last_seen:\n l_i = last_seen[nums[i]]\n dp[i][j] = dp[l_i][j] + 1\n else:\n dp[i][j] = maxi[i - 1][j - 1] + 1\n if nums[i] in last_seen:\n l_i = last_seen[nums[i]]\n dp[i][j] = max(dp[i][j], dp[l_i][j] + 1)\n maxi[i][j] = max(dp[i][j], maxi[i - 1][j])\n last_seen[nums[i]] = i\n \n return maxi[n -1][k]\n\n","memory":"27800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n=len(nums)\n dp=[[0 for i in range(k+1)] for j in range(n)]\n maxi=[[0 for i in range(k+1)] for j in range(n)]\n mp={}\n for i in range(n):\n for j in range(k+1):\n if(i==0):\n dp[i][j]=1\n maxi[i][j]=max(maxi[i][j],dp[i][j])\n elif(j==0):\n dp[i][j]=1\n t=mp.get(nums[i],-1)\n if(t!=-1):\n dp[i][j]=max(dp[i][j],dp[t][j]+1)\n else:\n dp[i][j]=maxi[i-1][j-1]+1\n t=mp.get(nums[i],-1)\n if(t!=-1):\n dp[i][j]=max(dp[i][j],dp[t][j]+1)\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\n mp[nums[i]]=i\n return max(dp[n-1][k],maxi[n-1][k])","memory":"27900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n cnt1 = Counter(nums)\n res = max(cnt1.values())\n d = collections.defaultdict(dict)\n k_length = collections.defaultdict(int)\n d[nums[0]][k] = 1\n k_length[k] = 1\n \n for i in range(1, len(nums)):\n tmp = collections.defaultdict(int)\n if nums[i] in d:\n for cnt in d[nums[i]]:\n d[nums[i]][cnt] += 1\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\n res = max(res, d[nums[i]][cnt])\n else:\n d[nums[i]][k] = 1\n \n for cnt in k_length:\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\n if cnt:\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\n res = max(res, d[nums[i]][cnt-1])\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1],tmp[cnt-1])\n \n # print(\"k_length\",k_length) \n k_length = tmp\n # print(d, nums[i], res)\n return res","memory":"28000"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","memory":"28900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n\n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","memory":"29200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length ","memory":"29200"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","memory":"29300"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","memory":"29400"},{"code":"from collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n size = len(nums)\n lengths = [[1] * (k + 1) for _ in range(size)]\n max_length = 1\n max_lengths = [-1] * (k + 1)\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\n \n for i in range(size):\n for j in range(k + 1):\n for l in range(j):\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\n \n if nums[i] in num_to_lengths_map[j]:\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\n \n max_length = max(max_length, lengths[i][j])\n \n for j in range(k + 1):\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\n \n return max_length","memory":"29500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = defaultdict(int)\\n prev_max = [0] * n\\n cur_max = [0] * n\\n\\n for _ in range(k + 1):\\n for j in range(n - 1, -1, -1):\\n dp[nums[j]] = max(\\n dp[nums[j]] + 1,\\n prev_max[j + 1] + 1 if j != n - 1 else 0\\n )\\n\\n cur_max[j] = max(\\n cur_max[j + 1] if j != n - 1 else 0,\\n dp[nums[j]]\\n )\\n \\n dp.clear()\\n prev_max = cur_max[:]\\n\\n return max(cur_max)\",\n \"memory\": \"17300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [0]*len(nums)\\n for _ in range(k+1):\\n new_dp, dic, max_len = [], {}, 0\\n for i, num in enumerate(nums):\\n new_dp.append(max(new_dp[dic[num]], max_len)+1 if num in dic else max_len+1)\\n dic[num] = i\\n max_len = max(dp[i], max_len)\\n dp = new_dp\\n return max(dp)\",\n \"memory\": \"17400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n longest = [0] * (k)\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n # prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if longest[j - 1] != 0:\\n dp[j][n] = max(dp[j][n], longest[j - 1] + 1)\\n\\n for j in range(k):\\n longest[j] = max(longest[j], dp[j][n])\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n\\n \",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_index = -1\\n transformed_numbers = {}\\n\\n for j in range(len(nums)):\\n n = nums[j]\\n if n in transformed_numbers:\\n nums[j] = transformed_numbers[n]\\n else:\\n last_index = last_index + 1\\n nums[j] = last_index\\n transformed_numbers[n] = last_index\\n\\n if last_index == 0:\\n return len(nums)\\n\\n longest = [0] * (k)\\n dp = [[0] * (last_index + 1) for _ in range(k + 1)]\\n\\n for n in nums:\\n\\n dp[0][n] += 1\\n\\n for j in range(1, k + 1):\\n if dp[j][n] != 0:\\n dp[j][n] += 1\\n # prev = max(dp[j - 1][:n] + dp[j - 1][n + 1:])\\n if longest[j - 1] != 0:\\n dp[j][n] = max(dp[j][n], longest[j - 1] + 1)\\n\\n for j in range(k):\\n longest[j] = max(longest[j], dp[j][n])\\n\\n return max([max(dp_elem) for dp_elem in dp])\\n\\n \",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # make it more efficient by skipping the contiguous portions\\n # having the same character (so instead of adding the character once,\\n # add it the length of block times)\\n res = [0 for _ in range(k + 1)]\\n dp = {nums[i]: [0 for _ in range(k + 1)] for i in range(len(nums))}\\n\\n # try for each number to find the maximum length trying\\n # all the possible remaining changes\\n for num in nums:\\n # this traversal is an optimization, to\\n # reduce the number of dimensions needed for\\n # dp, so you don't have to store the index\\n # of the last used element\\n for remainingK in reversed(range(k + 1)):\\n dp[num][remainingK] = max(1 + dp[num][remainingK], (1 + res[remainingK - 1]) if remainingK - 1 >= 0 else 0)\\n res[remainingK] = max(res[remainingK], dp[num][remainingK])\\n\\n return max(res)\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # make it more efficient by skipping the contiguous portions\\n # having the same character (so instead of adding the character once,\\n # add it the length of block times)\\n res = [0 for _ in range(k + 1)]\\n dp = {nums[i]: [0 for _ in range(k + 1)] for i in range(len(nums))}\\n\\n # try for each number to find the maximum length trying\\n # all the possible remaining changes\\n for num in nums:\\n # this traversal is an optimization, to\\n # reduce the number of dimensions needed for\\n # dp, so you don't have to store the index\\n # of the last used element\\n for remainingK in reversed(range(k + 1)):\\n dp[num][remainingK] = max(1 + dp[num][remainingK], (1 + res[remainingK - 1]) if remainingK - 1 >= 0 else 0)\\n res[remainingK] = max(res[remainingK], dp[num][remainingK])\\n\\n return res[k]\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n if k == 0:\\n cnt = Counter(nums)\\n return cnt.most_common(1)[0][1]\\n\\n dp = [0 for _ in range(k + 1)]\\n\\n hmap = {}\\n for num in nums:\\n if num not in hmap:\\n hmap[num] = [0] * (k + 1)\\n li = hmap[num]\\n for i in range(k + 1):\\n\\n li[i] = 1 + max(li[i], dp[i - 1]) if i > 0 else 1 + li[i]\\n\\n for i in range(k + 1):\\n if li[i] > dp[i]:\\n dp[i] = li[i]\\n return max(dp)\",\n \"memory\": \"19600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n c = Counter(nums)\\n if k == 0:\\n return max(c.values())\\n if max(c.values()) == 1:\\n return min(k + 1, n)\\n \\n runs = {}\\n best = [0] * (k + 1)\\n for x in nums:\\n if x not in runs:\\n runs[x] = [1] * (k + 1)\\n else:\\n runs[x] = [z + 1 for z in runs[x]]\\n runs[x][1:] = [max(lo + 1, xrun) for lo, xrun in zip(best, runs[x][1:])]\\n best[1:] = [max(lo + 1, b) for lo, b in pairwise(best)]\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best)\",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef maximumLength(self, nums: List[int], k: int) -> int:\\n\\t\\td = defaultdict(list)\\n\\t\\tfor i, x in enumerate(nums): d[x].append(i)\\n\\t\\tm = {x: i for i, x in enumerate(sorted(d.keys()))}\\n\\t\\ta = [m[x] for x in nums]\\n\\t\\tdp, res = [[0] * len(d) for _ in range(k + 1)], [0] * (k + 1)\\n\\t\\tfor x in a:\\n\\t\\t\\tfor i in range(k, -1, -1):\\n\\t\\t\\t\\tdp[i][x] = max(dp[i][x] + 1, res[i - 1] + 1 if i > 0 else 0)\\n\\t\\t\\t\\tres[i] = max(res[i], dp[i][x])\\n\\t\\treturn res[k]\",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length_by_num = {-1: [0]*(k+1)}\\n total_max_length = [0]*(k+1)\\n for n in nums:\\n n_max_length = [1] + [1+a for a in total_max_length[:-1]]\\n if n in max_length_by_num:\\n n_max_length = [a+1 if a >= b else b for a,b in zip(max_length_by_num[n], n_max_length)]\\n max_length_by_num[n] = n_max_length\\n total_max_length = [a if b < a else b for a,b in zip(n_max_length, total_max_length)]\\n\\n return max(total_max_length)\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n runs = {}\\n best = [0] * (k + 1)\\n for x in nums:\\n if x not in runs:\\n runs[x] = [1] * (k + 1)\\n else:\\n runs[x] = [z + 1 for z in runs[x]]\\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best)\\n \",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n runs = {} # Dictionary to store subsequences for each number\\n best = [0] * (k + 1) # Best subsequences for differences from 0 to k\\n\\n for x in nums: # Iterate through each number in nums\\n if x not in runs:\\n runs[x] = [1] * (k + 1) # Initialize subsequences if x is new\\n else:\\n runs[x] = [z + 1 for z in runs[x]] # Increment subsequences for x\\n \\n # Update runs[x] for differences 1 to k\\n runs[x][1:] = [max(otherrun + 1, xrun) for otherrun, xrun in zip(best, runs[x][1:])]\\n\\n # Update best subsequences\\n best = [max(b, xrun) for b, xrun in zip(best, runs[x])]\\n \\n return max(best) # Return the length of the longest subsequence\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n\\n seq = {}\\n best = [0] * (k+1)\\n for n in nums:\\n if n not in seq:\\n seq[n] = [1] * (k+1)\\n else:\\n seq[n] = [l+1 for l in seq[n]]\\n \\n seq[n][1:] = [max(s, b+1) for b, s in zip(best, seq[n][1:])]\\n best = [max(b, s) for b, s in zip(best, seq[n])]\\n return best[-1]\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (n + 1) for _ in range(k + 2)]\\n for i in range(1, k + 2):\\n memo = {}\\n for j in range(1, n + 1):\\n adj_same = memo.get(nums[j - 1], 0)\\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same] + 1)\\n memo[nums[j - 1]] = j\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\\n return dp[k + 1][n]\\n\",\n \"memory\": \"22000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (n + 1) for _ in range(k + 2)]\\n for i in range(1, k + 2):\\n memo = {}\\n for j in range(1, n + 1):\\n adj_same = memo.get(nums[j - 1], 0)\\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same] + 1)\\n memo[nums[j - 1]] = j\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\\n return dp[k + 1][n]\\n\",\n \"memory\": \"22100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * (n + 1) for _ in range(k + 2)]\\n memo = {}\\n adj_same = []\\n for i in range(n):\\n if nums[i] not in memo:\\n adj_same.append(0)\\n else:\\n adj_same.append(memo[nums[i]])\\n memo[nums[i]] = i + 1\\n for i in range(1, k + 2):\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1, dp[i][adj_same[j - 1]] + 1)\\n for j in range(1, n + 1):\\n dp[i][j] = max(dp[i][j], dp[i][j - 1])\\n return dp[k + 1][n]\\n\",\n \"memory\": \"22200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # Store elements and their counts in a list of lists\\n a = [[nums[0], 1]]\\n for x in nums[1:]:\\n if a[-1][0] == x:\\n a[-1][1] += 1\\n else:\\n a.append([x, 1])\\n\\n n = len(a)\\n dp = [[0] * (k + 1) for _ in range(n)]\\n bst = [0] * (k + 1)\\n lastOcc = {}\\n\\n for i in range(n):\\n current_val = a[i][0]\\n current_count = a[i][1]\\n t = lastOcc.get(current_val)\\n\\n for j in range(min(i + 1, k + 1)):\\n dp[i][j] = current_count\\n if j > 0:\\n dp[i][j] += bst[j - 1]\\n if t is not None:\\n dp[i][j] = max(dp[i][j], dp[t][j] + current_count)\\n\\n for j in range(k + 1):\\n bst[j] = max(bst[j], dp[i][j])\\n\\n lastOcc[current_val] = i\\n\\n return max(bst)\\n\",\n \"memory\": \"23500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n a = [[nums[0], 0]]\\n for x in nums:\\n if a[-1][0] == x:\\n a[-1][1] += 1\\n else:\\n a.append([x, 1])\\n\\n n = len(a)\\n ans = 0\\n # print(a)\\n # print()\\n \\n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\\n bst = [0 for _ in range(k + 1)]\\n lastOcc = {}\\n\\n for i in range(n):\\n t = lastOcc.get(a[i][0], None)\\n\\n for j in range(min(i + 1, k + 1)):\\n s = [ a[i][1] ]\\n # if i > 0:\\n # s.append(dp[i - 1][j])\\n if j > 0 and i > 0:\\n s[0] += bst[j - 1]\\n if t is not None:\\n s.append( dp[t][j] + a[i][1] ) \\n \\n dp[i][j] = max(s)\\n \\n for j in range(k + 1):\\n bst[j] = max(bst[j], dp[i][j])\\n\\n lastOcc[a[i][0]] = i\\n \\n # print(*dp, sep='\\\\n')\\n\\n return max(bst)\",\n \"memory\": \"23600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0]*(k+1) for i in range(n)]\\n last=[0]*(k+1)\\n d={}\\n for i,val in enumerate(nums):\\n for j in range(k,-1,-1):\\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\\n last[j]=max(last[j],dp[i][j])\\n d[val]=i \\n return last[k]\",\n \"memory\": \"24100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0]*(k+1) for i in range(n)]\\n last=[0]*(k+1)\\n d={}\\n for i,val in enumerate(nums):\\n for j in range(k,-1,-1):\\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\\n last[j]=max(last[j],dp[i][j])\\n d[val]=i \\n return last[k]\",\n \"memory\": \"24200\"\n },\n {\n \"code\": \"from functools import cache\\nfrom collections import defaultdict\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * len(nums) for i in range(k + 1)]\\n count = defaultdict(int)\\n for j in range(len(nums)):\\n count[nums[j]] += 1\\n dp[0][j] = count[nums[j]]\\n for i in range(1, k + 1):\\n dp[i][0] = 1\\n for i in range(1, k + 1):\\n count_for_cur_k = defaultdict(int)\\n count_for_cur_k[nums[0]] = 1\\n max_for_prev_k = dp[i - 1][0]\\n \\n for j in range(1, len(nums)):\\n \\n dp[i][j] = max(max_for_prev_k + 1, count_for_cur_k[nums[j]] + 1)\\n max_for_prev_k = max(max_for_prev_k, dp[i - 1][j])\\n count_for_cur_k[nums[j]] = max(count_for_cur_k[nums[j]], dp[i][j])\\n # for row in dp:\\n # print(row)\\n return max([max(row) for row in dp])\\n\\n\\n\\n\\n\\n\\n \",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [defaultdict(int) for _ in range(k+1)]\\n res = [0] * (k+1)\\n\\n for a in nums:\\n for i in range(k, -1, -1):\\n dp[i][a] = max(dp[i][a] + 1, res[i-1] + 1 if i else 0)\\n res[i] = max(res[i], dp[i][a])\\n \\n return res[k]\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [defaultdict(int) for _ in range(k + 1)]\\n res = [0] * (k + 1)\\n for num in nums:\\n for i in range(k, -1, -1):\\n dp[i][num] = max(dp[i][num] + 1, res[i - 1] + 1 if i else 0)\\n res[i] = max(res[i], dp[i][num])\\n return res[k]\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [defaultdict(int) for _ in range(k+1)]\\n mx = [0 for _ in range(k+1)]\\n ans = 0\\n for num in nums:\\n for j in range(k, -1, -1):\\n dp[j][num] = max(dp[j][num], mx[j-1] if j else 0)+1\\n mx[j] = max(mx[j],dp[j][num])\\n return mx[-1]\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n dp = [defaultdict(int) for i in range(k + 1)]\\n res = [0] * (k + 1)\\n for a in A:\\n for i in range(k, -1, -1):\\n dp[i][a] = max(dp[i][a] + 1, res[i - 1] + 1 if i else 0)\\n res[i] = max(res[i], dp[i][a])\\n return res[k]\",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # Initialize dp[c][num] = maximum length ending with num using c changes\\n dp = [defaultdict(int) for _ in range(k + 1)]\\n # Initialize max_dp[c] = maximum length over all nums with c changes\\n max_dp = [0] * (k + 1)\\n \\n for num in nums:\\n # We need to iterate c from high to low to avoid overwriting states\\n for c in range(k, -1, -1):\\n # Option 1: Start a new subsequence with num\\n if dp[c][num] < 1:\\n dp[c][num] = 1\\n if max_dp[c] < dp[c][num]:\\n max_dp[c] = dp[c][num]\\n \\n # Option 2: Extend existing subsequence ending with num (no change)\\n if dp[c][num] > 0:\\n extended_length = dp[c][num] + 1\\n if dp[c][num] < extended_length:\\n dp[c][num] = extended_length\\n if max_dp[c] < dp[c][num]:\\n max_dp[c] = dp[c][num]\\n \\n # Option 3: Change to num from any different last_num (increase c by 1)\\n if c > 0:\\n # max_dp[c-1] is the maximum length for c-1 changes\\n potential_length = max_dp[c - 1] + 1\\n if dp[c][num] < potential_length:\\n dp[c][num] = potential_length\\n if max_dp[c] < dp[c][num]:\\n max_dp[c] = dp[c][num]\\n \\n # The answer is the maximum value in max_dp\\n return max(max_dp) - 1\\n\",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if k >= len(nums) - 1:\\n return len(nums)\\n\\n maxes = [[{}, 0] for _ in range(k + 1)]\\n for num in nums:\\n for i in range(k, -1, -1):\\n answer = 1 + maxes[i][0].get(num, 0)\\n if i > 0:\\n answer = max(answer, 1 + maxes[i - 1][1])\\n\\n maxes[i][0][num] = answer\\n maxes[i][1] = max(maxes[i][1], answer)\\n\\n return maxes[-1][1]\",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 0:\\n return 0\\n\\n dp = [[0] * (k + 1) for _ in range(n)]\\n for i in range(n):\\n dp[i][0] = 1\\n\\n res = 1\\n for j in range(k + 1):\\n max1 = 1\\n num_map = {nums[0]: 0}\\n\\n for i in range(1, n):\\n dp[i][j] = 1\\n if i > 0 and j > 0:\\n max1 = max(max1, dp[i - 1][j - 1] + 1)\\n dp[i][j] = max(dp[i][j], max1)\\n\\n if nums[i] in num_map:\\n dp[i][j] = max(dp[i][j], dp[num_map[nums[i]]][j] + 1)\\n\\n num_map[nums[i]] = i\\n res = max(res, dp[i][j])\\n\\n return res\",\n \"memory\": \"25000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n best = [0] * (k+1)\\n last = {}\\n dp = [[1] * (k+1) for _ in nums]\\n \\n for i, e in enumerate(nums):\\n for x in range(k+1):\\n if e in last:\\n dp[i][x] = dp[last[e]][x] + 1\\n if x < k:\\n dp[i][x] = max(dp[i][x], best[x+1] + 1)\\n \\n best[x] = max(best[x], dp[i][x])\\n last[e] = i\\n \\n #print(f\\\"best: {best}\\\")\\n #print(dp)\\n \\n return max(best)\\n \",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0]*(k+1) for i in range(n)]\\n last=[0]*(k+1)\\n d={}\\n for i,val in enumerate(nums):\\n for j in range(k,-1,-1):\\n dp[i][j]=max(dp[i][j],last[j-1]+1 if j else 1,dp[d[val]][j]+1 if val in d else 1)\\n last[j]=max(last[j],dp[i][j])\\n d[val]=i \\n return last[k]\",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0]*(k+1) for _ in range(n)]\\n prevs = [-1]*n\\n tmp_map = {}\\n for i in range(n):\\n if nums[i] not in tmp_map:\\n tmp_map[nums[i]] = i\\n else:\\n prevs[i] = tmp_map[nums[i]]\\n tmp_map[nums[i]] = i\\n \\n max_k_length = {}\\n ans = 0\\n \\n for i in range(n):\\n for j in range(k+1):\\n if prevs[i] != -1:\\n dp[i][j] = max(dp[i][j], dp[prevs[i]][j]+1)\\n if j==0:\\n dp[i][j] = max(dp[i][j], 1)\\n if j-1 in max_k_length:\\n dp[i][j] = max(dp[i][j], max_k_length[j-1]+1)\\n ans = max(ans, dp[i][j])\\n for j in range(min(i,k)+1):\\n max_k_length[j] = max(max_k_length.get(j, 0), dp[i][j])\\n \\n return ans\",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n k += 1\\n dp = [[0] * n for _ in range(k)]\\n\\n for i in range(k):\\n seen = defaultdict(int)\\n best = 0\\n for j in range(n - 1, -1, -1):\\n dp[i][j] = max(seen[nums[j]], best) + 1\\n seen[nums[j]] = dp[i][j]\\n if i > 0:\\n best = max(best, dp[i - 1][j])\\n\\n return max(dp[-1])\",\n \"memory\": \"26000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0]*(n+1) for i in range(k+1)]\\n max_dp = [[0]*(n+1) for i in range(k+1)]\\n prev = defaultdict(int)\\n for j in range(0, k+1):\\n for i in range(1, n+1):\\n p = prev[nums[i-1]]\\n dp[j][i] = 1 + max(dp[j][p], max_dp[j-1][i-1] if j else 0)\\n max_dp[j][i] = max(max_dp[j][i-1], dp[j][i])\\n prev[nums[i-1]] = i\\n return max_dp[k][-1]\",\n \"memory\": \"26200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\\n max_dp, prev = [0] * (k + 1), {}\\n for i in range(len(nums) - 1, -1, -1):\\n p = prev[nums[i]] if nums[i] in prev else 0\\n for j in range(k, -1, -1):\\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i\\n return max(dp[i][k] for i in range(len(nums)))\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\\n max_dp = [0] * (k + 1)\\n prev = {}\\n for i in range(len(nums) - 1, -1, -1):\\n p = 0\\n \\n if nums[i] in prev:\\n p = prev[nums[i]]\\n \\n for j in range(k, -1, -1):\\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i\\n return max(dp[i][k] for i in range(len(nums)))\",\n \"memory\": \"26500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\\n max_dp = [0] * (k + 1)\\n prev = {}\\n for i in range(len(nums) - 1, -1, -1):\\n p = 0\\n \\n if nums[i] in prev:\\n p = prev[nums[i]]\\n \\n for j in range(k, -1, -1):\\n temp = 0\\n if j != 0:\\n temp = max_dp[j - 1]\\n dp[i][j] = 1 + max(dp[p][j], temp)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i\\n return max(dp[i][k] for i in range(len(nums)))\",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k + 1)] for i in range(len(nums))]\\n max_dp = [0] * (k + 1)\\n prev = {}\\n for i in range(len(nums) - 1, -1, -1):\\n p = 0\\n \\n if nums[i] in prev:\\n p = prev[nums[i]]\\n \\n for j in range(k, -1, -1):\\n prev_max = 0\\n if j != 0:\\n prev_max = max_dp[j - 1]\\n dp[i][j] = 1 + max(dp[p][j], prev_max)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i\\n return max(dp[i][k] for i in range(len(nums)))\",\n \"memory\": \"26600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], max_k: int) -> int:\\n n = len(nums)\\n dp = [[0 for i in range(max_k+ 1)] for i in range(n)]\\n max_dp,prev = [0]*(max_k + 1), dict()\\n for i in range(len(nums) - 1, -1, -1):\\n p = prev[nums[i]] if nums[i] in prev else 0 \\n for j in range(max_k,-1,-1):\\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i \\n \\n return max(dp[i][max_k] for i in range(n))\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n #############\\n \\n dp = [[1 for i in range(n)] for i in range(max_k + 1)]\\n\\n last_seen = [0 for i in range(n)]\\n prev = defaultdict(int)\\n for idx,num in enumerate(nums):\\n if num in prev:\\n dp[0][idx] = dp[0][prev[num]] + 1\\n last_seen[idx] = prev[num] \\n prev[num] = idx \\n \\n # print(dp)\\n\\n max_dp = [1 for i in range(n)]\\n for i in range(1,n):\\n max_dp[i] = max(max_dp[i-1],dp[0][i])\\n \\n for k in range(1,max_k + 1):\\n prev_max = copy.deepcopy(max_dp)\\n for i in range(1,n):\\n dp[k][i] = max(dp[k][last_seen[i]] + 1, prev_max[i - 1] + 1, max_dp[last_seen[i]] + 1)\\n max_dp[i] = max(dp[k][i], max_dp[i])\\n \\n return max(max_dp)\\n \\n\\n\\n \",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], max_k: int) -> int:\\n n = len(nums)\\n ### Solution for Starts with approach (seq start at idx i) with k differences\\n \\n dp = [[0 for i in range(max_k+ 1)] for i in range(n)]\\n max_dp,prev = [0]*(max_k + 1), dict()\\n for i in range(len(nums) - 1, -1, -1):\\n p = prev[nums[i]] if nums[i] in prev else 0 \\n for j in range(max_k,-1,-1):\\n dp[i][j] = 1 + max(dp[p][j], max_dp[j - 1] if j else 0)\\n max_dp[j] = max(max_dp[j], dp[i][j])\\n prev[nums[i]] = i \\n \\n return max(dp[i][max_k] for i in range(n))\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n ############# solution with seq ends with index i with k differences (Failed 20 test cases)\\n \\n dp = [[1 for i in range(n)] for i in range(max_k + 1)]\\n\\n last_seen = [0 for i in range(n)]\\n prev = defaultdict(int)\\n for idx,num in enumerate(nums):\\n if num in prev:\\n dp[0][idx] = dp[0][prev[num]] + 1\\n last_seen[idx] = prev[num] \\n prev[num] = idx \\n \\n # print(dp)\\n\\n max_dp = [1 for i in range(n)]\\n for i in range(1,n):\\n max_dp[i] = max(max_dp[i-1],dp[0][i])\\n \\n for k in range(1,max_k + 1):\\n prev_max = copy.deepcopy(max_dp)\\n for i in range(1,n):\\n dp[k][i] = max(dp[k][last_seen[i]] + 1, prev_max[i - 1] + 1, max_dp[last_seen[i]] + 1)\\n max_dp[i] = max(dp[k][i], max_dp[i])\\n \\n return max(max_dp)\\n \\n\\n\\n \",\n \"memory\": \"26700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n d = defaultdict(int)\\n dp = [[0]*(k+1) for _ in range(n+1)]\\n ps = [[0]*(k+1) for _ in range(n+1)]\\n # for i in range(1,n+1):\\n # dp[i][0] = 1\\n # ps[i][0] = 1\\n for i in range(1,n+1):\\n dp[i][0] = dp[d[nums[i-1]]][0]+1\\n ps[i][0] = max(ps[i-1][0],dp[i][0])\\n for j in range(1,k+1):\\n dp[i][j] = max(dp[d[nums[i-1]]][j],ps[i-1][j-1]) + 1\\n ps[i][j] = max(ps[i-1][j],dp[i][j])\\n d[nums[i-1]] = i\\n res = 0\\n for i in range(k+1):\\n res = max(res,ps[n][i])\\n return res\\n \",\n \"memory\": \"27200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n res = max(Counter(nums).values())\\n d = collections.defaultdict(dict)\\n k_length = collections.defaultdict(int)\\n d[nums[0]][k] = 1\\n k_length[k] = 1\\n \\n for i in range(1, len(nums)):\\n tmp = collections.defaultdict(int)\\n if nums[i] in d:\\n for cnt in d[nums[i]]:\\n d[nums[i]][cnt] += 1\\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\\n res = max(res, d[nums[i]][cnt])\\n else:\\n d[nums[i]][k] = 1\\n \\n for cnt in k_length:\\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\\n if cnt:\\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\\n res = max(res, d[nums[i]][cnt-1])\\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1])\\n k_length = tmp\\n \\n return res\",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0 for _ in range(k + 1)] for _ in range(n)]\\n maxi = [[0 for _ in range(k + 1)] for _ in range(n)]\\n last_seen = {}\\n for i in range(n):\\n for j in range(k + 1):\\n if i == 0:\\n dp[i][j] = 1\\n maxi[i][j] = dp[i][j]\\n elif j == 0:\\n dp[i][j] = 1\\n if nums[i] in last_seen:\\n l_i = last_seen[nums[i]]\\n dp[i][j] = dp[l_i][j] + 1\\n else:\\n dp[i][j] = maxi[i - 1][j - 1] + 1\\n if nums[i] in last_seen:\\n l_i = last_seen[nums[i]]\\n dp[i][j] = max(dp[i][j], dp[l_i][j] + 1)\\n maxi[i][j] = max(dp[i][j], maxi[i - 1][j])\\n last_seen[nums[i]] = i\\n \\n return maxi[n -1][k]\\n\\n\",\n \"memory\": \"27800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n=len(nums)\\n dp=[[0 for i in range(k+1)] for j in range(n)]\\n maxi=[[0 for i in range(k+1)] for j in range(n)]\\n mp={}\\n for i in range(n):\\n for j in range(k+1):\\n if(i==0):\\n dp[i][j]=1\\n maxi[i][j]=max(maxi[i][j],dp[i][j])\\n elif(j==0):\\n dp[i][j]=1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):\\n dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n else:\\n dp[i][j]=maxi[i-1][j-1]+1\\n t=mp.get(nums[i],-1)\\n if(t!=-1):\\n dp[i][j]=max(dp[i][j],dp[t][j]+1)\\n maxi[i][j]=max(dp[i][j],maxi[i-1][j])\\n mp[nums[i]]=i\\n return max(dp[n-1][k],maxi[n-1][k])\",\n \"memory\": \"27900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n cnt1 = Counter(nums)\\n res = max(cnt1.values())\\n d = collections.defaultdict(dict)\\n k_length = collections.defaultdict(int)\\n d[nums[0]][k] = 1\\n k_length[k] = 1\\n \\n for i in range(1, len(nums)):\\n tmp = collections.defaultdict(int)\\n if nums[i] in d:\\n for cnt in d[nums[i]]:\\n d[nums[i]][cnt] += 1\\n tmp[cnt] = max(k_length[cnt], d[nums[i]][cnt])\\n res = max(res, d[nums[i]][cnt])\\n else:\\n d[nums[i]][k] = 1\\n \\n for cnt in k_length:\\n tmp[cnt] = max(k_length[cnt], tmp[cnt])\\n if cnt:\\n d[nums[i]][cnt-1] = max(d[nums[i]].get(cnt-1, 0), k_length[cnt]+1)\\n res = max(res, d[nums[i]][cnt-1])\\n tmp[cnt-1] = max(k_length.get(cnt-1, 0), d[nums[i]][cnt-1],tmp[cnt-1])\\n \\n # print(\\\"k_length\\\",k_length) \\n k_length = tmp\\n # print(d, nums[i], res)\\n return res\",\n \"memory\": \"28000\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"memory\": \"28900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n\\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length \",\n \"memory\": \"29200\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"memory\": \"29300\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"memory\": \"29400\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n size = len(nums)\\n lengths = [[1] * (k + 1) for _ in range(size)]\\n max_length = 1\\n max_lengths = [-1] * (k + 1)\\n num_to_lengths_map = [defaultdict(int) for _ in range(k + 1)]\\n \\n for i in range(size):\\n for j in range(k + 1):\\n for l in range(j):\\n lengths[i][j] = max(lengths[i][j], 1 + max_lengths[l])\\n \\n if nums[i] in num_to_lengths_map[j]:\\n lengths[i][j] = max(lengths[i][j], 1 + num_to_lengths_map[j][nums[i]])\\n \\n max_length = max(max_length, lengths[i][j])\\n \\n for j in range(k + 1):\\n max_lengths[j] = max(max_lengths[j], lengths[i][j])\\n num_to_lengths_map[j][nums[i]] = max(num_to_lengths_map[j][nums[i]], lengths[i][j])\\n \\n return max_length\",\n \"memory\": \"29500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":50,"string":"50"}}},{"rowIdx":2462,"cells":{"question_id":{"kind":"number","value":2710,"string":"2,710"},"name":{"kind":"string","value":"minimum-operations-to-reduce-an-integer-to-0"},"content":{"kind":"string","value":"<p>You are given a positive integer <code>n</code>, you can do the following operation <strong>any</strong> number of times:</p>\n\n<ul>\n\t<li>Add or subtract a <strong>power</strong> of <code>2</code> from <code>n</code>.</li>\n</ul>\n\n<p>Return <em>the <strong>minimum</strong> number of operations to make </em><code>n</code><em> equal to </em><code>0</code>.</p>\n\n<p>A number <code>x</code> is power of <code>2</code> if <code>x == 2<sup>i</sup></code> where <code>i >= 0</code><em>.</em></p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 39\n<strong>Output:</strong> 3\n<strong>Explanation:</strong> We can do the following operations:\n- Add 2<sup>0</sup> = 1 to n, so now n = 40.\n- Subtract 2<sup>3</sup> = 8 from n, so now n = 32.\n- Subtract 2<sup>5</sup> = 32 from n, so now n = 0.\nIt can be shown that 3 is the minimum number of operations we need to make n equal to 0.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> n = 54\n<strong>Output:</strong> 3\n<strong>Explanation:</strong> We can do the following operations:\n- Add 2<sup>1</sup> = 2 to n, so now n = 56.\n- Add 2<sup>3</sup> = 8 to n, so now n = 64.\n- Subtract 2<sup>6</sup> = 64 from n, so now n = 0.\nSo the minimum number of operations is 3.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n <= 10<sup>5</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":55.75953197498487,"string":"55.759532"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["dynamic-programming","greedy","bit-manipulation"],"string":"[\n \"dynamic-programming\",\n \"greedy\",\n \"bit-manipulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"14\", 0.1473], [\"19\", 0.1473], [\"20\", 0.2946], [\"21\", 0.1473], [\"22\", 0.1473], [\"23\", 0.7364], [\"24\", 0.7364], [\"25\", 0.7364], [\"26\", 1.4728], [\"27\", 2.7982], [\"28\", 3.0928], [\"29\", 3.2401], [\"30\", 4.8601], [\"31\", 3.0928], [\"32\", 5.5965], [\"33\", 7.2165], [\"34\", 6.6274], [\"35\", 6.7747], [\"36\", 8.2474], [\"37\", 7.0692], [\"38\", 7.2165], [\"39\", 5.0074], [\"40\", 4.8601], [\"41\", 3.9764], [\"42\", 3.5346], [\"43\", 2.3564], [\"44\", 2.2091], [\"45\", 1.1782], [\"46\", 0.5891], [\"48\", 0.1473], [\"49\", 0.1473], [\"50\", 0.1473], [\"84\", 0.2946], [\"103\", 0.1473]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16100\", 0.1473], [\"16200\", 0.7364], [\"16300\", 3.2401], [\"16400\", 24.3004], [\"16500\", 37.2607], [\"16600\", 25.3314], [\"16700\", 3.9764]]}"},"rt_list":{"kind":"list like","value":[{"code":"import math\n\nclass Solution:\n def minOperations(self, n: int) -> int:\n try:\n ops = 0\n while True:\n closest_power_2 = 2**round(math.log2(n))\n print(closest_power_2, closest_power_2-n, n, ops)\n power2 = round(math.log2(abs(closest_power_2-n)))\n n = n-2**power2 if closest_power_2 <= n else n+2**power2\n ops+=1\n except ValueError:\n return ops+1\n ","runtime":"14"},{"code":"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\n# but, further, to reach 2**high, should be from 2**hihg; \n# to reach 2**low, should be from n - 2**low \n\nclass Solution:\n def minOperations(self, n: int) -> int:\n if n == 0:\n return 0\n \n # if n is power of 2\n if (n & (n - 1) == 0) and n != 0:\n return 1\n\n high = ceil(math.log2(n))\n low = floor(math.log2(n))\n\n sel1 = self.minOperations(pow(2, high) - n) + 1\n sel2 = self.minOperations(n - pow(2, low)) + 1\n\n return min(sel1, sel2)","runtime":"19"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n ans = 0\n while n:\n if n&1 and (n//2)&1:\n n+=1\n ans+=1\n while n%2 == 0:\n n//=2\n else:\n ans += n%2\n n//=2\n \n return ans","runtime":"20"},{"code":"import math\n\nclass Solution:\n def distance_power_of_two(self, n):\n \"\"\"\n Returns integer representing distnace of n to the nearest power of 2\n \"\"\"\n if n == 0:\n return 0\n res = math.log(n)/math.log(2)\n if res.is_integer():\n return 0\n else:\n left_power = n - 2 ** int(math.floor(res))\n right_power = 2 ** int(math.ceil(res)) - n\n final = min(left_power, right_power)\n return final\n\n def minOperations(self, n: int) -> int:\n if not n:\n return 0\n ops = 1\n remainder = self.distance_power_of_two(n)\n while remainder > 0:\n ops += 1\n remainder = self.distance_power_of_two(remainder)\n return ops\n\n\n\n ","runtime":"21"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n \n n_op = 0\n while(n != 0):\n max_exp_lower = self.my_lower_log2(n) # lower part of lg(n)\n max_exp_upper = max_exp_lower + 1\n sub = n - 2 ** max_exp_lower\n up = 2 ** max_exp_upper - n\n if sub < up:\n n = sub\n else:\n n = up\n n_op += 1\n return n_op\n\n\n def my_lower_log2(self, n:int)->int:\n exp = 0\n while(n > 1):\n n = n // 2\n exp += 1\n return exp","runtime":"22"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n # We convert the given number to its binary form.\n # If we only use substract operation, we can reduce one 1 at one time.\n # If we use add operation, we may achieve more optimal solution, such as 11111.\n # Hence we can leverage DP for this.\n # M(n) = min(M(n - (n & -n)), M(n + (n & -n))).\n # The first case is to directly remove the lowest bit.\n # The second case is to add the lowest bit in order to wrap the continuous left-hand-side bits.\n # The base case: M(0) = 0, M(1) = 0, M(2^n) = 1.\n dp = {}\n dp[0] = 0\n\n def helper(x):\n if x in dp:\n return dp[x]\n if x & (x - 1) == 0:\n dp[x] = 1\n return 1\n lb = x & (-x)\n return min(helper(x + lb), helper(x - lb)) + 1\n\n return helper(n)","runtime":"23"},{"code":"class Solution:\n def getClosestPowerOfTwo(self, n: int) -> int:\n power = 0\n while(n > 1):\n n = round(n / 2)\n power += 1\n return 2 ** power\n\n def minOperations(self, n: int) -> int:\n operation = 0\n while (n > 0):\n closestPower = self.getClosestPowerOfTwo(n)\n n = abs(n - closestPower)\n operation += 1\n return operation\n ","runtime":"24"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n res = 0\n while n > 0:\n if n & 3 == 0:\n n >>= 2\n elif n & 3 == 1:\n n >>= 1\n res += 1\n elif n & 3 == 2:\n n >>= 1\n else:\n n += 1\n res += 1\n return res","runtime":"25"},{"code":"import math \n\nclass Solution:\n def minOperations(self, n: int) -> int:\n result = 0\n while n != 0:\n closest = pow(2,round(math.log2(n)))\n n = abs(n - closest)\n result += 1\n return result","runtime":"26"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n totalOp = 0\n while n > 0:\n if (n & 1) == 0:\n # xx0 -> ignore\n n >>= 1\n elif (n & 2) != 0:\n # xx11 -> add one\n n += 1\n totalOp += 1\n else:\n # xx01 -> remove one\n n >>= 2\n totalOp += 1\n return totalOp","runtime":"27"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n count = 0\n\n while n:\n exponent = 1\n while 2**exponent < n:\n exponent += 1\n \n first_formula = abs(2**exponent - n)\n second_formula = abs(2**(exponent-1) - n)\n n = min(first_formula, second_formula)\n count += 1\n \n return count","runtime":"28"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n cnt = 0\n while n:\n exp = 1\n while n > 2**exp:\n exp += 1\n n = min(2**exp - n, n-2**(exp-1))\n cnt += 1\n return cnt\n\n\n\n","runtime":"29"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n it = 0\n while ( n>0 ):\n m = int(math.log(n,2))\n if ( n-math.pow(2,m)>math.pow(2,m+1)-n ):\n n = math.pow(2,m+1) - n\n else:\n n = n - math.pow(2,m)\n it += 1\n return it","runtime":"30"},{"code":"class Solution:\n # 返回把x操作成0的最少次数\n @cache\n def dfs(self, x):\n if (x & (x-1)) == 0:\n return 1\n lb = x & -x\n return 1 + min(self.dfs(x+lb), self.dfs(x-lb))\n\n def minOperations(self, n: int) -> int:\n '''\n 回溯，枚举是 + 2^k 还是 - 2^k\n 2^k = lowbit(the first 1 from right to left) = x & -x\n '''\n return self.dfs(n)\n\n","runtime":"31"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n if n & (n-1) == 0: return 1 # x is a power of 2\n x, p = n, 0\n while (x := x >> 1) != 0: \n p += 1 # 2^p < x, the largest power\n prev2, next2 = 1 << p, 1 << (p+1)\n # greedy\n # return 1 + min(self.minOperations(next2 - n), self.minOperations(n - prev2))\n return 1 + self.minOperations(min(next2 - n, n - prev2))\n ","runtime":"31"},{"code":"from math import log2,ceil\nclass Solution:\n def minOperations(self, n: int) -> int:\n min_count = 0\n conseq_one=0\n while n:\n if n&1:\n conseq_one+=1\n elif conseq_one:\n min_count+=1\n\n if conseq_one==1:\n conseq_one=0\n else:\n conseq_one=1\n n>>=1\n if conseq_one==1:\n min_count+=1\n elif conseq_one>1:\n min_count+=2\n return min_count\n\n ","runtime":"32"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n bin_repr = bin(n)[2:]\n num_operations = 0\n have_carry = False\n zero_changed_to_one = False\n\n for index, val in enumerate(bin_repr):\n i = len(bin_repr) - index -1\n\n \n\n if bin_repr[i] == '0' and have_carry:\n have_carry = False\n zero_changed_to_one = True\n if bin_repr[i] == '1' or zero_changed_to_one: \n if i == 0:\n return num_operations + 1\n\n zero_changed_to_one = False\n\n if not have_carry: \n if bin_repr[i-1] == '1':\n have_carry = True \n num_operations += 1\n\n return num_operations\n \n # def minOperations(self, n: int) -> int:\n # self.orig_n = n\n # self.calc_hash = {}\n # return self.func(n, 0, 0)\n\n # def func(self, n, power, num_ops):\n # if (n, power) in self.calc_hash:\n # return self.calc_hash[(n,power,num_ops)] \n\n # if n == 0:\n # return num_ops\n\n # if n < 0:\n # return sys.maxsize\n\n # minimum = sys.maxsize\n\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\n # if (self.orig_n < pow(2, power)):\n # return minimum\n\n # minimum = min(minimum, self.func(n, power+1, num_ops))\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\n # self.calc_hash[(n, power,num_ops)] = minimum \n \n # return minimum\n \n\n ","runtime":"33"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n def count1(i):\n binary_list = [int(x) for x in bin(i)[2:]]\n return binary_list.count(1)\n\n b = [int(x) for x in bin(n)[2:]]\n res = 0\n for i in range(len(b)):\n prev = n\n post = n + pow(2, i)\n prev1 = count1(prev)\n post1 = count1(post)\n\n if post1 + 1 <= prev1:\n res += 1\n n = post\n \n return res + count1(n)","runtime":"34"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n ops = 0\n while n > 0:\n if n & 3 == 3:\n ops += 1\n n += 1\n print(n,ops)\n else:\n ops += n & 1\n n >>= 1\n\n return ops","runtime":"35"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n @cache\n def dfs(x):\n if (x&(x-1))==0:\n return 1\n \n lb = x&-x\n return 1+min(dfs(x+lb), dfs(x-lb))\n \n return dfs(n)\n ","runtime":"36"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n res = 0\n while n > 0:\n if n % 2 == 0:\n n >>= 1\n elif (n & 2) > 0:\n n += 1\n res += 1\n \n else:\n res += 1\n n >>= 2\n \n return res","runtime":"37"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n \n ans = 0\n while n:\n exp = 0\n while n > 2**exp:\n exp += 1\n ans += 1\n n = min(abs(n - 2**exp), abs(n - 2**(exp-1)))\n return ans\n\n \n","runtime":"38"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n bin_repr = bin(n)[2:]\n num_operations = 0\n have_carry = False\n zero_changed_to_one = False\n\n for index, val in enumerate(bin_repr):\n i = len(bin_repr) - index -1\n\n print(\"i: \", i)\n print(\"bin_repr[i]: \", bin_repr[i])\n\n if bin_repr[i] == '0' and have_carry:\n have_carry = False\n #num_operations += 1\n zero_changed_to_one = True\n if bin_repr[i] == '1' or zero_changed_to_one: \n if i == 0:\n return num_operations + 1\n\n zero_changed_to_one = False\n\n if not have_carry: \n if bin_repr[i-1] == '1':\n have_carry = True \n num_operations += 1\n\n return num_operations\n \n # def minOperations(self, n: int) -> int:\n # self.orig_n = n\n # self.calc_hash = {}\n # return self.func(n, 0, 0)\n\n # def func(self, n, power, num_ops):\n # if (n, power) in self.calc_hash:\n # return self.calc_hash[(n,power,num_ops)] \n\n # if n == 0:\n # return num_ops\n\n # if n < 0:\n # return sys.maxsize\n\n # minimum = sys.maxsize\n\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\n # if (self.orig_n < pow(2, power)):\n # return minimum\n\n # minimum = min(minimum, self.func(n, power+1, num_ops))\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\n # self.calc_hash[(n, power,num_ops)] = minimum \n \n # return minimum\n \n\n ","runtime":"39"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n b='0'+bin(n)[2:].strip('0')\n groups=re.findall('1+|0+',b)\n i=1\n answ=0\n while i<len(groups):\n if len(groups[-i])==1:\n answ+=1\n elif 1<len(groups[-i-1]):\n answ+=2\n else:\n answ+=1\n if i+2<=len(groups):\n groups[-i-2]+='1'\n else:\n answ+=1\n i+=2\n return answ ","runtime":"40"},{"code":"import math\n\nclass Solution:\n def minOperations(self, n: int) -> int:\n self.n = n\n def max_power2(num):\n power = math.floor(math.log(num, 2))\n return 2 ** power\n def min_power2(num):\n power = math.ceil(math.log(num, 2))\n return 2 ** power\n self.moves = 0\n def search():\n self.n = min(self.n - max_power2(self.n), min_power2(self.n) - self.n)\n self.moves+=1\n \n while self.n > 0:\n search()\n return self.moves\n ","runtime":"41"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n # The strategy is that when the end of n is\n # 1. consecutive 1s, add 1 (2^0).\n # 2. single 1, substract 1 (2^0).\n # 3. 0, substract 2^k to omit the last 1. Equivalently, n >> 1.\n #\n # e.g.\n #\n # n = 0b101\n # n -= 2^0 -> 0b100\n # n -= 2^2 -> 0b0\n # n = 0b1011\n # n += 2^0 -> 0b1100\n # n -= 2^2 -> 0b1000\n # n -= 2^3 -> 0b0\n ans = 0\n\n while n > 0:\n if (n & 3) == 3:\n n += 1\n ans += 1\n elif n % 2 == 1:\n n -= 1\n ans += 1\n else:\n n >>= 1\n\n return ans","runtime":"41"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n res = 0\n while n > 0:\n if n & 3 == 0:\n n >>= 2\n elif n & 3 == 1:\n n >>= 1\n res += 1\n elif n & 3 == 2:\n n >>= 1\n else:\n n += 1\n res += 1\n return res","runtime":"42"},{"code":"class Solution:\n def __init__(self):\n self.d = {}\n def minOperations(self, n: int) -> int:\n self.d[1] = 1\n return self.find_operations(n)\n\n def find_operations(self, n):\n if n in self.d:\n return self.d[n]\n x = n // 2\n if n % 2 == 0:\n self.d[x] = self.find_operations(x)\n self.d[n] = self.d[x]\n return self.d[n]\n else:\n self.d[n] = min(self.find_operations(x+1)+1, self.find_operations(x)+1)\n return self.d[n]\n\n ","runtime":"43"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n def count1(i):\n binary_list = [int(x) for x in bin(i)[2:]]\n return binary_list.count(1)\n\n b = [int(x) for x in bin(n)[2:]]\n res = 0\n for i in range(len(b)):\n prev = n\n post = n + pow(2, i)\n prev1 = count1(prev)\n post1 = count1(post)\n\n if post1 + 1 <= prev1:\n res += 1\n n = post\n \n return res + count1(n)","runtime":"44"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n # 그리디\n powers = []\n power = 1\n while power <= 100000:\n powers.append(power)\n power *= 2\n answer = 0\n while n > 0:\n closest = min(powers, key = lambda p: abs(n-p))\n n = abs(n-closest) # 가장 차이가 작은 2의 지수승\n answer += 1\n return answer\n\n","runtime":"45"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n # We convert the given number to its binary form.\n # If we only use substract operation, we can reduce one 1 at one time.\n # If we use add operation, we may achieve more optimal solution, such as 11111.\n # Hence we can leverage DP for this.\n # M(n) = min(M(n - (n & -n)), M(n + (n & -n))).\n # The first case is to directly remove the lowest bit.\n # The second case is to add the lowest bit in order to wrap the continuous left-hand-side bits.\n # The base case: M(0) = 0, M(1) = 0, M(2^n) = 1.\n dp = {}\n dp[0] = 0\n\n def helper(x):\n if x in dp:\n return dp[x]\n if x & (x - 1) == 0:\n dp[x] = 1\n return 1\n lb = x & (-x)\n return min(helper(x + lb), helper(x - lb)) + 1\n\n return helper(n)","runtime":"46"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n binary = bin(n)[2:]\n\n count = 0\n\n print(f\"Binary rep: {binary}\")\n\n # iterate from least significant to most significant digits \n sequence_of_one = 0\n for i in range(len(binary)-1, -2, -1):\n if i == -1 or binary[i] == '0':\n if sequence_of_one>1:\n # add one to turn these 1s into 0\n num_to_add = '1'\n addition_range = len(binary) - (i+1+sequence_of_one)\n for _ in range(addition_range):\n num_to_add += '0'\n\n print(f\"Adding {num_to_add} to {binary}\")\n binary = bin(int(binary, 2) + int(num_to_add, 2))[2:]\n print(f\"New binary {binary}\")\n sequence_of_one = 1\n count +=1\n\n else:\n sequence_of_one = 0\n\n\n else:\n sequence_of_one +=1\n\n print(binary)\n\n # calculate amount of 1s\n for digit in binary:\n if digit == '1':\n count +=1\n\n return count\n\n\n\n\n \n\n \n\n \n\n \n\n \n\n \n\n\n\n\n ","runtime":"48"},{"code":"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\n# but, further, to reach 2**high, should be from 2**hihg; \n# to reach 2**low, should be from n - 2**low \n\nclass Solution:\n def minOperations(self, n: int) -> int:\n if n == 0:\n return 0\n\n # if n is power of 2\n if (n & (n - 1) == 0) and n != 0:\n return 1\n\n high = ceil(math.log2(n))\n low = floor(math.log2(n))\n\n # steps to reach higher bound\n sel1 = self.minOperations(pow(2, high) - n) + 1\n # steps to reach lower bound\n sel2 = self.minOperations(n - pow(2, low)) + 1\n\n return min(sel1, sel2)","runtime":"49"},{"code":"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\n# but, further, to reach 2**high, should be from 2**hihg; \n# to reach 2**low, should be from n - 2**low \n\nclass Solution:\n def minOperations(self, n: int) -> int:\n if n == 0:\n return 0\n \n # if n is power of 2\n if (n & (n - 1) == 0) and n != 0:\n return 1\n\n high = ceil(math.log2(n))\n low = floor(math.log2(n))\n\n sel1 = self.minOperations(pow(2, high) - n) + 1\n sel2 = self.minOperations(n - pow(2, low)) + 1\n\n return min(sel1, sel2)","runtime":"50"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n\n if n <= 2:\n return 1\n\n val = 0\n while (2 ** val) < n:\n val += 1\n \n low_diff = n - (2 ** (val - 1))\n high_diff = (2 ** val) - n\n \n dp = [0] * (max(high_diff, low_diff) + 1)\n\n dp[1] = 1\n dp[2] = 1\n\n low_2 = 2\n high_2 = 4\n for i in range(3, max(high_diff, low_diff) + 1):\n\n if i == high_2:\n low_2 *= 2\n high_2 *= 2\n dp[i] = 1\n else:\n to_low = i - low_2\n to_high = high_2 - i\n dp[i] = min(dp[to_high], dp[to_low]) + 1\n \n return min(dp[high_diff], dp[low_diff]) + 1\n\n \n \n \n \n \n\n \n\n ","runtime":"84"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n def get_pow2(n):\n count = 0\n while n>0:\n count+=1\n n=int(n/2)\n return count\n k = get_pow2(n)\n\n pow2 = pow(2,k-1)+1\n dp = [0]*pow2\n dp[0]=0\n dp[1]=1\n low,high=1,2\n for i in range(2,pow2):\n if i==high:\n dp[i]=1\n low=i\n high*=2\n else:\n dp[i]=1+min(dp[high-i],dp[i-low])\n if n==low or n==high:\n return 1\n return 1+min(dp[high-n],dp[n-low])\n\n\n\n","runtime":"103"}],"string":"[\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n try:\\n ops = 0\\n while True:\\n closest_power_2 = 2**round(math.log2(n))\\n print(closest_power_2, closest_power_2-n, n, ops)\\n power2 = round(math.log2(abs(closest_power_2-n)))\\n n = n-2**power2 if closest_power_2 <= n else n+2**power2\\n ops+=1\\n except ValueError:\\n return ops+1\\n \",\n \"runtime\": \"14\"\n },\n {\n \"code\": \"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\\n# but, further, to reach 2**high, should be from 2**hihg; \\n# to reach 2**low, should be from n - 2**low \\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n if n == 0:\\n return 0\\n \\n # if n is power of 2\\n if (n & (n - 1) == 0) and n != 0:\\n return 1\\n\\n high = ceil(math.log2(n))\\n low = floor(math.log2(n))\\n\\n sel1 = self.minOperations(pow(2, high) - n) + 1\\n sel2 = self.minOperations(n - pow(2, low)) + 1\\n\\n return min(sel1, sel2)\",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n ans = 0\\n while n:\\n if n&1 and (n//2)&1:\\n n+=1\\n ans+=1\\n while n%2 == 0:\\n n//=2\\n else:\\n ans += n%2\\n n//=2\\n \\n return ans\",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def distance_power_of_two(self, n):\\n \\\"\\\"\\\"\\n Returns integer representing distnace of n to the nearest power of 2\\n \\\"\\\"\\\"\\n if n == 0:\\n return 0\\n res = math.log(n)/math.log(2)\\n if res.is_integer():\\n return 0\\n else:\\n left_power = n - 2 ** int(math.floor(res))\\n right_power = 2 ** int(math.ceil(res)) - n\\n final = min(left_power, right_power)\\n return final\\n\\n def minOperations(self, n: int) -> int:\\n if not n:\\n return 0\\n ops = 1\\n remainder = self.distance_power_of_two(n)\\n while remainder > 0:\\n ops += 1\\n remainder = self.distance_power_of_two(remainder)\\n return ops\\n\\n\\n\\n \",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n \\n n_op = 0\\n while(n != 0):\\n max_exp_lower = self.my_lower_log2(n) # lower part of lg(n)\\n max_exp_upper = max_exp_lower + 1\\n sub = n - 2 ** max_exp_lower\\n up = 2 ** max_exp_upper - n\\n if sub < up:\\n n = sub\\n else:\\n n = up\\n n_op += 1\\n return n_op\\n\\n\\n def my_lower_log2(self, n:int)->int:\\n exp = 0\\n while(n > 1):\\n n = n // 2\\n exp += 1\\n return exp\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n # We convert the given number to its binary form.\\n # If we only use substract operation, we can reduce one 1 at one time.\\n # If we use add operation, we may achieve more optimal solution, such as 11111.\\n # Hence we can leverage DP for this.\\n # M(n) = min(M(n - (n & -n)), M(n + (n & -n))).\\n # The first case is to directly remove the lowest bit.\\n # The second case is to add the lowest bit in order to wrap the continuous left-hand-side bits.\\n # The base case: M(0) = 0, M(1) = 0, M(2^n) = 1.\\n dp = {}\\n dp[0] = 0\\n\\n def helper(x):\\n if x in dp:\\n return dp[x]\\n if x & (x - 1) == 0:\\n dp[x] = 1\\n return 1\\n lb = x & (-x)\\n return min(helper(x + lb), helper(x - lb)) + 1\\n\\n return helper(n)\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def getClosestPowerOfTwo(self, n: int) -> int:\\n power = 0\\n while(n > 1):\\n n = round(n / 2)\\n power += 1\\n return 2 ** power\\n\\n def minOperations(self, n: int) -> int:\\n operation = 0\\n while (n > 0):\\n closestPower = self.getClosestPowerOfTwo(n)\\n n = abs(n - closestPower)\\n operation += 1\\n return operation\\n \",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n res = 0\\n while n > 0:\\n if n & 3 == 0:\\n n >>= 2\\n elif n & 3 == 1:\\n n >>= 1\\n res += 1\\n elif n & 3 == 2:\\n n >>= 1\\n else:\\n n += 1\\n res += 1\\n return res\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"import math \\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n result = 0\\n while n != 0:\\n closest = pow(2,round(math.log2(n)))\\n n = abs(n - closest)\\n result += 1\\n return result\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n totalOp = 0\\n while n > 0:\\n if (n & 1) == 0:\\n # xx0 -> ignore\\n n >>= 1\\n elif (n & 2) != 0:\\n # xx11 -> add one\\n n += 1\\n totalOp += 1\\n else:\\n # xx01 -> remove one\\n n >>= 2\\n totalOp += 1\\n return totalOp\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n count = 0\\n\\n while n:\\n exponent = 1\\n while 2**exponent < n:\\n exponent += 1\\n \\n first_formula = abs(2**exponent - n)\\n second_formula = abs(2**(exponent-1) - n)\\n n = min(first_formula, second_formula)\\n count += 1\\n \\n return count\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n cnt = 0\\n while n:\\n exp = 1\\n while n > 2**exp:\\n exp += 1\\n n = min(2**exp - n, n-2**(exp-1))\\n cnt += 1\\n return cnt\\n\\n\\n\\n\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n it = 0\\n while ( n>0 ):\\n m = int(math.log(n,2))\\n if ( n-math.pow(2,m)>math.pow(2,m+1)-n ):\\n n = math.pow(2,m+1) - n\\n else:\\n n = n - math.pow(2,m)\\n it += 1\\n return it\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n # 返回把x操作成0的最少次数\\n @cache\\n def dfs(self, x):\\n if (x & (x-1)) == 0:\\n return 1\\n lb = x & -x\\n return 1 + min(self.dfs(x+lb), self.dfs(x-lb))\\n\\n def minOperations(self, n: int) -> int:\\n '''\\n 回溯，枚举是 + 2^k 还是 - 2^k\\n 2^k = lowbit(the first 1 from right to left) = x & -x\\n '''\\n return self.dfs(n)\\n\\n\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n if n & (n-1) == 0: return 1 # x is a power of 2\\n x, p = n, 0\\n while (x := x >> 1) != 0: \\n p += 1 # 2^p < x, the largest power\\n prev2, next2 = 1 << p, 1 << (p+1)\\n # greedy\\n # return 1 + min(self.minOperations(next2 - n), self.minOperations(n - prev2))\\n return 1 + self.minOperations(min(next2 - n, n - prev2))\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"from math import log2,ceil\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n min_count = 0\\n conseq_one=0\\n while n:\\n if n&1:\\n conseq_one+=1\\n elif conseq_one:\\n min_count+=1\\n\\n if conseq_one==1:\\n conseq_one=0\\n else:\\n conseq_one=1\\n n>>=1\\n if conseq_one==1:\\n min_count+=1\\n elif conseq_one>1:\\n min_count+=2\\n return min_count\\n\\n \",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n bin_repr = bin(n)[2:]\\n num_operations = 0\\n have_carry = False\\n zero_changed_to_one = False\\n\\n for index, val in enumerate(bin_repr):\\n i = len(bin_repr) - index -1\\n\\n \\n\\n if bin_repr[i] == '0' and have_carry:\\n have_carry = False\\n zero_changed_to_one = True\\n if bin_repr[i] == '1' or zero_changed_to_one: \\n if i == 0:\\n return num_operations + 1\\n\\n zero_changed_to_one = False\\n\\n if not have_carry: \\n if bin_repr[i-1] == '1':\\n have_carry = True \\n num_operations += 1\\n\\n return num_operations\\n \\n # def minOperations(self, n: int) -> int:\\n # self.orig_n = n\\n # self.calc_hash = {}\\n # return self.func(n, 0, 0)\\n\\n # def func(self, n, power, num_ops):\\n # if (n, power) in self.calc_hash:\\n # return self.calc_hash[(n,power,num_ops)] \\n\\n # if n == 0:\\n # return num_ops\\n\\n # if n < 0:\\n # return sys.maxsize\\n\\n # minimum = sys.maxsize\\n\\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\\n # if (self.orig_n < pow(2, power)):\\n # return minimum\\n\\n # minimum = min(minimum, self.func(n, power+1, num_ops))\\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\\n # self.calc_hash[(n, power,num_ops)] = minimum \\n \\n # return minimum\\n \\n\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n def count1(i):\\n binary_list = [int(x) for x in bin(i)[2:]]\\n return binary_list.count(1)\\n\\n b = [int(x) for x in bin(n)[2:]]\\n res = 0\\n for i in range(len(b)):\\n prev = n\\n post = n + pow(2, i)\\n prev1 = count1(prev)\\n post1 = count1(post)\\n\\n if post1 + 1 <= prev1:\\n res += 1\\n n = post\\n \\n return res + count1(n)\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n ops = 0\\n while n > 0:\\n if n & 3 == 3:\\n ops += 1\\n n += 1\\n print(n,ops)\\n else:\\n ops += n & 1\\n n >>= 1\\n\\n return ops\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n @cache\\n def dfs(x):\\n if (x&(x-1))==0:\\n return 1\\n \\n lb = x&-x\\n return 1+min(dfs(x+lb), dfs(x-lb))\\n \\n return dfs(n)\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n res = 0\\n while n > 0:\\n if n % 2 == 0:\\n n >>= 1\\n elif (n & 2) > 0:\\n n += 1\\n res += 1\\n \\n else:\\n res += 1\\n n >>= 2\\n \\n return res\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n \\n ans = 0\\n while n:\\n exp = 0\\n while n > 2**exp:\\n exp += 1\\n ans += 1\\n n = min(abs(n - 2**exp), abs(n - 2**(exp-1)))\\n return ans\\n\\n \\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n bin_repr = bin(n)[2:]\\n num_operations = 0\\n have_carry = False\\n zero_changed_to_one = False\\n\\n for index, val in enumerate(bin_repr):\\n i = len(bin_repr) - index -1\\n\\n print(\\\"i: \\\", i)\\n print(\\\"bin_repr[i]: \\\", bin_repr[i])\\n\\n if bin_repr[i] == '0' and have_carry:\\n have_carry = False\\n #num_operations += 1\\n zero_changed_to_one = True\\n if bin_repr[i] == '1' or zero_changed_to_one: \\n if i == 0:\\n return num_operations + 1\\n\\n zero_changed_to_one = False\\n\\n if not have_carry: \\n if bin_repr[i-1] == '1':\\n have_carry = True \\n num_operations += 1\\n\\n return num_operations\\n \\n # def minOperations(self, n: int) -> int:\\n # self.orig_n = n\\n # self.calc_hash = {}\\n # return self.func(n, 0, 0)\\n\\n # def func(self, n, power, num_ops):\\n # if (n, power) in self.calc_hash:\\n # return self.calc_hash[(n,power,num_ops)] \\n\\n # if n == 0:\\n # return num_ops\\n\\n # if n < 0:\\n # return sys.maxsize\\n\\n # minimum = sys.maxsize\\n\\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\\n # if (self.orig_n < pow(2, power)):\\n # return minimum\\n\\n # minimum = min(minimum, self.func(n, power+1, num_ops))\\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\\n # self.calc_hash[(n, power,num_ops)] = minimum \\n \\n # return minimum\\n \\n\\n \",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n b='0'+bin(n)[2:].strip('0')\\n groups=re.findall('1+|0+',b)\\n i=1\\n answ=0\\n while i<len(groups):\\n if len(groups[-i])==1:\\n answ+=1\\n elif 1<len(groups[-i-1]):\\n answ+=2\\n else:\\n answ+=1\\n if i+2<=len(groups):\\n groups[-i-2]+='1'\\n else:\\n answ+=1\\n i+=2\\n return answ \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"import math\\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n self.n = n\\n def max_power2(num):\\n power = math.floor(math.log(num, 2))\\n return 2 ** power\\n def min_power2(num):\\n power = math.ceil(math.log(num, 2))\\n return 2 ** power\\n self.moves = 0\\n def search():\\n self.n = min(self.n - max_power2(self.n), min_power2(self.n) - self.n)\\n self.moves+=1\\n \\n while self.n > 0:\\n search()\\n return self.moves\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n # The strategy is that when the end of n is\\n # 1. consecutive 1s, add 1 (2^0).\\n # 2. single 1, substract 1 (2^0).\\n # 3. 0, substract 2^k to omit the last 1. Equivalently, n >> 1.\\n #\\n # e.g.\\n #\\n # n = 0b101\\n # n -= 2^0 -> 0b100\\n # n -= 2^2 -> 0b0\\n # n = 0b1011\\n # n += 2^0 -> 0b1100\\n # n -= 2^2 -> 0b1000\\n # n -= 2^3 -> 0b0\\n ans = 0\\n\\n while n > 0:\\n if (n & 3) == 3:\\n n += 1\\n ans += 1\\n elif n % 2 == 1:\\n n -= 1\\n ans += 1\\n else:\\n n >>= 1\\n\\n return ans\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n res = 0\\n while n > 0:\\n if n & 3 == 0:\\n n >>= 2\\n elif n & 3 == 1:\\n n >>= 1\\n res += 1\\n elif n & 3 == 2:\\n n >>= 1\\n else:\\n n += 1\\n res += 1\\n return res\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.d = {}\\n def minOperations(self, n: int) -> int:\\n self.d[1] = 1\\n return self.find_operations(n)\\n\\n def find_operations(self, n):\\n if n in self.d:\\n return self.d[n]\\n x = n // 2\\n if n % 2 == 0:\\n self.d[x] = self.find_operations(x)\\n self.d[n] = self.d[x]\\n return self.d[n]\\n else:\\n self.d[n] = min(self.find_operations(x+1)+1, self.find_operations(x)+1)\\n return self.d[n]\\n\\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n def count1(i):\\n binary_list = [int(x) for x in bin(i)[2:]]\\n return binary_list.count(1)\\n\\n b = [int(x) for x in bin(n)[2:]]\\n res = 0\\n for i in range(len(b)):\\n prev = n\\n post = n + pow(2, i)\\n prev1 = count1(prev)\\n post1 = count1(post)\\n\\n if post1 + 1 <= prev1:\\n res += 1\\n n = post\\n \\n return res + count1(n)\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n # 그리디\\n powers = []\\n power = 1\\n while power <= 100000:\\n powers.append(power)\\n power *= 2\\n answer = 0\\n while n > 0:\\n closest = min(powers, key = lambda p: abs(n-p))\\n n = abs(n-closest) # 가장 차이가 작은 2의 지수승\\n answer += 1\\n return answer\\n\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n # We convert the given number to its binary form.\\n # If we only use substract operation, we can reduce one 1 at one time.\\n # If we use add operation, we may achieve more optimal solution, such as 11111.\\n # Hence we can leverage DP for this.\\n # M(n) = min(M(n - (n & -n)), M(n + (n & -n))).\\n # The first case is to directly remove the lowest bit.\\n # The second case is to add the lowest bit in order to wrap the continuous left-hand-side bits.\\n # The base case: M(0) = 0, M(1) = 0, M(2^n) = 1.\\n dp = {}\\n dp[0] = 0\\n\\n def helper(x):\\n if x in dp:\\n return dp[x]\\n if x & (x - 1) == 0:\\n dp[x] = 1\\n return 1\\n lb = x & (-x)\\n return min(helper(x + lb), helper(x - lb)) + 1\\n\\n return helper(n)\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n binary = bin(n)[2:]\\n\\n count = 0\\n\\n print(f\\\"Binary rep: {binary}\\\")\\n\\n # iterate from least significant to most significant digits \\n sequence_of_one = 0\\n for i in range(len(binary)-1, -2, -1):\\n if i == -1 or binary[i] == '0':\\n if sequence_of_one>1:\\n # add one to turn these 1s into 0\\n num_to_add = '1'\\n addition_range = len(binary) - (i+1+sequence_of_one)\\n for _ in range(addition_range):\\n num_to_add += '0'\\n\\n print(f\\\"Adding {num_to_add} to {binary}\\\")\\n binary = bin(int(binary, 2) + int(num_to_add, 2))[2:]\\n print(f\\\"New binary {binary}\\\")\\n sequence_of_one = 1\\n count +=1\\n\\n else:\\n sequence_of_one = 0\\n\\n\\n else:\\n sequence_of_one +=1\\n\\n print(binary)\\n\\n # calculate amount of 1s\\n for digit in binary:\\n if digit == '1':\\n count +=1\\n\\n return count\\n\\n\\n\\n\\n \\n\\n \\n\\n \\n\\n \\n\\n \\n\\n \\n\\n\\n\\n\\n \",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\\n# but, further, to reach 2**high, should be from 2**hihg; \\n# to reach 2**low, should be from n - 2**low \\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n if n == 0:\\n return 0\\n\\n # if n is power of 2\\n if (n & (n - 1) == 0) and n != 0:\\n return 1\\n\\n high = ceil(math.log2(n))\\n low = floor(math.log2(n))\\n\\n # steps to reach higher bound\\n sel1 = self.minOperations(pow(2, high) - n) + 1\\n # steps to reach lower bound\\n sel2 = self.minOperations(n - pow(2, low)) + 1\\n\\n return min(sel1, sel2)\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"# at this point, to reach 0, can be from 2**high through subtraction or, from 2**low, from addition.\\n# but, further, to reach 2**high, should be from 2**hihg; \\n# to reach 2**low, should be from n - 2**low \\n\\nclass Solution:\\n def minOperations(self, n: int) -> int:\\n if n == 0:\\n return 0\\n \\n # if n is power of 2\\n if (n & (n - 1) == 0) and n != 0:\\n return 1\\n\\n high = ceil(math.log2(n))\\n low = floor(math.log2(n))\\n\\n sel1 = self.minOperations(pow(2, high) - n) + 1\\n sel2 = self.minOperations(n - pow(2, low)) + 1\\n\\n return min(sel1, sel2)\",\n \"runtime\": \"50\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n\\n if n <= 2:\\n return 1\\n\\n val = 0\\n while (2 ** val) < n:\\n val += 1\\n \\n low_diff = n - (2 ** (val - 1))\\n high_diff = (2 ** val) - n\\n \\n dp = [0] * (max(high_diff, low_diff) + 1)\\n\\n dp[1] = 1\\n dp[2] = 1\\n\\n low_2 = 2\\n high_2 = 4\\n for i in range(3, max(high_diff, low_diff) + 1):\\n\\n if i == high_2:\\n low_2 *= 2\\n high_2 *= 2\\n dp[i] = 1\\n else:\\n to_low = i - low_2\\n to_high = high_2 - i\\n dp[i] = min(dp[to_high], dp[to_low]) + 1\\n \\n return min(dp[high_diff], dp[low_diff]) + 1\\n\\n \\n \\n \\n \\n \\n\\n \\n\\n \",\n \"runtime\": \"84\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n def get_pow2(n):\\n count = 0\\n while n>0:\\n count+=1\\n n=int(n/2)\\n return count\\n k = get_pow2(n)\\n\\n pow2 = pow(2,k-1)+1\\n dp = [0]*pow2\\n dp[0]=0\\n dp[1]=1\\n low,high=1,2\\n for i in range(2,pow2):\\n if i==high:\\n dp[i]=1\\n low=i\\n high*=2\\n else:\\n dp[i]=1+min(dp[high-i],dp[i-low])\\n if n==low or n==high:\\n return 1\\n return 1+min(dp[high-n],dp[n-low])\\n\\n\\n\\n\",\n \"runtime\": \"103\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":36,"string":"36"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n ans = 0\n while n > 0:\n expo = int(log2(n))\n n = min(n-2**expo, 2 ** (expo+1) - n)\n ans += 1\n return ans","memory":"16100"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n\n cnt = 0\n\n while n != 0:\n lower = n - 2 ** int(log2(n))\n upper = 2 ** (int(log2(n)) + 1) - n\n n = min(lower, upper) \n cnt += 1\n\n return cnt ","memory":"16200"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n # greddy approach\n cnt = 0\n while n:\n exp = 1\n while 2**exp < n: exp += 1 # find the closest power of 2\n n = min(abs(2**exp - n), abs(2**(exp-1) - n)) # get the min\n cnt += 1\n return cnt","memory":"16300"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n num_ops = 0\n\n while n != 0:\n log_n = math.log2(abs(n))\n \n if n > 0:\n n -= 2**(round(log_n))\n else:\n n += 2**(round(log_n))\n num_ops +=1\n return num_ops\n\n ","memory":"16400"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n totalOp = 0\n while n > 0:\n if (n & 1) == 0:\n # xx0 -> ignore\n n >>= 1\n elif (n & 2) != 0:\n # xx11 -> add one\n n += 1\n totalOp += 1\n else:\n # xx01 -> remove one\n n >>= 2\n totalOp += 1\n return totalOp","memory":"16400"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n bin_repr = bin(n)[2:]\n num_operations = 0\n have_carry = False\n zero_changed_to_one = False\n\n for index, val in enumerate(bin_repr):\n i = len(bin_repr) - index -1\n\n \n\n if bin_repr[i] == '0' and have_carry:\n have_carry = False\n zero_changed_to_one = True\n if bin_repr[i] == '1' or zero_changed_to_one: \n if i == 0:\n return num_operations + 1\n\n zero_changed_to_one = False\n\n if not have_carry: \n if bin_repr[i-1] == '1':\n have_carry = True \n num_operations += 1\n\n return num_operations\n \n # def minOperations(self, n: int) -> int:\n # self.orig_n = n\n # self.calc_hash = {}\n # return self.func(n, 0, 0)\n\n # def func(self, n, power, num_ops):\n # if (n, power) in self.calc_hash:\n # return self.calc_hash[(n,power,num_ops)] \n\n # if n == 0:\n # return num_ops\n\n # if n < 0:\n # return sys.maxsize\n\n # minimum = sys.maxsize\n\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\n # if (self.orig_n < pow(2, power)):\n # return minimum\n\n # minimum = min(minimum, self.func(n, power+1, num_ops))\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\n # self.calc_hash[(n, power,num_ops)] = minimum \n \n # return minimum\n \n\n ","memory":"16500"},{"code":"class Solution:\n def __init__(self):\n self.d = {}\n def minOperations(self, n: int) -> int:\n self.d[1] = 1\n return self.find_operations(n)\n\n def find_operations(self, n):\n if n in self.d:\n return self.d[n]\n x = n // 2\n if n % 2 == 0:\n self.d[x] = self.find_operations(x)\n self.d[n] = self.d[x]\n return self.d[n]\n else:\n self.d[n] = min(self.find_operations(x+1)+1, self.find_operations(x)+1)\n return self.d[n]\n\n ","memory":"16600"},{"code":"class Solution:\n def minOperations(self, n: int) -> int:\n b='0'+bin(n)[2:].strip('0')\n groups=re.findall('1+|0+',b)\n i=1\n answ=0\n while i<len(groups):\n if len(groups[-i])==1:\n answ+=1\n elif 1<len(groups[-i-1]):\n answ+=2\n else:\n answ+=1\n if i+2<=len(groups):\n groups[-i-2]+='1'\n else:\n answ+=1\n i+=2\n return answ ","memory":"16700"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n ans = 0\\n while n > 0:\\n expo = int(log2(n))\\n n = min(n-2**expo, 2 ** (expo+1) - n)\\n ans += 1\\n return ans\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n\\n cnt = 0\\n\\n while n != 0:\\n lower = n - 2 ** int(log2(n))\\n upper = 2 ** (int(log2(n)) + 1) - n\\n n = min(lower, upper) \\n cnt += 1\\n\\n return cnt \",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n # greddy approach\\n cnt = 0\\n while n:\\n exp = 1\\n while 2**exp < n: exp += 1 # find the closest power of 2\\n n = min(abs(2**exp - n), abs(2**(exp-1) - n)) # get the min\\n cnt += 1\\n return cnt\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n num_ops = 0\\n\\n while n != 0:\\n log_n = math.log2(abs(n))\\n \\n if n > 0:\\n n -= 2**(round(log_n))\\n else:\\n n += 2**(round(log_n))\\n num_ops +=1\\n return num_ops\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n totalOp = 0\\n while n > 0:\\n if (n & 1) == 0:\\n # xx0 -> ignore\\n n >>= 1\\n elif (n & 2) != 0:\\n # xx11 -> add one\\n n += 1\\n totalOp += 1\\n else:\\n # xx01 -> remove one\\n n >>= 2\\n totalOp += 1\\n return totalOp\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n bin_repr = bin(n)[2:]\\n num_operations = 0\\n have_carry = False\\n zero_changed_to_one = False\\n\\n for index, val in enumerate(bin_repr):\\n i = len(bin_repr) - index -1\\n\\n \\n\\n if bin_repr[i] == '0' and have_carry:\\n have_carry = False\\n zero_changed_to_one = True\\n if bin_repr[i] == '1' or zero_changed_to_one: \\n if i == 0:\\n return num_operations + 1\\n\\n zero_changed_to_one = False\\n\\n if not have_carry: \\n if bin_repr[i-1] == '1':\\n have_carry = True \\n num_operations += 1\\n\\n return num_operations\\n \\n # def minOperations(self, n: int) -> int:\\n # self.orig_n = n\\n # self.calc_hash = {}\\n # return self.func(n, 0, 0)\\n\\n # def func(self, n, power, num_ops):\\n # if (n, power) in self.calc_hash:\\n # return self.calc_hash[(n,power,num_ops)] \\n\\n # if n == 0:\\n # return num_ops\\n\\n # if n < 0:\\n # return sys.maxsize\\n\\n # minimum = sys.maxsize\\n\\n # minimum = min(minimum, self.func(n-pow(2, power), power+1, num_ops+1))\\n # if (self.orig_n < pow(2, power)):\\n # return minimum\\n\\n # minimum = min(minimum, self.func(n, power+1, num_ops))\\n # minimum = min(minimum, self.func(n+pow(2, power), power+1, num_ops+1))\\n # self.calc_hash[(n, power,num_ops)] = minimum \\n \\n # return minimum\\n \\n\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.d = {}\\n def minOperations(self, n: int) -> int:\\n self.d[1] = 1\\n return self.find_operations(n)\\n\\n def find_operations(self, n):\\n if n in self.d:\\n return self.d[n]\\n x = n // 2\\n if n % 2 == 0:\\n self.d[x] = self.find_operations(x)\\n self.d[n] = self.d[x]\\n return self.d[n]\\n else:\\n self.d[n] = min(self.find_operations(x+1)+1, self.find_operations(x)+1)\\n return self.d[n]\\n\\n \",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, n: int) -> int:\\n b='0'+bin(n)[2:].strip('0')\\n groups=re.findall('1+|0+',b)\\n i=1\\n answ=0\\n while i<len(groups):\\n if len(groups[-i])==1:\\n answ+=1\\n elif 1<len(groups[-i-1]):\\n answ+=2\\n else:\\n answ+=1\\n if i+2<=len(groups):\\n groups[-i-2]+='1'\\n else:\\n answ+=1\\n i+=2\\n return answ \",\n \"memory\": \"16700\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":8,"string":"8"}}},{"rowIdx":2463,"cells":{"question_id":{"kind":"number","value":2708,"string":"2,708"},"name":{"kind":"string","value":"find-the-string-with-lcp"},"content":{"kind":"string","value":"<p>We define the <code>lcp</code> matrix of any <strong>0-indexed</strong> string <code>word</code> of <code>n</code> lowercase English letters as an <code>n x n</code> grid such that:</p>\n\n<ul>\n\t<li><code>lcp[i][j]</code> is equal to the length of the <strong>longest common prefix</strong> between the substrings <code>word[i,n-1]</code> and <code>word[j,n-1]</code>.</li>\n</ul>\n\n<p>Given an <code>n x n</code> matrix <code>lcp</code>, return the alphabetically smallest string <code>word</code> that corresponds to <code>lcp</code>. If there is no such string, return an empty string.</p>\n\n<p>A string <code>a</code> is lexicographically smaller than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears earlier in the alphabet than the corresponding letter in <code>b</code>. For example, <code>"aabd"</code> is lexicographically smaller than <code>"aaca"</code> because the first position they differ is at the third letter, and <code>'b'</code> comes before <code>'c'</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]\n<strong>Output:</strong> "abab"\n<strong>Explanation:</strong> lcp corresponds to any 4 letter string with two alternating letters. The lexicographically smallest of them is "abab".\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,1]]\n<strong>Output:</strong> "aaaa"\n<strong>Explanation:</strong> lcp corresponds to any 4 letter string with a single distinct letter. The lexicographically smallest of them is "aaaa". \n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> lcp = [[4,3,2,1],[3,3,2,1],[2,2,2,1],[1,1,1,3]]\n<strong>Output:</strong> ""\n<strong>Explanation:</strong> lcp[3][3] cannot be equal to 3 since word[3,...,3] consists of only a single letter; Thus, no answer exists.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n == </code><code>lcp.length == </code><code>lcp[i].length</code> <code><= 1000</code></li>\n\t<li><code><font face=\"monospace\">0 <= lcp[i][j] <= n</font></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":31.58609619065259,"string":"31.586096"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","string","dynamic-programming","greedy","union-find","matrix"],"string":"[\n \"array\",\n \"string\",\n \"dynamic-programming\",\n \"greedy\",\n \"union-find\",\n \"matrix\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1398\", 1.4286], [\"1424\", 1.4286], [\"1452\", 1.4286], [\"1453\", 1.4286], [\"1458\", 1.4286], [\"1466\", 1.4286], [\"1467\", 1.4286], [\"1483\", 1.4286], [\"1490\", 1.4286], [\"1494\", 1.4286], [\"1499\", 1.4286], [\"1507\", 1.4286], [\"1514\", 1.4286], [\"1519\", 1.4286], [\"1528\", 1.4286], [\"1530\", 2.8571], [\"1534\", 1.4286], [\"1537\", 1.4286], [\"1574\", 1.4286], [\"1575\", 1.4286], [\"1580\", 1.4286], [\"1592\", 1.4286], [\"1602\", 1.4286], [\"1633\", 1.4286], [\"1636\", 1.4286], [\"1639\", 2.8571], [\"1643\", 1.4286], [\"1644\", 1.4286], [\"1648\", 1.4286], [\"1653\", 1.4286], [\"1654\", 1.4286], [\"1655\", 1.4286], [\"1665\", 1.4286], [\"1667\", 1.4286], [\"1669\", 1.4286], [\"1675\", 2.8571], [\"1679\", 1.4286], [\"1682\", 1.4286], [\"1686\", 1.4286], [\"1687\", 1.4286], [\"1689\", 1.4286], [\"1693\", 1.4286], [\"1695\", 1.4286], [\"1700\", 1.4286], [\"1704\", 1.4286], [\"1707\", 1.4286], [\"1713\", 1.4286], [\"1717\", 1.4286], [\"1726\", 1.4286], [\"1729\", 1.4286], [\"1733\", 1.4286], [\"1737\", 2.8571], [\"1740\", 1.4286], [\"1746\", 2.8571], [\"1751\", 1.4286], [\"1781\", 1.4286], [\"1783\", 1.4286], [\"1836\", 1.4286], [\"1890\", 1.4286], [\"1893\", 1.4286], [\"1940\", 1.4286]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"76700\", 1.4286], [\"77400\", 4.2857], [\"77700\", 1.4286], [\"77800\", 1.4286], [\"77900\", 24.2857], [\"78000\", 38.5714], [\"78100\", 14.2857], [\"78200\", 5.7143], [\"78300\", 1.4286], [\"78600\", 1.4286]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\n # Second, we have:\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\n # := 0 otherwise\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\n n = len(lcp)\n ans = [None] * n\n cur = 0\n # Check the diagonal elements\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n # Check the symmetry of the matrix\n for i in range(n):\n for j in range(i):\n if lcp[i][j] != lcp[j][i]:\n return \"\"\n for ch in string.ascii_lowercase:\n # Start from the first unset one\n ans[cur] = ch\n for i in range(cur + 1, n):\n if ans[i] is not None:\n continue\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\n if lcp[cur][i] == nxt + 1:\n ans[i] = ch\n else:\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\n if lcp[cur][i] != 0:\n return \"\"\n while cur < n and ans[cur] is not None:\n cur += 1\n if cur == n:\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\n for i in range(n):\n for j in range(i):\n if ans[i] != ans[j] and lcp[i][j] != 0:\n return \"\"\n return \"\".join(ans)\n # Letters are used up.\n return \"\"","runtime":"1398"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\n # Second, we have:\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\n # := 0 otherwise\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\n n = len(lcp)\n ans = [None] * n\n cur = 0\n # Check the diagonal elements\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n # Check the symmetry of the matrix\n for i in range(n):\n for j in range(i):\n if lcp[i][j] != lcp[j][i]:\n return \"\"\n for ch in string.ascii_lowercase:\n # Start from the first unset one\n ans[cur] = ch\n for i in range(cur + 1, n):\n if ans[i] is not None:\n continue\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\n if lcp[cur][i] == nxt + 1:\n ans[i] = ch\n else:\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\n if lcp[cur][i] != 0:\n return \"\"\n while cur < n and ans[cur] is not None:\n cur += 1\n if cur == n:\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\n for i in range(n):\n for j in range(i):\n if ans[i] != ans[j] and lcp[i][j] != 0:\n return \"\"\n return \"\".join(ans)\n # Letters are used up.\n return \"\"","runtime":"1424"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n\n # build s\n s = ['' for _ in range(n)]\n c = 'a' # 'a' .... 'z'\n for i in range(n):\n if s[i] != '':\n continue\n if c > 'z': \n return \"\"\n s[i] = c\n for j in range(n):\n if lcp[i][j] > 0: # len(common_prefix(s[i:] , s[j:])) > 0\n s[j] = s[i] \n c = chr(ord(c) + 1)\n\n print(\"\".join(s))\n\n # validate last column and last row\n for i in range(n):\n if lcp[i][n - 1] != (s[i] == s[n-1]):\n return \"\"\n if lcp[n-1][i] != (s[i] == s[n-1]):\n return \"\"\n\n # validate rest of lcp: if s[i] == s[j] => lcp[i][j] = 1 + lcp[i+1][j+1]\n for i in range(n-1):\n for j in range(n-1):\n if s[i] == s[j]:\n if lcp[i][j] != 1 + lcp[i+1][j+1]: \n return \"\"\n else: # char at i and j are different => lcp[i][j] should be 0\n if lcp[i][j] != 0:\n return \"\"\n\n return \"\".join(s)","runtime":"1452"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n letters = [None] * n\n curr_l = 'a'\n \n for i in range(n):\n if lcp[i][i] != n-i: return \"\"\n lcp[i].append(0)\n \n for i in range(n):\n l = letters[i]\n if l is not None:\n for j in range(i+1, n):\n if lcp[i][j] != lcp[j][i]: return \"\"\n if lcp[i][j] and letters[j] != l: return \"\"\n else:\n if curr_l > 'z': return \"\"\n for j in range(i, n):\n if lcp[i][j] != lcp[j][i]: return \"\"\n if lcp[i][j]:\n if letters[j]:\n if letters[j] != curr_l: return \"\"\n else:\n letters[j] = curr_l\n curr_l = chr(ord(curr_l) + 1)\n \n \n for i in range(n-1):\n for j in range(i+1, n):\n if letters[i] == letters[j] and lcp[i][j]!=lcp[i+1][j+1]+1:\n return \"\"\n \n \n return ''.join(letters)","runtime":"1453"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n #Construct string\n s = [\"\" for i in range(len(lcp))]\n c = 'a'\n\n for i in range(len(lcp)):\n if s[i] != \"\":\n continue\n if c > 'z':\n return \"\"\n s[i] = c\n for j in range(len(lcp)):\n if lcp[i][j] > 0:\n s[j] = s[i]\n c = chr(ord(c)+1)\n\n #Validate string\n for i in range(len(lcp)):\n if lcp[i][len(lcp)-1] != (s[i]==s[len(lcp)-1]):\n return \"\"\n if lcp[len(lcp)-1][i] != (s[i]==s[len(lcp)-1]):\n return \"\"\n \n\n for i in range(len(lcp)-1):\n for j in range(len(lcp)-1):\n if s[i] == s[j]:\n if lcp[i][j] != 1+lcp[i+1][j+1]:\n return \"\"\n else:\n if lcp[i][j] != 0:\n return \"\"\n\n return \"\".join(s)","runtime":"1458"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s = [\"\"] * n\n i = 0\n for c in ascii_lowercase:\n while i < n and s[i]:\n i += 1\n if i == n:\n break\n for j in range(i, n):\n if lcp[i][j]:\n s[j] = c\n if \"\" in s:\n return \"\"\n for i in range(n - 1, -1, -1):\n for j in range(n - 1, -1, -1):\n if s[i] == s[j]:\n if i == n - 1 or j == n - 1:\n if lcp[i][j] != 1:\n return \"\"\n elif lcp[i][j] != lcp[i + 1][j + 1] + 1:\n return \"\"\n elif lcp[i][j]:\n return \"\"\n return \"\".join(s)","runtime":"1466"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\n # Second, we have:\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\n # := 0 otherwise\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\n n = len(lcp)\n ans = [None] * n\n cur = 0\n # Check the diagonal elements\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n # Check the symmetry of the matrix\n for i in range(n):\n for j in range(i):\n if lcp[i][j] != lcp[j][i]:\n return \"\"\n for ch in string.ascii_lowercase:\n # Start from the first unset one\n ans[cur] = ch\n for i in range(cur + 1, n):\n if ans[i] is not None:\n continue\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\n if lcp[cur][i] == nxt + 1:\n ans[i] = ch\n else:\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\n if lcp[cur][i] != 0:\n return \"\"\n while cur < n and ans[cur] is not None:\n cur += 1\n if cur == n:\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\n for i in range(n):\n for j in range(i):\n if ans[i] != ans[j] and lcp[i][j] != 0:\n return \"\"\n return \"\".join(ans)\n # Letters are used up.\n return \"\"","runtime":"1467"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n A = [0] * n\n c = 1\n for i in range(n):\n if A[i]: continue\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n A[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n if A[i]==A[j]:\n v=lcp[i+1][j+1] +1 if i+1<n and j+1<n else 1\n else:\n v=0\n if lcp[i][j] != v:\n return ''\n return ''.join([chr(ord('a')+i-1) for i in A])","runtime":"1483"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n res = ''\n if not check_valid_lcp(lcp):\n return ''\n\n for i in range(len(lcp)): \n exact = set()\n diff = set()\n for j in range(i):\n if lcp[i][j] > 0:\n exact.add(res[j])\n else:\n diff.add(res[j])\n if len(exact) > 1:\n return ''\n if len(exact) == 1:\n res += (list(exact)[0])\n if res[i] in diff:\n return ''\n if len(exact) == 0:\n c = choose_diff_char(diff)\n if c == '':\n return ''\n res += c\n\n return res\n\nalphabet = [chr(i+ ord('a')) for i in range(26)]\ndef choose_diff_char(diff):\n for c in alphabet:\n if c not in diff:\n return c\n return ''\n\ndef check_valid_lcp(lcp):\n for i in range(len(lcp)):\n if lcp[i][i] != len(lcp) - i:\n return False\n for j in range(i):\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > len(lcp) - i:\n return False\n if i == len(lcp)-1:\n next_value = 0\n else:\n next_value = lcp[i+1][j+1]\n\n if lcp[i][j] !=0 and lcp[i][j] != next_value+1:\n return False\n return True","runtime":"1490"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n A = [0] * n\n c = 1\n for i in range(n):\n if A[i]: continue\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n A[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n if A[i]==A[j]:\n v=lcp[i+1][j+1] +1 if i+1<n and j+1<n else 1\n else:\n v=0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + i - 1) for i in A)","runtime":"1494"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n idx = 0\n n = len(lcp)\n word = ['0' for _ in range(n)]\n for i in range(26):\n while idx < n and word[idx] != '0':\n idx += 1\n if idx == n:\n break\n for j in range(idx, n):\n if lcp[idx][j]:\n word[j] = chr(ord('a')+i)\n for i in range(n):\n if word[i] == '0':\n return \"\"\n # print(word)\n dp = [[0]*n for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if word[i] != word[j]:\n dp[i][j] = 0\n elif i == n-1 or j == n-1:\n dp[i][j] = 1\n else:\n dp[i][j] = dp[i+1][j+1] + 1\n if dp[i][j] != lcp[i][j]:\n return \"\"\n # print(dp)\n return ''.join(word) \n ","runtime":"1499"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n A = [0] * n\n c = 1\n for i in range(n):\n if A[i]: continue\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n A[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\n v = v + 1 if A[i] == A[j] else 0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + i - 1) for i in A)","runtime":"1507"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n res = [0] * n\n c = 1\n for i in range(n):\n if res[i] == 0:\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n res[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\n v = v + 1 if res[i] == res[j] else 0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + num - 1) for num in res)","runtime":"1514"},{"code":"class Solution:\n def findTheString(self, lcp: list[list[int]]) -> str:\n n = len(lcp)\n \n # start with the possibility that any letter can be placed anywhere\n s = ['abcdefghijklmnopqrstuvwxyz' for _ in range(n)] \n # storing this array takes O(26*n) = O(n) space.\n \n # arbitrarily assing the final letter in the string\n s[-1] = 'z'\n \n for row in range(n-1,-1,-1):\n for col in range(n-1, row-1, -1):\n # lcp has to be symmetric\n if lcp[row][col] != lcp[col][row]: return('')\n\n if row == col:\n # lcp[i][i] has to equal n-i\n if lcp[row][col] != n-row: return('')\n\n # once we have compared s[row] with s[row+1:] and eliminated all letters from the possible choices for s[row], we can freely assign one out of the remaining pool. If nothing remains in the pool, a valid string does not exist.\n if len(s[row]): s[row] = s[row][-1]\n else: return('')\n continue\n \n c = s[col]\n \n # if lcp[row][col] is zero, we remove s[col] from the list of possible letters for s[row]\n if lcp[row][col] == 0:\n if s[row][-1] == c: s[row] = s[row][:-1]\n if not s[row]: return('')\n continue\n \n # if lcp[i][j] is nonzero then it must equal lcp[i+1][j+1] + 1 \n if lcp[row][col] > min(n-row, n-col): return('')\n if col < n-1 and lcp[row+1][col+1] != lcp[row][col]-1: return('')\n \n # once all these checks have been passed and lcp[row][col] is nonzero, we can safely assign s[row] to be equal to s[col]\n if c not in s[row]: return('')\n else: s[row] = c\n \n # from the existing string s (a list of characters at the momen), generate the lexicographically smallest one\n sub = 26*[None]\n newLetter = 'a'\n for i, c in enumerate(s):\n if sub[ord(c)-ord('a')] is None:\n sub[ord(c)-ord('a')] = newLetter\n s[i] = newLetter\n newLetter = chr(ord(newLetter)+1)\n else:\n s[i] = sub[ord(s[i])-ord('a')]\n \n return(''.join(s))","runtime":"1519"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n A = [0] * n\n c = 1\n for i in range(n):\n if A[i]: continue\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n A[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\n v = v + 1 if A[i] == A[j] else 0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + i - 1) for i in A)","runtime":"1528"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # 1. Identifying if the LCP matrix is valid.\n # 2. Creating an output string.\n # 3. Check validity?? Why do we need to do this?\n\n # Matrix validity.\n # First position should always be the length of lcp.\n if lcp[0][0] != len(lcp):\n return \"\"\n \n # It should be a symmetrical matrix with the diagonal\n # in decreasing order.\n # Also the number at each col should be less than or equal\n # to the remaining number of letters.\n n = lcp[0][0]\n for i in range(n):\n if lcp[i][i] != n-i:\n return \"\"\n\n for j in range(i+1, n):\n if lcp[i][j] != lcp[j][i]:\n return \"\"\n\n if lcp[i][j] > n-j:\n return \"\"\n \n if lcp[i][j] != 0 and i<n-1 and j<n-1 and lcp[i][j] != lcp[i+1][j+1] + 1:\n return \"\"\n\n result = [None] * n\n letter = chr(ord(\"a\") - 1)\n\n for i in range(n):\n if result[i] is None:\n letter = chr(ord(letter) + 1) \n if letter > \"z\":\n return \"\"\n result[i] = letter\n\n for j in range(i+1, n):\n if lcp[i][j] != 0:\n if result[j] is None:\n result[j] = letter\n else: # Check that letters in position i and j are the same.\n if result[i] != result[j]:\n return \"\"\n\n for i in range(n):\n for j in range(i+1, n):\n # Check for contradictions once all the letters are filled.\n if lcp[i][j] == 0 and result[i] == result[j]:\n return \"\"\n\n return \"\".join(result)","runtime":"1530"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n ans = []\n for i in range(n): \n tabu = set()\n for j in range(i): \n if lcp[i][j]: \n ans.append(ans[j])\n break\n else: tabu.add(ans[j])\n else: \n for ch in ascii_lowercase: \n if ch not in tabu: \n ans.append(ch)\n break\n else: return \"\"\n dp = [[0]*n for _ in range(n)]\n for i in range(n-1, -1, -1): \n for j in range(n-1, -1, -1): \n if ans[i] == ans[j]: \n if i == n-1 or j == n-1: dp[i][j] = 1\n else: dp[i][j] = 1 + dp[i+1][j+1]\n if dp[i][j] != lcp[i][j]: return \"\"\n return \"\".join(ans) ","runtime":"1534"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n ans = []\n for i in range(n): \n tabu = set()\n for j in range(i): \n if lcp[i][j]: \n ans.append(ans[j])\n break\n else: tabu.add(ans[j])\n else: \n for ch in ascii_lowercase: \n if ch not in tabu: \n ans.append(ch)\n break\n else: return \"\"\n dp = [[0]*n for _ in range(n)]\n for i in range(n-1, -1, -1): \n for j in range(n-1, -1, -1): \n if ans[i] == ans[j]: \n if i == n-1 or j == n-1: dp[i][j] = 1\n else: dp[i][j] = 1 + dp[i+1][j+1]\n if dp[i][j] != lcp[i][j]: return \"\"\n return \"\".join(ans)","runtime":"1537"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n return findTheString(lcp)\n\n\ndef findTheString(lcp: list[list[int]]) -> str:\n assert len(lcp) > 0\n assert len(lcp) == len(lcp[0])\n size = len(lcp)\n\n def isTrans(matrix: list[list[int]]) -> bool:\n for r in range(size):\n for c in range(r + 1, size):\n if matrix[r][c] != matrix[c][r]:\n return False\n return True\n\n def reduceCheck(lcp: list[list[int]]) -> bool:\n if lcp[0][0] != size:\n return False\n for r in range(size):\n for c in range(r, size):\n lspLen = lcp[r][c]\n if lspLen == 0:\n continue\n if lspLen > size - c or lspLen > size - r:\n return False\n if lspLen >= 1 and c + 1 < size and lspLen != lcp[r + 1][c + 1] + 1:\n return False\n return True\n\n if not isTrans(lcp) or not reduceCheck(lcp):\n return \"\"\n\n chars = range(26)\n word: dict[int, int] = {}\n for idx in range(size):\n invalids = set(word[i] for i in range(idx) if lcp[i][idx] == 0)\n sameAs = set(word[i] for i in range(idx) if lcp[i][idx] > 0)\n if len(sameAs) > 1:\n return \"\"\n if len(sameAs) == 1 and len(invalids.intersection(sameAs)) != 0:\n return \"\"\n if len(sameAs) == 1:\n word[idx] = sameAs.pop()\n selected = next((c for c in chars if c not in invalids), None)\n if selected is None:\n return \"\"\n word[idx] = selected\n\n return \"\".join(chr(ord(\"a\") + word[i]) for i in range(size))\n\n\n\"\"\"\n- Diagonal must be n, n-1, ..., 1, according to definition\n- Must M == transpose(M)\n\nabab\n bab\n\n4 0 2 0\n0 3 0 1\n2 0 2 0\n0 1 0 1\n\naab\n\n3 1 0\n 2 0\n 1\n\naaa\n\n3 2 1 \n 2 1\n 1\n\nabaab\n\n5 0 1 2 0\n 4 0 0 1\n 3 1 0\n 2 0\n 1\n\nabca\n\n4 0 0 1\n 3 0 0\n 2 0\n 1\n\nabcabcab\n\n8 0 0 5 0 0 2 0\n 7 0 0 4 0 0 1\n 6 0 0 3 0 0\n 5 0 0 2 0\n 4 0 0 1\n 3 0 0\n 2 0\n 1\n\nabcab\n5 0 0 2 0\n 4 0 0 1\n 3 0 0 \n 2 0 \n 1\n\nabb\n\n3 0 0\n 2 1\n\naba\n3 0 1\n 2 0\n 1\n\nabc\n3 0 0\n 2 1\n 1\n\nabbb\n4 0 0 0\n 3 2 1\n 2 1\n 1\n\nabcd...z\n26 0 ... 0\n 25 0 ... 0\n 24\n ...\n\"\"\"\n","runtime":"1574"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n max_alpha = ord('a')\n groups = list(range(n))\n not_equal = []\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return \"\"\n if i > 0 and ((lcp[i-1][j-1] > 0 and lcp[i][j] != lcp[i-1][j-1] - 1)):\n return \"\"\n if lcp[i][j] > n - i or lcp[i][j] > n - j:\n return \"\"\n if lcp[i][j] > 0:\n if groups[j] != j and groups[j] != groups[i]:\n return \"\"\n groups[j] = groups[i]\n else:\n not_equal.append((i, j))\n assignments = {}\n s = []\n for v in groups:\n if v not in assignments:\n assignments[v] = chr(max_alpha)\n if not assignments[v].isalpha():\n return \"\"\n max_alpha += 1\n s.append(assignments[v])\n if any(s[i] == s[j] for i, j in not_equal):\n return \"\" \n return \"\".join(s)","runtime":"1575"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # lcp[i][j] = lcp[i-1][j-1] + 1 if s[i] == s[j] else 0\n # [3:4] == [1:2]\n # 1 != 2\n # 3 != 2\n # 1 != 4\n # 3 != 4\n n = len(lcp)\n\n # ord(a) == 97\n s = ['a' for i in range(n)]\n \n for i in range(n):\n for j in range(i):\n if lcp[i][j] == 0:\n if s[i] == s[j]:\n s[i] = chr(ord(s[i])+1)\n \n s = ''.join(s)\n if any(ord(c) > ord('z') for c in s):\n return ''\n\n lcp2 = [[0 for i in range(n+1)] for j in range(n+1)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n lcp2[i][j] = lcp2[i+1][j+1] + 1 if s[i]==s[j] else 0\n for i in range(n):\n for j in range(n):\n if lcp2[i][j] != lcp[i][j]:\n return ''\n return s","runtime":"1580"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n ans = ['']*n\n\n i = 0\n for c in ascii_lowercase: \n while i < n and ans[i]: \n i += 1\n if i == n:\n break\n for j in range(i, n):\n if lcp[i][j]:\n ans[j] = c\n\n if \"\" in ans:\n return ''\n\n for i in range(n-1, -1, -1): \n for j in range(n-1, -1, -1): \n if ans[i] == ans[j]: \n if i == n-1 or j == n-1:\n if lcp[i][j] != 1:\n return ''\n elif lcp[i][j] != lcp[i+1][j+1] + 1:\n return ''\n else:\n if lcp[i][j]:\n return ''\n\n return ''.join(ans)","runtime":"1592"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n \n grid = [[] * n for _ in range(n)]\n for i in range(n):\n if lcp[i][i] != (n - i):\n return ''\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n d = lcp[i][j]\n if d > (n - max(i, j)):\n return ''\n if d > 0:\n if (j + 1) < n and lcp[i + 1][j + 1] != (d - 1):\n return ''\n grid[i].append(j)\n grid[j].append(i)\n\n # dfs and build connected graph.\n ts = [0] * n\n\n def dfs(x, now):\n if ts[x] != 0:\n return ts[x] == now\n ts[x] = now\n for y in grid[x]:\n if not dfs(y, now):\n return False\n return True\n\n now = 1\n for i in range(n):\n if ts[i]: continue\n # too much connected graphs.\n if now > 26: return ''\n if not dfs(i, now):\n return ''\n now += 1\n\n ans = [''] * n\n for i in range(n):\n ans[i] = chr(ord('a') + ts[i] - 1)\n ans = ''.join(ans)\n\n \n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] == 0 and ans[i] == ans[j]:\n return ''\n\n return ans","runtime":"1602"},{"code":"\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern - fix syntax error\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n): # fix syntax error\n if lcp[i][j] > 0: # fix syntax error\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)\n","runtime":"1633"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","runtime":"1636"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1639"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1639"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1643"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]: \n return '' \n pattern[j] = pattern[i]\n\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)\n","runtime":"1644"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","runtime":"1648"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","runtime":"1653"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1654"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","runtime":"1655"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern — the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1665"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","runtime":"1667"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1669"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1675"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1679"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1682"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1686"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n uf = [i for i in range(n)]\n \n def find(x):\n if uf[x] == x:\n return x\n uf[x] = find(uf[x])\n return uf[x]\n \n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\n for i in range(n):\n # bc symbols are equal to themselves\n if lcp[i][i] + i != n:\n return \"\"\n for j in range(i + 1, n):\n # border and symmetry check\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\n return \"\"\n \n if lcp[i][j]:\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\n return \"\"\n \n uf[i] = uf[j] = min(find(i), find(j))\n \n # Step 2: Check all conditions fulfilled and self-consistent.\n for i in range(n):\n for j in range(i + 1, n):\n # cases: need to be unequal, but in reality opposite\n if lcp[i][j] == 0 and find(i) == find(j):\n return \"\"\n # if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\n # return \"\"\n \n # Step 3: Use union find structure to fill answer with chars.\n ret = [None] * n\n letter = 97 # ASCII code of 'a' letter\n for i in range(len(ret)):\n val = find(i)\n if ret[val] is not None:\n ret[i] = ret[val]\n else:\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\n if letter == 123:\n return \"\"\n ret[i] = chr(letter)\n letter += 1\n return ''.join(ret)","runtime":"1687"},{"code":"class UnionFind: \n def __init__(self, n):\n self.parents = [i for i in range (n)]\n self.ranks = [0 for i in range (n)]\n def find(self, u):\n if self.parents[u] != u:\n self.parents[u] = self.find(self.parents[u])\n return self.parents[u]\n def union(self, u, v):\n par_u = self.find(u)\n par_v = self.find(v)\n if par_u == par_v:\n return \n if self.ranks[par_u] <= self.ranks[par_v]:\n self.parents[par_u] = par_v\n if self.ranks[par_u] == self.ranks[par_v]:\n self.ranks[par_v] += 1\n else:\n self.parents[par_v] = par_u\nclass Solution:\n def findTheString(self, matrix: List[List[int]]) -> str:\n n = len(matrix)\n union = UnionFind(n)\n for i in range (n):\n if matrix[i][i] + i != n:\n return \"\"\n for j in range (i + 1, n):\n if matrix[i][j] != matrix[j][i]:\n return \"\"\n if matrix[i][j] + j > n:\n return \"\"\n if matrix[i][j] > 0:\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\n return \"\"\n union.union(i, j)\n for i in range (n):\n for j in range (i + 1, n):\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\n return \"\"\n \n cur_char_ord = ord(\"a\")\n res = []\n d = dict()\n for i in range (n):\n key = union.find(i)\n if key not in d:\n if cur_char_ord > ord(\"z\"):\n return \"\"\n d[key] = chr(cur_char_ord)\n cur_char_ord += 1\n \n res.append(d[key])\n \n return \"\".join(res)","runtime":"1689"},{"code":"\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern — the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)\n","runtime":"1693"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1695"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","runtime":"1700"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # O(n^2)\n equal = [[None] * len(lcp) for _ in range(len(lcp))]\n for i, r in enumerate(lcp):\n for j, v in enumerate(r):\n if equal[i][j] is not None: # (i, j) in previously added diagonal\n if equal[i][j] is True:\n if lcp[i][j] + 1 != lcp[i - 1][j - 1]:\n # impossible\n print(\"impossible positive\", i, j)\n return \"\"\n else:\n if lcp[i][j] > 0 or lcp[i - 1][j - 1] > 1:\n print(\"impossible negative\", i, j)\n return \"\"\n else:\n if i + v > len(lcp) or j + v > len(lcp):\n print(\"diagonal too long\", i, j)\n return \"\"\n for k in range(0, v):\n equal[i+k][j+k] = True\n if i + v < len(lcp) and j + v < len(lcp):\n equal[i+v][j+v] = False\n\n for i in range(len(lcp)):\n for j in range(len(lcp)):\n if equal[i][j] != equal[j][i]:\n return \"\"\n \n for row in equal:\n print(row)\n \n answer = [None] * len(lcp)\n for letter in \"abcdefghijklmnopqrstuvwxyz\":\n first_none_idx = None\n for i, x in enumerate(answer):\n if x is None:\n first_none_idx = i\n break\n if first_none_idx is None:\n break\n for j in range(0, len(lcp)):\n if equal[first_none_idx][j]:\n if answer[j] is not None:\n return \"\"\n answer[j] = letter\n for x in answer:\n if x is None:\n return \"\"\n return \"\".join(answer)\n\n #\n # up to 1000, 1e6 pairs","runtime":"1704"},{"code":"class UnionFind: \n def __init__(self, n):\n self.parents = [i for i in range (n)]\n self.ranks = [0 for i in range (n)]\n def find(self, u):\n if self.parents[u] != u:\n self.parents[u] = self.find(self.parents[u])\n return self.parents[u]\n def union(self, u, v):\n par_u = self.find(u)\n par_v = self.find(v)\n if par_u == par_v:\n return \n if self.ranks[par_u] <= self.ranks[par_v]:\n self.parents[par_u] = par_v\n if self.ranks[par_u] == self.ranks[par_v]:\n self.ranks[par_v] += 1\n else:\n self.parents[par_v] = par_u\nclass Solution:\n def findTheString(self, matrix: List[List[int]]) -> str:\n n = len(matrix)\n union = UnionFind(n)\n for i in range (n):\n if matrix[i][i] + i != n:\n return \"\"\n for j in range (i + 1, n):\n if matrix[i][j] != matrix[j][i]:\n return \"\"\n if matrix[i][j] + j > n:\n return \"\"\n if matrix[i][j] > 0:\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\n return \"\"\n union.union(i, j)\n for i in range (n):\n for j in range (i + 1, n):\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\n return \"\"\n \n cur_char_ord = ord(\"a\")\n res = []\n d = dict()\n for i in range (n):\n key = union.find(i)\n if key not in d:\n if cur_char_ord > ord(\"z\"):\n return \"\"\n d[key] = chr(cur_char_ord)\n cur_char_ord += 1\n \n res.append(d[key])\n \n return \"\".join(res)","runtime":"1707"},{"code":"class UnionFind: \n def __init__(self, n):\n self.parents = [i for i in range (n)]\n self.ranks = [0 for i in range (n)]\n def find(self, u):\n if self.parents[u] != u:\n self.parents[u] = self.find(self.parents[u])\n return self.parents[u]\n def union(self, u, v):\n par_u = self.find(u)\n par_v = self.find(v)\n if par_u == par_v:\n return \n if self.ranks[par_u] <= self.ranks[par_v]:\n self.parents[par_u] = par_v\n if self.ranks[par_u] == self.ranks[par_v]:\n self.ranks[par_v] += 1\n else:\n self.parents[par_v] = par_u\nclass Solution:\n def findTheString(self, matrix: List[List[int]]) -> str:\n n = len(matrix)\n union = UnionFind(n)\n for i in range (n):\n if matrix[i][i] + i != n:\n return \"\"\n for j in range (i + 1, n):\n if matrix[i][j] != matrix[j][i]:\n return \"\"\n if matrix[i][j] + i > n:\n return \"\"\n if matrix[i][j] + j > n:\n return \"\"\n if matrix[i][j] > 0:\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\n return \"\"\n union.union(i, j)\n for i in range (n):\n for j in range (i + 1, n):\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\n return \"\"\n \n cur_char_ord = ord(\"a\")\n res = []\n d = dict()\n for i in range (n):\n key = union.find(i)\n if key not in d:\n if cur_char_ord > ord(\"z\"):\n return \"\"\n d[key] = chr(cur_char_ord)\n cur_char_ord += 1\n \n res.append(d[key])\n \n return \"\".join(res)","runtime":"1713"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n \n for ea in range(len(lcp)):\n \n for jh in range(len(lcp[0])):\n if lcp[ea][jh] != lcp[jh][ea]:\n return ''\n for ea in range(len(lcp)):\n leng = len(lcp) - ea\n if lcp[ea][ea] != leng:\n return ''\n \n quiq = True\n for jh in range(len(lcp)):\n thesis = lcp[jh][jh:]\n \n donk = thesis[::-1]\n if donk != [1 + i for i in range(len(donk))]:\n quiq = False\n if quiq:\n return 'a'*len(lcp)\n \n not_equal = defaultdict(set)\n \n equal = defaultdict(set)\n \n for ea in range(len(lcp)):\n \n for jh in range(len(lcp[0])):\n if lcp[ea][jh] != lcp[jh][ea]:\n return ''\n \n for ea in range(len(lcp)):\n for jh in range(ea, len(lcp)):\n \n end = lcp[ea][jh]\n \n if end + jh> len(lcp):\n return ''\n if ea == jh:\n continue\n \n \n \n for sk in range(lcp[ea][jh]):\n equal[sk + ea].add(sk + jh)\n equal[sk + jh].add(sk + ea)\n \n if end < len(lcp):\n end = lcp[ea][jh]\n\n not_equal[jh + end].add(ea + end)\n not_equal[ea + end].add(jh + end)\n \n if all([len(list(not_equal[j])) == 0 for j in list(not_equal.keys())]):\n return 'a' * len(lcp)\n \n print(equal, not_equal)\n \n \n for ea in equal.keys():\n \n basis = list(equal[ea])\n print(basis)\n for nth in range(len(basis)):\n for kth in range(nth + 1, len(basis)):\n \n n = basis[nth]\n k = basis[kth]\n \n if n in not_equal[k] or k in not_equal[n]:\n \n return ''\n for jh in not_equal.keys():\n if ea == jh:\n for jh in equal[ea]:\n if jh in not_equal[ea]:\n return ''\n basis = ['a' for i in range(len(lcp))]\n \n \n alpha = 'abcdefghijklmnopqrstuvwxyz'\n \n \n \n for ea in range(len(basis)):\n \n if len(equal[ea]) > 0:\n if min(equal[ea]) < ea:\n basis[ea] = basis[min(equal[ea])]\n print('hit')\n continue\n basils = [i for i in not_equal[ea] if i < ea]\n donks = list([i for i in alpha])\n for jh in basils:\n\n \n if basis[jh] in donks:\n donks.remove(basis[jh])\n if len(donks) == 0:\n return ''\n basis[ea] = min(donks)\n \n return ''.join(basis)\n \n","runtime":"1717"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n p = [i for i in range(n)]\n def find(x):\n if x!=p[x]:\n p[x] = find(p[x])\n return p[x]\n \n for i in range(n-1,-1,-1):\n for j in range(i,-1,-1):\n if i == j and lcp[i][j]!=n-i:return \"\"\n if i!=j:\n if lcp[i][j]!=lcp[j][i]: return \"\"\n if lcp[i][j]>0:\n pi,pj = sorted([find(i),find(j)])\n if pi!=pj:\n p[pj] = pi\n #print([find(i) for i in range(n)])\n ff = [find(i) for i in range(n)]\n res = ''\n dic = {}\n unused = 0\n for i in range(n):\n if ff[i] in dic:\n res += dic[ff[i]]\n else:\n if unused >= 26: return ''\n dic[ff[i]] = chr(ord('a')+unused)\n unused += 1\n res += dic[ff[i]]\n for i in range(n):\n for j in range(i+1,n):\n a = lcp[i][j]\n if res[i:i+a]!=res[j:j+a]:return ''\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\n\n return res\n \n\n \n \n\n ","runtime":"1726"},{"code":"class UnionFind: \n def __init__(self, n):\n self.parents = [i for i in range (n)]\n self.ranks = [0 for i in range (n)]\n def find(self, u):\n if self.parents[u] != u:\n self.parents[u] = self.find(self.parents[u])\n return self.parents[u]\n def union(self, u, v):\n par_u = self.find(u)\n par_v = self.find(v)\n if par_u == par_v:\n return \n if self.ranks[par_u] <= self.ranks[par_v]:\n self.parents[par_u] = par_v\n if self.ranks[par_u] == self.ranks[par_v]:\n self.ranks[par_v] += 1\n else:\n self.parents[par_v] = par_u\nclass Solution:\n def findTheString(self, matrix: List[List[int]]) -> str:\n n = len(matrix)\n union = UnionFind(n)\n for i in range (n):\n if matrix[i][i] + i != n:\n return \"\"\n for j in range (i + 1, n):\n if matrix[i][j] != matrix[j][i]:\n return \"\"\n if matrix[i][j] + j > n:\n return \"\"\n if matrix[i][j] > 0:\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\n return \"\"\n union.union(i, j)\n for i in range (n):\n for j in range (i + 1, n):\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\n return \"\"\n \n cur_char_ord = ord(\"a\")\n res = []\n d = dict()\n for i in range (n):\n key = union.find(i)\n if key not in d:\n if cur_char_ord > ord(\"z\"):\n return \"\"\n d[key] = chr(cur_char_ord)\n cur_char_ord += 1\n \n res.append(d[key])\n \n return \"\".join(res)","runtime":"1729"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n uf = [i for i in range(n)]\n \n def find(x):\n if uf[x] == x:\n return x\n uf[x] = find(uf[x])\n return uf[x]\n \n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\n for i in range(n):\n # bc symbols are equal to themselves\n if lcp[i][i] + i != n:\n return \"\"\n for j in range(i + 1, n):\n # border and symmetry check\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\n return \"\"\n \n if lcp[i][j]:\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\n return \"\"\n \n uf[i] = uf[j] = min(find(i), find(j))\n \n # Step 2: Check all conditions fulfilled and self-consistent.\n for i in range(n):\n for j in range(i + 1, n):\n # cases: need to be unequal, but in reality opposite\n if lcp[i][j] == 0 and find(i) == find(j):\n return \"\"\n if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\n return \"\"\n \n # Step 3: Use union find structure to fill answer with chars.\n ret = [None] * n\n letter = 97 # ASCII code of 'a' letter\n for i in range(len(ret)):\n val = find(i)\n if ret[val] is not None:\n ret[i] = ret[val]\n else:\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\n if letter == 123:\n return \"\"\n ret[i] = chr(letter)\n letter += 1\n return ''.join(ret)","runtime":"1733"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n p = [i for i in range(n)]\n def find(x):\n if x!=p[x]:\n p[x] = find(p[x])\n return p[x]\n \n for i in range(n-1,-1,-1):\n for j in range(i,-1,-1):\n if i == j and lcp[i][j]!=n-i:return \"\"\n if i!=j:\n if lcp[i][j]!=lcp[j][i]: return \"\"\n if lcp[i][j]>0:\n pi,pj = sorted([find(i),find(j)])\n if pi!=pj:\n p[pj] = pi\n ff = [find(i) for i in range(n)]\n res = ''\n dic = {}\n unused = 0\n for i in range(n):\n if ff[i] in dic:\n res += dic[ff[i]]\n else:\n if unused >= 26: return ''\n dic[ff[i]] = chr(ord('a')+unused)\n unused += 1\n res += dic[ff[i]]\n for i in range(n):\n for j in range(i+1,n):\n a = lcp[i][j]\n if res[i:i+a]!=res[j:j+a]:return ''\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\n\n return res\n \n\n \n \n\n ","runtime":"1737"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n uf = [i for i in range(n)]\n \n def find(x):\n if uf[x] == x:\n return x\n uf[x] = find(uf[x])\n return uf[x]\n \n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\n for i in range(n):\n # bc symbols are equal to themselves\n if lcp[i][i] + i != n:\n return \"\"\n for j in range(i + 1, n):\n # border and symmetry check\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\n return \"\"\n \n if lcp[i][j]:\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\n return \"\"\n \n uf[i] = uf[j] = min(find(i), find(j))\n \n # Step 2: Check all conditions fulfilled and self-consistent.\n for i in range(n):\n for j in range(i + 1, n):\n # cases: need to be unequal, but in reality opposite\n if lcp[i][j] == 0 and find(i) == find(j):\n return \"\"\n if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\n return \"\"\n \n # Step 3: Use union find structure to fill answer with chars.\n ret = [None] * n\n letter = 97 # ASCII code of 'a' letter\n for i in range(len(ret)):\n val = find(i)\n if ret[val] is not None:\n ret[i] = ret[val]\n else:\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\n if letter == 123:\n return \"\"\n ret[i] = chr(letter)\n letter += 1\n return ''.join(ret)","runtime":"1740"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n p = [i for i in range(n)]\n def find(x):\n if x!=p[x]:\n p[x] = find(p[x])\n return p[x]\n \n for i in range(n-1,-1,-1):\n for j in range(i,-1,-1):\n if i == j and lcp[i][j]!=n-i:return \"\"\n if i!=j:\n if lcp[i][j]!=lcp[j][i]: return \"\"\n if lcp[i][j]>0:\n pi,pj = sorted([find(i),find(j)])\n if pi!=pj:\n p[pj] = pi\n ff = [find(i) for i in range(n)]\n res = ''\n dic = {}\n unused = 0\n for i in range(n):\n if ff[i] in dic:\n res += dic[ff[i]]\n else:\n if unused >= 26: return ''\n dic[ff[i]] = chr(ord('a')+unused)\n unused += 1\n res += dic[ff[i]]\n for i in range(n):\n for j in range(i+1,n):\n a = lcp[i][j]\n if res[i:i+a]!=res[j:j+a]:return ''\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\n\n return res\n \n\n \n \n\n ","runtime":"1746"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n p = [i for i in range(n)]\n def find(x):\n if x!=p[x]:\n p[x] = find(p[x])\n return p[x]\n \n for i in range(n-1,-1,-1):\n for j in range(i,-1,-1):\n if i == j and lcp[i][j]!=n-i:return \"\"\n if i!=j:\n if lcp[i][j]!=lcp[j][i]: return \"\"\n if lcp[i][j]>0:\n pi,pj = sorted([find(i),find(j)])\n if pi!=pj:\n p[pj] = pi\n ff = [find(i) for i in range(n)]\n res = ''\n dic = {}\n unused = 0\n for i in range(n):\n if ff[i] in dic:\n res += dic[ff[i]]\n else:\n if unused >= 26: return ''\n dic[ff[i]] = chr(ord('a')+unused)\n unused += 1\n res += dic[ff[i]]\n for i in range(n):\n for j in range(i+1,n):\n a = lcp[i][j]\n if res[i:i+a]!=res[j:j+a]:return ''\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\n\n return res\n \n\n \n \n\n ","runtime":"1751"},{"code":"class Solution:\n def findTheString(self, lcp):\n n = len(lcp)\n\n dict1 = defaultdict(int)\n\n def find(x):\n if x not in dict1:\n return x\n else:\n if x != dict1[x]:\n dict1[x] = find(dict1[x])\n return dict1[x]\n\n def union(x,y):\n a,b = find(x),find(y)\n\n if a > b:\n dict1[a] = b\n else:\n dict1[b] = a\n\n for i in range(n):\n for j in range(i):\n if lcp[i][j]: union(i,j)\n\n ans = [find(i) for i in range(n)]\n\n for i in range(n):\n for j in range(n):\n val = lcp[i+1][j+1] if i+1 < n and j+1 < n else 0\n val = val + 1 if ans[i] == ans[j] else 0\n if val != lcp[i][j]:\n return \"\"\n\n group = set(ans)\n if len(group) > 26: return \"\"\n dict2 = {x:i for i,x in enumerate(sorted(group))}\n\n res = []\n\n for i,k in enumerate(ans):\n res.append(chr(97+dict2[k]))\n\n return \"\".join(res)","runtime":"1781"},{"code":"class DSU:\n def __init__(self, n):\n self.n = n\n self.p = [i for i in range(n)]\n self.r = [0 for _ in range(n)]\n \n def find(self, u):\n if self.p[u] != u:\n self.p[u] = self.find(self.p[u])\n return self.p[u]\n \n def union(self, u, v):\n pu, pv = self.find(u), self.find(v)\n if pu == pv:\n return\n ru, rv = self.r[pu], self.r[pv]\n if ru > rv:\n self.p[pv] = pu\n elif ru < rv:\n self.p[pu] = pv\n else:\n self.p[pv] = pu\n self.r[pu] += 1\n\n\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp) \n dsu = DSU(n)\n ban = set()\n\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > n - j or lcp[i][j] > n - i:\n return \"\"\n\n size = lcp[i][j]\n\n if size == 0:\n ban.add((i, j))\n \n else:\n for k in range(size):\n if dsu.find(i + k) == dsu.find(j + k):\n break\n if (i + k, j + k) in ban:\n return \"\"\n dsu.union(i + k, j + k)\n\n if j + size < n:\n if dsu.find(i + size) == dsu.find(j + size):\n return \"\"\n ban.add((i + size, j + size))\n \n for i, j in ban:\n if dsu.find(i) == dsu.find(j):\n return \"\"\n\n res = [\"\" for _ in range(n)]\n candidate = ord(\"a\")\n for i in range(n):\n p = dsu.find(i)\n if res[p]:\n res[i] = res[p]\n else:\n if candidate > ord(\"z\"):\n return \"\"\n res[i] = res[p] = chr(candidate)\n candidate += 1\n\n return \"\".join(res)\n ","runtime":"1783"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n t = [i for i in range(len(lcp))]\n for i in range(len(lcp)):\n for j in range(i+1, len(lcp)):\n if lcp[i][j] != 0: t[j] = t[i]\n res = \"\"\n d = {}\n for i in range(len(t)): \n if t[i] in d: pass\n elif len(d.keys()) < 26:\n d[t[i]] = chr(len(d.keys())+97)\n else: return \"\"\n res += d[t[i]]\n for i in range(len(lcp)):\n for j in range(len(lcp)):\n if i+lcp[i][j]>len(res) or j+lcp[i][j] > len(res) or res[i:i+lcp[i][j]] != res[j:j+lcp[i][j]]:\n return \"\"\n if i+lcp[i][j]+1 <= len(res) and j+lcp[i][j]+1 <= len(res) and (res[i:i+lcp[i][j]+1] == res[j:j+lcp[i][j]+1]):\n return \"\"\n return res","runtime":"1893"},{"code":"class DSU:\n def __init__(self, n):\n self.n = n\n self.p = [i for i in range(n)]\n self.r = [0 for _ in range(n)]\n \n def find(self, u):\n if self.p[u] != u:\n self.p[u] = self.find(self.p[u])\n return self.p[u]\n \n def union(self, u, v):\n pu, pv = self.find(u), self.find(v)\n if pu == pv:\n return\n ru, rv = self.r[pu], self.r[pv]\n if ru > rv:\n self.p[pv] = pu\n elif ru < rv:\n self.p[pu] = pv\n else:\n self.p[pv] = pu\n self.r[pu] += 1\n\n\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp) \n dsu = DSU(n)\n ban = set()\n\n for i in range(n):\n if lcp[i][i] != n - i:\n return \"\"\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > n - j or lcp[i][j] > n - i:\n return \"\"\n\n size = lcp[i][j]\n\n if size == 0:\n ban.add((i, j))\n\n for k in range(size):\n if dsu.find(i + k) == dsu.find(j + k):\n break\n if (i + k, j + k) in ban:\n return \"\"\n dsu.union(i + k, j + k)\n\n if j + size < n:\n if dsu.find(i + size) == dsu.find(j + size):\n return \"\"\n ban.add((i + size, j + size))\n \n for i, j in ban:\n if dsu.find(i) == dsu.find(j):\n return \"\"\n\n res = [\"\" for _ in range(n)]\n candidate = ord(\"a\")\n for i in range(n):\n p = dsu.find(i)\n if res[p]:\n res[i] = res[p]\n else:\n if candidate > ord(\"z\"):\n return \"\"\n res[i] = res[p] = chr(candidate)\n candidate += 1\n\n return \"\".join(res)\n ","runtime":"1940"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\\n # Second, we have:\\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\\n # := 0 otherwise\\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\\n n = len(lcp)\\n ans = [None] * n\\n cur = 0\\n # Check the diagonal elements\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n # Check the symmetry of the matrix\\n for i in range(n):\\n for j in range(i):\\n if lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n for ch in string.ascii_lowercase:\\n # Start from the first unset one\\n ans[cur] = ch\\n for i in range(cur + 1, n):\\n if ans[i] is not None:\\n continue\\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\\n if lcp[cur][i] == nxt + 1:\\n ans[i] = ch\\n else:\\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\\n if lcp[cur][i] != 0:\\n return \\\"\\\"\\n while cur < n and ans[cur] is not None:\\n cur += 1\\n if cur == n:\\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\\n for i in range(n):\\n for j in range(i):\\n if ans[i] != ans[j] and lcp[i][j] != 0:\\n return \\\"\\\"\\n return \\\"\\\".join(ans)\\n # Letters are used up.\\n return \\\"\\\"\",\n \"runtime\": \"1398\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\\n # Second, we have:\\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\\n # := 0 otherwise\\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\\n n = len(lcp)\\n ans = [None] * n\\n cur = 0\\n # Check the diagonal elements\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n # Check the symmetry of the matrix\\n for i in range(n):\\n for j in range(i):\\n if lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n for ch in string.ascii_lowercase:\\n # Start from the first unset one\\n ans[cur] = ch\\n for i in range(cur + 1, n):\\n if ans[i] is not None:\\n continue\\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\\n if lcp[cur][i] == nxt + 1:\\n ans[i] = ch\\n else:\\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\\n if lcp[cur][i] != 0:\\n return \\\"\\\"\\n while cur < n and ans[cur] is not None:\\n cur += 1\\n if cur == n:\\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\\n for i in range(n):\\n for j in range(i):\\n if ans[i] != ans[j] and lcp[i][j] != 0:\\n return \\\"\\\"\\n return \\\"\\\".join(ans)\\n # Letters are used up.\\n return \\\"\\\"\",\n \"runtime\": \"1424\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n\\n # build s\\n s = ['' for _ in range(n)]\\n c = 'a' # 'a' .... 'z'\\n for i in range(n):\\n if s[i] != '':\\n continue\\n if c > 'z': \\n return \\\"\\\"\\n s[i] = c\\n for j in range(n):\\n if lcp[i][j] > 0: # len(common_prefix(s[i:] , s[j:])) > 0\\n s[j] = s[i] \\n c = chr(ord(c) + 1)\\n\\n print(\\\"\\\".join(s))\\n\\n # validate last column and last row\\n for i in range(n):\\n if lcp[i][n - 1] != (s[i] == s[n-1]):\\n return \\\"\\\"\\n if lcp[n-1][i] != (s[i] == s[n-1]):\\n return \\\"\\\"\\n\\n # validate rest of lcp: if s[i] == s[j] => lcp[i][j] = 1 + lcp[i+1][j+1]\\n for i in range(n-1):\\n for j in range(n-1):\\n if s[i] == s[j]:\\n if lcp[i][j] != 1 + lcp[i+1][j+1]: \\n return \\\"\\\"\\n else: # char at i and j are different => lcp[i][j] should be 0\\n if lcp[i][j] != 0:\\n return \\\"\\\"\\n\\n return \\\"\\\".join(s)\",\n \"runtime\": \"1452\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n letters = [None] * n\\n curr_l = 'a'\\n \\n for i in range(n):\\n if lcp[i][i] != n-i: return \\\"\\\"\\n lcp[i].append(0)\\n \\n for i in range(n):\\n l = letters[i]\\n if l is not None:\\n for j in range(i+1, n):\\n if lcp[i][j] != lcp[j][i]: return \\\"\\\"\\n if lcp[i][j] and letters[j] != l: return \\\"\\\"\\n else:\\n if curr_l > 'z': return \\\"\\\"\\n for j in range(i, n):\\n if lcp[i][j] != lcp[j][i]: return \\\"\\\"\\n if lcp[i][j]:\\n if letters[j]:\\n if letters[j] != curr_l: return \\\"\\\"\\n else:\\n letters[j] = curr_l\\n curr_l = chr(ord(curr_l) + 1)\\n \\n \\n for i in range(n-1):\\n for j in range(i+1, n):\\n if letters[i] == letters[j] and lcp[i][j]!=lcp[i+1][j+1]+1:\\n return \\\"\\\"\\n \\n \\n return ''.join(letters)\",\n \"runtime\": \"1453\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n #Construct string\\n s = [\\\"\\\" for i in range(len(lcp))]\\n c = 'a'\\n\\n for i in range(len(lcp)):\\n if s[i] != \\\"\\\":\\n continue\\n if c > 'z':\\n return \\\"\\\"\\n s[i] = c\\n for j in range(len(lcp)):\\n if lcp[i][j] > 0:\\n s[j] = s[i]\\n c = chr(ord(c)+1)\\n\\n #Validate string\\n for i in range(len(lcp)):\\n if lcp[i][len(lcp)-1] != (s[i]==s[len(lcp)-1]):\\n return \\\"\\\"\\n if lcp[len(lcp)-1][i] != (s[i]==s[len(lcp)-1]):\\n return \\\"\\\"\\n \\n\\n for i in range(len(lcp)-1):\\n for j in range(len(lcp)-1):\\n if s[i] == s[j]:\\n if lcp[i][j] != 1+lcp[i+1][j+1]:\\n return \\\"\\\"\\n else:\\n if lcp[i][j] != 0:\\n return \\\"\\\"\\n\\n return \\\"\\\".join(s)\",\n \"runtime\": \"1458\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s = [\\\"\\\"] * n\\n i = 0\\n for c in ascii_lowercase:\\n while i < n and s[i]:\\n i += 1\\n if i == n:\\n break\\n for j in range(i, n):\\n if lcp[i][j]:\\n s[j] = c\\n if \\\"\\\" in s:\\n return \\\"\\\"\\n for i in range(n - 1, -1, -1):\\n for j in range(n - 1, -1, -1):\\n if s[i] == s[j]:\\n if i == n - 1 or j == n - 1:\\n if lcp[i][j] != 1:\\n return \\\"\\\"\\n elif lcp[i][j] != lcp[i + 1][j + 1] + 1:\\n return \\\"\\\"\\n elif lcp[i][j]:\\n return \\\"\\\"\\n return \\\"\\\".join(s)\",\n \"runtime\": \"1466\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # First of all, lcp[i][i] = n - i. If this does not hold, then the lcp matrix is invalid. Also, lcp must be a symmetric matrix, because we have lcp[i][j] == lcp[j][i]. If it is not symmetric, the matrix is not valid.\\n # Second, we have:\\n # lcp(i, j) := lcp(i + 1, j + 1) if [i] == [j]\\n # := 0 otherwise\\n # Let's set s[0] = 'a', then checking lcp[0][.] to see if any character equals to s[0], and will be set to 'a'.\\n # Then we start with the first unset index i and check lcp[i][.] to see if any character equals to s[i].\\n # Continue until we have set all the indices or all 26 alphabets are used up, which results in invalid.\\n n = len(lcp)\\n ans = [None] * n\\n cur = 0\\n # Check the diagonal elements\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n # Check the symmetry of the matrix\\n for i in range(n):\\n for j in range(i):\\n if lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n for ch in string.ascii_lowercase:\\n # Start from the first unset one\\n ans[cur] = ch\\n for i in range(cur + 1, n):\\n if ans[i] is not None:\\n continue\\n nxt = lcp[cur + 1][i + 1] if cur + 1 < n and i + 1 < n else 0\\n if lcp[cur][i] == nxt + 1:\\n ans[i] = ch\\n else:\\n # In this case, lcp[cur][i] must be 0 because s[cur] != s[i]\\n if lcp[cur][i] != 0:\\n return \\\"\\\"\\n while cur < n and ans[cur] is not None:\\n cur += 1\\n if cur == n:\\n # Now we have found an answer. We want to double check if lcp[i][j] != 0 for s[i] != s[j].\\n for i in range(n):\\n for j in range(i):\\n if ans[i] != ans[j] and lcp[i][j] != 0:\\n return \\\"\\\"\\n return \\\"\\\".join(ans)\\n # Letters are used up.\\n return \\\"\\\"\",\n \"runtime\": \"1467\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n A = [0] * n\\n c = 1\\n for i in range(n):\\n if A[i]: continue\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n A[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n if A[i]==A[j]:\\n v=lcp[i+1][j+1] +1 if i+1<n and j+1<n else 1\\n else:\\n v=0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join([chr(ord('a')+i-1) for i in A])\",\n \"runtime\": \"1483\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n res = ''\\n if not check_valid_lcp(lcp):\\n return ''\\n\\n for i in range(len(lcp)): \\n exact = set()\\n diff = set()\\n for j in range(i):\\n if lcp[i][j] > 0:\\n exact.add(res[j])\\n else:\\n diff.add(res[j])\\n if len(exact) > 1:\\n return ''\\n if len(exact) == 1:\\n res += (list(exact)[0])\\n if res[i] in diff:\\n return ''\\n if len(exact) == 0:\\n c = choose_diff_char(diff)\\n if c == '':\\n return ''\\n res += c\\n\\n return res\\n\\nalphabet = [chr(i+ ord('a')) for i in range(26)]\\ndef choose_diff_char(diff):\\n for c in alphabet:\\n if c not in diff:\\n return c\\n return ''\\n\\ndef check_valid_lcp(lcp):\\n for i in range(len(lcp)):\\n if lcp[i][i] != len(lcp) - i:\\n return False\\n for j in range(i):\\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > len(lcp) - i:\\n return False\\n if i == len(lcp)-1:\\n next_value = 0\\n else:\\n next_value = lcp[i+1][j+1]\\n\\n if lcp[i][j] !=0 and lcp[i][j] != next_value+1:\\n return False\\n return True\",\n \"runtime\": \"1490\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n A = [0] * n\\n c = 1\\n for i in range(n):\\n if A[i]: continue\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n A[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n if A[i]==A[j]:\\n v=lcp[i+1][j+1] +1 if i+1<n and j+1<n else 1\\n else:\\n v=0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + i - 1) for i in A)\",\n \"runtime\": \"1494\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n idx = 0\\n n = len(lcp)\\n word = ['0' for _ in range(n)]\\n for i in range(26):\\n while idx < n and word[idx] != '0':\\n idx += 1\\n if idx == n:\\n break\\n for j in range(idx, n):\\n if lcp[idx][j]:\\n word[j] = chr(ord('a')+i)\\n for i in range(n):\\n if word[i] == '0':\\n return \\\"\\\"\\n # print(word)\\n dp = [[0]*n for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if word[i] != word[j]:\\n dp[i][j] = 0\\n elif i == n-1 or j == n-1:\\n dp[i][j] = 1\\n else:\\n dp[i][j] = dp[i+1][j+1] + 1\\n if dp[i][j] != lcp[i][j]:\\n return \\\"\\\"\\n # print(dp)\\n return ''.join(word) \\n \",\n \"runtime\": \"1499\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n A = [0] * n\\n c = 1\\n for i in range(n):\\n if A[i]: continue\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n A[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\\n v = v + 1 if A[i] == A[j] else 0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + i - 1) for i in A)\",\n \"runtime\": \"1507\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n res = [0] * n\\n c = 1\\n for i in range(n):\\n if res[i] == 0:\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n res[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\\n v = v + 1 if res[i] == res[j] else 0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + num - 1) for num in res)\",\n \"runtime\": \"1514\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: list[list[int]]) -> str:\\n n = len(lcp)\\n \\n # start with the possibility that any letter can be placed anywhere\\n s = ['abcdefghijklmnopqrstuvwxyz' for _ in range(n)] \\n # storing this array takes O(26*n) = O(n) space.\\n \\n # arbitrarily assing the final letter in the string\\n s[-1] = 'z'\\n \\n for row in range(n-1,-1,-1):\\n for col in range(n-1, row-1, -1):\\n # lcp has to be symmetric\\n if lcp[row][col] != lcp[col][row]: return('')\\n\\n if row == col:\\n # lcp[i][i] has to equal n-i\\n if lcp[row][col] != n-row: return('')\\n\\n # once we have compared s[row] with s[row+1:] and eliminated all letters from the possible choices for s[row], we can freely assign one out of the remaining pool. If nothing remains in the pool, a valid string does not exist.\\n if len(s[row]): s[row] = s[row][-1]\\n else: return('')\\n continue\\n \\n c = s[col]\\n \\n # if lcp[row][col] is zero, we remove s[col] from the list of possible letters for s[row]\\n if lcp[row][col] == 0:\\n if s[row][-1] == c: s[row] = s[row][:-1]\\n if not s[row]: return('')\\n continue\\n \\n # if lcp[i][j] is nonzero then it must equal lcp[i+1][j+1] + 1 \\n if lcp[row][col] > min(n-row, n-col): return('')\\n if col < n-1 and lcp[row+1][col+1] != lcp[row][col]-1: return('')\\n \\n # once all these checks have been passed and lcp[row][col] is nonzero, we can safely assign s[row] to be equal to s[col]\\n if c not in s[row]: return('')\\n else: s[row] = c\\n \\n # from the existing string s (a list of characters at the momen), generate the lexicographically smallest one\\n sub = 26*[None]\\n newLetter = 'a'\\n for i, c in enumerate(s):\\n if sub[ord(c)-ord('a')] is None:\\n sub[ord(c)-ord('a')] = newLetter\\n s[i] = newLetter\\n newLetter = chr(ord(newLetter)+1)\\n else:\\n s[i] = sub[ord(s[i])-ord('a')]\\n \\n return(''.join(s))\",\n \"runtime\": \"1519\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n A = [0] * n\\n c = 1\\n for i in range(n):\\n if A[i]: continue\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n A[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\\n v = v + 1 if A[i] == A[j] else 0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + i - 1) for i in A)\",\n \"runtime\": \"1528\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # 1. Identifying if the LCP matrix is valid.\\n # 2. Creating an output string.\\n # 3. Check validity?? Why do we need to do this?\\n\\n # Matrix validity.\\n # First position should always be the length of lcp.\\n if lcp[0][0] != len(lcp):\\n return \\\"\\\"\\n \\n # It should be a symmetrical matrix with the diagonal\\n # in decreasing order.\\n # Also the number at each col should be less than or equal\\n # to the remaining number of letters.\\n n = lcp[0][0]\\n for i in range(n):\\n if lcp[i][i] != n-i:\\n return \\\"\\\"\\n\\n for j in range(i+1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n\\n if lcp[i][j] > n-j:\\n return \\\"\\\"\\n \\n if lcp[i][j] != 0 and i<n-1 and j<n-1 and lcp[i][j] != lcp[i+1][j+1] + 1:\\n return \\\"\\\"\\n\\n result = [None] * n\\n letter = chr(ord(\\\"a\\\") - 1)\\n\\n for i in range(n):\\n if result[i] is None:\\n letter = chr(ord(letter) + 1) \\n if letter > \\\"z\\\":\\n return \\\"\\\"\\n result[i] = letter\\n\\n for j in range(i+1, n):\\n if lcp[i][j] != 0:\\n if result[j] is None:\\n result[j] = letter\\n else: # Check that letters in position i and j are the same.\\n if result[i] != result[j]:\\n return \\\"\\\"\\n\\n for i in range(n):\\n for j in range(i+1, n):\\n # Check for contradictions once all the letters are filled.\\n if lcp[i][j] == 0 and result[i] == result[j]:\\n return \\\"\\\"\\n\\n return \\\"\\\".join(result)\",\n \"runtime\": \"1530\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n ans = []\\n for i in range(n): \\n tabu = set()\\n for j in range(i): \\n if lcp[i][j]: \\n ans.append(ans[j])\\n break\\n else: tabu.add(ans[j])\\n else: \\n for ch in ascii_lowercase: \\n if ch not in tabu: \\n ans.append(ch)\\n break\\n else: return \\\"\\\"\\n dp = [[0]*n for _ in range(n)]\\n for i in range(n-1, -1, -1): \\n for j in range(n-1, -1, -1): \\n if ans[i] == ans[j]: \\n if i == n-1 or j == n-1: dp[i][j] = 1\\n else: dp[i][j] = 1 + dp[i+1][j+1]\\n if dp[i][j] != lcp[i][j]: return \\\"\\\"\\n return \\\"\\\".join(ans) \",\n \"runtime\": \"1534\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n ans = []\\n for i in range(n): \\n tabu = set()\\n for j in range(i): \\n if lcp[i][j]: \\n ans.append(ans[j])\\n break\\n else: tabu.add(ans[j])\\n else: \\n for ch in ascii_lowercase: \\n if ch not in tabu: \\n ans.append(ch)\\n break\\n else: return \\\"\\\"\\n dp = [[0]*n for _ in range(n)]\\n for i in range(n-1, -1, -1): \\n for j in range(n-1, -1, -1): \\n if ans[i] == ans[j]: \\n if i == n-1 or j == n-1: dp[i][j] = 1\\n else: dp[i][j] = 1 + dp[i+1][j+1]\\n if dp[i][j] != lcp[i][j]: return \\\"\\\"\\n return \\\"\\\".join(ans)\",\n \"runtime\": \"1537\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n return findTheString(lcp)\\n\\n\\ndef findTheString(lcp: list[list[int]]) -> str:\\n assert len(lcp) > 0\\n assert len(lcp) == len(lcp[0])\\n size = len(lcp)\\n\\n def isTrans(matrix: list[list[int]]) -> bool:\\n for r in range(size):\\n for c in range(r + 1, size):\\n if matrix[r][c] != matrix[c][r]:\\n return False\\n return True\\n\\n def reduceCheck(lcp: list[list[int]]) -> bool:\\n if lcp[0][0] != size:\\n return False\\n for r in range(size):\\n for c in range(r, size):\\n lspLen = lcp[r][c]\\n if lspLen == 0:\\n continue\\n if lspLen > size - c or lspLen > size - r:\\n return False\\n if lspLen >= 1 and c + 1 < size and lspLen != lcp[r + 1][c + 1] + 1:\\n return False\\n return True\\n\\n if not isTrans(lcp) or not reduceCheck(lcp):\\n return \\\"\\\"\\n\\n chars = range(26)\\n word: dict[int, int] = {}\\n for idx in range(size):\\n invalids = set(word[i] for i in range(idx) if lcp[i][idx] == 0)\\n sameAs = set(word[i] for i in range(idx) if lcp[i][idx] > 0)\\n if len(sameAs) > 1:\\n return \\\"\\\"\\n if len(sameAs) == 1 and len(invalids.intersection(sameAs)) != 0:\\n return \\\"\\\"\\n if len(sameAs) == 1:\\n word[idx] = sameAs.pop()\\n selected = next((c for c in chars if c not in invalids), None)\\n if selected is None:\\n return \\\"\\\"\\n word[idx] = selected\\n\\n return \\\"\\\".join(chr(ord(\\\"a\\\") + word[i]) for i in range(size))\\n\\n\\n\\\"\\\"\\\"\\n- Diagonal must be n, n-1, ..., 1, according to definition\\n- Must M == transpose(M)\\n\\nabab\\n bab\\n\\n4 0 2 0\\n0 3 0 1\\n2 0 2 0\\n0 1 0 1\\n\\naab\\n\\n3 1 0\\n 2 0\\n 1\\n\\naaa\\n\\n3 2 1 \\n 2 1\\n 1\\n\\nabaab\\n\\n5 0 1 2 0\\n 4 0 0 1\\n 3 1 0\\n 2 0\\n 1\\n\\nabca\\n\\n4 0 0 1\\n 3 0 0\\n 2 0\\n 1\\n\\nabcabcab\\n\\n8 0 0 5 0 0 2 0\\n 7 0 0 4 0 0 1\\n 6 0 0 3 0 0\\n 5 0 0 2 0\\n 4 0 0 1\\n 3 0 0\\n 2 0\\n 1\\n\\nabcab\\n5 0 0 2 0\\n 4 0 0 1\\n 3 0 0 \\n 2 0 \\n 1\\n\\nabb\\n\\n3 0 0\\n 2 1\\n\\naba\\n3 0 1\\n 2 0\\n 1\\n\\nabc\\n3 0 0\\n 2 1\\n 1\\n\\nabbb\\n4 0 0 0\\n 3 2 1\\n 2 1\\n 1\\n\\nabcd...z\\n26 0 ... 0\\n 25 0 ... 0\\n 24\\n ...\\n\\\"\\\"\\\"\\n\",\n \"runtime\": \"1574\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n max_alpha = ord('a')\\n groups = list(range(n))\\n not_equal = []\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n if i > 0 and ((lcp[i-1][j-1] > 0 and lcp[i][j] != lcp[i-1][j-1] - 1)):\\n return \\\"\\\"\\n if lcp[i][j] > n - i or lcp[i][j] > n - j:\\n return \\\"\\\"\\n if lcp[i][j] > 0:\\n if groups[j] != j and groups[j] != groups[i]:\\n return \\\"\\\"\\n groups[j] = groups[i]\\n else:\\n not_equal.append((i, j))\\n assignments = {}\\n s = []\\n for v in groups:\\n if v not in assignments:\\n assignments[v] = chr(max_alpha)\\n if not assignments[v].isalpha():\\n return \\\"\\\"\\n max_alpha += 1\\n s.append(assignments[v])\\n if any(s[i] == s[j] for i, j in not_equal):\\n return \\\"\\\" \\n return \\\"\\\".join(s)\",\n \"runtime\": \"1575\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # lcp[i][j] = lcp[i-1][j-1] + 1 if s[i] == s[j] else 0\\n # [3:4] == [1:2]\\n # 1 != 2\\n # 3 != 2\\n # 1 != 4\\n # 3 != 4\\n n = len(lcp)\\n\\n # ord(a) == 97\\n s = ['a' for i in range(n)]\\n \\n for i in range(n):\\n for j in range(i):\\n if lcp[i][j] == 0:\\n if s[i] == s[j]:\\n s[i] = chr(ord(s[i])+1)\\n \\n s = ''.join(s)\\n if any(ord(c) > ord('z') for c in s):\\n return ''\\n\\n lcp2 = [[0 for i in range(n+1)] for j in range(n+1)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n lcp2[i][j] = lcp2[i+1][j+1] + 1 if s[i]==s[j] else 0\\n for i in range(n):\\n for j in range(n):\\n if lcp2[i][j] != lcp[i][j]:\\n return ''\\n return s\",\n \"runtime\": \"1580\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n ans = ['']*n\\n\\n i = 0\\n for c in ascii_lowercase: \\n while i < n and ans[i]: \\n i += 1\\n if i == n:\\n break\\n for j in range(i, n):\\n if lcp[i][j]:\\n ans[j] = c\\n\\n if \\\"\\\" in ans:\\n return ''\\n\\n for i in range(n-1, -1, -1): \\n for j in range(n-1, -1, -1): \\n if ans[i] == ans[j]: \\n if i == n-1 or j == n-1:\\n if lcp[i][j] != 1:\\n return ''\\n elif lcp[i][j] != lcp[i+1][j+1] + 1:\\n return ''\\n else:\\n if lcp[i][j]:\\n return ''\\n\\n return ''.join(ans)\",\n \"runtime\": \"1592\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n \\n grid = [[] * n for _ in range(n)]\\n for i in range(n):\\n if lcp[i][i] != (n - i):\\n return ''\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n d = lcp[i][j]\\n if d > (n - max(i, j)):\\n return ''\\n if d > 0:\\n if (j + 1) < n and lcp[i + 1][j + 1] != (d - 1):\\n return ''\\n grid[i].append(j)\\n grid[j].append(i)\\n\\n # dfs and build connected graph.\\n ts = [0] * n\\n\\n def dfs(x, now):\\n if ts[x] != 0:\\n return ts[x] == now\\n ts[x] = now\\n for y in grid[x]:\\n if not dfs(y, now):\\n return False\\n return True\\n\\n now = 1\\n for i in range(n):\\n if ts[i]: continue\\n # too much connected graphs.\\n if now > 26: return ''\\n if not dfs(i, now):\\n return ''\\n now += 1\\n\\n ans = [''] * n\\n for i in range(n):\\n ans[i] = chr(ord('a') + ts[i] - 1)\\n ans = ''.join(ans)\\n\\n \\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] == 0 and ans[i] == ans[j]:\\n return ''\\n\\n return ans\",\n \"runtime\": \"1602\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern - fix syntax error\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n): # fix syntax error\\n if lcp[i][j] > 0: # fix syntax error\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\\n\",\n \"runtime\": \"1633\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"runtime\": \"1636\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1639\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1639\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1643\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]: \\n return '' \\n pattern[j] = pattern[i]\\n\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\\n\",\n \"runtime\": \"1644\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"runtime\": \"1648\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"runtime\": \"1653\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1654\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"runtime\": \"1655\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern — the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1665\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"runtime\": \"1667\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1669\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1675\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1679\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1682\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1686\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n uf = [i for i in range(n)]\\n \\n def find(x):\\n if uf[x] == x:\\n return x\\n uf[x] = find(uf[x])\\n return uf[x]\\n \\n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\\n for i in range(n):\\n # bc symbols are equal to themselves\\n if lcp[i][i] + i != n:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n # border and symmetry check\\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n \\n if lcp[i][j]:\\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\\n return \\\"\\\"\\n \\n uf[i] = uf[j] = min(find(i), find(j))\\n \\n # Step 2: Check all conditions fulfilled and self-consistent.\\n for i in range(n):\\n for j in range(i + 1, n):\\n # cases: need to be unequal, but in reality opposite\\n if lcp[i][j] == 0 and find(i) == find(j):\\n return \\\"\\\"\\n # if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\\n # return \\\"\\\"\\n \\n # Step 3: Use union find structure to fill answer with chars.\\n ret = [None] * n\\n letter = 97 # ASCII code of 'a' letter\\n for i in range(len(ret)):\\n val = find(i)\\n if ret[val] is not None:\\n ret[i] = ret[val]\\n else:\\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\\n if letter == 123:\\n return \\\"\\\"\\n ret[i] = chr(letter)\\n letter += 1\\n return ''.join(ret)\",\n \"runtime\": \"1687\"\n },\n {\n \"code\": \"class UnionFind: \\n def __init__(self, n):\\n self.parents = [i for i in range (n)]\\n self.ranks = [0 for i in range (n)]\\n def find(self, u):\\n if self.parents[u] != u:\\n self.parents[u] = self.find(self.parents[u])\\n return self.parents[u]\\n def union(self, u, v):\\n par_u = self.find(u)\\n par_v = self.find(v)\\n if par_u == par_v:\\n return \\n if self.ranks[par_u] <= self.ranks[par_v]:\\n self.parents[par_u] = par_v\\n if self.ranks[par_u] == self.ranks[par_v]:\\n self.ranks[par_v] += 1\\n else:\\n self.parents[par_v] = par_u\\nclass Solution:\\n def findTheString(self, matrix: List[List[int]]) -> str:\\n n = len(matrix)\\n union = UnionFind(n)\\n for i in range (n):\\n if matrix[i][i] + i != n:\\n return \\\"\\\"\\n for j in range (i + 1, n):\\n if matrix[i][j] != matrix[j][i]:\\n return \\\"\\\"\\n if matrix[i][j] + j > n:\\n return \\\"\\\"\\n if matrix[i][j] > 0:\\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\\n return \\\"\\\"\\n union.union(i, j)\\n for i in range (n):\\n for j in range (i + 1, n):\\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\\n return \\\"\\\"\\n \\n cur_char_ord = ord(\\\"a\\\")\\n res = []\\n d = dict()\\n for i in range (n):\\n key = union.find(i)\\n if key not in d:\\n if cur_char_ord > ord(\\\"z\\\"):\\n return \\\"\\\"\\n d[key] = chr(cur_char_ord)\\n cur_char_ord += 1\\n \\n res.append(d[key])\\n \\n return \\\"\\\".join(res)\",\n \"runtime\": \"1689\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern — the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\\n\",\n \"runtime\": \"1693\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1695\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"runtime\": \"1700\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # O(n^2)\\n equal = [[None] * len(lcp) for _ in range(len(lcp))]\\n for i, r in enumerate(lcp):\\n for j, v in enumerate(r):\\n if equal[i][j] is not None: # (i, j) in previously added diagonal\\n if equal[i][j] is True:\\n if lcp[i][j] + 1 != lcp[i - 1][j - 1]:\\n # impossible\\n print(\\\"impossible positive\\\", i, j)\\n return \\\"\\\"\\n else:\\n if lcp[i][j] > 0 or lcp[i - 1][j - 1] > 1:\\n print(\\\"impossible negative\\\", i, j)\\n return \\\"\\\"\\n else:\\n if i + v > len(lcp) or j + v > len(lcp):\\n print(\\\"diagonal too long\\\", i, j)\\n return \\\"\\\"\\n for k in range(0, v):\\n equal[i+k][j+k] = True\\n if i + v < len(lcp) and j + v < len(lcp):\\n equal[i+v][j+v] = False\\n\\n for i in range(len(lcp)):\\n for j in range(len(lcp)):\\n if equal[i][j] != equal[j][i]:\\n return \\\"\\\"\\n \\n for row in equal:\\n print(row)\\n \\n answer = [None] * len(lcp)\\n for letter in \\\"abcdefghijklmnopqrstuvwxyz\\\":\\n first_none_idx = None\\n for i, x in enumerate(answer):\\n if x is None:\\n first_none_idx = i\\n break\\n if first_none_idx is None:\\n break\\n for j in range(0, len(lcp)):\\n if equal[first_none_idx][j]:\\n if answer[j] is not None:\\n return \\\"\\\"\\n answer[j] = letter\\n for x in answer:\\n if x is None:\\n return \\\"\\\"\\n return \\\"\\\".join(answer)\\n\\n #\\n # up to 1000, 1e6 pairs\",\n \"runtime\": \"1704\"\n },\n {\n \"code\": \"class UnionFind: \\n def __init__(self, n):\\n self.parents = [i for i in range (n)]\\n self.ranks = [0 for i in range (n)]\\n def find(self, u):\\n if self.parents[u] != u:\\n self.parents[u] = self.find(self.parents[u])\\n return self.parents[u]\\n def union(self, u, v):\\n par_u = self.find(u)\\n par_v = self.find(v)\\n if par_u == par_v:\\n return \\n if self.ranks[par_u] <= self.ranks[par_v]:\\n self.parents[par_u] = par_v\\n if self.ranks[par_u] == self.ranks[par_v]:\\n self.ranks[par_v] += 1\\n else:\\n self.parents[par_v] = par_u\\nclass Solution:\\n def findTheString(self, matrix: List[List[int]]) -> str:\\n n = len(matrix)\\n union = UnionFind(n)\\n for i in range (n):\\n if matrix[i][i] + i != n:\\n return \\\"\\\"\\n for j in range (i + 1, n):\\n if matrix[i][j] != matrix[j][i]:\\n return \\\"\\\"\\n if matrix[i][j] + j > n:\\n return \\\"\\\"\\n if matrix[i][j] > 0:\\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\\n return \\\"\\\"\\n union.union(i, j)\\n for i in range (n):\\n for j in range (i + 1, n):\\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\\n return \\\"\\\"\\n \\n cur_char_ord = ord(\\\"a\\\")\\n res = []\\n d = dict()\\n for i in range (n):\\n key = union.find(i)\\n if key not in d:\\n if cur_char_ord > ord(\\\"z\\\"):\\n return \\\"\\\"\\n d[key] = chr(cur_char_ord)\\n cur_char_ord += 1\\n \\n res.append(d[key])\\n \\n return \\\"\\\".join(res)\",\n \"runtime\": \"1707\"\n },\n {\n \"code\": \"class UnionFind: \\n def __init__(self, n):\\n self.parents = [i for i in range (n)]\\n self.ranks = [0 for i in range (n)]\\n def find(self, u):\\n if self.parents[u] != u:\\n self.parents[u] = self.find(self.parents[u])\\n return self.parents[u]\\n def union(self, u, v):\\n par_u = self.find(u)\\n par_v = self.find(v)\\n if par_u == par_v:\\n return \\n if self.ranks[par_u] <= self.ranks[par_v]:\\n self.parents[par_u] = par_v\\n if self.ranks[par_u] == self.ranks[par_v]:\\n self.ranks[par_v] += 1\\n else:\\n self.parents[par_v] = par_u\\nclass Solution:\\n def findTheString(self, matrix: List[List[int]]) -> str:\\n n = len(matrix)\\n union = UnionFind(n)\\n for i in range (n):\\n if matrix[i][i] + i != n:\\n return \\\"\\\"\\n for j in range (i + 1, n):\\n if matrix[i][j] != matrix[j][i]:\\n return \\\"\\\"\\n if matrix[i][j] + i > n:\\n return \\\"\\\"\\n if matrix[i][j] + j > n:\\n return \\\"\\\"\\n if matrix[i][j] > 0:\\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\\n return \\\"\\\"\\n union.union(i, j)\\n for i in range (n):\\n for j in range (i + 1, n):\\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\\n return \\\"\\\"\\n \\n cur_char_ord = ord(\\\"a\\\")\\n res = []\\n d = dict()\\n for i in range (n):\\n key = union.find(i)\\n if key not in d:\\n if cur_char_ord > ord(\\\"z\\\"):\\n return \\\"\\\"\\n d[key] = chr(cur_char_ord)\\n cur_char_ord += 1\\n \\n res.append(d[key])\\n \\n return \\\"\\\".join(res)\",\n \"runtime\": \"1713\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n \\n for ea in range(len(lcp)):\\n \\n for jh in range(len(lcp[0])):\\n if lcp[ea][jh] != lcp[jh][ea]:\\n return ''\\n for ea in range(len(lcp)):\\n leng = len(lcp) - ea\\n if lcp[ea][ea] != leng:\\n return ''\\n \\n quiq = True\\n for jh in range(len(lcp)):\\n thesis = lcp[jh][jh:]\\n \\n donk = thesis[::-1]\\n if donk != [1 + i for i in range(len(donk))]:\\n quiq = False\\n if quiq:\\n return 'a'*len(lcp)\\n \\n not_equal = defaultdict(set)\\n \\n equal = defaultdict(set)\\n \\n for ea in range(len(lcp)):\\n \\n for jh in range(len(lcp[0])):\\n if lcp[ea][jh] != lcp[jh][ea]:\\n return ''\\n \\n for ea in range(len(lcp)):\\n for jh in range(ea, len(lcp)):\\n \\n end = lcp[ea][jh]\\n \\n if end + jh> len(lcp):\\n return ''\\n if ea == jh:\\n continue\\n \\n \\n \\n for sk in range(lcp[ea][jh]):\\n equal[sk + ea].add(sk + jh)\\n equal[sk + jh].add(sk + ea)\\n \\n if end < len(lcp):\\n end = lcp[ea][jh]\\n\\n not_equal[jh + end].add(ea + end)\\n not_equal[ea + end].add(jh + end)\\n \\n if all([len(list(not_equal[j])) == 0 for j in list(not_equal.keys())]):\\n return 'a' * len(lcp)\\n \\n print(equal, not_equal)\\n \\n \\n for ea in equal.keys():\\n \\n basis = list(equal[ea])\\n print(basis)\\n for nth in range(len(basis)):\\n for kth in range(nth + 1, len(basis)):\\n \\n n = basis[nth]\\n k = basis[kth]\\n \\n if n in not_equal[k] or k in not_equal[n]:\\n \\n return ''\\n for jh in not_equal.keys():\\n if ea == jh:\\n for jh in equal[ea]:\\n if jh in not_equal[ea]:\\n return ''\\n basis = ['a' for i in range(len(lcp))]\\n \\n \\n alpha = 'abcdefghijklmnopqrstuvwxyz'\\n \\n \\n \\n for ea in range(len(basis)):\\n \\n if len(equal[ea]) > 0:\\n if min(equal[ea]) < ea:\\n basis[ea] = basis[min(equal[ea])]\\n print('hit')\\n continue\\n basils = [i for i in not_equal[ea] if i < ea]\\n donks = list([i for i in alpha])\\n for jh in basils:\\n\\n \\n if basis[jh] in donks:\\n donks.remove(basis[jh])\\n if len(donks) == 0:\\n return ''\\n basis[ea] = min(donks)\\n \\n return ''.join(basis)\\n \\n\",\n \"runtime\": \"1717\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n p = [i for i in range(n)]\\n def find(x):\\n if x!=p[x]:\\n p[x] = find(p[x])\\n return p[x]\\n \\n for i in range(n-1,-1,-1):\\n for j in range(i,-1,-1):\\n if i == j and lcp[i][j]!=n-i:return \\\"\\\"\\n if i!=j:\\n if lcp[i][j]!=lcp[j][i]: return \\\"\\\"\\n if lcp[i][j]>0:\\n pi,pj = sorted([find(i),find(j)])\\n if pi!=pj:\\n p[pj] = pi\\n #print([find(i) for i in range(n)])\\n ff = [find(i) for i in range(n)]\\n res = ''\\n dic = {}\\n unused = 0\\n for i in range(n):\\n if ff[i] in dic:\\n res += dic[ff[i]]\\n else:\\n if unused >= 26: return ''\\n dic[ff[i]] = chr(ord('a')+unused)\\n unused += 1\\n res += dic[ff[i]]\\n for i in range(n):\\n for j in range(i+1,n):\\n a = lcp[i][j]\\n if res[i:i+a]!=res[j:j+a]:return ''\\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\\n\\n return res\\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1726\"\n },\n {\n \"code\": \"class UnionFind: \\n def __init__(self, n):\\n self.parents = [i for i in range (n)]\\n self.ranks = [0 for i in range (n)]\\n def find(self, u):\\n if self.parents[u] != u:\\n self.parents[u] = self.find(self.parents[u])\\n return self.parents[u]\\n def union(self, u, v):\\n par_u = self.find(u)\\n par_v = self.find(v)\\n if par_u == par_v:\\n return \\n if self.ranks[par_u] <= self.ranks[par_v]:\\n self.parents[par_u] = par_v\\n if self.ranks[par_u] == self.ranks[par_v]:\\n self.ranks[par_v] += 1\\n else:\\n self.parents[par_v] = par_u\\nclass Solution:\\n def findTheString(self, matrix: List[List[int]]) -> str:\\n n = len(matrix)\\n union = UnionFind(n)\\n for i in range (n):\\n if matrix[i][i] + i != n:\\n return \\\"\\\"\\n for j in range (i + 1, n):\\n if matrix[i][j] != matrix[j][i]:\\n return \\\"\\\"\\n if matrix[i][j] + j > n:\\n return \\\"\\\"\\n if matrix[i][j] > 0:\\n if j + 1 < n and matrix[i + 1][j + 1] + 1 != matrix[i][j]:\\n return \\\"\\\"\\n union.union(i, j)\\n for i in range (n):\\n for j in range (i + 1, n):\\n if matrix[i][j] == 0 and union.find(i) == union.find(j):\\n return \\\"\\\"\\n \\n cur_char_ord = ord(\\\"a\\\")\\n res = []\\n d = dict()\\n for i in range (n):\\n key = union.find(i)\\n if key not in d:\\n if cur_char_ord > ord(\\\"z\\\"):\\n return \\\"\\\"\\n d[key] = chr(cur_char_ord)\\n cur_char_ord += 1\\n \\n res.append(d[key])\\n \\n return \\\"\\\".join(res)\",\n \"runtime\": \"1729\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n uf = [i for i in range(n)]\\n \\n def find(x):\\n if uf[x] == x:\\n return x\\n uf[x] = find(uf[x])\\n return uf[x]\\n \\n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\\n for i in range(n):\\n # bc symbols are equal to themselves\\n if lcp[i][i] + i != n:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n # border and symmetry check\\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n \\n if lcp[i][j]:\\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\\n return \\\"\\\"\\n \\n uf[i] = uf[j] = min(find(i), find(j))\\n \\n # Step 2: Check all conditions fulfilled and self-consistent.\\n for i in range(n):\\n for j in range(i + 1, n):\\n # cases: need to be unequal, but in reality opposite\\n if lcp[i][j] == 0 and find(i) == find(j):\\n return \\\"\\\"\\n if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\\n return \\\"\\\"\\n \\n # Step 3: Use union find structure to fill answer with chars.\\n ret = [None] * n\\n letter = 97 # ASCII code of 'a' letter\\n for i in range(len(ret)):\\n val = find(i)\\n if ret[val] is not None:\\n ret[i] = ret[val]\\n else:\\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\\n if letter == 123:\\n return \\\"\\\"\\n ret[i] = chr(letter)\\n letter += 1\\n return ''.join(ret)\",\n \"runtime\": \"1733\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n p = [i for i in range(n)]\\n def find(x):\\n if x!=p[x]:\\n p[x] = find(p[x])\\n return p[x]\\n \\n for i in range(n-1,-1,-1):\\n for j in range(i,-1,-1):\\n if i == j and lcp[i][j]!=n-i:return \\\"\\\"\\n if i!=j:\\n if lcp[i][j]!=lcp[j][i]: return \\\"\\\"\\n if lcp[i][j]>0:\\n pi,pj = sorted([find(i),find(j)])\\n if pi!=pj:\\n p[pj] = pi\\n ff = [find(i) for i in range(n)]\\n res = ''\\n dic = {}\\n unused = 0\\n for i in range(n):\\n if ff[i] in dic:\\n res += dic[ff[i]]\\n else:\\n if unused >= 26: return ''\\n dic[ff[i]] = chr(ord('a')+unused)\\n unused += 1\\n res += dic[ff[i]]\\n for i in range(n):\\n for j in range(i+1,n):\\n a = lcp[i][j]\\n if res[i:i+a]!=res[j:j+a]:return ''\\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\\n\\n return res\\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1737\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n uf = [i for i in range(n)]\\n \\n def find(x):\\n if uf[x] == x:\\n return x\\n uf[x] = find(uf[x])\\n return uf[x]\\n \\n # Step 1: Use rules from lcp array to unify same symbols. Simultaneously checking for inconsistencies.\\n for i in range(n):\\n # bc symbols are equal to themselves\\n if lcp[i][i] + i != n:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n # border and symmetry check\\n if j + lcp[i][j] > n or lcp[i][j] != lcp[j][i]:\\n return \\\"\\\"\\n \\n if lcp[i][j]:\\n if j + 1 < n and lcp[i + 1][j + 1] + 1 != lcp[i][j]:\\n return \\\"\\\"\\n \\n uf[i] = uf[j] = min(find(i), find(j))\\n \\n # Step 2: Check all conditions fulfilled and self-consistent.\\n for i in range(n):\\n for j in range(i + 1, n):\\n # cases: need to be unequal, but in reality opposite\\n if lcp[i][j] == 0 and find(i) == find(j):\\n return \\\"\\\"\\n if lcp[i][j] > 0 and lcp[i][j] + j < n and find(i + lcp[i][j]) == find(j + lcp[i][j]):\\n return \\\"\\\"\\n \\n # Step 3: Use union find structure to fill answer with chars.\\n ret = [None] * n\\n letter = 97 # ASCII code of 'a' letter\\n for i in range(len(ret)):\\n val = find(i)\\n if ret[val] is not None:\\n ret[i] = ret[val]\\n else:\\n # if needed more letters, we can't afford it, as 'z' has 122 ASCII code\\n if letter == 123:\\n return \\\"\\\"\\n ret[i] = chr(letter)\\n letter += 1\\n return ''.join(ret)\",\n \"runtime\": \"1740\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n p = [i for i in range(n)]\\n def find(x):\\n if x!=p[x]:\\n p[x] = find(p[x])\\n return p[x]\\n \\n for i in range(n-1,-1,-1):\\n for j in range(i,-1,-1):\\n if i == j and lcp[i][j]!=n-i:return \\\"\\\"\\n if i!=j:\\n if lcp[i][j]!=lcp[j][i]: return \\\"\\\"\\n if lcp[i][j]>0:\\n pi,pj = sorted([find(i),find(j)])\\n if pi!=pj:\\n p[pj] = pi\\n ff = [find(i) for i in range(n)]\\n res = ''\\n dic = {}\\n unused = 0\\n for i in range(n):\\n if ff[i] in dic:\\n res += dic[ff[i]]\\n else:\\n if unused >= 26: return ''\\n dic[ff[i]] = chr(ord('a')+unused)\\n unused += 1\\n res += dic[ff[i]]\\n for i in range(n):\\n for j in range(i+1,n):\\n a = lcp[i][j]\\n if res[i:i+a]!=res[j:j+a]:return ''\\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\\n\\n return res\\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1746\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n p = [i for i in range(n)]\\n def find(x):\\n if x!=p[x]:\\n p[x] = find(p[x])\\n return p[x]\\n \\n for i in range(n-1,-1,-1):\\n for j in range(i,-1,-1):\\n if i == j and lcp[i][j]!=n-i:return \\\"\\\"\\n if i!=j:\\n if lcp[i][j]!=lcp[j][i]: return \\\"\\\"\\n if lcp[i][j]>0:\\n pi,pj = sorted([find(i),find(j)])\\n if pi!=pj:\\n p[pj] = pi\\n ff = [find(i) for i in range(n)]\\n res = ''\\n dic = {}\\n unused = 0\\n for i in range(n):\\n if ff[i] in dic:\\n res += dic[ff[i]]\\n else:\\n if unused >= 26: return ''\\n dic[ff[i]] = chr(ord('a')+unused)\\n unused += 1\\n res += dic[ff[i]]\\n for i in range(n):\\n for j in range(i+1,n):\\n a = lcp[i][j]\\n if res[i:i+a]!=res[j:j+a]:return ''\\n if i+a < n and j+a < n and res[i:i+a+1]==res[j:j+a+1]:return ''\\n\\n return res\\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1751\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp):\\n n = len(lcp)\\n\\n dict1 = defaultdict(int)\\n\\n def find(x):\\n if x not in dict1:\\n return x\\n else:\\n if x != dict1[x]:\\n dict1[x] = find(dict1[x])\\n return dict1[x]\\n\\n def union(x,y):\\n a,b = find(x),find(y)\\n\\n if a > b:\\n dict1[a] = b\\n else:\\n dict1[b] = a\\n\\n for i in range(n):\\n for j in range(i):\\n if lcp[i][j]: union(i,j)\\n\\n ans = [find(i) for i in range(n)]\\n\\n for i in range(n):\\n for j in range(n):\\n val = lcp[i+1][j+1] if i+1 < n and j+1 < n else 0\\n val = val + 1 if ans[i] == ans[j] else 0\\n if val != lcp[i][j]:\\n return \\\"\\\"\\n\\n group = set(ans)\\n if len(group) > 26: return \\\"\\\"\\n dict2 = {x:i for i,x in enumerate(sorted(group))}\\n\\n res = []\\n\\n for i,k in enumerate(ans):\\n res.append(chr(97+dict2[k]))\\n\\n return \\\"\\\".join(res)\",\n \"runtime\": \"1781\"\n },\n {\n \"code\": \"class DSU:\\n def __init__(self, n):\\n self.n = n\\n self.p = [i for i in range(n)]\\n self.r = [0 for _ in range(n)]\\n \\n def find(self, u):\\n if self.p[u] != u:\\n self.p[u] = self.find(self.p[u])\\n return self.p[u]\\n \\n def union(self, u, v):\\n pu, pv = self.find(u), self.find(v)\\n if pu == pv:\\n return\\n ru, rv = self.r[pu], self.r[pv]\\n if ru > rv:\\n self.p[pv] = pu\\n elif ru < rv:\\n self.p[pu] = pv\\n else:\\n self.p[pv] = pu\\n self.r[pu] += 1\\n\\n\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp) \\n dsu = DSU(n)\\n ban = set()\\n\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > n - j or lcp[i][j] > n - i:\\n return \\\"\\\"\\n\\n size = lcp[i][j]\\n\\n if size == 0:\\n ban.add((i, j))\\n \\n else:\\n for k in range(size):\\n if dsu.find(i + k) == dsu.find(j + k):\\n break\\n if (i + k, j + k) in ban:\\n return \\\"\\\"\\n dsu.union(i + k, j + k)\\n\\n if j + size < n:\\n if dsu.find(i + size) == dsu.find(j + size):\\n return \\\"\\\"\\n ban.add((i + size, j + size))\\n \\n for i, j in ban:\\n if dsu.find(i) == dsu.find(j):\\n return \\\"\\\"\\n\\n res = [\\\"\\\" for _ in range(n)]\\n candidate = ord(\\\"a\\\")\\n for i in range(n):\\n p = dsu.find(i)\\n if res[p]:\\n res[i] = res[p]\\n else:\\n if candidate > ord(\\\"z\\\"):\\n return \\\"\\\"\\n res[i] = res[p] = chr(candidate)\\n candidate += 1\\n\\n return \\\"\\\".join(res)\\n \",\n \"runtime\": \"1783\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n t = [i for i in range(len(lcp))]\\n for i in range(len(lcp)):\\n for j in range(i+1, len(lcp)):\\n if lcp[i][j] != 0: t[j] = t[i]\\n res = \\\"\\\"\\n d = {}\\n for i in range(len(t)): \\n if t[i] in d: pass\\n elif len(d.keys()) < 26:\\n d[t[i]] = chr(len(d.keys())+97)\\n else: return \\\"\\\"\\n res += d[t[i]]\\n for i in range(len(lcp)):\\n for j in range(len(lcp)):\\n if i+lcp[i][j]>len(res) or j+lcp[i][j] > len(res) or res[i:i+lcp[i][j]] != res[j:j+lcp[i][j]]:\\n return \\\"\\\"\\n if i+lcp[i][j]+1 <= len(res) and j+lcp[i][j]+1 <= len(res) and (res[i:i+lcp[i][j]+1] == res[j:j+lcp[i][j]+1]):\\n return \\\"\\\"\\n return res\",\n \"runtime\": \"1893\"\n },\n {\n \"code\": \"class DSU:\\n def __init__(self, n):\\n self.n = n\\n self.p = [i for i in range(n)]\\n self.r = [0 for _ in range(n)]\\n \\n def find(self, u):\\n if self.p[u] != u:\\n self.p[u] = self.find(self.p[u])\\n return self.p[u]\\n \\n def union(self, u, v):\\n pu, pv = self.find(u), self.find(v)\\n if pu == pv:\\n return\\n ru, rv = self.r[pu], self.r[pv]\\n if ru > rv:\\n self.p[pv] = pu\\n elif ru < rv:\\n self.p[pu] = pv\\n else:\\n self.p[pv] = pu\\n self.r[pu] += 1\\n\\n\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp) \\n dsu = DSU(n)\\n ban = set()\\n\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return \\\"\\\"\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i] or lcp[i][j] > n - j or lcp[i][j] > n - i:\\n return \\\"\\\"\\n\\n size = lcp[i][j]\\n\\n if size == 0:\\n ban.add((i, j))\\n\\n for k in range(size):\\n if dsu.find(i + k) == dsu.find(j + k):\\n break\\n if (i + k, j + k) in ban:\\n return \\\"\\\"\\n dsu.union(i + k, j + k)\\n\\n if j + size < n:\\n if dsu.find(i + size) == dsu.find(j + size):\\n return \\\"\\\"\\n ban.add((i + size, j + size))\\n \\n for i, j in ban:\\n if dsu.find(i) == dsu.find(j):\\n return \\\"\\\"\\n\\n res = [\\\"\\\" for _ in range(n)]\\n candidate = ord(\\\"a\\\")\\n for i in range(n):\\n p = dsu.find(i)\\n if res[p]:\\n res[i] = res[p]\\n else:\\n if candidate > ord(\\\"z\\\"):\\n return \\\"\\\"\\n res[i] = res[p] = chr(candidate)\\n candidate += 1\\n\\n return \\\"\\\".join(res)\\n \",\n \"runtime\": \"1940\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":60,"string":"60"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","memory":"76700"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n A = [0] * n\n c = 1\n for i in range(n):\n if A[i]: continue\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n A[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\n v = v + 1 if A[i] == A[j] else 0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + i - 1) for i in A)","memory":"77400"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern \\u2014 the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)","memory":"77700"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n res = [0] * n\n c = 1\n for i in range(n):\n if res[i] == 0:\n if c > 26: return ''\n for j in range(i, n):\n if lcp[i][j]:\n res[j] = c\n c += 1\n for i in range(n):\n for j in range(n):\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\n v = v + 1 if res[i] == res[j] else 0\n if lcp[i][j] != v:\n return ''\n return ''.join(chr(ord('a') + num - 1) for num in res)","memory":"77800"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","memory":"77900"},{"code":"class Solution:\n def z_function(self, s):\n n = len(s)\n z = [0] * n\n l, r = 0, 0\n for i in range(1, n):\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\n else:\n z[i] = max(0, r - i + 1)\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\n if i + z[i] - 1 > r:\n l = i\n r = i + z[i] - 1\n z[0] = len(s)\n return z\n\n def findTheString(self, lcp: List[List[int]]) -> str:\n n = len(lcp)\n s, idx = [''] * n, 0\n for i in range(n):\n if i + lcp[i][i] != n: return ''\n if s[i] == '':\n if idx > 25: return ''\n s[i] = chr(ord('a') + idx)\n idx += 1\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]: return ''\n if lcp[i][j]:\n if s[j] != '' and s[j] != s[i]: return ''\n s[j] = s[i]\n s = ''.join(s)\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s","memory":"78000"},{"code":"\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern — the only possible candidate for answer\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n):\n if lcp[i][j] > 0:\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)\n","memory":"78100"},{"code":"\nclass Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n # simple validation\n n = len(lcp)\n for i in range(n):\n for j in range(i + 1, n):\n if lcp[i][j] != lcp[j][i]:\n return ''\n if lcp[i][j] > n - j:\n return ''\n for i in range(n):\n if lcp[i][i] != n - i:\n return ''\n \n # build pattern - fix syntax error\n pattern = [None for _ in range(n)]\n next_el_ind = 0\n for i in range(n):\n if pattern[i] is not None:\n continue\n pattern[i] = next_el_ind\n next_el_ind += 1\n for j in range(i+1, n): # fix syntax error\n if lcp[i][j] > 0: # fix syntax error\n if pattern[j] is not None and pattern[j] != pattern[i]:\n return ''\n pattern[j] = pattern[i]\n \n # check if lcp is valid - check that pattern's lcp == original lcp\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\n for i in range(n-1, -1, -1):\n for j in range(n-1, -1, -1):\n if pattern[i] == pattern[j]:\n if max(i, j) + 1 < n:\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\n else:\n pattern_lcp[i][j] = 1\n for i in range(n):\n for j in range(n):\n if lcp[i][j] != pattern_lcp[i][j]:\n return ''\n \n # check that answer has no more than 26 distinct elements\n if max(pattern) > ord('z') - ord('a'):\n return ''\n\n return ''.join(chr(ord('a') + ind) for ind in pattern)\n","memory":"78200"},{"code":"class Solution:\n def findTheString(self, lcp: List[List[int]]) -> str:\n \n for ea in range(len(lcp)):\n \n for jh in range(len(lcp[0])):\n if lcp[ea][jh] != lcp[jh][ea]:\n return ''\n for ea in range(len(lcp)):\n leng = len(lcp) - ea\n if lcp[ea][ea] != leng:\n return ''\n \n quiq = True\n for jh in range(len(lcp)):\n thesis = lcp[jh][jh:]\n \n donk = thesis[::-1]\n if donk != [1 + i for i in range(len(donk))]:\n quiq = False\n if quiq:\n return 'a'*len(lcp)\n \n not_equal = defaultdict(set)\n \n equal = defaultdict(set)\n \n for ea in range(len(lcp)):\n \n for jh in range(len(lcp[0])):\n if lcp[ea][jh] != lcp[jh][ea]:\n return ''\n \n for ea in range(len(lcp)):\n for jh in range(ea, len(lcp)):\n \n end = lcp[ea][jh]\n \n if end + jh> len(lcp):\n return ''\n if ea == jh:\n continue\n \n \n \n for sk in range(lcp[ea][jh]):\n equal[sk + ea].add(sk + jh)\n equal[sk + jh].add(sk + ea)\n \n if end < len(lcp):\n end = lcp[ea][jh]\n\n not_equal[jh + end].add(ea + end)\n not_equal[ea + end].add(jh + end)\n \n if all([len(list(not_equal[j])) == 0 for j in list(not_equal.keys())]):\n return 'a' * len(lcp)\n \n print(equal, not_equal)\n \n \n for ea in equal.keys():\n \n basis = list(equal[ea])\n print(basis)\n for nth in range(len(basis)):\n for kth in range(nth + 1, len(basis)):\n \n n = basis[nth]\n k = basis[kth]\n \n if n in not_equal[k] or k in not_equal[n]:\n \n return ''\n for jh in not_equal.keys():\n if ea == jh:\n for jh in equal[ea]:\n if jh in not_equal[ea]:\n return ''\n basis = ['a' for i in range(len(lcp))]\n \n \n alpha = 'abcdefghijklmnopqrstuvwxyz'\n \n \n \n for ea in range(len(basis)):\n \n if len(equal[ea]) > 0:\n if min(equal[ea]) < ea:\n basis[ea] = basis[min(equal[ea])]\n print('hit')\n continue\n basils = [i for i in not_equal[ea] if i < ea]\n donks = list([i for i in alpha])\n for jh in basils:\n\n \n if basis[jh] in donks:\n donks.remove(basis[jh])\n if len(donks) == 0:\n return ''\n basis[ea] = min(donks)\n \n return ''.join(basis)\n \n","memory":"78300"},{"code":"class dsu():\n\tdef __init__(self,n):\n\t\tself.parent=[0]*(n)\n\t\tself.sz=[0]*(n)\n\n\tdef make_set(self,v):\n\t\tself.parent[v]=v\n\t\tself.sz[v]=1\n\n\tdef find_set(self,v):\n\t\tif v==self.parent[v]:\n\t\t\treturn v\n\t\tself.parent[v]=self.find_set(self.parent[v])\n\t\treturn self.parent[v]\n\n\tdef union(self,a,b):\n\t\ta=self.find_set(a)\n\t\tb=self.find_set(b)\n\t\tif a==b:\n\t\t\treturn\n\t\tif self.sz[a]<self.sz[b]:\n\t\t\ta,b=b,a\n\t\tself.parent[b]=a\n\t\tself.sz[a]+=self.sz[b]\n\n\tdef getsize(self,v):\n\t\treturn self.sz[self.find_set(v)]\ndef Z(s):\n\tn=len(s)\n\tx=0;y=0\n\tz=[0]*(n)\n\tfor i in range(1,n):\n\t\tz[i]=max(0,min(z[i-x],y-i+1))\n\t\twhile i+z[i]<n and s[z[i]]==s[i+z[i]]:\n\t\t\tx=i\n\t\t\ty=i+z[i]\n\t\t\tz[i]+=1\n\treturn z\nclass Solution:\n def findTheString(self, l: List[List[int]]) -> str:\n pairs=[]\n n=len(l)\n ds=dsu(n)\n for i in range(n):\n ds.make_set(i)\n for i in range(n):\n for j in range(n):\n if l[i][j]:\n if ds.find_set(i)!=ds.find_set(j):\n ds.union(i,j)\n st=defaultdict(list)\n for i in range(n):\n st[ds.find_set(i)].append(i)\n vis=[0]*n\n let=\"abcdefghijklmnopqrstuvwxyz\"\n print(len(let))\n base=0\n sr=[\"-1\"]*n\n for i in range(n):\n \n if vis[i]:\n continue\n for vl in st[ds.find_set(i)]:\n vis[vl]=1\n sr[vl]=let[base]\n base+=1\n if base>=26:\n base=0\n # return \"\"\n fl=False\n lc=[]\n sr=\"\".join(sr)\n for i in range(n):\n li=sr[i:]\n x=li+\"#\"+sr\n zr=Z(x)\n print(zr)\n lc.append(zr[len(li)+1:])\n if lc!=l:\n return \"\"\n return sr","memory":"78600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"memory\": \"76700\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n A = [0] * n\\n c = 1\\n for i in range(n):\\n if A[i]: continue\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n A[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\\n v = v + 1 if A[i] == A[j] else 0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + i - 1) for i in A)\",\n \"memory\": \"77400\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern \\\\u2014 the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\",\n \"memory\": \"77700\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n res = [0] * n\\n c = 1\\n for i in range(n):\\n if res[i] == 0:\\n if c > 26: return ''\\n for j in range(i, n):\\n if lcp[i][j]:\\n res[j] = c\\n c += 1\\n for i in range(n):\\n for j in range(n):\\n v = lcp[i + 1][j + 1] if i + 1 < n and j + 1 < n else 0\\n v = v + 1 if res[i] == res[j] else 0\\n if lcp[i][j] != v:\\n return ''\\n return ''.join(chr(ord('a') + num - 1) for num in res)\",\n \"memory\": \"77800\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"memory\": \"77900\"\n },\n {\n \"code\": \"class Solution:\\n def z_function(self, s):\\n n = len(s)\\n z = [0] * n\\n l, r = 0, 0\\n for i in range(1, n):\\n if i <= r and z[i - l] < r - i + 1:z[i] = z[i - l]\\n else:\\n z[i] = max(0, r - i + 1)\\n while i + z[i] < n and s[z[i]] == s[i + z[i]]:z[i] += 1\\n if i + z[i] - 1 > r:\\n l = i\\n r = i + z[i] - 1\\n z[0] = len(s)\\n return z\\n\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n n = len(lcp)\\n s, idx = [''] * n, 0\\n for i in range(n):\\n if i + lcp[i][i] != n: return ''\\n if s[i] == '':\\n if idx > 25: return ''\\n s[i] = chr(ord('a') + idx)\\n idx += 1\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]: return ''\\n if lcp[i][j]:\\n if s[j] != '' and s[j] != s[i]: return ''\\n s[j] = s[i]\\n s = ''.join(s)\\n return '' if any(self.z_function(s[i:]) != lcp[i][i:] for i in range(n)) else s\",\n \"memory\": \"78000\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern — the only possible candidate for answer\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n):\\n if lcp[i][j] > 0:\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\\n\",\n \"memory\": \"78100\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n # simple validation\\n n = len(lcp)\\n for i in range(n):\\n for j in range(i + 1, n):\\n if lcp[i][j] != lcp[j][i]:\\n return ''\\n if lcp[i][j] > n - j:\\n return ''\\n for i in range(n):\\n if lcp[i][i] != n - i:\\n return ''\\n \\n # build pattern - fix syntax error\\n pattern = [None for _ in range(n)]\\n next_el_ind = 0\\n for i in range(n):\\n if pattern[i] is not None:\\n continue\\n pattern[i] = next_el_ind\\n next_el_ind += 1\\n for j in range(i+1, n): # fix syntax error\\n if lcp[i][j] > 0: # fix syntax error\\n if pattern[j] is not None and pattern[j] != pattern[i]:\\n return ''\\n pattern[j] = pattern[i]\\n \\n # check if lcp is valid - check that pattern's lcp == original lcp\\n pattern_lcp = [[0 for _ in range(n)] for _ in range(n)]\\n for i in range(n-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if pattern[i] == pattern[j]:\\n if max(i, j) + 1 < n:\\n pattern_lcp[i][j] = pattern_lcp[i+1][j+1] + 1\\n else:\\n pattern_lcp[i][j] = 1\\n for i in range(n):\\n for j in range(n):\\n if lcp[i][j] != pattern_lcp[i][j]:\\n return ''\\n \\n # check that answer has no more than 26 distinct elements\\n if max(pattern) > ord('z') - ord('a'):\\n return ''\\n\\n return ''.join(chr(ord('a') + ind) for ind in pattern)\\n\",\n \"memory\": \"78200\"\n },\n {\n \"code\": \"class Solution:\\n def findTheString(self, lcp: List[List[int]]) -> str:\\n \\n for ea in range(len(lcp)):\\n \\n for jh in range(len(lcp[0])):\\n if lcp[ea][jh] != lcp[jh][ea]:\\n return ''\\n for ea in range(len(lcp)):\\n leng = len(lcp) - ea\\n if lcp[ea][ea] != leng:\\n return ''\\n \\n quiq = True\\n for jh in range(len(lcp)):\\n thesis = lcp[jh][jh:]\\n \\n donk = thesis[::-1]\\n if donk != [1 + i for i in range(len(donk))]:\\n quiq = False\\n if quiq:\\n return 'a'*len(lcp)\\n \\n not_equal = defaultdict(set)\\n \\n equal = defaultdict(set)\\n \\n for ea in range(len(lcp)):\\n \\n for jh in range(len(lcp[0])):\\n if lcp[ea][jh] != lcp[jh][ea]:\\n return ''\\n \\n for ea in range(len(lcp)):\\n for jh in range(ea, len(lcp)):\\n \\n end = lcp[ea][jh]\\n \\n if end + jh> len(lcp):\\n return ''\\n if ea == jh:\\n continue\\n \\n \\n \\n for sk in range(lcp[ea][jh]):\\n equal[sk + ea].add(sk + jh)\\n equal[sk + jh].add(sk + ea)\\n \\n if end < len(lcp):\\n end = lcp[ea][jh]\\n\\n not_equal[jh + end].add(ea + end)\\n not_equal[ea + end].add(jh + end)\\n \\n if all([len(list(not_equal[j])) == 0 for j in list(not_equal.keys())]):\\n return 'a' * len(lcp)\\n \\n print(equal, not_equal)\\n \\n \\n for ea in equal.keys():\\n \\n basis = list(equal[ea])\\n print(basis)\\n for nth in range(len(basis)):\\n for kth in range(nth + 1, len(basis)):\\n \\n n = basis[nth]\\n k = basis[kth]\\n \\n if n in not_equal[k] or k in not_equal[n]:\\n \\n return ''\\n for jh in not_equal.keys():\\n if ea == jh:\\n for jh in equal[ea]:\\n if jh in not_equal[ea]:\\n return ''\\n basis = ['a' for i in range(len(lcp))]\\n \\n \\n alpha = 'abcdefghijklmnopqrstuvwxyz'\\n \\n \\n \\n for ea in range(len(basis)):\\n \\n if len(equal[ea]) > 0:\\n if min(equal[ea]) < ea:\\n basis[ea] = basis[min(equal[ea])]\\n print('hit')\\n continue\\n basils = [i for i in not_equal[ea] if i < ea]\\n donks = list([i for i in alpha])\\n for jh in basils:\\n\\n \\n if basis[jh] in donks:\\n donks.remove(basis[jh])\\n if len(donks) == 0:\\n return ''\\n basis[ea] = min(donks)\\n \\n return ''.join(basis)\\n \\n\",\n \"memory\": \"78300\"\n },\n {\n \"code\": \"class dsu():\\n\\tdef __init__(self,n):\\n\\t\\tself.parent=[0]*(n)\\n\\t\\tself.sz=[0]*(n)\\n\\n\\tdef make_set(self,v):\\n\\t\\tself.parent[v]=v\\n\\t\\tself.sz[v]=1\\n\\n\\tdef find_set(self,v):\\n\\t\\tif v==self.parent[v]:\\n\\t\\t\\treturn v\\n\\t\\tself.parent[v]=self.find_set(self.parent[v])\\n\\t\\treturn self.parent[v]\\n\\n\\tdef union(self,a,b):\\n\\t\\ta=self.find_set(a)\\n\\t\\tb=self.find_set(b)\\n\\t\\tif a==b:\\n\\t\\t\\treturn\\n\\t\\tif self.sz[a]<self.sz[b]:\\n\\t\\t\\ta,b=b,a\\n\\t\\tself.parent[b]=a\\n\\t\\tself.sz[a]+=self.sz[b]\\n\\n\\tdef getsize(self,v):\\n\\t\\treturn self.sz[self.find_set(v)]\\ndef Z(s):\\n\\tn=len(s)\\n\\tx=0;y=0\\n\\tz=[0]*(n)\\n\\tfor i in range(1,n):\\n\\t\\tz[i]=max(0,min(z[i-x],y-i+1))\\n\\t\\twhile i+z[i]<n and s[z[i]]==s[i+z[i]]:\\n\\t\\t\\tx=i\\n\\t\\t\\ty=i+z[i]\\n\\t\\t\\tz[i]+=1\\n\\treturn z\\nclass Solution:\\n def findTheString(self, l: List[List[int]]) -> str:\\n pairs=[]\\n n=len(l)\\n ds=dsu(n)\\n for i in range(n):\\n ds.make_set(i)\\n for i in range(n):\\n for j in range(n):\\n if l[i][j]:\\n if ds.find_set(i)!=ds.find_set(j):\\n ds.union(i,j)\\n st=defaultdict(list)\\n for i in range(n):\\n st[ds.find_set(i)].append(i)\\n vis=[0]*n\\n let=\\\"abcdefghijklmnopqrstuvwxyz\\\"\\n print(len(let))\\n base=0\\n sr=[\\\"-1\\\"]*n\\n for i in range(n):\\n \\n if vis[i]:\\n continue\\n for vl in st[ds.find_set(i)]:\\n vis[vl]=1\\n sr[vl]=let[base]\\n base+=1\\n if base>=26:\\n base=0\\n # return \\\"\\\"\\n fl=False\\n lc=[]\\n sr=\\\"\\\".join(sr)\\n for i in range(n):\\n li=sr[i:]\\n x=li+\\\"#\\\"+sr\\n zr=Z(x)\\n print(zr)\\n lc.append(zr[len(li)+1:])\\n if lc!=l:\\n return \\\"\\\"\\n return sr\",\n \"memory\": \"78600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":2464,"cells":{"question_id":{"kind":"number","value":3476,"string":"3,476"},"name":{"kind":"string","value":"find-minimum-operations-to-make-all-elements-divisible-by-three"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code>. In one operation, you can add or subtract 1 from <strong>any</strong> element of <code>nums</code>.</p>\n\n<p>Return the <strong>minimum</strong> number of operations to make all elements of <code>nums</code> divisible by 3.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,4]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">3</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>All array elements can be made divisible by 3 using 3 operations:</p>\n\n<ul>\n\t<li>Subtract 1 from 1.</li>\n\t<li>Add 1 to 2.</li>\n\t<li>Subtract 1 from 4.</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [3,6,9]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">0</span></p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 50</code></li>\n\t<li><code>1 <= nums[i] <= 50</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":89.93196330202117,"string":"89.931963"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","math"],"string":"[\n \"array\",\n \"math\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18\", 0.0312], [\"19\", 0.0312], [\"21\", 0.0156], [\"22\", 0.078], [\"23\", 0.0624], [\"24\", 0.1248], [\"25\", 0.1248], [\"26\", 0.2652], [\"27\", 0.4835], [\"28\", 0.6551], [\"29\", 0.6083], [\"30\", 0.8891], [\"31\", 1.4038], [\"32\", 2.1681], [\"33\", 2.2149], [\"34\", 2.4489], [\"35\", 3.5876], [\"36\", 5.2722], [\"37\", 4.6327], [\"38\", 4.2583], [\"39\", 6.754], [\"40\", 8.3294], [\"41\", 6.2081], [\"42\", 6.1769], [\"43\", 7.7679], [\"44\", 7.9707], [\"45\", 6.2081], [\"46\", 5.1162], [\"47\", 4.5703], [\"48\", 4.1179]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"15900\", 0.0156], [\"16100\", 0.0312], [\"16200\", 0.0624], [\"16300\", 1.6534], [\"16400\", 16.7213], [\"16500\", 32.569], [\"16600\", 43.5813]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n sum = 0 \n for i in nums:\n if i % 3 != 0:\n sum+=1\n \n return sum","runtime":"18"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count =0\n for i in nums:\n if i%3!=0:\n count=count+1\n return count\n \n\n ","runtime":"19"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n if i%3!=0:\n c+=1\n return c","runtime":"21"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n counter: int = 0\n for num in nums:\n numTest = num + 1\n counter += self.ifdivisiblebythree(numTest)\n numTest = num - 1\n counter += self.ifdivisiblebythree(numTest)\n return counter\n\n def ifdivisiblebythree(self, numToTest):\n if (numToTest % 3) == 0:\n return 1\n else:\n return 0\n\nif __name__ == \"__main__\":\n nums: List[int] = [1,2,3,4]\n solMinimumOperations = Solution()\n ans = solMinimumOperations.minimumOperations(nums)","runtime":"22"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n tot = 0\n for i in nums:\n if i%3 != 0:\n if (i+1)%3 == 0 or (i-1)%3 == 0:\n tot += 1\n return tot\n ","runtime":"23"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count = 0\n\n for num in nums:\n if num % 3 != 0:\n count += 1\n return count","runtime":"24"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n ans = 0\n\n for num in nums:\n if num % 3 != 0:\n ans += 1\n\n return ans","runtime":"25"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n ops = 0\n for i in nums:\n if (i % 3 != 0):\n ops += 1\n return ops","runtime":"26"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for num in nums:\n if num%3!=0:\n count+=1\n\n return count","runtime":"27"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n result = 0\n for num in nums:\n if num % 3 != 0:\n result += 1\n return result","runtime":"28"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n \n c = 0\n\n for i in nums:\n\n if i%3 == 0: \n continue\n else:\n c += 1\n\n return c","runtime":"29"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n ans = 0\n for num in nums:\n if num%3 != 0:\n ans += 1\n return ans","runtime":"30"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c = 0\n for i in range(len(nums)):\n if nums[i]%3!=0:\n c+=1\n return c","runtime":"31"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n cnt = 0\n for n in nums:\n if n % 3:\n cnt += 1\n return cnt","runtime":"31"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=len(nums)\n for i in nums:\n if i%3==0:\n c=c-1\n return c","runtime":"32"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n if i%3!=0:\n c+=1\n return c\n ","runtime":"33"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n total = 0\n for i in nums:\n if (i % 3):\n total += 1\n return total\n","runtime":"34"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n n = 1\n c = 0\n for i in range(len(nums)):\n num=nums[i]-1\n numadd = nums[i]+1\n if num%3==0:\n c+=1\n if numadd%3==0:\n c+=1\n return c","runtime":"34"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n if i%3==0:\n count+=0\n else:\n count+=1\n return count","runtime":"35"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n operations = 0\n for num in nums:\n if num % 3:\n operations += 1\n return operations","runtime":"35"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n nums = [num % 3 for num in nums]\n\n ctr =Counter(nums)\n\n return ctr[1] + ctr[2]","runtime":"36"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n if i%3 ==0:\n continue\n else:\n c+=1\n return c\n\n ","runtime":"36"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count = 0\n for num in nums:\n if num % 3 != 0:\n count += 1\n return count","runtime":"37"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n if i%3!=0:\n count+=1\n return count\n ","runtime":"37"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n if i%3!=0:\n c+=1\n return c","runtime":"38"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n cnt = 0\n for i in range(len(nums)):\n if nums[i] % 3 != 0:\n cnt += 1\n\n return cnt","runtime":"38"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n return len([n for n in nums if n % 3 != 0])","runtime":"39"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n return sum(num % 3 != 0 for num in nums)","runtime":"39"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c = 0\n for x in nums:\n if x % 3 != 0:\n c = c + 1\n return c","runtime":"40"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n if i%3!=0:\n c+=1\n else:\n continue\n return c\n","runtime":"40"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n sum=0\n for i in nums:\n if i%3!=0:\n sum+=1\n return sum","runtime":"41"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n op = 0\n \n for i in range(len(nums)):\n mod = nums[i] % 3\n if mod != 0:\n nums[i] += (1 if mod == 2 else -1)\n op += 1\n \n return op","runtime":"41"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n res = 0\n for num in nums:\n if not num % 3 == 0:\n res += 1\n return res","runtime":"42"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n res = 0\n for i in nums:\n if i%3!=0:\n res+=1\n return res","runtime":"43"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n op = 0\n \n for num in range(len(nums)):\n if nums[num] % 3 != 0:\n if nums[num] % 3 == 1:\n nums[num] -= 1\n op += 1\n if nums[num] % 3 == 2:\n nums[num] += 1\n op += 1\n return op","runtime":"43"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n return sum([1 if n%3 else 0 for n in nums])","runtime":"44"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n \n \n \n k1=0\n for i in range(len(nums)):\n if nums[i]%3==1:\n k1=k1+1\n elif nums[i]%3==2:\n k1=k1+1\n return k1\n \n ","runtime":"44"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n if i%3==0:\n continue\n else:\n count+=1\n return count","runtime":"45"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n minOp = 0\n\n for num in nums:\n minOp += min(num % 3, 3 - (num % 3))\n \n return minOp\n\n","runtime":"45"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n counter = 0 \n for x in nums : \n if x % 3 != 0 : counter +=1\n return counter\n","runtime":"46"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count = 0\n for num in nums:\n remainder = num % 3\n if remainder == 1:\n count += 1 \n elif remainder == 2:\n count += 1 \n\n return count","runtime":"46"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count = 0\n for num in nums:\n if num % 3 != 0:\n count+=1\n\n return count","runtime":"47"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n if i%3!=0:\n count+=1\n return count\n ","runtime":"47"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n count+=min(i%3,3-(i%3))\n return count\n ","runtime":"48"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n sum = 0 \\n for i in nums:\\n if i % 3 != 0:\\n sum+=1\\n \\n return sum\",\n \"runtime\": \"18\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count =0\\n for i in nums:\\n if i%3!=0:\\n count=count+1\\n return count\\n \\n\\n \",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n if i%3!=0:\\n c+=1\\n return c\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n counter: int = 0\\n for num in nums:\\n numTest = num + 1\\n counter += self.ifdivisiblebythree(numTest)\\n numTest = num - 1\\n counter += self.ifdivisiblebythree(numTest)\\n return counter\\n\\n def ifdivisiblebythree(self, numToTest):\\n if (numToTest % 3) == 0:\\n return 1\\n else:\\n return 0\\n\\nif __name__ == \\\"__main__\\\":\\n nums: List[int] = [1,2,3,4]\\n solMinimumOperations = Solution()\\n ans = solMinimumOperations.minimumOperations(nums)\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n tot = 0\\n for i in nums:\\n if i%3 != 0:\\n if (i+1)%3 == 0 or (i-1)%3 == 0:\\n tot += 1\\n return tot\\n \",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count = 0\\n\\n for num in nums:\\n if num % 3 != 0:\\n count += 1\\n return count\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n ans = 0\\n\\n for num in nums:\\n if num % 3 != 0:\\n ans += 1\\n\\n return ans\",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n ops = 0\\n for i in nums:\\n if (i % 3 != 0):\\n ops += 1\\n return ops\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for num in nums:\\n if num%3!=0:\\n count+=1\\n\\n return count\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n result = 0\\n for num in nums:\\n if num % 3 != 0:\\n result += 1\\n return result\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n \\n c = 0\\n\\n for i in nums:\\n\\n if i%3 == 0: \\n continue\\n else:\\n c += 1\\n\\n return c\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for num in nums:\\n if num%3 != 0:\\n ans += 1\\n return ans\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c = 0\\n for i in range(len(nums)):\\n if nums[i]%3!=0:\\n c+=1\\n return c\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n cnt = 0\\n for n in nums:\\n if n % 3:\\n cnt += 1\\n return cnt\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=len(nums)\\n for i in nums:\\n if i%3==0:\\n c=c-1\\n return c\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n if i%3!=0:\\n c+=1\\n return c\\n \",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n total = 0\\n for i in nums:\\n if (i % 3):\\n total += 1\\n return total\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n n = 1\\n c = 0\\n for i in range(len(nums)):\\n num=nums[i]-1\\n numadd = nums[i]+1\\n if num%3==0:\\n c+=1\\n if numadd%3==0:\\n c+=1\\n return c\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n if i%3==0:\\n count+=0\\n else:\\n count+=1\\n return count\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n operations = 0\\n for num in nums:\\n if num % 3:\\n operations += 1\\n return operations\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n nums = [num % 3 for num in nums]\\n\\n ctr =Counter(nums)\\n\\n return ctr[1] + ctr[2]\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n if i%3 ==0:\\n continue\\n else:\\n c+=1\\n return c\\n\\n \",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count = 0\\n for num in nums:\\n if num % 3 != 0:\\n count += 1\\n return count\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n if i%3!=0:\\n count+=1\\n return count\\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n if i%3!=0:\\n c+=1\\n return c\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n cnt = 0\\n for i in range(len(nums)):\\n if nums[i] % 3 != 0:\\n cnt += 1\\n\\n return cnt\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n return len([n for n in nums if n % 3 != 0])\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n return sum(num % 3 != 0 for num in nums)\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c = 0\\n for x in nums:\\n if x % 3 != 0:\\n c = c + 1\\n return c\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n if i%3!=0:\\n c+=1\\n else:\\n continue\\n return c\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n sum=0\\n for i in nums:\\n if i%3!=0:\\n sum+=1\\n return sum\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n op = 0\\n \\n for i in range(len(nums)):\\n mod = nums[i] % 3\\n if mod != 0:\\n nums[i] += (1 if mod == 2 else -1)\\n op += 1\\n \\n return op\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n res = 0\\n for num in nums:\\n if not num % 3 == 0:\\n res += 1\\n return res\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n res = 0\\n for i in nums:\\n if i%3!=0:\\n res+=1\\n return res\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n op = 0\\n \\n for num in range(len(nums)):\\n if nums[num] % 3 != 0:\\n if nums[num] % 3 == 1:\\n nums[num] -= 1\\n op += 1\\n if nums[num] % 3 == 2:\\n nums[num] += 1\\n op += 1\\n return op\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n return sum([1 if n%3 else 0 for n in nums])\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n \\n \\n \\n k1=0\\n for i in range(len(nums)):\\n if nums[i]%3==1:\\n k1=k1+1\\n elif nums[i]%3==2:\\n k1=k1+1\\n return k1\\n \\n \",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n if i%3==0:\\n continue\\n else:\\n count+=1\\n return count\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n minOp = 0\\n\\n for num in nums:\\n minOp += min(num % 3, 3 - (num % 3))\\n \\n return minOp\\n\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n counter = 0 \\n for x in nums : \\n if x % 3 != 0 : counter +=1\\n return counter\\n\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count = 0\\n for num in nums:\\n remainder = num % 3\\n if remainder == 1:\\n count += 1 \\n elif remainder == 2:\\n count += 1 \\n\\n return count\",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count = 0\\n for num in nums:\\n if num % 3 != 0:\\n count+=1\\n\\n return count\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n if i%3!=0:\\n count+=1\\n return count\\n \",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n count+=min(i%3,3-(i%3))\\n return count\\n \",\n \"runtime\": \"48\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":44,"string":"44"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n return sum(1 if i % 3 != 0 else 0 for i in nums)","memory":"15900"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n c=0\n for i in nums:\n rem=i%3\n if rem==1:\n c+=1\n elif rem==2:\n c+=1\n return c\n","memory":"16100"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n skibidi=0\n for item in nums:\n remainder=item%3\n if remainder==1 or remainder==2:\n skibidi+=1\n\n return skibidi","memory":"16200"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n ans = 0\n for num in nums:\n if num%3!=0:\n ans+=1\n return ans","memory":"16300"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count = 0\n for num in nums:\n if num % 3 != 0:\n count+=1\n\n return count","memory":"16400"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n ops=0\n for n in nums:\n z=n%3\n ops+=z if z<2 else 1\n return ops","memory":"16400"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n count=0\n for i in nums:\n if i%3==0:\n count+=0\n else:\n count+=1\n return count","memory":"16600"},{"code":"class Solution:\n def minimumOperations(self, nums: List[int]) -> int:\n minOp = 0\n\n for num in nums:\n minOp += min(num % 3, 3 - (num % 3))\n \n return minOp\n\n","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n return sum(1 if i % 3 != 0 else 0 for i in nums)\",\n \"memory\": \"15900\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in nums:\\n rem=i%3\\n if rem==1:\\n c+=1\\n elif rem==2:\\n c+=1\\n return c\\n\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n skibidi=0\\n for item in nums:\\n remainder=item%3\\n if remainder==1 or remainder==2:\\n skibidi+=1\\n\\n return skibidi\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for num in nums:\\n if num%3!=0:\\n ans+=1\\n return ans\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count = 0\\n for num in nums:\\n if num % 3 != 0:\\n count+=1\\n\\n return count\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n ops=0\\n for n in nums:\\n z=n%3\\n ops+=z if z<2 else 1\\n return ops\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in nums:\\n if i%3==0:\\n count+=0\\n else:\\n count+=1\\n return count\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def minimumOperations(self, nums: List[int]) -> int:\\n minOp = 0\\n\\n for num in nums:\\n minOp += min(num % 3, 3 - (num % 3))\\n \\n return minOp\\n\\n\",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":8,"string":"8"}}},{"rowIdx":2465,"cells":{"question_id":{"kind":"number","value":3475,"string":"3,475"},"name":{"kind":"string","value":"minimum-operations-to-make-binary-array-elements-equal-to-one-i"},"content":{"kind":"string","value":"<p>You are given a <span data-keyword=\"binary-array\">binary array</span> <code>nums</code>.</p>\n\n<p>You can do the following operation on the array <strong>any</strong> number of times (possibly zero):</p>\n\n<ul>\n\t<li>Choose <strong>any</strong> 3 <strong>consecutive</strong> elements from the array and <strong>flip</strong> <strong>all</strong> of them.</li>\n</ul>\n\n<p><strong>Flipping</strong> an element means changing its value from 0 to 1, and from 1 to 0.</p>\n\n<p>Return the <strong>minimum</strong> number of operations required to make all elements in <code>nums</code> equal to 1. If it is impossible, return -1.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [0,1,1,1,0,0]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">3</span></p>\n\n<p><strong>Explanation:</strong><br />\nWe can do the following operations:</p>\n\n<ul>\n\t<li>Choose the elements at indices 0, 1 and 2. The resulting array is <code>nums = [<u><strong>1</strong></u>,<u><strong>0</strong></u>,<u><strong>0</strong></u>,1,0,0]</code>.</li>\n\t<li>Choose the elements at indices 1, 2 and 3. The resulting array is <code>nums = [1,<u><strong>1</strong></u>,<u><strong>1</strong></u>,<strong><u>0</u></strong>,0,0]</code>.</li>\n\t<li>Choose the elements at indices 3, 4 and 5. The resulting array is <code>nums = [1,1,1,<strong><u>1</u></strong>,<u><strong>1</strong></u>,<u><strong>1</strong></u>]</code>.</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [0,1,1,1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">-1</span></p>\n\n<p><strong>Explanation:</strong><br />\nIt is impossible to make all elements equal to 1.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>3 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= nums[i] <= 1</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":71.06634080457923,"string":"71.066341"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","bit-manipulation","queue","sliding-window","prefix-sum"],"string":"[\n \"array\",\n \"bit-manipulation\",\n \"queue\",\n \"sliding-window\",\n \"prefix-sum\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"196\", 0.2946], [\"208\", 0.2946], [\"220\", 0.1473], [\"232\", 0.1473], [\"244\", 0.2946], [\"256\", 0.2946], [\"269\", 0.4418], [\"281\", 0.1473], [\"293\", 0.2946], [\"305\", 0.2946], [\"317\", 0.1473], [\"330\", 0.4418], [\"342\", 0.5891], [\"354\", 0.5891], [\"366\", 0.5891], [\"378\", 0.8837], [\"390\", 0.7364], [\"403\", 0.8837], [\"415\", 0.8837], [\"427\", 0.8837], [\"439\", 0.4418], [\"451\", 1.3255], [\"463\", 0.8837], [\"476\", 1.4728], [\"488\", 0.8837], [\"500\", 1.3255], [\"512\", 1.7673], [\"524\", 0.4418], [\"536\", 0.8837], [\"549\", 1.1782], [\"561\", 0.5891], [\"573\", 1.3255], [\"585\", 1.3255], [\"597\", 0.8837], [\"610\", 1.1782], [\"622\", 1.9146], [\"634\", 0.8837], [\"646\", 1.1782], [\"658\", 0.4418], [\"670\", 0.4418], [\"683\", 0.1473], [\"695\", 0.7364], [\"707\", 2.0619], [\"719\", 0.7364], [\"731\", 1.0309], [\"743\", 1.62], [\"756\", 1.1782], [\"768\", 0.8837], [\"780\", 1.3255], [\"792\", 0.2946], [\"804\", 1.0309], [\"817\", 0.8837], [\"829\", 1.4728], [\"841\", 0.7364], [\"853\", 0.7364], [\"865\", 0.8837], [\"877\", 0.2946], [\"890\", 1.1782], [\"902\", 0.4418], [\"914\", 0.2946], [\"926\", 0.8837], [\"938\", 0.5891], [\"950\", 1.0309], [\"963\", 1.0309], [\"975\", 0.7364], [\"987\", 0.1473], [\"999\", 0.7364], [\"1011\", 0.7364], [\"1023\", 0.5891], [\"1036\", 4.5657000000000005], [\"1048\", 6.6274999999999995], [\"1060\", 6.4803], [\"1072\", 5.4492], [\"1084\", 3.9766], [\"1097\", 2.9457999999999998], [\"1109\", 3.3875], [\"1121\", 3.6820000000000004], [\"1133\", 0.8837999999999999], [\"1145\", 1.9147999999999998], [\"1157\", 0.5892]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"18600\", 0.1473], [\"19400\", 0.1473], [\"19500\", 0.1473], [\"19700\", 0.1473], [\"19800\", 0.4418], [\"19900\", 1.9146], [\"20000\", 3.9764], [\"20100\", 6.1856], [\"20200\", 11.4875], [\"20300\", 17.5258], [\"20400\", 17.0839], [\"20500\", 17.9676], [\"20600\", 5.1546], [\"20700\", 3.0928], [\"20800\", 4.1237], [\"20900\", 2.3564]]}"},"rt_list":{"kind":"list like","value":[{"code":"\ndef minOperations(nums: List[int]) -> int:\n count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n count += 1\n nums[i] = 1\n nums[i + 1] = abs(nums[i + 1] - 1)\n nums[i + 2] = abs(nums[i + 2] - 1)\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return count\n\n\nwith open(\"user.out\", \"w\") as Solution:\n for nums in map(loads, stdin): Solution.write(f\"{minOperations(nums)}\\n\")\nexit() ","runtime":"196"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n flips = 0\n\n for i in range(n-2):\n if nums[i]==0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n \n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1","runtime":"196"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n b1, b2 = nums[:2]\n result = 0\n for i in range(2, len(nums)):\n b0, b1, b2 = b1, b2, nums[i]\n if b0 == 0:\n result += 1\n b1 ^= 1\n b2 ^= 1\n return result if b1 and b2 else -1\n","runtime":"208"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\n n = len(nums)\n flips = 0\n\n for i in range(n - 2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1","runtime":"220"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n\n for i in range(len(nums) - 2):\n if nums[i] == 1:\n continue\n else:\n res += 1\n nums[i] = 1\n nums[i + 1] = 1 - nums[i + 1]\n nums[i + 2] = 1 - nums[i + 2]\n \n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return res","runtime":"232"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n\n for i in range(n-2):\n if nums[i] == 0:\n res += 1\n nums[i] = 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-1] == 1 and nums[-2] == 1:\n return res\n else:\n return -1","runtime":"244"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n for i in range(len(nums)-2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1\n\n","runtime":"256"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n\n for i in range(n - 2):\n if nums[i] == 0:\n res += 1\n nums[i] = 1\n nums[i + 1] = 1 - nums[i + 1]\n nums[i + 2] = 1 - nums[i + 2]\n\n if nums[-1] == nums[-2] == 1:\n return res\n else:\n return -1","runtime":"269"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ret = 0\n for i in range(n - 2):\n if nums[i] == 0:\n ret += 1\n nums[i + 1] = 1 - nums[i + 1]\n nums[i + 2] = 1 - nums[i + 2]\n return ret if nums[-1] == nums[-2] == 1 else -1","runtime":"281"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n flips += 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n return flips if nums[-2] and nums[-1] else -1\n","runtime":"293"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] = 1\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\n count += 1\n return -1 if nums[n - 1] == 0 or nums[n - 2] == 0 or nums[n - 3] == 0 else count","runtime":"305"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n count += 1\n nums[i] = 1\n nums[i + 1] = abs(nums[i + 1] - 1)\n nums[i + 2] = abs(nums[i + 2] - 1)\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return count","runtime":"305"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] = 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n ans += 1\n\n if nums[-2] == 0 or nums[-1] == 0:\n return -1\n return ans","runtime":"317"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n count = 0\n for l in range(len(nums)-2):\n if nums[l] == 0:\n count += 1\n nums[l] = 1\n nums[l+1] = not nums[l+1]\n nums[l+2] = not nums[l+2]\n\n if nums[-1] == nums[-2] == nums[-3] == 1: # Edge case\n return count\n return -1\n ","runtime":"330"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n for i in range(len(nums) - 2):\n if nums[i]: continue\n nums[i + 1] = 1 - nums[i + 1]\n nums[i + 2] = 1 - nums[i + 2]\n ans += 1\n return ans if nums[-1] * nums[-2] else -1","runtime":"342"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] = 1\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\n count += 1\n if 0 in nums:\n return -1\n return count","runtime":"354"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n a = 0\n b = 0\n flips = 0\n for num in nums[:-2]:\n flip = 1 - ((num + flips) % 2)\n flips, a, b = flips + flip - a, b, flip\n ans += flip\n if 1 - ((nums[-2] + flips) % 2):\n return -1\n if 1 - ((nums[-1] + flips - a) % 2):\n return -1\n return ans","runtime":"366"},{"code":"'''\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\n\nComplexity\nLet $$ N := $$ length of input list\n\nTime\n$$O(N)$$\n\nSpace \n$$O(1)$$ ( Explicit and Implicit )\n'''\nclass Solution:\n # hint : think inducitvely\n def minOperations(self, nums: List[int]) -> int:\n # do not read the final two indices ( test both are zeroed out as well !)\n minOps = 0\n for idx in range(len(nums) - 2):\n if(nums[idx] == 0):\n minOps += 1\n nums[idx] = 1 - nums[idx]\n nums[idx+1] = 1 - nums[idx+1]\n nums[idx+2] = 1 - nums[idx+2]\n lastIdx = len(nums) - 1\n secondLastIdx = len(nums) - 2\n if(not(nums[lastIdx] == 1 and nums[secondLastIdx] == 1)):\n return -1\n return minOps","runtime":"378"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n count = 0\n\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n count += 1\n nums[i] = 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-1] == 1 and nums[-2] == 1:\n return count\n else:\n return -1","runtime":"390"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n l = 0\n\n for r in range(len(nums) - 2):\n if nums[r] == 0:\n nums[r] = 1\n if not nums[r + 1]:\n nums[r + 1] = 1\n else:\n nums[r + 1] = 0\n if not nums[r + 2]:\n nums[r + 2] = 1\n else:\n nums[r + 2] = 0\n \n res += 1\n\n return res if sum(nums[-2:]) == 2 else -1","runtime":"403"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n count = 0\n for i in range(n - 2):\n if nums[i] == 0:\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n count += 1\n if nums[n - 1] == 0 or nums[n - 2] == 0:\n return -1\n return count","runtime":"415"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n n += 1\n return n if nums[-1] == nums[-2] == 1 else -1","runtime":"427"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flip_count = 0\n\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i + 0] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n flip_count += 1\n\n return flip_count if (nums[-2] & nums[-1]) else -1","runtime":"439"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n result = 0\n for i in range(n-2):\n if nums[i] == 0:\n result += 1\n nums[i],nums[i+1],nums[i+2] = 1, 1 - nums[i+1], 1 - nums[i+2]\n \n for i in range(n-2,n):\n if nums[i] == 0:\n return - 1\n return result\n\n ","runtime":"451"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n r, n = 0, len(nums)\n for i in range(n - 2):\n if nums[i] == 1:\n continue\n nums[i+1], nums[i+2] = 1 - nums[i+1], 1 - nums[i+2]\n r += 1\n return r if nums[-1] == nums[-2] == 1 else -1","runtime":"463"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n cnt = 0\n for i in range(n-2):\n if nums[i]==0:\n # must flip (i,i+1,i+2)\n nums[i] = 1\n nums[i+1] = 1-nums[i+1]\n nums[i+2] = 1-nums[i+2]\n cnt += 1\n if nums[n-1]==1 and nums[n-2]==1:\n return cnt\n else:\n return -1","runtime":"476"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \"\"\"\n nums : binary array\n\n 1 operation:\n flip 3 consecutive elements\n\n Return the minimum number of operations required\n to make all elements in nums equal to 1.\n If impossible => -1\n \"\"\"\n count_op = 0\n n = len(nums)\n for l in range(n - 2):\n if nums[l] == 0:\n count_op += 1\n nums[l + 1] = 1 - nums[l + 1]\n nums[l + 2] = 1 - nums[l + 2]\n\n return count_op if nums[n - 1] == 1 == nums[n - 2] else -1\n","runtime":"488"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n c=0\n for i in range(len(nums)-2):\n if nums[i]==0:\n c=c+1\n nums[i]=1\n if(nums[i+1]==0):\n nums[i+1]=1\n else:\n nums[i+1]=0\n if(nums[i+2]==0):\n nums[i+2]=1\n else:\n nums[i+2]=0\n if(nums[-1]==0 or nums[-2]==0):\n return -1\n return c\n\n\n \n ","runtime":"500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\n n = len(nums)\n flips = 0\n\n for i in range(n - 2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1","runtime":"512"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n length = len(nums)\n count = 0\n for index in range(length - 2):\n if nums[index] == 0:\n nums[index] ^= 1\n nums[index + 1] ^= 1\n nums[index + 2] ^= 1\n count += 1\n\n for index in range(length - 2, length):\n if nums[index] == 0:\n return -1\n\n return count\n","runtime":"524"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n counter = 0\n for n in range(len(nums) - 2):\n\n if nums[n] == 0:\n nums[n] = 1 - nums[n]\n nums[n + 1] = 1 - nums[n + 1]\n nums[n + 2] = 1 - nums[n + 2]\n counter += 1\n\n\n if 0 in nums:\n counter = -1\n return counter\n","runtime":"536"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n result = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n result += 1\n my_set = set(nums)\n if len(my_set) == 1 and 1 in my_set:\n return result\n else:\n return -1","runtime":"549"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n n = len(nums)\n flip_count = 0\n next_flip, next_next_flip = 0, 0 # False, False\n\n for i in range(n - 2):\n if i == n - 3:\n # the last 3 elements to check\n if (nums[i] + next_flip) % 2 == 1:\n # no need to flip\n if (nums[i+1] + next_next_flip) % 2 == nums[i+2] == 1:\n return flip_count\n else:\n return -1\n else:\n # needs a flip\n flip_count += 1\n if (nums[i+1] + next_next_flip + 1) % 2 == (nums[i+2] + 1) % 2 == 1:\n return flip_count\n else:\n return -1\n \n if (nums[i] + next_flip) % 2 == 1:\n # no need to flip\n next_flip, next_next_flip = next_next_flip, 0\n else:\n # need to flip\n flip_count += 1\n next_flip, next_next_flip = (next_next_flip + 1) % 2, 1","runtime":"561"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n ans = 0\n\n for i in range(len(nums) - 2):\n\n if nums[i] == 0:\n nums[i] = 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n ans += 1\n\n \n return ans if nums[-1] == 1 and nums[-2] == 1 else -1\n ","runtime":"573"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n flipped = [0]*n \n flip = 0\n for i in range(n):\n if i>=3:\n # valid end \n flip ^= flipped[i-3]\n if nums[i] == flip:\n if i+3> n:\n return -1\n ans +=1\n flip ^= 1\n flipped[i] = 1\n \n \n return ans\n ","runtime":"585"},{"code":"from typing import List\n\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n \n for i in range(n - 2):\n if nums[i] == 0:\n res += 1\n nums[i] = 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n \n if nums[-1] == 1 and nums[-2] == 1:\n return res\n else:\n return -1","runtime":"597"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count=0\n for x in range(len(nums)-2):\n if nums[x]==0:\n count+=1\n nums[x]=1\n if nums[x+1]==1: nums[x+1]=0 \n else: nums[x+1]=1 \n if nums[x+2]==1: nums[x+2]=0 \n else: nums[x+2]=1\n if 0 in nums: return -1\n else: return count ","runtime":"610"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\n n = len(nums)\n flips = 0\n\n for i in range(n - 2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1","runtime":"622"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n operations = 0\n\n for i in range(n - 2): # leave last 2 elements\n if nums[i] == 0:\n # Flip the current element and the next two elements\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n operations += 1\n \n # Check the last two elements\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n\n return operations","runtime":"634"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n for i in range(len(nums)-2):\n val = nums[i]\n if val == 0:\n nums[i] = 1-nums[i]\n nums[i+1] = 1-nums[i+1]\n nums[i+2] = 1-nums[i+2]\n ans += 1\n if sum(nums) == len(nums):\n return ans\n return -1","runtime":"646"},{"code":"'''\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\n\nComplexity\nLet $$ N := $$ length of input list\n\nTime\n$$O(N)$$\n\nSpace \n$$O(1)$$ ( Explicit and Implicit )\n'''\nclass Solution:\n # hint : think inducitvely\n def minOperations(self, nums: List[int]) -> int:\n # do not read the final two indices ( test both are zeroed out as well !)\n minOps = 0\n for idx in range(len(nums) - 2):\n if(nums[idx] == 0):\n minOps += 1\n nums[idx] = 1 - nums[idx]\n nums[idx+1] = 1 - nums[idx+1]\n nums[idx+2] = 1 - nums[idx+2]\n lastIdx = len(nums) - 1\n secondLastIdx = len(nums) - 2\n if(nums[lastIdx] == 1 and nums[secondLastIdx] == 1):\n return minOps\n return -1","runtime":"658"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ops_count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n ops_count += 1\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n n = len(nums)\n if nums[n - 2] == 0 or nums[n - 1] == 0:\n return -1\n else:\n return ops_count\n ","runtime":"670"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n # array of binary numbers, called nums\n # can choose 3 consec, flip all of them (1 to 0, 0 to 1)\n\n # want all elements to equal 1\n\n # want to keep shifting left pointer until you hit a 0, then call flip\n # can think of it as having a right pointer starting from idx = 2, and this keeps going till it hits the end\n # at each iter, check if the one two below is 0. if so, flip\n # if 1, continue\n num_operations = 0\n for r in range(2, len(nums)):\n if nums[r-2] == 0:\n num_operations += 1\n nums[r-2] = 1\n nums[r-1] = (nums[r-1]+1) % 2\n nums[r] = (nums[r]+1) % 2\n else:\n continue\n \n # done, check if \n if nums[-2] == 1 == nums[-1]:\n return num_operations\n else: \n return -1\n \n #ex) [0, 1, 1, 1]\n # [1, 1, 0, 0]\n ","runtime":"683"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\n n = len(nums)\n flips = 0\n\n for i in range(n - 2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n\n if nums[-2] == 1 and nums[-1] == 1:\n return flips\n else:\n return -1","runtime":"695"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n n += 1\n return n if nums[-1] == nums[-2] == nums[-3] == 1 else -1","runtime":"707"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count=0\n for i in range(len(nums)-2):\n if nums[i]==0:\n nums[i]^=1\n nums[i+1]^=1\n nums[i+2]^=1\n count+=1\n if nums[-1]==0 or nums[-2]==0:\n return -1\n return count","runtime":"719"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n tot = 0\n for i in range(n-2):\n if nums[i] == 0:\n tot += 1\n nums[i] = 1\n nums[i+1] = 1-nums[i+1]\n nums[i+2] = 1-nums[i+2]\n return tot if (nums[n-2] == 1 and nums[n-1] == 1) else -1","runtime":"731"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count=0\n for x in range(len(nums)-2):\n if nums[x]==0:\n count+=1\n nums[x]=1\n if nums[x+1]==1: nums[x+1]=0 \n else: nums[x+1]=1 \n if nums[x+2]==1: nums[x+2]=0 \n else: nums[x+2]=1\n if 0 in nums: return -1\n else: return count ","runtime":"743"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n res = 0\n i = 0\n while i + 2 < n:\n if nums[i] == 0:\n nums[i+1] = 1- nums[i+1]\n nums[i+2] = 1- nums[i+2]\n res +=1\n i +=1\n\n return res if nums[n-1] and nums[n-2] else -1","runtime":"756"},{"code":"'''\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\n\nComplexity\nLet $$ N := $$ length of input list\n\nTime\n$$O(N)$$\n\nSpace \n$$O(1)$$ ( Explicit and Implicit )\n'''\nclass Solution:\n # hint : think inducitvely\n def minOperations(self, nums: List[int]) -> int:\n # do not read the final two indices ( test both are zeroed out as well !)\n minOps = 0\n for idx in range(len(nums) - 2):\n if(nums[idx] == 0):\n minOps += 1\n nums[idx] = 1 - nums[idx]\n nums[idx+1] = 1 - nums[idx+1]\n nums[idx+2] = 1 - nums[idx+2]\n if(not(nums[-1] == 1 and nums[-2] == 1)):\n return -1\n return minOps","runtime":"768"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans=0\n l=0\n r=0\n # if len(nums)\n while r<len(nums):\n if r-l+1==3:\n if nums[l]==0:\n nums[l]=1\n nums[l+1]=1-nums[l+1]\n nums[r]=1-nums[r]\n l+=1\n ans+=1\n else:\n l+=1\n r+=1\n if len(nums)>2:\n if nums[-3]==0 or nums[-2]==0 or nums[-1]==0:\n return -1\n return ans\n\n","runtime":"780"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n= len(nums)\n res = 0 \n for i in range(n-2):\n if nums[i]== 0 :\n res+=1 \n nums[i]=1 \n nums[i+1] = 1-nums[i+1]\n nums[i+2] = 1- nums[i+2]\n if sum(nums) == len(nums):\n return res \n else : return -1 ","runtime":"792"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = total = 0\n k = 3\n for i in range(len(nums)):\n if i >= k and nums[i - k] == 2:\n flips -= 1\n if (flips % 2) == nums[i]:\n if i + k > len(nums):\n return -1\n nums[i] = 2\n flips += 1\n total += 1\n return total\n ","runtime":"804"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n ans += 1\n return ans if nums[-2] and nums[-1] else -1","runtime":"804"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n num_of_op = 0\n for i in range(len(nums) - 2):\n if nums[i] != 1:\n nums[i] = 1\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\n num_of_op += 1\n\n return num_of_op if nums[-1] == 1 and nums[-2] == 1 else -1\n","runtime":"817"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n count = 0\n for l in range(len(nums)-2):\n if nums[l] == 0:\n count += 1\n nums[l] = 1\n nums[l+1] = not nums[l+1]\n nums[l+2] = not nums[l+2]\n\n if len(set(nums)) == 1:\n return count\n \n return -1\n ","runtime":"829"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n i = 0\n operations = 0\n while(i < len(nums) - 2 ):\n if (nums[i] == 0):\n nums[i] = 1\n operations += 1\n if(nums[i + 1] == 0):\n nums[i + 1] = 1\n else: \n nums[i+1] = 0\n\n if(nums[i + 2] == 0):\n nums[i + 2] = 1\n else: \n nums[i+2] = 0\n i += 1\n\n while(i < len(nums)):\n if(nums[i] == 0):\n return -1\n i +=1\n return operations\n","runtime":"841"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n for i, x in enumerate(nums):\n if x == 0:\n if i + 2 >= len(nums):\n return -1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n ans += 1\n return ans","runtime":"877"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n count = 0\n for i in range(n - 2):\n if nums[i] == 0:\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n count += 1\n if nums[n - 1] == 0 or nums[n - 2] == 0:\n return -1\n return count","runtime":"890"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ind = 0\n count = 0\n while(ind < len(nums)-2):\n if nums[ind] == 1:\n ind += 1\n continue\n \n nums[ind+1] = abs(1 - nums[ind+1])\n nums[ind+2] = abs(1 - nums[ind+2])\n count += 1\n ind += 1\n\n return count if nums[-1] + nums[-2] == 2 else -1\n\n\n\n","runtime":"902"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n def flip(l, i):\n l[i] = not(l[i])\n l[i+1] = not(l[i+1])\n l[i+2] = not(l[i+2])\n return l\n\n def test(l):\n count = 0\n if not l.count(0):\n return count\n if l.index(0) > len(l) - 3:\n return -1\n for i in range(l.index(0), len(l) - 2):\n if not l[i]:\n count += 1\n #l[i] = 1\n #l[i+1] = not(l[i+1])\n #l[i+2] = not(l[i+2])\n flip(l, i)\n additional_count = test(l)\n if additional_count < 0:\n return -1\n count += additional_count\n return count\n return test(nums)","runtime":"914"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n i = 0\n flips = 0\n while i < len(nums):\n if nums[i] == 0:\n if i >= len(nums) - 2:\n return -1\n nums[i] = 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n flips += 1\n i += 1\n return flips","runtime":"926"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n n = len(nums)\n\n isFlipped = [0] * (n+1)\n\n flipCount = 0\n\n res = 0\n\n for i in range(n):\n flipCount += isFlipped[i]\n\n if (nums[i] + flipCount) % 2 == 0:\n\n if i + 3 > n:\n return -1\n \n flipCount += 1\n isFlipped[i+3] -= 1\n res += 1\n\n return res\n \n\n\n ","runtime":"938"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n left, right = 0, 2\n count = 0\n\n while right<len(nums):\n\n if nums[left] == 0:\n #flip\n nums[left] = 1\n nums[right-1] = 1 - nums[right-1]\n nums[right] = 1 - nums[right]\n\n count+=1\n \n left+=1\n right+=1\n\n if nums[-1]==0 or nums[-2]==0:\n return -1\n\n return count\n","runtime":"950"},{"code":"class Solution:\n def minOperations(self, nums):\n n, count = len(nums), 0\n\n for i in range(n-2):\n if nums[i] == 0:\n count += 1 \n nums[i] += 1 \n nums[i+1] = (nums[i+1]+1)%2 \n nums[i+2] = (nums[i+2]+1)%2 \n\n return count if max(nums) == min(nums) == 1 else -1 ","runtime":"963"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n count = 0\n for i in range(n-2):\n if nums[i] == 0:\n for j in range(i,i+3):\n nums[j] = 1 - nums[j] # flip\n count += 1\n for i in range(n-2,n):\n if nums[i] == 0:\n return -1\n return count\n\n \n","runtime":"963"},{"code":"\"\"\"\nTrick: Sliding Window\n\nWe can use sliding window trick. We always check window of size 3, but\nthe moving forward step can be 1, 2 or 3.\n\nLet us see several scenarios:\n\n[1, *, *] => forward step is 1: index from i to i+1; no need to increment cnt of operations\n\nFor below scenarios, we need increment the n_operations\n\n[0, 1, *, *, *, ...] => [1, 0, *, *] => forward step is 1: index from i to i+1; \n[0, 0, 1, *, *, ....] => [1, 1, 0] => forward step is 2: index from i to i+2; \n[0, 0, 0, *, * , ....] => [1, 1, 1, * ] => forward step is 3: index from i to i+3.\n\n\nAfter we do the sliding window, we can guarantee the first n - 2 elements must be 1\nand the remaining 2 elements not sure. If they were both 1s, return the cnt of operations.\nOtherwise, we can not make all elements to be 1, and return -1.\n\n0 0, 0\n\"\"\"\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n i = 0\n while i < len(nums) - 2:\n if nums[i] == 1:\n i += 1\n else:\n res += 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n if nums[i+1] == 0:\n i += 1\n else:\n if nums[i+2] == 0:\n i += 2\n else:\n i += 3\n \n if nums[-1] == 1 and nums[-2] == 1:\n return res\n return -1\n \n \n \n \n \n ","runtime":"975"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n num_operations = 0\n\n for i in range(len(nums)-2):\n n = nums[i]\n if n == 0:\n num_operations += 1\n nums[i] = 1\n nums[i+1] = nums[i+1] ^ 1\n nums[i+2] = nums[i+2] ^ 1\n \n for i in range(len(nums)):\n if nums[i] == 0:\n return -1\n \n return num_operations\n","runtime":"987"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n oper = 0\n total = 0\n for i in range(0, len(nums)-2):\n if nums[i] == 0:\n nums[i] = 1\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2] \n oper += 1\n\n total += nums[i]\n \n if total + sum(nums[i+1:i+3]) == len(nums):\n return oper\n return -1\n","runtime":"999"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n l = 0\n for i in range(0, len(nums) - 2):\n if nums[i] == 0 and i + 2 < len(nums):\n nums[i] = 1 - nums[i]\n nums[i+1] = 1 - nums[i+1]\n nums[i+2] = 1 - nums[i+2]\n l += 1\n if sum(nums) != len(nums):\n return -1\n return l","runtime":"1011"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n idx = 0\n steps = 0\n n = len(nums)\n while idx < n-2:\n\n if nums[idx]==0:\n steps+=1\n nums[idx] = not nums[idx]\n nums[idx+1] = not nums[idx+1]\n nums[idx+2] = not nums[idx+2]\n \n idx+=1\n \n if 0 in nums:\n return -1\n return steps\n\n \"\"\"\n 0,1,1,1\n 1,0,0,1\n 1,1,1,0\n \"\"\"\n \n\n\n\n \n\n","runtime":"1023"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for i, n in enumerate(nums):\n if n == 1:\n continue\n if i + 2 >= len(nums):\n return -1\n res += 1\n if nums[i + 1] == 0:\n nums[i + 1] = 1\n else:\n nums[i + 1] = 0\n if nums[i + 2] == 0:\n nums[i + 2] = 1\n else:\n nums[i + 2] = 0\n return res\n","runtime":"1036"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n len_nums=len(nums)\n operation=0\n for i in range(len_nums-2):\n\n if nums[i] == 0 :\n count=3\n j=i\n while count > 0:\n if nums[j] == 0:\n nums[j]=1\n else:\n nums[j]=0\n j+=1\n count-=1\n operation+=1\n if nums[-1] == 1 and nums[-2] == 1:\n return operation\n else:\n return -1\n \n\n ","runtime":"1036"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n index = 0\n while index <= len(nums)-3:\n if nums[index] == 0:\n nums[index] = 1\n nums[index+1] = 1 if nums[index+1] == 0 else 0\n nums[index+2] = 1 if nums[index+2] == 0 else 0\n ans += 1\n index += 1\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return ans\n\n ","runtime":"1048"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n # count = 0\n # for i in range(len(nums)-2):\n # if nums[i] == 1:\n # continue\n \n # nums[i] = 1 - nums[i]\n # nums[i+1] = 1 - nums[i+1]\n # nums[i+2] = 1 - nums[i+2]\n \n # count+=1\n \n # if nums[-1] == 1 and nums[-2] == 1 and nums[-3] == 1:\n # return count\n # return -1\n\n q = deque()\n count = 0\n \n for i in range(len(nums)):\n\n # makes sure queue doesn't have more than 2 elements.\n if q and q[0] + 2 < i:\n q.popleft()\n \n # 0 and queue length is even\n # 1 and queue length is odd\n if (nums[i] + len(q))%2 == 0:\n if i + 3 > len(nums):\n return -1\n \n count+=1\n q.append(i)\n \n return count\n","runtime":"1048"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n i = 0\n while(i < len(nums)):\n if(nums[i] == 0):\n if(i+2 < len(nums)):\n nums[i] = 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n count += 1\n else:\n return -1\n i += 1\n \n return count\n","runtime":"1060"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flip = 0\n for i in range(len(nums)-2):\n if nums[i] == 0:\n flip += 1\n for j in range(i,i+3):\n if nums[j] == 0:\n nums[j] = 1\n else:\n nums[j] = 0\n return flip if nums.count(1) == len(nums) else -1","runtime":"1060"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n N = len(nums)\n cnt = 0\n for i in range(N-2):\n if nums[i] == 0:\n for j in range(i, i+3):\n nums[j] ^= 1\n cnt += 1\n\n last = sum(nums[N-3:])\n if last == 3:\n return cnt\n if last == 0:\n return cnt + 1\n return -1\n\n","runtime":"1072"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n cnt = 0\n if nums.count(0) == 1:\n return -1\n\n\n for i in range(len(nums)):\n if nums[i] == 0 and i+3 > len(nums):\n return -1\n\n elif nums[i] == 0 and i+3 <= len(nums) :\n nums[i] ^=1\n nums[i+1] ^=1\n nums[i+2] ^=1\n cnt +=1\n return cnt \n\n\n\n\n\n\n ","runtime":"1072"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n start, end = 0, 3\n res = 0\n \n while end <= len(nums):\n if nums[start] == 0:\n for i in range(start, end):\n if nums[i] == 0:\n nums[i] = 1\n else:\n nums[i] = 0\n res += 1\n start += 1\n end += 1\n\n for i in range(start, end-1):\n if nums[i] == 0:\n return -1\n \n return res\n ","runtime":"1084"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n total=0\n for i in range(0, len(nums)-2):\n if nums[i]==0:\n nums[i] += 1\n nums[i] %= 2\n nums[i+1] += 1\n nums[i+1] %= 2\n nums[i+2] += 1\n nums[i+2] %= 2\n total+=1\n if nums[-1]==1 and nums[-2]==1:\n return total\n return -1","runtime":"1084"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n, total = len(nums), 0\n \n for i in range(n-2):\n if nums[i] == 0:\n total += 1\n for x in range(3):\n nums[i+x] = 0 if nums[i+x] else 1\n \n return total if sum(nums) == n else -1\n ","runtime":"1097"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n length = len(nums)\n\n count = 0\n i = 0\n for i in range(length - 3):\n a = nums[i]\n b = nums[i+1]\n c = nums[i+2]\n\n \n\n if a != 1:\n nums[i] = 1\n count += 1\n\n if b == 1:\n nums[i+1] = 0\n else:\n nums[i+1] = 1\n\n if c == 1:\n nums[i+2] = 0\n else:\n nums[i+2] = 1\n i += 1\n\n if (nums[i] == nums[i+1] and nums[i] == nums[i+2]):\n if nums[i] == 0:\n return count + 1\n else:\n return count\n \n return -1","runtime":"1097"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n i = 0\n length = len(nums)\n while i <= length - 3 and count < length:\n if not nums[i] == 0:\n i += 1\n continue\n for j in range(3):\n nums[i + j] ^= 1 \n count += 1\n i += 1\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return count","runtime":"1109"},{"code":"class Solution:\n def minOperations(self, arr: List[int]) -> int:\n c=0\n for i in range(len(arr)-2):\n if arr[i]==0:\n c+=1\n for j in range(i,i+3):\n if arr[j]==0:\n arr[j]=1\n else:\n arr[j]=0\n else:\n continue\n flag=False\n for i in range(len(arr)):\n if arr[i]==0:\n flag=True\n\n if flag:\n return -1\n else:\n return c\n","runtime":"1109"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n i,j = 0,0\n size = len(nums)\n count = 0\n while j < size:\n if j - i + 1 < 3:\n j += 1\n else:\n if nums[i] == 0:\n count += 1\n for k in range(i,j + 1):\n nums[k] = 1 - nums[k]\n i += 1\n j += 1\n for i in range(size):\n if nums[i] != 1:\n return -1\n return count","runtime":"1121"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n h = {1: 0, 0: 1}\n l = 0\n while nums[l] == 1:\n l += 1\n if l == len(nums):\n return 0\n\n ans = 0\n while True:\n for i in range(l, l + 3):\n if i == len(nums):\n return -1\n nums[i] = h[nums[i]]\n ans += 1\n while nums[l] == 1:\n l += 1\n if l == len(nums):\n return ans","runtime":"1121"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ptrA = 0\n ptrB = 2\n operations = 0\n while ptrB <= len(nums)-1:\n if nums[ptrA] == 0:\n for i in range(3):\n nums[ptrA+i] ^= 1\n operations += 1 \n ptrA+=1\n ptrB+=1\n if nums[-1]==0 or nums[-2]==0:\n return -1\n return operations\n\n\n ","runtime":"1133"},{"code":"class Solution:\n def minOperations(self, arr: List[int]) -> int:\n n = len(arr)\n op = [0]*n\n res = 0\n num = lambda i, op: abs(op[i]%2 - arr[i])\n\n for i in range(n-2):\n if num(i, op) == 0:\n res += 1\n for j in range(3):\n op[i+j] += 1\n \n if num(n-2, op) == 1 and num(n-1, op) == 1:\n return res\n \n return -1","runtime":"1133"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n l = 0\n while nums[l] == 1:\n l += 1\n if l == len(nums):\n return 0\n\n ans = 0\n while True:\n for i in range(l, l + 3):\n if i == len(nums):\n return -1\n nums[i] = 1 - nums[i]\n ans += 1\n while nums[l] == 1:\n l += 1\n if l == len(nums):\n return ans","runtime":"1145"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n l = 0\n ans = 0\n\n for r in range(len(nums)):\n if l != len(nums)-1 and len(nums)-r >= 3:\n if nums[r] == 0:\n ans += 1\n for l in range(r,r+3):\n if nums[l] == 0:\n nums[l] = 1\n else:\n nums[l] = 0\n if 0 in nums:\n return -1\n else:\n return ans","runtime":"1145"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n if len(nums) < 3:\n return -1\n strnums = \"\".join(map(str, nums))\n i = 3\n q = strnums[:3]\n count = 0\n while i < len(strnums):\n # print(i, q, count)\n if len(q) < 3:\n q = q + strnums[i]\n i += 1\n else:\n if q == \"111\":\n q = \"\"\n elif q == \"110\":\n q = \"0\"\n elif q == \"101\":\n q = \"01\"\n elif q == \"100\":\n q = \"00\"\n elif q == \"011\":\n q = \"00\"\n count += 1\n elif q == \"010\":\n q = \"01\"\n count += 1\n elif q == \"001\":\n q = \"0\"\n count += 1\n elif q == \"000\":\n q = \"\"\n count += 1\n # print(i, q, count)\n if q == \"\" or q == \"1\" or q == \"11\" or q == \"111\":\n return count\n elif q == \"000\":\n return count + 1\n else:\n return -1\n\n\n \n \n ","runtime":"1157"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n operations, i = 0, 0\n while i < len(nums)-2:\n if nums[i] == 0:\n for j in range(3):\n if nums[i+j] == 0:\n nums[i+j] = 1\n else:\n nums[i+j] = 0\n i += 1\n operations += 1\n else: \n i += 1\n\n if i == len(nums) - 2 and nums.count(0) != 0:\n return -1\n else: return operations","runtime":"1157"}],"string":"[\n {\n \"code\": \"\\ndef minOperations(nums: List[int]) -> int:\\n count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n count += 1\\n nums[i] = 1\\n nums[i + 1] = abs(nums[i + 1] - 1)\\n nums[i + 2] = abs(nums[i + 2] - 1)\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return count\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for nums in map(loads, stdin): Solution.write(f\\\"{minOperations(nums)}\\\\n\\\")\\nexit() \",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n flips = 0\\n\\n for i in range(n-2):\\n if nums[i]==0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n \\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\",\n \"runtime\": \"196\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n b1, b2 = nums[:2]\\n result = 0\\n for i in range(2, len(nums)):\\n b0, b1, b2 = b1, b2, nums[i]\\n if b0 == 0:\\n result += 1\\n b1 ^= 1\\n b2 ^= 1\\n return result if b1 and b2 else -1\\n\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\\n n = len(nums)\\n flips = 0\\n\\n for i in range(n - 2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\",\n \"runtime\": \"220\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n\\n for i in range(len(nums) - 2):\\n if nums[i] == 1:\\n continue\\n else:\\n res += 1\\n nums[i] = 1\\n nums[i + 1] = 1 - nums[i + 1]\\n nums[i + 2] = 1 - nums[i + 2]\\n \\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return res\",\n \"runtime\": \"232\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n\\n for i in range(n-2):\\n if nums[i] == 0:\\n res += 1\\n nums[i] = 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-1] == 1 and nums[-2] == 1:\\n return res\\n else:\\n return -1\",\n \"runtime\": \"244\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n for i in range(len(nums)-2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\\n\\n\",\n \"runtime\": \"256\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n\\n for i in range(n - 2):\\n if nums[i] == 0:\\n res += 1\\n nums[i] = 1\\n nums[i + 1] = 1 - nums[i + 1]\\n nums[i + 2] = 1 - nums[i + 2]\\n\\n if nums[-1] == nums[-2] == 1:\\n return res\\n else:\\n return -1\",\n \"runtime\": \"269\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n ret = 0\\n for i in range(n - 2):\\n if nums[i] == 0:\\n ret += 1\\n nums[i + 1] = 1 - nums[i + 1]\\n nums[i + 2] = 1 - nums[i + 2]\\n return ret if nums[-1] == nums[-2] == 1 else -1\",\n \"runtime\": \"281\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n return flips if nums[-2] and nums[-1] else -1\\n\",\n \"runtime\": \"293\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] = 1\\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\\n count += 1\\n return -1 if nums[n - 1] == 0 or nums[n - 2] == 0 or nums[n - 3] == 0 else count\",\n \"runtime\": \"305\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n count += 1\\n nums[i] = 1\\n nums[i + 1] = abs(nums[i + 1] - 1)\\n nums[i + 2] = abs(nums[i + 2] - 1)\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return count\",\n \"runtime\": \"305\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] = 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n ans += 1\\n\\n if nums[-2] == 0 or nums[-1] == 0:\\n return -1\\n return ans\",\n \"runtime\": \"317\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n count = 0\\n for l in range(len(nums)-2):\\n if nums[l] == 0:\\n count += 1\\n nums[l] = 1\\n nums[l+1] = not nums[l+1]\\n nums[l+2] = not nums[l+2]\\n\\n if nums[-1] == nums[-2] == nums[-3] == 1: # Edge case\\n return count\\n return -1\\n \",\n \"runtime\": \"330\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for i in range(len(nums) - 2):\\n if nums[i]: continue\\n nums[i + 1] = 1 - nums[i + 1]\\n nums[i + 2] = 1 - nums[i + 2]\\n ans += 1\\n return ans if nums[-1] * nums[-2] else -1\",\n \"runtime\": \"342\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] = 1\\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\\n count += 1\\n if 0 in nums:\\n return -1\\n return count\",\n \"runtime\": \"354\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n a = 0\\n b = 0\\n flips = 0\\n for num in nums[:-2]:\\n flip = 1 - ((num + flips) % 2)\\n flips, a, b = flips + flip - a, b, flip\\n ans += flip\\n if 1 - ((nums[-2] + flips) % 2):\\n return -1\\n if 1 - ((nums[-1] + flips - a) % 2):\\n return -1\\n return ans\",\n \"runtime\": \"366\"\n },\n {\n \"code\": \"'''\\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\\n\\nComplexity\\nLet $$ N := $$ length of input list\\n\\nTime\\n$$O(N)$$\\n\\nSpace \\n$$O(1)$$ ( Explicit and Implicit )\\n'''\\nclass Solution:\\n # hint : think inducitvely\\n def minOperations(self, nums: List[int]) -> int:\\n # do not read the final two indices ( test both are zeroed out as well !)\\n minOps = 0\\n for idx in range(len(nums) - 2):\\n if(nums[idx] == 0):\\n minOps += 1\\n nums[idx] = 1 - nums[idx]\\n nums[idx+1] = 1 - nums[idx+1]\\n nums[idx+2] = 1 - nums[idx+2]\\n lastIdx = len(nums) - 1\\n secondLastIdx = len(nums) - 2\\n if(not(nums[lastIdx] == 1 and nums[secondLastIdx] == 1)):\\n return -1\\n return minOps\",\n \"runtime\": \"378\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n count = 0\\n\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n count += 1\\n nums[i] = 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-1] == 1 and nums[-2] == 1:\\n return count\\n else:\\n return -1\",\n \"runtime\": \"390\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n l = 0\\n\\n for r in range(len(nums) - 2):\\n if nums[r] == 0:\\n nums[r] = 1\\n if not nums[r + 1]:\\n nums[r + 1] = 1\\n else:\\n nums[r + 1] = 0\\n if not nums[r + 2]:\\n nums[r + 2] = 1\\n else:\\n nums[r + 2] = 0\\n \\n res += 1\\n\\n return res if sum(nums[-2:]) == 2 else -1\",\n \"runtime\": \"403\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n count = 0\\n for i in range(n - 2):\\n if nums[i] == 0:\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n count += 1\\n if nums[n - 1] == 0 or nums[n - 2] == 0:\\n return -1\\n return count\",\n \"runtime\": \"415\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n n += 1\\n return n if nums[-1] == nums[-2] == 1 else -1\",\n \"runtime\": \"427\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flip_count = 0\\n\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i + 0] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n flip_count += 1\\n\\n return flip_count if (nums[-2] & nums[-1]) else -1\",\n \"runtime\": \"439\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n result = 0\\n for i in range(n-2):\\n if nums[i] == 0:\\n result += 1\\n nums[i],nums[i+1],nums[i+2] = 1, 1 - nums[i+1], 1 - nums[i+2]\\n \\n for i in range(n-2,n):\\n if nums[i] == 0:\\n return - 1\\n return result\\n\\n \",\n \"runtime\": \"451\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n r, n = 0, len(nums)\\n for i in range(n - 2):\\n if nums[i] == 1:\\n continue\\n nums[i+1], nums[i+2] = 1 - nums[i+1], 1 - nums[i+2]\\n r += 1\\n return r if nums[-1] == nums[-2] == 1 else -1\",\n \"runtime\": \"463\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n cnt = 0\\n for i in range(n-2):\\n if nums[i]==0:\\n # must flip (i,i+1,i+2)\\n nums[i] = 1\\n nums[i+1] = 1-nums[i+1]\\n nums[i+2] = 1-nums[i+2]\\n cnt += 1\\n if nums[n-1]==1 and nums[n-2]==1:\\n return cnt\\n else:\\n return -1\",\n \"runtime\": \"476\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n nums : binary array\\n\\n 1 operation:\\n flip 3 consecutive elements\\n\\n Return the minimum number of operations required\\n to make all elements in nums equal to 1.\\n If impossible => -1\\n \\\"\\\"\\\"\\n count_op = 0\\n n = len(nums)\\n for l in range(n - 2):\\n if nums[l] == 0:\\n count_op += 1\\n nums[l + 1] = 1 - nums[l + 1]\\n nums[l + 2] = 1 - nums[l + 2]\\n\\n return count_op if nums[n - 1] == 1 == nums[n - 2] else -1\\n\",\n \"runtime\": \"488\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in range(len(nums)-2):\\n if nums[i]==0:\\n c=c+1\\n nums[i]=1\\n if(nums[i+1]==0):\\n nums[i+1]=1\\n else:\\n nums[i+1]=0\\n if(nums[i+2]==0):\\n nums[i+2]=1\\n else:\\n nums[i+2]=0\\n if(nums[-1]==0 or nums[-2]==0):\\n return -1\\n return c\\n\\n\\n \\n \",\n \"runtime\": \"500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\\n n = len(nums)\\n flips = 0\\n\\n for i in range(n - 2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\",\n \"runtime\": \"512\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n length = len(nums)\\n count = 0\\n for index in range(length - 2):\\n if nums[index] == 0:\\n nums[index] ^= 1\\n nums[index + 1] ^= 1\\n nums[index + 2] ^= 1\\n count += 1\\n\\n for index in range(length - 2, length):\\n if nums[index] == 0:\\n return -1\\n\\n return count\\n\",\n \"runtime\": \"524\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n counter = 0\\n for n in range(len(nums) - 2):\\n\\n if nums[n] == 0:\\n nums[n] = 1 - nums[n]\\n nums[n + 1] = 1 - nums[n + 1]\\n nums[n + 2] = 1 - nums[n + 2]\\n counter += 1\\n\\n\\n if 0 in nums:\\n counter = -1\\n return counter\\n\",\n \"runtime\": \"536\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n result = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n result += 1\\n my_set = set(nums)\\n if len(my_set) == 1 and 1 in my_set:\\n return result\\n else:\\n return -1\",\n \"runtime\": \"549\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n n = len(nums)\\n flip_count = 0\\n next_flip, next_next_flip = 0, 0 # False, False\\n\\n for i in range(n - 2):\\n if i == n - 3:\\n # the last 3 elements to check\\n if (nums[i] + next_flip) % 2 == 1:\\n # no need to flip\\n if (nums[i+1] + next_next_flip) % 2 == nums[i+2] == 1:\\n return flip_count\\n else:\\n return -1\\n else:\\n # needs a flip\\n flip_count += 1\\n if (nums[i+1] + next_next_flip + 1) % 2 == (nums[i+2] + 1) % 2 == 1:\\n return flip_count\\n else:\\n return -1\\n \\n if (nums[i] + next_flip) % 2 == 1:\\n # no need to flip\\n next_flip, next_next_flip = next_next_flip, 0\\n else:\\n # need to flip\\n flip_count += 1\\n next_flip, next_next_flip = (next_next_flip + 1) % 2, 1\",\n \"runtime\": \"561\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n ans = 0\\n\\n for i in range(len(nums) - 2):\\n\\n if nums[i] == 0:\\n nums[i] = 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n ans += 1\\n\\n \\n return ans if nums[-1] == 1 and nums[-2] == 1 else -1\\n \",\n \"runtime\": \"573\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n flipped = [0]*n \\n flip = 0\\n for i in range(n):\\n if i>=3:\\n # valid end \\n flip ^= flipped[i-3]\\n if nums[i] == flip:\\n if i+3> n:\\n return -1\\n ans +=1\\n flip ^= 1\\n flipped[i] = 1\\n \\n \\n return ans\\n \",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n \\n for i in range(n - 2):\\n if nums[i] == 0:\\n res += 1\\n nums[i] = 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n \\n if nums[-1] == 1 and nums[-2] == 1:\\n return res\\n else:\\n return -1\",\n \"runtime\": \"597\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count=0\\n for x in range(len(nums)-2):\\n if nums[x]==0:\\n count+=1\\n nums[x]=1\\n if nums[x+1]==1: nums[x+1]=0 \\n else: nums[x+1]=1 \\n if nums[x+2]==1: nums[x+2]=0 \\n else: nums[x+2]=1\\n if 0 in nums: return -1\\n else: return count \",\n \"runtime\": \"610\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\\n n = len(nums)\\n flips = 0\\n\\n for i in range(n - 2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\",\n \"runtime\": \"622\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n operations = 0\\n\\n for i in range(n - 2): # leave last 2 elements\\n if nums[i] == 0:\\n # Flip the current element and the next two elements\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n operations += 1\\n \\n # Check the last two elements\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n\\n return operations\",\n \"runtime\": \"634\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for i in range(len(nums)-2):\\n val = nums[i]\\n if val == 0:\\n nums[i] = 1-nums[i]\\n nums[i+1] = 1-nums[i+1]\\n nums[i+2] = 1-nums[i+2]\\n ans += 1\\n if sum(nums) == len(nums):\\n return ans\\n return -1\",\n \"runtime\": \"646\"\n },\n {\n \"code\": \"'''\\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\\n\\nComplexity\\nLet $$ N := $$ length of input list\\n\\nTime\\n$$O(N)$$\\n\\nSpace \\n$$O(1)$$ ( Explicit and Implicit )\\n'''\\nclass Solution:\\n # hint : think inducitvely\\n def minOperations(self, nums: List[int]) -> int:\\n # do not read the final two indices ( test both are zeroed out as well !)\\n minOps = 0\\n for idx in range(len(nums) - 2):\\n if(nums[idx] == 0):\\n minOps += 1\\n nums[idx] = 1 - nums[idx]\\n nums[idx+1] = 1 - nums[idx+1]\\n nums[idx+2] = 1 - nums[idx+2]\\n lastIdx = len(nums) - 1\\n secondLastIdx = len(nums) - 2\\n if(nums[lastIdx] == 1 and nums[secondLastIdx] == 1):\\n return minOps\\n return -1\",\n \"runtime\": \"658\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ops_count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n ops_count += 1\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n n = len(nums)\\n if nums[n - 2] == 0 or nums[n - 1] == 0:\\n return -1\\n else:\\n return ops_count\\n \",\n \"runtime\": \"670\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n # array of binary numbers, called nums\\n # can choose 3 consec, flip all of them (1 to 0, 0 to 1)\\n\\n # want all elements to equal 1\\n\\n # want to keep shifting left pointer until you hit a 0, then call flip\\n # can think of it as having a right pointer starting from idx = 2, and this keeps going till it hits the end\\n # at each iter, check if the one two below is 0. if so, flip\\n # if 1, continue\\n num_operations = 0\\n for r in range(2, len(nums)):\\n if nums[r-2] == 0:\\n num_operations += 1\\n nums[r-2] = 1\\n nums[r-1] = (nums[r-1]+1) % 2\\n nums[r] = (nums[r]+1) % 2\\n else:\\n continue\\n \\n # done, check if \\n if nums[-2] == 1 == nums[-1]:\\n return num_operations\\n else: \\n return -1\\n \\n #ex) [0, 1, 1, 1]\\n # [1, 1, 0, 0]\\n \",\n \"runtime\": \"683\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # return nums.count(0) if nums.count(0) % 3 == 0 else -1\\n n = len(nums)\\n flips = 0\\n\\n for i in range(n - 2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n\\n if nums[-2] == 1 and nums[-1] == 1:\\n return flips\\n else:\\n return -1\",\n \"runtime\": \"695\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n n += 1\\n return n if nums[-1] == nums[-2] == nums[-3] == 1 else -1\",\n \"runtime\": \"707\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in range(len(nums)-2):\\n if nums[i]==0:\\n nums[i]^=1\\n nums[i+1]^=1\\n nums[i+2]^=1\\n count+=1\\n if nums[-1]==0 or nums[-2]==0:\\n return -1\\n return count\",\n \"runtime\": \"719\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n tot = 0\\n for i in range(n-2):\\n if nums[i] == 0:\\n tot += 1\\n nums[i] = 1\\n nums[i+1] = 1-nums[i+1]\\n nums[i+2] = 1-nums[i+2]\\n return tot if (nums[n-2] == 1 and nums[n-1] == 1) else -1\",\n \"runtime\": \"731\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count=0\\n for x in range(len(nums)-2):\\n if nums[x]==0:\\n count+=1\\n nums[x]=1\\n if nums[x+1]==1: nums[x+1]=0 \\n else: nums[x+1]=1 \\n if nums[x+2]==1: nums[x+2]=0 \\n else: nums[x+2]=1\\n if 0 in nums: return -1\\n else: return count \",\n \"runtime\": \"743\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n res = 0\\n i = 0\\n while i + 2 < n:\\n if nums[i] == 0:\\n nums[i+1] = 1- nums[i+1]\\n nums[i+2] = 1- nums[i+2]\\n res +=1\\n i +=1\\n\\n return res if nums[n-1] and nums[n-2] else -1\",\n \"runtime\": \"756\"\n },\n {\n \"code\": \"'''\\nURL := https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i/description/\\n3191. Minimum Operations to Make Binary Array Elements Equal to One I\\n\\nComplexity\\nLet $$ N := $$ length of input list\\n\\nTime\\n$$O(N)$$\\n\\nSpace \\n$$O(1)$$ ( Explicit and Implicit )\\n'''\\nclass Solution:\\n # hint : think inducitvely\\n def minOperations(self, nums: List[int]) -> int:\\n # do not read the final two indices ( test both are zeroed out as well !)\\n minOps = 0\\n for idx in range(len(nums) - 2):\\n if(nums[idx] == 0):\\n minOps += 1\\n nums[idx] = 1 - nums[idx]\\n nums[idx+1] = 1 - nums[idx+1]\\n nums[idx+2] = 1 - nums[idx+2]\\n if(not(nums[-1] == 1 and nums[-2] == 1)):\\n return -1\\n return minOps\",\n \"runtime\": \"768\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans=0\\n l=0\\n r=0\\n # if len(nums)\\n while r<len(nums):\\n if r-l+1==3:\\n if nums[l]==0:\\n nums[l]=1\\n nums[l+1]=1-nums[l+1]\\n nums[r]=1-nums[r]\\n l+=1\\n ans+=1\\n else:\\n l+=1\\n r+=1\\n if len(nums)>2:\\n if nums[-3]==0 or nums[-2]==0 or nums[-1]==0:\\n return -1\\n return ans\\n\\n\",\n \"runtime\": \"780\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n= len(nums)\\n res = 0 \\n for i in range(n-2):\\n if nums[i]== 0 :\\n res+=1 \\n nums[i]=1 \\n nums[i+1] = 1-nums[i+1]\\n nums[i+2] = 1- nums[i+2]\\n if sum(nums) == len(nums):\\n return res \\n else : return -1 \",\n \"runtime\": \"792\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = total = 0\\n k = 3\\n for i in range(len(nums)):\\n if i >= k and nums[i - k] == 2:\\n flips -= 1\\n if (flips % 2) == nums[i]:\\n if i + k > len(nums):\\n return -1\\n nums[i] = 2\\n flips += 1\\n total += 1\\n return total\\n \",\n \"runtime\": \"804\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n ans += 1\\n return ans if nums[-2] and nums[-1] else -1\",\n \"runtime\": \"804\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n num_of_op = 0\\n for i in range(len(nums) - 2):\\n if nums[i] != 1:\\n nums[i] = 1\\n nums[i + 1] = 1 if nums[i + 1] == 0 else 0\\n nums[i + 2] = 1 if nums[i + 2] == 0 else 0\\n num_of_op += 1\\n\\n return num_of_op if nums[-1] == 1 and nums[-2] == 1 else -1\\n\",\n \"runtime\": \"817\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n count = 0\\n for l in range(len(nums)-2):\\n if nums[l] == 0:\\n count += 1\\n nums[l] = 1\\n nums[l+1] = not nums[l+1]\\n nums[l+2] = not nums[l+2]\\n\\n if len(set(nums)) == 1:\\n return count\\n \\n return -1\\n \",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n i = 0\\n operations = 0\\n while(i < len(nums) - 2 ):\\n if (nums[i] == 0):\\n nums[i] = 1\\n operations += 1\\n if(nums[i + 1] == 0):\\n nums[i + 1] = 1\\n else: \\n nums[i+1] = 0\\n\\n if(nums[i + 2] == 0):\\n nums[i + 2] = 1\\n else: \\n nums[i+2] = 0\\n i += 1\\n\\n while(i < len(nums)):\\n if(nums[i] == 0):\\n return -1\\n i +=1\\n return operations\\n\",\n \"runtime\": \"841\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for i, x in enumerate(nums):\\n if x == 0:\\n if i + 2 >= len(nums):\\n return -1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n ans += 1\\n return ans\",\n \"runtime\": \"877\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n count = 0\\n for i in range(n - 2):\\n if nums[i] == 0:\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n count += 1\\n if nums[n - 1] == 0 or nums[n - 2] == 0:\\n return -1\\n return count\",\n \"runtime\": \"890\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ind = 0\\n count = 0\\n while(ind < len(nums)-2):\\n if nums[ind] == 1:\\n ind += 1\\n continue\\n \\n nums[ind+1] = abs(1 - nums[ind+1])\\n nums[ind+2] = abs(1 - nums[ind+2])\\n count += 1\\n ind += 1\\n\\n return count if nums[-1] + nums[-2] == 2 else -1\\n\\n\\n\\n\",\n \"runtime\": \"902\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n def flip(l, i):\\n l[i] = not(l[i])\\n l[i+1] = not(l[i+1])\\n l[i+2] = not(l[i+2])\\n return l\\n\\n def test(l):\\n count = 0\\n if not l.count(0):\\n return count\\n if l.index(0) > len(l) - 3:\\n return -1\\n for i in range(l.index(0), len(l) - 2):\\n if not l[i]:\\n count += 1\\n #l[i] = 1\\n #l[i+1] = not(l[i+1])\\n #l[i+2] = not(l[i+2])\\n flip(l, i)\\n additional_count = test(l)\\n if additional_count < 0:\\n return -1\\n count += additional_count\\n return count\\n return test(nums)\",\n \"runtime\": \"914\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n i = 0\\n flips = 0\\n while i < len(nums):\\n if nums[i] == 0:\\n if i >= len(nums) - 2:\\n return -1\\n nums[i] = 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n flips += 1\\n i += 1\\n return flips\",\n \"runtime\": \"926\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n\\n isFlipped = [0] * (n+1)\\n\\n flipCount = 0\\n\\n res = 0\\n\\n for i in range(n):\\n flipCount += isFlipped[i]\\n\\n if (nums[i] + flipCount) % 2 == 0:\\n\\n if i + 3 > n:\\n return -1\\n \\n flipCount += 1\\n isFlipped[i+3] -= 1\\n res += 1\\n\\n return res\\n \\n\\n\\n \",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n left, right = 0, 2\\n count = 0\\n\\n while right<len(nums):\\n\\n if nums[left] == 0:\\n #flip\\n nums[left] = 1\\n nums[right-1] = 1 - nums[right-1]\\n nums[right] = 1 - nums[right]\\n\\n count+=1\\n \\n left+=1\\n right+=1\\n\\n if nums[-1]==0 or nums[-2]==0:\\n return -1\\n\\n return count\\n\",\n \"runtime\": \"950\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums):\\n n, count = len(nums), 0\\n\\n for i in range(n-2):\\n if nums[i] == 0:\\n count += 1 \\n nums[i] += 1 \\n nums[i+1] = (nums[i+1]+1)%2 \\n nums[i+2] = (nums[i+2]+1)%2 \\n\\n return count if max(nums) == min(nums) == 1 else -1 \",\n \"runtime\": \"963\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n count = 0\\n for i in range(n-2):\\n if nums[i] == 0:\\n for j in range(i,i+3):\\n nums[j] = 1 - nums[j] # flip\\n count += 1\\n for i in range(n-2,n):\\n if nums[i] == 0:\\n return -1\\n return count\\n\\n \\n\",\n \"runtime\": \"963\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nTrick: Sliding Window\\n\\nWe can use sliding window trick. We always check window of size 3, but\\nthe moving forward step can be 1, 2 or 3.\\n\\nLet us see several scenarios:\\n\\n[1, *, *] => forward step is 1: index from i to i+1; no need to increment cnt of operations\\n\\nFor below scenarios, we need increment the n_operations\\n\\n[0, 1, *, *, *, ...] => [1, 0, *, *] => forward step is 1: index from i to i+1; \\n[0, 0, 1, *, *, ....] => [1, 1, 0] => forward step is 2: index from i to i+2; \\n[0, 0, 0, *, * , ....] => [1, 1, 1, * ] => forward step is 3: index from i to i+3.\\n\\n\\nAfter we do the sliding window, we can guarantee the first n - 2 elements must be 1\\nand the remaining 2 elements not sure. If they were both 1s, return the cnt of operations.\\nOtherwise, we can not make all elements to be 1, and return -1.\\n\\n0 0, 0\\n\\\"\\\"\\\"\\nclass Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n i = 0\\n while i < len(nums) - 2:\\n if nums[i] == 1:\\n i += 1\\n else:\\n res += 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n if nums[i+1] == 0:\\n i += 1\\n else:\\n if nums[i+2] == 0:\\n i += 2\\n else:\\n i += 3\\n \\n if nums[-1] == 1 and nums[-2] == 1:\\n return res\\n return -1\\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"975\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n num_operations = 0\\n\\n for i in range(len(nums)-2):\\n n = nums[i]\\n if n == 0:\\n num_operations += 1\\n nums[i] = 1\\n nums[i+1] = nums[i+1] ^ 1\\n nums[i+2] = nums[i+2] ^ 1\\n \\n for i in range(len(nums)):\\n if nums[i] == 0:\\n return -1\\n \\n return num_operations\\n\",\n \"runtime\": \"987\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n oper = 0\\n total = 0\\n for i in range(0, len(nums)-2):\\n if nums[i] == 0:\\n nums[i] = 1\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2] \\n oper += 1\\n\\n total += nums[i]\\n \\n if total + sum(nums[i+1:i+3]) == len(nums):\\n return oper\\n return -1\\n\",\n \"runtime\": \"999\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n l = 0\\n for i in range(0, len(nums) - 2):\\n if nums[i] == 0 and i + 2 < len(nums):\\n nums[i] = 1 - nums[i]\\n nums[i+1] = 1 - nums[i+1]\\n nums[i+2] = 1 - nums[i+2]\\n l += 1\\n if sum(nums) != len(nums):\\n return -1\\n return l\",\n \"runtime\": \"1011\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n idx = 0\\n steps = 0\\n n = len(nums)\\n while idx < n-2:\\n\\n if nums[idx]==0:\\n steps+=1\\n nums[idx] = not nums[idx]\\n nums[idx+1] = not nums[idx+1]\\n nums[idx+2] = not nums[idx+2]\\n \\n idx+=1\\n \\n if 0 in nums:\\n return -1\\n return steps\\n\\n \\\"\\\"\\\"\\n 0,1,1,1\\n 1,0,0,1\\n 1,1,1,0\\n \\\"\\\"\\\"\\n \\n\\n\\n\\n \\n\\n\",\n \"runtime\": \"1023\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for i, n in enumerate(nums):\\n if n == 1:\\n continue\\n if i + 2 >= len(nums):\\n return -1\\n res += 1\\n if nums[i + 1] == 0:\\n nums[i + 1] = 1\\n else:\\n nums[i + 1] = 0\\n if nums[i + 2] == 0:\\n nums[i + 2] = 1\\n else:\\n nums[i + 2] = 0\\n return res\\n\",\n \"runtime\": \"1036\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n len_nums=len(nums)\\n operation=0\\n for i in range(len_nums-2):\\n\\n if nums[i] == 0 :\\n count=3\\n j=i\\n while count > 0:\\n if nums[j] == 0:\\n nums[j]=1\\n else:\\n nums[j]=0\\n j+=1\\n count-=1\\n operation+=1\\n if nums[-1] == 1 and nums[-2] == 1:\\n return operation\\n else:\\n return -1\\n \\n\\n \",\n \"runtime\": \"1036\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n index = 0\\n while index <= len(nums)-3:\\n if nums[index] == 0:\\n nums[index] = 1\\n nums[index+1] = 1 if nums[index+1] == 0 else 0\\n nums[index+2] = 1 if nums[index+2] == 0 else 0\\n ans += 1\\n index += 1\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return ans\\n\\n \",\n \"runtime\": \"1048\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n # count = 0\\n # for i in range(len(nums)-2):\\n # if nums[i] == 1:\\n # continue\\n \\n # nums[i] = 1 - nums[i]\\n # nums[i+1] = 1 - nums[i+1]\\n # nums[i+2] = 1 - nums[i+2]\\n \\n # count+=1\\n \\n # if nums[-1] == 1 and nums[-2] == 1 and nums[-3] == 1:\\n # return count\\n # return -1\\n\\n q = deque()\\n count = 0\\n \\n for i in range(len(nums)):\\n\\n # makes sure queue doesn't have more than 2 elements.\\n if q and q[0] + 2 < i:\\n q.popleft()\\n \\n # 0 and queue length is even\\n # 1 and queue length is odd\\n if (nums[i] + len(q))%2 == 0:\\n if i + 3 > len(nums):\\n return -1\\n \\n count+=1\\n q.append(i)\\n \\n return count\\n\",\n \"runtime\": \"1048\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n i = 0\\n while(i < len(nums)):\\n if(nums[i] == 0):\\n if(i+2 < len(nums)):\\n nums[i] = 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n count += 1\\n else:\\n return -1\\n i += 1\\n \\n return count\\n\",\n \"runtime\": \"1060\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flip = 0\\n for i in range(len(nums)-2):\\n if nums[i] == 0:\\n flip += 1\\n for j in range(i,i+3):\\n if nums[j] == 0:\\n nums[j] = 1\\n else:\\n nums[j] = 0\\n return flip if nums.count(1) == len(nums) else -1\",\n \"runtime\": \"1060\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n N = len(nums)\\n cnt = 0\\n for i in range(N-2):\\n if nums[i] == 0:\\n for j in range(i, i+3):\\n nums[j] ^= 1\\n cnt += 1\\n\\n last = sum(nums[N-3:])\\n if last == 3:\\n return cnt\\n if last == 0:\\n return cnt + 1\\n return -1\\n\\n\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n cnt = 0\\n if nums.count(0) == 1:\\n return -1\\n\\n\\n for i in range(len(nums)):\\n if nums[i] == 0 and i+3 > len(nums):\\n return -1\\n\\n elif nums[i] == 0 and i+3 <= len(nums) :\\n nums[i] ^=1\\n nums[i+1] ^=1\\n nums[i+2] ^=1\\n cnt +=1\\n return cnt \\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n start, end = 0, 3\\n res = 0\\n \\n while end <= len(nums):\\n if nums[start] == 0:\\n for i in range(start, end):\\n if nums[i] == 0:\\n nums[i] = 1\\n else:\\n nums[i] = 0\\n res += 1\\n start += 1\\n end += 1\\n\\n for i in range(start, end-1):\\n if nums[i] == 0:\\n return -1\\n \\n return res\\n \",\n \"runtime\": \"1084\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n total=0\\n for i in range(0, len(nums)-2):\\n if nums[i]==0:\\n nums[i] += 1\\n nums[i] %= 2\\n nums[i+1] += 1\\n nums[i+1] %= 2\\n nums[i+2] += 1\\n nums[i+2] %= 2\\n total+=1\\n if nums[-1]==1 and nums[-2]==1:\\n return total\\n return -1\",\n \"runtime\": \"1084\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n, total = len(nums), 0\\n \\n for i in range(n-2):\\n if nums[i] == 0:\\n total += 1\\n for x in range(3):\\n nums[i+x] = 0 if nums[i+x] else 1\\n \\n return total if sum(nums) == n else -1\\n \",\n \"runtime\": \"1097\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n length = len(nums)\\n\\n count = 0\\n i = 0\\n for i in range(length - 3):\\n a = nums[i]\\n b = nums[i+1]\\n c = nums[i+2]\\n\\n \\n\\n if a != 1:\\n nums[i] = 1\\n count += 1\\n\\n if b == 1:\\n nums[i+1] = 0\\n else:\\n nums[i+1] = 1\\n\\n if c == 1:\\n nums[i+2] = 0\\n else:\\n nums[i+2] = 1\\n i += 1\\n\\n if (nums[i] == nums[i+1] and nums[i] == nums[i+2]):\\n if nums[i] == 0:\\n return count + 1\\n else:\\n return count\\n \\n return -1\",\n \"runtime\": \"1097\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n i = 0\\n length = len(nums)\\n while i <= length - 3 and count < length:\\n if not nums[i] == 0:\\n i += 1\\n continue\\n for j in range(3):\\n nums[i + j] ^= 1 \\n count += 1\\n i += 1\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return count\",\n \"runtime\": \"1109\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, arr: List[int]) -> int:\\n c=0\\n for i in range(len(arr)-2):\\n if arr[i]==0:\\n c+=1\\n for j in range(i,i+3):\\n if arr[j]==0:\\n arr[j]=1\\n else:\\n arr[j]=0\\n else:\\n continue\\n flag=False\\n for i in range(len(arr)):\\n if arr[i]==0:\\n flag=True\\n\\n if flag:\\n return -1\\n else:\\n return c\\n\",\n \"runtime\": \"1109\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n i,j = 0,0\\n size = len(nums)\\n count = 0\\n while j < size:\\n if j - i + 1 < 3:\\n j += 1\\n else:\\n if nums[i] == 0:\\n count += 1\\n for k in range(i,j + 1):\\n nums[k] = 1 - nums[k]\\n i += 1\\n j += 1\\n for i in range(size):\\n if nums[i] != 1:\\n return -1\\n return count\",\n \"runtime\": \"1121\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n h = {1: 0, 0: 1}\\n l = 0\\n while nums[l] == 1:\\n l += 1\\n if l == len(nums):\\n return 0\\n\\n ans = 0\\n while True:\\n for i in range(l, l + 3):\\n if i == len(nums):\\n return -1\\n nums[i] = h[nums[i]]\\n ans += 1\\n while nums[l] == 1:\\n l += 1\\n if l == len(nums):\\n return ans\",\n \"runtime\": \"1121\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ptrA = 0\\n ptrB = 2\\n operations = 0\\n while ptrB <= len(nums)-1:\\n if nums[ptrA] == 0:\\n for i in range(3):\\n nums[ptrA+i] ^= 1\\n operations += 1 \\n ptrA+=1\\n ptrB+=1\\n if nums[-1]==0 or nums[-2]==0:\\n return -1\\n return operations\\n\\n\\n \",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, arr: List[int]) -> int:\\n n = len(arr)\\n op = [0]*n\\n res = 0\\n num = lambda i, op: abs(op[i]%2 - arr[i])\\n\\n for i in range(n-2):\\n if num(i, op) == 0:\\n res += 1\\n for j in range(3):\\n op[i+j] += 1\\n \\n if num(n-2, op) == 1 and num(n-1, op) == 1:\\n return res\\n \\n return -1\",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n l = 0\\n while nums[l] == 1:\\n l += 1\\n if l == len(nums):\\n return 0\\n\\n ans = 0\\n while True:\\n for i in range(l, l + 3):\\n if i == len(nums):\\n return -1\\n nums[i] = 1 - nums[i]\\n ans += 1\\n while nums[l] == 1:\\n l += 1\\n if l == len(nums):\\n return ans\",\n \"runtime\": \"1145\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n l = 0\\n ans = 0\\n\\n for r in range(len(nums)):\\n if l != len(nums)-1 and len(nums)-r >= 3:\\n if nums[r] == 0:\\n ans += 1\\n for l in range(r,r+3):\\n if nums[l] == 0:\\n nums[l] = 1\\n else:\\n nums[l] = 0\\n if 0 in nums:\\n return -1\\n else:\\n return ans\",\n \"runtime\": \"1145\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n if len(nums) < 3:\\n return -1\\n strnums = \\\"\\\".join(map(str, nums))\\n i = 3\\n q = strnums[:3]\\n count = 0\\n while i < len(strnums):\\n # print(i, q, count)\\n if len(q) < 3:\\n q = q + strnums[i]\\n i += 1\\n else:\\n if q == \\\"111\\\":\\n q = \\\"\\\"\\n elif q == \\\"110\\\":\\n q = \\\"0\\\"\\n elif q == \\\"101\\\":\\n q = \\\"01\\\"\\n elif q == \\\"100\\\":\\n q = \\\"00\\\"\\n elif q == \\\"011\\\":\\n q = \\\"00\\\"\\n count += 1\\n elif q == \\\"010\\\":\\n q = \\\"01\\\"\\n count += 1\\n elif q == \\\"001\\\":\\n q = \\\"0\\\"\\n count += 1\\n elif q == \\\"000\\\":\\n q = \\\"\\\"\\n count += 1\\n # print(i, q, count)\\n if q == \\\"\\\" or q == \\\"1\\\" or q == \\\"11\\\" or q == \\\"111\\\":\\n return count\\n elif q == \\\"000\\\":\\n return count + 1\\n else:\\n return -1\\n\\n\\n \\n \\n \",\n \"runtime\": \"1157\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n operations, i = 0, 0\\n while i < len(nums)-2:\\n if nums[i] == 0:\\n for j in range(3):\\n if nums[i+j] == 0:\\n nums[i+j] = 1\\n else:\\n nums[i+j] = 0\\n i += 1\\n operations += 1\\n else: \\n i += 1\\n\\n if i == len(nums) - 2 and nums.count(0) != 0:\\n return -1\\n else: return operations\",\n \"runtime\": \"1157\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":93,"string":"93"},"mm_list":{"kind":"list like","value":[{"code":"\ndef minOperations(nums: List[int]) -> int:\n count = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n count += 1\n nums[i] = 1\n nums[i + 1] = abs(nums[i + 1] - 1)\n nums[i + 2] = abs(nums[i + 2] - 1)\n if nums[-1] == 0 or nums[-2] == 0:\n return -1\n return count\n\n\nwith open(\"user.out\", \"w\") as Solution:\n for nums in map(loads, stdin): Solution.write(f\"{minOperations(nums)}\\n\")\nexit() ","memory":"18600"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ind = 0\n count = 0\n while(ind < len(nums)-2):\n if nums[ind] == 1:\n ind += 1\n continue\n \n nums[ind+1] = abs(1 - nums[ind+1])\n nums[ind+2] = abs(1 - nums[ind+2])\n count += 1\n ind += 1\n\n return count if nums[-1] + nums[-2] == 2 else -1\n\n\n\n","memory":"19400"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count=0\n for i in range(len(nums)-2):\n if nums[i]==0:\n for j in range(3):\n if nums[i + j] ==0:\n nums[i + j] = 1\n else:\n nums[i + j] = 0 \n count+=1\n if all(num ==1 for num in nums):\n return count\n else:\n return -1","memory":"19500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n for i in range(len(nums)-2):\n if nums[i] == 0:\n flips += 1\n nums[i] = 1\n nums[i+1] ^= 1\n nums[i+2] ^= 1\n return flips if nums[-1] == 1 and nums[-2] == 1 else -1\n ","memory":"19700"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n count = 0\n while len(nums) > 2:\n cur = nums.pop()\n if not cur:\n nums[-1] ^= 1\n nums[-2] ^= 1\n count += 1\n \n return count if (nums[0] and nums[1]) else -1\n ","memory":"19800"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n count = 0\n while len(nums) > 2:\n cur = nums.pop()\n if not cur:\n nums[-1] = (nums[-1]+1)%2\n nums[-2] = (nums[-2]+1)%2\n count += 1\n \n return count if (nums[0] and nums[1]) else -1\n ","memory":"19900"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n op=0\n for i in range(len(nums)):\n if nums[i]!=1:\n if i+2 < len(nums):\n for j in range(i,i+3):\n if nums[j]==1:\n nums[j]=0\n else:\n nums[j]=1\n op+=1\n else:\n return -1\n return op\n\n ","memory":"20000"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n for i in range(len(nums) - 2):\n if nums[i]: continue\n nums[i + 1] = 1 - nums[i + 1]\n nums[i + 2] = 1 - nums[i + 2]\n ans += 1\n return ans if nums[-1] * nums[-2] else -1","memory":"20100"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n c=0\n for i in range(len(nums)-2):\n if nums[i]==0:\n c=c+1\n nums[i]=1\n if(nums[i+1]==0):\n nums[i+1]=1\n else:\n nums[i+1]=0\n if(nums[i+2]==0):\n nums[i+2]=1\n else:\n nums[i+2]=0\n if(nums[-1]==0 or nums[-2]==0):\n return -1\n return c\n\n\n \n ","memory":"20100"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n i = 0\n j = 0\n cnt = 0\n while j < len(nums):\n if j-i+1 < 3:\n j +=1\n elif j-i+1 == 3:\n if nums[i] == 0:\n cnt +=1\n for k in range(i,j+1):\n if nums[k] == 0:\n nums[k] = 1\n elif nums[k] == 1:\n nums[k] = 0\n #print(nums)\n i +=1\n j +=1\n if len(nums) == sum(nums):\n return cnt\n else:\n return -1\n\n\n\n\n ","memory":"20200"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n tot = 0\n for i in range(n-2):\n if nums[i] == 0:\n tot += 1\n nums[i] = 1\n nums[i+1] = 1-nums[i+1]\n nums[i+2] = 1-nums[i+2]\n return tot if (nums[n-2] == 1 and nums[n-1] == 1) else -1","memory":"20200"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0 \n \n for l in range(len(nums)-2):\n \n if(nums[l]==0):\n ans+=1\n nums[l]=1\n if(l+1<len(nums)):\n if(nums[l+1]==1):\n nums[l+1]=0\n else:\n nums[l+1]=1\n if(l+2<len(nums)):\n if(nums[l+2]==1):\n nums[l+2]=0\n else:\n nums[l+2]=1\n if 0 in nums:\n return -1\n return ans","memory":"20300"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n n = len(nums)\n cnt = Counter(nums)\n \n res = 0\n for i in range(n-2):\n if nums[i] == 0:\n for j in range(3):\n nums[i+j] ^= 1\n res += 1\n \n if nums != [1] * n:\n return -1\n return res\n \n \n ","memory":"20400"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for i in range(len(nums)):\n if nums[i] == 0:\n if len(nums) - i <= 2:\n res = -1\n break\n res += 1\n nums[i], nums[i+1], nums[i+2] = not nums[i], not nums[i+1], not nums[i+2]\n return res","memory":"20400"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for i in range(len(nums)):\n if nums[i] == 0:\n if len(nums) - i <= 2:\n res = -1\n break\n res += 1\n nums[i], nums[i+1], nums[i+2] = int(not bool(nums[i])), int(not bool(nums[i+1])), int(not bool(nums[i+2]))\n return res","memory":"20500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ans = 0\n flipped = [0]*n \n flip = 0\n for i in range(n):\n if i>=3:\n # valid end \n flip ^= flipped[i-3]\n if nums[i] == flip:\n if i+3> n:\n return -1\n ans +=1\n flip ^= 1\n flipped[i] = 1\n \n \n return ans\n ","memory":"20500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans=0\n l=0\n r=0\n # if len(nums)\n while r<len(nums):\n if r-l+1==3:\n if nums[l]==0:\n nums[l]=1\n nums[l+1]=1-nums[l+1]\n nums[r]=1-nums[r]\n l+=1\n ans+=1\n else:\n l+=1\n r+=1\n if len(nums)>2:\n if nums[-3]==0 or nums[-2]==0 or nums[-1]==0:\n return -1\n return ans\n\n","memory":"20600"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n n += 1\n return n if nums[-1] == nums[-2] == 1 else -1","memory":"20700"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = 0\n for i in range(len(nums) - 2):\n if nums[i] == 0:\n nums[i] ^= 1\n nums[i + 1] ^= 1\n nums[i + 2] ^= 1\n n += 1\n return n if nums[-1] == nums[-2] == nums[-3] == 1 else -1","memory":"20800"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n\n for i in range(len(nums)-2):\n if nums[i] == 0:\n for j in range(i,i+3):\n if nums[j]:\n nums[j] = 0\n else:\n nums[j] = 1\n count += 1\n if nums.count(1) == len(nums):\n return count\n\n else:\n return -1\n\n","memory":"20900"}],"string":"[\n {\n \"code\": \"\\ndef minOperations(nums: List[int]) -> int:\\n count = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n count += 1\\n nums[i] = 1\\n nums[i + 1] = abs(nums[i + 1] - 1)\\n nums[i + 2] = abs(nums[i + 2] - 1)\\n if nums[-1] == 0 or nums[-2] == 0:\\n return -1\\n return count\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for nums in map(loads, stdin): Solution.write(f\\\"{minOperations(nums)}\\\\n\\\")\\nexit() \",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ind = 0\\n count = 0\\n while(ind < len(nums)-2):\\n if nums[ind] == 1:\\n ind += 1\\n continue\\n \\n nums[ind+1] = abs(1 - nums[ind+1])\\n nums[ind+2] = abs(1 - nums[ind+2])\\n count += 1\\n ind += 1\\n\\n return count if nums[-1] + nums[-2] == 2 else -1\\n\\n\\n\\n\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count=0\\n for i in range(len(nums)-2):\\n if nums[i]==0:\\n for j in range(3):\\n if nums[i + j] ==0:\\n nums[i + j] = 1\\n else:\\n nums[i + j] = 0 \\n count+=1\\n if all(num ==1 for num in nums):\\n return count\\n else:\\n return -1\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n for i in range(len(nums)-2):\\n if nums[i] == 0:\\n flips += 1\\n nums[i] = 1\\n nums[i+1] ^= 1\\n nums[i+2] ^= 1\\n return flips if nums[-1] == 1 and nums[-2] == 1 else -1\\n \",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n count = 0\\n while len(nums) > 2:\\n cur = nums.pop()\\n if not cur:\\n nums[-1] ^= 1\\n nums[-2] ^= 1\\n count += 1\\n \\n return count if (nums[0] and nums[1]) else -1\\n \",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n count = 0\\n while len(nums) > 2:\\n cur = nums.pop()\\n if not cur:\\n nums[-1] = (nums[-1]+1)%2\\n nums[-2] = (nums[-2]+1)%2\\n count += 1\\n \\n return count if (nums[0] and nums[1]) else -1\\n \",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n op=0\\n for i in range(len(nums)):\\n if nums[i]!=1:\\n if i+2 < len(nums):\\n for j in range(i,i+3):\\n if nums[j]==1:\\n nums[j]=0\\n else:\\n nums[j]=1\\n op+=1\\n else:\\n return -1\\n return op\\n\\n \",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n for i in range(len(nums) - 2):\\n if nums[i]: continue\\n nums[i + 1] = 1 - nums[i + 1]\\n nums[i + 2] = 1 - nums[i + 2]\\n ans += 1\\n return ans if nums[-1] * nums[-2] else -1\",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n c=0\\n for i in range(len(nums)-2):\\n if nums[i]==0:\\n c=c+1\\n nums[i]=1\\n if(nums[i+1]==0):\\n nums[i+1]=1\\n else:\\n nums[i+1]=0\\n if(nums[i+2]==0):\\n nums[i+2]=1\\n else:\\n nums[i+2]=0\\n if(nums[-1]==0 or nums[-2]==0):\\n return -1\\n return c\\n\\n\\n \\n \",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n i = 0\\n j = 0\\n cnt = 0\\n while j < len(nums):\\n if j-i+1 < 3:\\n j +=1\\n elif j-i+1 == 3:\\n if nums[i] == 0:\\n cnt +=1\\n for k in range(i,j+1):\\n if nums[k] == 0:\\n nums[k] = 1\\n elif nums[k] == 1:\\n nums[k] = 0\\n #print(nums)\\n i +=1\\n j +=1\\n if len(nums) == sum(nums):\\n return cnt\\n else:\\n return -1\\n\\n\\n\\n\\n \",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n tot = 0\\n for i in range(n-2):\\n if nums[i] == 0:\\n tot += 1\\n nums[i] = 1\\n nums[i+1] = 1-nums[i+1]\\n nums[i+2] = 1-nums[i+2]\\n return tot if (nums[n-2] == 1 and nums[n-1] == 1) else -1\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0 \\n \\n for l in range(len(nums)-2):\\n \\n if(nums[l]==0):\\n ans+=1\\n nums[l]=1\\n if(l+1<len(nums)):\\n if(nums[l+1]==1):\\n nums[l+1]=0\\n else:\\n nums[l+1]=1\\n if(l+2<len(nums)):\\n if(nums[l+2]==1):\\n nums[l+2]=0\\n else:\\n nums[l+2]=1\\n if 0 in nums:\\n return -1\\n return ans\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n cnt = Counter(nums)\\n \\n res = 0\\n for i in range(n-2):\\n if nums[i] == 0:\\n for j in range(3):\\n nums[i+j] ^= 1\\n res += 1\\n \\n if nums != [1] * n:\\n return -1\\n return res\\n \\n \\n \",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n if len(nums) - i <= 2:\\n res = -1\\n break\\n res += 1\\n nums[i], nums[i+1], nums[i+2] = not nums[i], not nums[i+1], not nums[i+2]\\n return res\",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n if len(nums) - i <= 2:\\n res = -1\\n break\\n res += 1\\n nums[i], nums[i+1], nums[i+2] = int(not bool(nums[i])), int(not bool(nums[i+1])), int(not bool(nums[i+2]))\\n return res\",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n ans = 0\\n flipped = [0]*n \\n flip = 0\\n for i in range(n):\\n if i>=3:\\n # valid end \\n flip ^= flipped[i-3]\\n if nums[i] == flip:\\n if i+3> n:\\n return -1\\n ans +=1\\n flip ^= 1\\n flipped[i] = 1\\n \\n \\n return ans\\n \",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans=0\\n l=0\\n r=0\\n # if len(nums)\\n while r<len(nums):\\n if r-l+1==3:\\n if nums[l]==0:\\n nums[l]=1\\n nums[l+1]=1-nums[l+1]\\n nums[r]=1-nums[r]\\n l+=1\\n ans+=1\\n else:\\n l+=1\\n r+=1\\n if len(nums)>2:\\n if nums[-3]==0 or nums[-2]==0 or nums[-1]==0:\\n return -1\\n return ans\\n\\n\",\n \"memory\": \"20600\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n n += 1\\n return n if nums[-1] == nums[-2] == 1 else -1\",\n \"memory\": \"20700\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = 0\\n for i in range(len(nums) - 2):\\n if nums[i] == 0:\\n nums[i] ^= 1\\n nums[i + 1] ^= 1\\n nums[i + 2] ^= 1\\n n += 1\\n return n if nums[-1] == nums[-2] == nums[-3] == 1 else -1\",\n \"memory\": \"20800\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n\\n for i in range(len(nums)-2):\\n if nums[i] == 0:\\n for j in range(i,i+3):\\n if nums[j]:\\n nums[j] = 0\\n else:\\n nums[j] = 1\\n count += 1\\n if nums.count(1) == len(nums):\\n return count\\n\\n else:\\n return -1\\n\\n\",\n \"memory\": \"20900\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":20,"string":"20"}}},{"rowIdx":2466,"cells":{"question_id":{"kind":"number","value":3477,"string":"3,477"},"name":{"kind":"string","value":"minimum-operations-to-make-binary-array-elements-equal-to-one-ii"},"content":{"kind":"string","value":"<p>You are given a <span data-keyword=\"binary-array\">binary array</span> <code>nums</code>.</p>\n\n<p>You can do the following operation on the array <strong>any</strong> number of times (possibly zero):</p>\n\n<ul>\n\t<li>Choose <strong>any</strong> index <code>i</code> from the array and <strong>flip</strong> <strong>all</strong> the elements from index <code>i</code> to the end of the array.</li>\n</ul>\n\n<p><strong>Flipping</strong> an element means changing its value from 0 to 1, and from 1 to 0.</p>\n\n<p>Return the <strong>minimum</strong> number of operations required to make all elements in <code>nums</code> equal to 1.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [0,1,1,0,1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong><br />\nWe can do the following operations:</p>\n\n<ul>\n\t<li>Choose the index <code>i = 1</code><span class=\"example-io\">. The resulting array will be <code>nums = [0,<u><strong>0</strong></u>,<u><strong>0</strong></u>,<u><strong>1</strong></u>,<u><strong>0</strong></u>]</code>.</span></li>\n\t<li>Choose the index <code>i = 0</code><span class=\"example-io\">. The resulting array will be <code>nums = [<u><strong>1</strong></u>,<u><strong>1</strong></u>,<u><strong>1</strong></u>,<u><strong>0</strong></u>,<u><strong>1</strong></u>]</code>.</span></li>\n\t<li>Choose the index <code>i = 4</code><span class=\"example-io\">. The resulting array will be <code>nums = [1,1,1,0,<u><strong>0</strong></u>]</code>.</span></li>\n\t<li>Choose the index <code>i = 3</code><span class=\"example-io\">. The resulting array will be <code>nums = [1,1,1,<u><strong>1</strong></u>,<u><strong>1</strong></u>]</code>.</span></li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,0,0,0]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong><br />\nWe can do the following operation:</p>\n\n<ul>\n\t<li>Choose the index <code>i = 1</code><span class=\"example-io\">. The resulting array will be <code>nums = [1,<u><strong>1</strong></u>,<u><strong>1</strong></u>,<u><strong>1</strong></u>]</code>.</span></li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>0 <= nums[i] <= 1</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":65.33948729355502,"string":"65.339487"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming","greedy"],"string":"[\n \"array\",\n \"dynamic-programming\",\n \"greedy\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"1024\", 0.4854], [\"1026\", 0.2427], [\"1027\", 0.4854], [\"1029\", 0.2427], [\"1030\", 0.4854], [\"1031\", 0.2427], [\"1033\", 0.4854], [\"1034\", 0.4854], [\"1036\", 0.2427], [\"1037\", 0.2427], [\"1039\", 0.2427], [\"1040\", 1.2136], [\"1042\", 0.4854], [\"1043\", 0.4854], [\"1045\", 0.2427], [\"1046\", 0.2427], [\"1047\", 0.4854], [\"1049\", 0.2427], [\"1050\", 0.7282], [\"1052\", 2.1845], [\"1053\", 0.2427], [\"1055\", 0.4854], [\"1056\", 0.7282], [\"1058\", 0.2427], [\"1059\", 2.4272], [\"1060\", 0.9709], [\"1062\", 2.6699], [\"1063\", 0.9709], [\"1065\", 2.4272], [\"1066\", 1.4563], [\"1068\", 1.2136], [\"1069\", 2.9126], [\"1071\", 0.7282], [\"1072\", 1.9418], [\"1074\", 0.9709], [\"1075\", 1.2136], [\"1076\", 1.2136], [\"1078\", 3.1553], [\"1079\", 1.9417], [\"1081\", 0.7282], [\"1082\", 4.3689], [\"1084\", 1.4563], [\"1085\", 4.6116], [\"1087\", 1.9417], [\"1088\", 2.4272], [\"1089\", 1.2136], [\"1091\", 2.6699], [\"1092\", 0.7282], [\"1094\", 3.398], [\"1095\", 0.9709], [\"1097\", 0.7282], [\"1098\", 2.1845], [\"1100\", 0.7282], [\"1101\", 1.9418], [\"1103\", 1.2136], [\"1104\", 1.4563], [\"1105\", 0.4854], [\"1107\", 3.398], [\"1108\", 0.7282], [\"1110\", 1.699], [\"1111\", 2.4272], [\"1113\", 1.2136], [\"1114\", 2.4272], [\"1116\", 0.9709], [\"1117\", 1.2136], [\"1118\", 0.4854], [\"1120\", 0.9708], [\"1121\", 1.2136], [\"1123\", 0.7281], [\"1124\", 0.4854], [\"1126\", 0.4854], [\"1127\", 0.9709], [\"1129\", 0.2427], [\"1130\", 0.2427], [\"1132\", 1.2136], [\"1133\", 0.4854], [\"1134\", 0.9709], [\"1136\", 0.7282], [\"1137\", 0.2427]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19400\", 0.4854], [\"19500\", 0.4854], [\"19600\", 2.4272], [\"19700\", 1.4563], [\"19800\", 1.2136], [\"19900\", 0.7282], [\"20000\", 0.2427], [\"20100\", 2.1845], [\"20200\", 14.8058], [\"20300\", 35.6796], [\"20400\", 17.9612], [\"20500\", 8.7379], [\"20600\", 6.5534]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = current = 0\n for num in nums:\n if num == current:\n flips += 1\n current = not current\n return flips\n","runtime":"1024"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = current = 0\n for num in nums:\n if num == current:\n flips += 1\n current = not current\n return flips\n","runtime":"1024"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n c = 0\n flip = 0 \n for num in nums:\n if num == flip: \n c += 1\n flip = 1 - flip \n return c\n","runtime":"1026"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for x in nums:\n if res & 1 == x:\n res += 1\n return res","runtime":"1030"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n expected = 1\n\n for num in nums:\n if num != expected:\n flips += 1\n expected = 1 - expected\n\n return flips\n","runtime":"1031"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ele = 0\n count = 0\n for num in nums:\n if num == ele:\n count += 1\n ele = 1 - ele\n return count\n ","runtime":"1033"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n cur = 0\n \n for y in nums:\n if y == cur:\n res += 1\n cur = 1 - cur\n \n return res\n \n ","runtime":"1034"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n op=0\n check=1\n for i in nums:\n if i!=check:\n op+=1\n check=1-check\n return op","runtime":"1036"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flipped = 1\n count = 0\n for n in nums:\n if n != flipped:\n count += 1\n flipped = not flipped\n return count\n ","runtime":"1037"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flipped = False\n count = 0\n\n for num in nums:\n if num == 0:\n if not flipped:\n flipped = not flipped\n count += 1\n else:\n if flipped:\n flipped = not flipped\n count += 1\n return count\n ","runtime":"1039"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n for num in nums:\n if num == flips % 2:\n flips+=1\n return flips","runtime":"1040"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n expected = 1\n\n for num in nums:\n if num != expected:\n flips += 1\n expected = 1 - expected\n\n return flips","runtime":"1042"},{"code":"class Solution:\n def minOperations(self, A: List[int]) -> int:\n res = 0\n for a in A:\n if a == res & 1:\n res += 1\n return res","runtime":"1043"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n curr = nums[-1]\n ops = 0\n \n for num in nums[:-1][::-1]:\n if num != curr:\n ops += 1\n curr = num\n \n return ops + (curr == 0)","runtime":"1045"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n result = 0\n flip = 0\n\n for num in nums:\n if num + flip != 1: # both num==flip same, either should be 1, not XOR?\n result += 1\n flip = 0 if flip == 1 else 1\n return result\n\n\n\"\"\"\n def minOperations(self, nums: List[int]) -> int:\n ops = 0\n for num in nums:\n if num ^ (ops % 2) == 0:\n ops += 1\n return ops\n[0,1,1,0,1], flip=0\ni=0: resul=1, flip=1\ni=1: resul=2, flip=0\ni:2: result=3 flip=1\ni=3:\ni=4:result=4, flip=0\n\n\n\n\"\"\"\n","runtime":"1046"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flipped = False\n count = 0\n for num in nums:\n if flipped == num:\n count += 1\n flipped = not flipped\n return count\n","runtime":"1047"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n flip_parity = 0\n for num in nums:\n if not (num ^ flip_parity):\n count += 1\n flip_parity = 1 - flip_parity\n return count","runtime":"1049"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n operations = 0\n current_bit = 1\n for char in nums:\n if char != current_bit:\n operations += 1\n current_bit = char\n return operations\n \n","runtime":"1050"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n return sum(1 for _ in groupby(nums)) - nums[0]\n \n ","runtime":"1052"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n needed = 1\n for num in nums:\n if num != needed:\n needed = num\n count += 1\n return count","runtime":"1053"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n tmp = 0\n for num in nums:\n if num == tmp:\n res += 1\n tmp = tmp^1\n return res","runtime":"1055"},{"code":"class Solution:\n def minOperations(self, A: List[int]) -> int:\n res = 0\n for a in A:\n if a == (res & 1):\n res += 1\n return res","runtime":"1056"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n c=0\n t=0\n for i in nums:\n if i==t:\n c+=1\n t=1-t\n return c\n","runtime":"1058"},{"code":"\"\"\"\nIdea: check 0's and 1's in alternating fashion. Each time we locate a 0 or 1,\nwe increment the count of the operation by 1.\n\nIn view of the operation, we need to do the operation from left to right by\nchecking 0's.\n\nwe need to first find the left most zero, and do 1 operation.\n\nop at index 0: 0, 1, 1, 0, 1 => 1, 0, 0, 1, 0\n\nThen we find the lest most zero gain, at do the operation:\n\nop at index 1: 1, 0, 0, 1, 0 => 1, 1, 1, 0, 1\n\nContinue to find zeros:\n\nop at index 3: 1, 1, 1, 0, 1 => 1, 1, 1, 1, 0\n\nop at index 4: 1, 1, 1, 1, 0 => 1, 1, 1, 1, 1\n\nThe indices involved are 0, 1, 3, 4.\n\nIf we \"ignore\" the flipping, the obove indices in the original arr\n\n0, 1, 3, 4\n0, 1, 1, 0, 1\n\ncorresponds to find 0, 1 in alternating fashion. As we have 4 indices,\nwe return 4.\n\n\"\"\"\n\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n cur = 0\n \n for y in nums:\n if y == cur:\n res += 1\n cur = 1 - cur\n \n return res\n \n ","runtime":"1059"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n for x in nums:\n if not x ^ (flips & 1):\n flips += 1\n return flips\n","runtime":"1059"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n expected = 1\n\n for num in nums:\n if num != expected:\n flips += 1\n expected = 1 - expected\n\n return flips","runtime":"1060"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for n in nums:\n if n == (res&1):\n res += 1\n\n return res","runtime":"1062"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n return sum(1 for _ in itertools.groupby(nums)) - nums[0]","runtime":"1062"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n result=0\n for i in nums:\n if i==result%2:\n result+=1\n return result","runtime":"1063"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips=0\n for num in nums:\n if flips % 2 == num:\n flips += 1\n return flips\n","runtime":"1063"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n flip_state = 0\n \n for num in nums:\n if num == flip_state:\n flips += 1\n flip_state = 1 - flip_state\n \n return flips","runtime":"1065"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ops = 0\n for num in nums:\n if num == ops % 2:\n ops += 1\n return ops\n","runtime":"1065"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n for x in nums:\n if (x + count) % 2 == 0:\n count += 1\n return count","runtime":"1066"},{"code":"\"\"\"\n这题和开关灯的那个很像，记得那道题是用高斯消元做的\n the left most number have the min flip times\n the right most number have the max flip times\n left -> right, accumulate the flip \n and decide if we need a new flip at that number\n\n\n [0,1,1,0,1]\n 第一个位置 换成 1，flipCnt = 1\n 第二个位置就是 0 （flipCnt 是奇数代表和原来不一样），需要再 flip 一下\n\"\"\"\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n # cnt is the accumulated flip for each number\n flipCnt = 0\n for x in nums:\n if x == 0 and flipCnt % 2 == 0 or x == 1 and flipCnt % 2 == 1:\n flipCnt += 1\n return flipCnt\n\n ","runtime":"1068"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n zero_found = False\n \n for i in range(len(nums)):\n if nums[i] == 0 and zero_found == False:\n zero_found = True\n elif nums[i] == 1 and zero_found == True:\n res += 2\n zero_found = False\n\n if nums[-1] == 0:\n res += 1\n \n return res ","runtime":"1069"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ret = flip = 0\n for a in nums:\n if a ^ flip == 0:\n ret += 1\n flip = 1 - flip\n return ret","runtime":"1069"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n out = 0\n if nums[-1]==0:\n out+=1\n i =len(nums)-1\n while i>=0 and nums[i]==0:\n nums[i]=1\n i-=1\n \n ct = 0\n zeroflag = False\n for i in range(len(nums)):\n if nums[i]==0:\n if zeroflag: continue\n ct+=1\n zeroflag = True\n else:\n zeroflag = False\n\n return out+2*ct","runtime":"1071"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n mode = 0\n ans = 0\n for i in nums:\n if i == mode:\n ans += 1\n mode = not mode\n return ans","runtime":"1072"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n flips = 0\n for num in nums:\n flipped_value = num if flips % 2 == 0 else not num\n if flipped_value == 0:\n flips += 1\n \n return flips\n\n ","runtime":"1072"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n for x in nums:\n if (x + count) % 2 == 0:\n count += 1\n return count","runtime":"1074"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n parity = res = 0\n for num in nums:\n if num ^ parity == 0:\n res += 1\n parity = 1 - parity\n return res\n","runtime":"1075"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n c=0\n p=0\n for i in nums:\n if(i==1):\n if(p%2==0):\n pass\n else:\n p=p+1\n c=c+1\n else:\n if(p%2==0):\n p=p+1\n c=c+1\n else:\n pass\n return c","runtime":"1075"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flip = res = 0 \n for n in nums:\n if (n + flip) % 2 == 0:\n flip += 1 \n res += 1 \n return res ","runtime":"1076"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n for x in nums:\n if (x + count) % 2 == 0:\n count += 1\n return count","runtime":"1078"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int: \n count = 0 \n flip = 0 \n \n for i in range(len(nums)):\n if nums[i] == flip:\n count += 1\n flip = 1 - flip \n \n return count","runtime":"1078"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n num_swipes = 0\n for num in nums:\n if (num + num_swipes) % 2 == 0:\n num_swipes += 1\n return num_swipes\n ","runtime":"1079"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n n = len(nums)\n cnt = 0\n for i in range(n):\n if (nums[i] + cnt) % 2 == 1:\n continue\n else:\n cnt += 1\n return cnt\n \n \n \n \n \n ","runtime":"1081"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ops = flag = 0\n for num in nums:\n if num == flag:\n ops += 1\n flag = 1 - flag\n\n return ops","runtime":"1082"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n \n idx = 0\n while idx < n and nums[idx] == 1:\n idx += 1\n \n res = 0\n flip = 0\n for i in range(idx, n):\n x = nums[i] ^ flip\n if x == 0:\n flip ^= 1\n res += 1\n \n return res\n ","runtime":"1082"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n flip = 0\n for n in nums:\n if n + flip != 1:\n res +=1\n flip = 1 - flip\n return res","runtime":"1084"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n flipped = False\n\n for n in nums:\n if n == 0 and not flipped:\n flipped = not flipped\n res += 1\n elif n == 1 and flipped:\n flipped = not flipped\n res += 1\n\n return res","runtime":"1085"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n if nums[0] == 0:\n flips += 1\n for i in range(1, len(nums)):\n if nums[i] != nums[i - 1]:\n flips += 1\n return flips\n","runtime":"1085"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n flip = 0\n \n for i in range(n):\n if (nums[i] == 1 and flip%2==1) or (nums[i] == 0 and flip%2==0):\n flip +=1\n return flip","runtime":"1087"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n=len(nums)\n res=0\n if nums[0]==0:\n res+=1\n for i in range(1,n):\n if nums[i]!=nums[i-1]:\n res+=1\n return res","runtime":"1088"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n operations = 0\n flipped = 0\n\n for i in range(len(nums)):\n current_state = nums[i] if flipped % 2 == 0 else 1 - nums[i]\n if current_state == 0:\n operations += 1\n flipped += 1\n\n return operations","runtime":"1088"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # to find number of islands of zero\n islands = 0\n i = 0\n while i < len(nums):\n if nums[i] == 0:\n j = i\n while j < len(nums) and nums[j] == 0:\n j += 1\n islands += 1\n i = j\n else:\n i += 1\n \n if islands % 2 == 0:\n if nums[i-1] == 0:\n return (islands*2)-1\n return islands * 2\n else:\n if nums[i-1] == 1:\n return islands*2\n return (islands*2) - 1\n \n ","runtime":"1089"},{"code":"class Solution:\n def minOperations(self, A: List[int]) -> int:\n ans = 0\n A = [x for x, g in groupby(A)]\n for i in range(len(A) - 1):\n if not A[i]:\n ans += A[i + 1] * 2\n return ans + (not A[-1])","runtime":"1091"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n flips = 0\n for num in nums:\n flipped_value = num if flips % 2 == 0 else not num\n if flipped_value == 0:\n flips += 1\n \n return flips\n\n ","runtime":"1091"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n flips = 0\n\n for n in nums:\n if n == 0:\n if flips % 2 == 0:\n # actual n = 0\n res += 1\n flips += 1\n else:\n # actual n = 1\n pass\n else:\n if flips % 2 == 0:\n # actual n = 1\n pass\n else:\n # actual n = 0\n res += 1\n flips += 1\n \n return res\n","runtime":"1092"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n firstZero = -1\n\n for i in range(len(nums)):\n if nums[i] == 0:\n firstZero = i\n break\n \n # if no zero is found then return 0, as there is nothing to change\n if firstZero == -1:\n return 0\n \n answer = 0\n for i in range(firstZero, len(nums)):\n if i == firstZero:\n answer += 1\n continue\n \n if nums[i] != nums[i - 1]:\n answer += 1\n \n return answer\n","runtime":"1094"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n=len(nums)\n c=0\n i=n-1\n is_one=False\n while i>=0:\n if nums[i]==1:\n is_one=True\n i-=1\n else:\n l=i\n # j=i\n while i>=0:\n if nums[i]==1:\n break\n l=i\n i-=1\n if l==n-1:\n c+=1\n else:\n if is_one:\n c+=2\n else:\n c+=1\n return c\n\n ","runtime":"1094"},{"code":"\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n ct = 0\n b = 0\n\n for k in nums:\n if (k + b) % 2 == 0:\n ct += 1\n b = (b + 1) % 2\n\n return ct","runtime":"1095"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","runtime":"1097"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n f=True\n for ele in nums:\n if ele==0:\n f=False\n if f:\n return 0\n i=0\n n=len(nums)\n first=True\n ans=0\n curr=0\n while i<n:\n if first:\n if nums[i]!=0:\n i+=1\n else:\n first=False\n ans+=1\n else:\n curr=nums[i]\n while i<n and nums[i]==curr:\n i+=1\n ans+=1\n return ans-1","runtime":"1103"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n count = 0\n for num in nums:\n count += (not num) ^ (count % 2)\n return count","runtime":"1104"},{"code":"class Solution:\n def minOperations(self, nums: list[int]) -> int:\n result, n, i = 0, len(nums), 0\n while i < n and nums[i] == 1: i += 1\n for j in range(i, n):\n if j == i or nums[j] != nums[j-1]: result += 1\n return result\n","runtime":"1104"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n index = len(nums) - 1\n count = 0\n while index - 1 >= 0:\n if nums[index - 1] != nums[index]:\n count += 1\n index -= 1\n if nums[0] == 0: count += 1\n return count","runtime":"1105"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n flip = False\n for i, val in enumerate(nums):\n if val ^ flip == 0:\n flip = not flip\n ans += 1\n return ans","runtime":"1107"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n zero_found = False\n \n for i in range(len(nums)):\n if nums[i] == 0 and zero_found == False:\n zero_found = True\n elif nums[i] == 1 and zero_found == True:\n res += 2\n zero_found = False\n\n if nums[-1] == 0:\n res += 1\n \n return res ","runtime":"1107"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","runtime":"1108"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0 if nums[0] == 1 else 1\n for i in range(1, len(nums)):\n res += (nums[i] + nums[i-1])%2\n return res\n","runtime":"1110"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n i = 0\n flips = 0\n while i < n:\n nums[i] = 1 - nums[i] if flips % 2 == 1 else nums[i]\n if nums[i] == 0:\n flips += 1\n \n i += 1\n return flips","runtime":"1111"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ops = 0\n\n # better to start from the leftmost index\n # 1 0 0 1 0\n # 1 1 1 0 1\n # 1 1 1 1 0\n # 1 1 1 1 1\n\n flips = 0\n\n # then continue and try to advance\n i = 0\n while i < n:\n if flips % 2 == 0:\n if nums[i] == 0:\n flips += 1\n else:\n if nums[i] == 1:\n flips += 1\n i += 1\n return flips","runtime":"1111"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 1 - nums[0]\n for i in range(1, len(nums)):\n res += (nums[i] + nums[i-1])%2\n return res\n","runtime":"1113"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # 10010\n # 11101\n # 11110\n # 11111\n # modifying whole array each time is expensive, we can remember modification count\n count = 0\n for val in nums:\n flipped = count % 2\n modified_val = val if not flipped else int(not bool(val))\n if modified_val == 0:\n count += 1\n return count\n ","runtime":"1114"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 1 - nums[0]\n n = len(nums)\n for i in range(1, n):\n res += (nums[i] + nums[i-1])%2\n return res\n","runtime":"1114"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # to find number of islands of zero\n islands = 0\n i = 0\n while i < len(nums):\n if nums[i] == 0:\n j = i\n while j < len(nums) and nums[j] == 0:\n j += 1\n islands += 1\n i = j\n else:\n i += 1\n \n if islands % 2 == 0:\n if nums[i-1] == 0:\n return (islands*2)-1\n return islands * 2\n else:\n if nums[i-1] == 1:\n return islands*2\n return (islands*2) - 1\n \n ","runtime":"1116"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n zero_found = False\n \n for i in range(len(nums)):\n if nums[i] == 0 and zero_found == False:\n zero_found = True\n elif nums[i] == 1 and zero_found == True:\n res += 2\n zero_found = False\n\n if nums[-1] == 0:\n res += 1\n \n return res","runtime":"1117"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","runtime":"1117"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n zero_encountered = False\n for idx in range(0, len(nums)):\n if nums[idx] == 0 and not zero_encountered:\n zero_encountered = True\n continue\n if nums[idx] == 1 and zero_encountered:\n zero_encountered = False\n count += 2\n \n if nums[-1] == 0:\n count += 1\n\n return count","runtime":"1118"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n i = 0\n flips = 0\n while i < n:\n if flips % 2 ==1:\n nums[i] = 1 - nums[i] \n else:\n nums[i]= nums[i]\n if nums[i] == 0:\n flips += 1\n \n i += 1\n return flips","runtime":"1120"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \"\"\"\n [0,1,0,1,0,0]\n \"\"\"\n seenOne = False\n n = len(nums)\n flips = 0\n for i, num in zip(range(n - 1, -1, -1), reversed(nums)):\n if num == 1:\n seenOne = True\n continue\n if num == 0 and i and nums[i - 1] == 0:\n continue\n \n flips += 1\n if seenOne:\n flips += 1\n\n return flips\n ","runtime":"1120"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n\n flips = 0\n for num in nums:\n flipped_value = num if flips % 2 == 0 else not num\n if flipped_value == 0:\n flips += 1\n \n return flips\n\n ","runtime":"1121"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n operations = 0\n for i in range (len(nums)): \n if i > 0 and nums[i] == 1 and nums[i-1] == 0:\n operations += 2\n if i == len(nums)-1 and nums[i] == 0:\n operations +=1\n else:\n continue \n return operations","runtime":"1123"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n r, n = 0, len(nums)\n def is1(i, r):\n return nums[i] == 1 and r % 2 == 0 or nums[i] == 0 and r % 2 == 1\n\n for i in range(n):\n if is1(i, r):\n continue\n r += 1\n return r","runtime":"1123"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n sc = 0\n for i in range(len(nums) - 2, -1, -1):\n if (nums[i+1] == 1 and nums[i] == 0) or (nums[i+1] == 0 and nums[i] == 1):\n sc += 1\n return sc + 1 if nums[0] == 0 else sc","runtime":"1124"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n index, n = 0, len(nums)\n first = nums[0]\n count = 0\n while index < n and nums[index] == 1:\n index += 1\n if index < n:\n count = 1\n first = nums[index]\n while index < n:\n if nums[index] != first:\n count += 1\n first = nums[index]\n index += 1\n \n return count\n \n\n","runtime":"1126"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flip = 0\n res = 0\n\n for i in range(len(nums)):\n num = nums[i] \n \n if flip:\n num = 0 if nums[i] == 1 else 1\n\n if num:\n continue\n\n res += 1\n flip ^= 1\n\n return res","runtime":"1127"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n convert_everything = [0] * 2\n for i in range(len(nums)-1, -1, -1):\n if nums[i] == 0:\n conv_to_0 = convert_everything[0]\n conv_to_1 = convert_everything[0] + 1\n else:\n conv_to_0 = convert_everything[1] + 1\n conv_to_1 = convert_everything[1]\n convert_everything = [conv_to_0, conv_to_1]\n return convert_everything[1]\n\n ","runtime":"1127"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # 1. Need to find a way to verify that the state of the array is correct\n #\n # 2. Then need to find an iterative way to achieve our results optimally\n #\n # 1. Could sum all the values and make sure they're equal to the length of the array (O(n))\n #\n # 2. Here's an algorithm (O(n)): \n # find the 1st location of a 0\n # flip all the values from that location on\n # increase the counter and continue\n #\n #\n # O(n^2)\n # Could probably do faster on that sum of values operation.\n #\n # We don't need to do sum of values if we just loop through \n # the array to find the first 0\n #\n # for all elements in array:\n # flip element by number of flips\n # -> do this by doing XOR by 1 for number of flips O(n)\n # -> could do this faster if we use modulo 2 for flips\n # if element is 0, flip and increment flip counter\n # else, keep going\n #\n # return flip counter\n #\n # O(n) time, O(1) space\n #\n # [0]\n # [0, 0, 0, 0, 0]\n # [1, 1, 1, 1, 1]\n # [0, 0, 0, 1, 0, 0, 1]\n\n flip_counter = 0\n mask = 1\n\n for bit in nums:\n if flip_counter % 2:\n bit = bit ^ mask\n \n if not bit:\n flip_counter += 1\n \n return flip_counter\n ","runtime":"1129"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n i = 0\n flips = 0\n while i < n:\n if flips % 2 ==1:\n nums[i] = 1 - nums[i] \n\n if nums[i] == 0:\n flips += 1\n \n i += 1\n return flips","runtime":"1130"},{"code":"class Solution:\n def minOperations(self, nums: list[int]) -> int:\n result, n, i = 0, len(nums), 0\n while i < n and nums[i] == 1: i += 1\n for j in range(i, n):\n if j == i or nums[j] != nums[j-1]: result += 1\n return result\n","runtime":"1132"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n zero_found = False\n \n for i in range(len(nums)):\n if nums[i] == 0 and zero_found == False:\n zero_found = True\n elif nums[i] == 1 and zero_found == True:\n res += 2\n zero_found = False\n\n if nums[-1] == 0:\n res += 1\n \n return res ","runtime":"1133"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = [0]*len(nums)\n ans[0] = 0 if nums[0] == 1 else 1\n for i in range(1, len(nums)):\n ans[i] = ans[i-1] + (1 if nums[i] != nums[i-1] else 0)\n return ans[-1]\n","runtime":"1134"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n return len(list(groupby(nums))) - nums[0]\n \n ","runtime":"1136"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)-2\n last = nums[-1]\n cnt = 0\n while n >= 0:\n if nums[n] != last:\n last = nums[n]\n cnt += 1\n n -= 1\n return cnt if last else cnt + 1\n","runtime":"1137"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = current = 0\\n for num in nums:\\n if num == current:\\n flips += 1\\n current = not current\\n return flips\\n\",\n \"runtime\": \"1024\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = current = 0\\n for num in nums:\\n if num == current:\\n flips += 1\\n current = not current\\n return flips\\n\",\n \"runtime\": \"1024\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n c = 0\\n flip = 0 \\n for num in nums:\\n if num == flip: \\n c += 1\\n flip = 1 - flip \\n return c\\n\",\n \"runtime\": \"1026\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for x in nums:\\n if res & 1 == x:\\n res += 1\\n return res\",\n \"runtime\": \"1030\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n expected = 1\\n\\n for num in nums:\\n if num != expected:\\n flips += 1\\n expected = 1 - expected\\n\\n return flips\\n\",\n \"runtime\": \"1031\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n ele = 0\\n count = 0\\n for num in nums:\\n if num == ele:\\n count += 1\\n ele = 1 - ele\\n return count\\n \",\n \"runtime\": \"1033\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n cur = 0\\n \\n for y in nums:\\n if y == cur:\\n res += 1\\n cur = 1 - cur\\n \\n return res\\n \\n \",\n \"runtime\": \"1034\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n op=0\\n check=1\\n for i in nums:\\n if i!=check:\\n op+=1\\n check=1-check\\n return op\",\n \"runtime\": \"1036\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flipped = 1\\n count = 0\\n for n in nums:\\n if n != flipped:\\n count += 1\\n flipped = not flipped\\n return count\\n \",\n \"runtime\": \"1037\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flipped = False\\n count = 0\\n\\n for num in nums:\\n if num == 0:\\n if not flipped:\\n flipped = not flipped\\n count += 1\\n else:\\n if flipped:\\n flipped = not flipped\\n count += 1\\n return count\\n \",\n \"runtime\": \"1039\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n for num in nums:\\n if num == flips % 2:\\n flips+=1\\n return flips\",\n \"runtime\": \"1040\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n expected = 1\\n\\n for num in nums:\\n if num != expected:\\n flips += 1\\n expected = 1 - expected\\n\\n return flips\",\n \"runtime\": \"1042\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, A: List[int]) -> int:\\n res = 0\\n for a in A:\\n if a == res & 1:\\n res += 1\\n return res\",\n \"runtime\": \"1043\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n curr = nums[-1]\\n ops = 0\\n \\n for num in nums[:-1][::-1]:\\n if num != curr:\\n ops += 1\\n curr = num\\n \\n return ops + (curr == 0)\",\n \"runtime\": \"1045\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n result = 0\\n flip = 0\\n\\n for num in nums:\\n if num + flip != 1: # both num==flip same, either should be 1, not XOR?\\n result += 1\\n flip = 0 if flip == 1 else 1\\n return result\\n\\n\\n\\\"\\\"\\\"\\n def minOperations(self, nums: List[int]) -> int:\\n ops = 0\\n for num in nums:\\n if num ^ (ops % 2) == 0:\\n ops += 1\\n return ops\\n[0,1,1,0,1], flip=0\\ni=0: resul=1, flip=1\\ni=1: resul=2, flip=0\\ni:2: result=3 flip=1\\ni=3:\\ni=4:result=4, flip=0\\n\\n\\n\\n\\\"\\\"\\\"\\n\",\n \"runtime\": \"1046\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flipped = False\\n count = 0\\n for num in nums:\\n if flipped == num:\\n count += 1\\n flipped = not flipped\\n return count\\n\",\n \"runtime\": \"1047\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n flip_parity = 0\\n for num in nums:\\n if not (num ^ flip_parity):\\n count += 1\\n flip_parity = 1 - flip_parity\\n return count\",\n \"runtime\": \"1049\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n operations = 0\\n current_bit = 1\\n for char in nums:\\n if char != current_bit:\\n operations += 1\\n current_bit = char\\n return operations\\n \\n\",\n \"runtime\": \"1050\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n return sum(1 for _ in groupby(nums)) - nums[0]\\n \\n \",\n \"runtime\": \"1052\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n needed = 1\\n for num in nums:\\n if num != needed:\\n needed = num\\n count += 1\\n return count\",\n \"runtime\": \"1053\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n tmp = 0\\n for num in nums:\\n if num == tmp:\\n res += 1\\n tmp = tmp^1\\n return res\",\n \"runtime\": \"1055\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, A: List[int]) -> int:\\n res = 0\\n for a in A:\\n if a == (res & 1):\\n res += 1\\n return res\",\n \"runtime\": \"1056\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n c=0\\n t=0\\n for i in nums:\\n if i==t:\\n c+=1\\n t=1-t\\n return c\\n\",\n \"runtime\": \"1058\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nIdea: check 0's and 1's in alternating fashion. Each time we locate a 0 or 1,\\nwe increment the count of the operation by 1.\\n\\nIn view of the operation, we need to do the operation from left to right by\\nchecking 0's.\\n\\nwe need to first find the left most zero, and do 1 operation.\\n\\nop at index 0: 0, 1, 1, 0, 1 => 1, 0, 0, 1, 0\\n\\nThen we find the lest most zero gain, at do the operation:\\n\\nop at index 1: 1, 0, 0, 1, 0 => 1, 1, 1, 0, 1\\n\\nContinue to find zeros:\\n\\nop at index 3: 1, 1, 1, 0, 1 => 1, 1, 1, 1, 0\\n\\nop at index 4: 1, 1, 1, 1, 0 => 1, 1, 1, 1, 1\\n\\nThe indices involved are 0, 1, 3, 4.\\n\\nIf we \\\"ignore\\\" the flipping, the obove indices in the original arr\\n\\n0, 1, 3, 4\\n0, 1, 1, 0, 1\\n\\ncorresponds to find 0, 1 in alternating fashion. As we have 4 indices,\\nwe return 4.\\n\\n\\\"\\\"\\\"\\n\\nclass Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n cur = 0\\n \\n for y in nums:\\n if y == cur:\\n res += 1\\n cur = 1 - cur\\n \\n return res\\n \\n \",\n \"runtime\": \"1059\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n for x in nums:\\n if not x ^ (flips & 1):\\n flips += 1\\n return flips\\n\",\n \"runtime\": \"1059\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n expected = 1\\n\\n for num in nums:\\n if num != expected:\\n flips += 1\\n expected = 1 - expected\\n\\n return flips\",\n \"runtime\": \"1060\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for n in nums:\\n if n == (res&1):\\n res += 1\\n\\n return res\",\n \"runtime\": \"1062\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n return sum(1 for _ in itertools.groupby(nums)) - nums[0]\",\n \"runtime\": \"1062\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n result=0\\n for i in nums:\\n if i==result%2:\\n result+=1\\n return result\",\n \"runtime\": \"1063\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips=0\\n for num in nums:\\n if flips % 2 == num:\\n flips += 1\\n return flips\\n\",\n \"runtime\": \"1063\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n flip_state = 0\\n \\n for num in nums:\\n if num == flip_state:\\n flips += 1\\n flip_state = 1 - flip_state\\n \\n return flips\",\n \"runtime\": \"1065\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ops = 0\\n for num in nums:\\n if num == ops % 2:\\n ops += 1\\n return ops\\n\",\n \"runtime\": \"1065\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n for x in nums:\\n if (x + count) % 2 == 0:\\n count += 1\\n return count\",\n \"runtime\": \"1066\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n这题和开关灯的那个很像，记得那道题是用高斯消元做的\\n the left most number have the min flip times\\n the right most number have the max flip times\\n left -> right, accumulate the flip \\n and decide if we need a new flip at that number\\n\\n\\n [0,1,1,0,1]\\n 第一个位置 换成 1，flipCnt = 1\\n 第二个位置就是 0 （flipCnt 是奇数代表和原来不一样），需要再 flip 一下\\n\\\"\\\"\\\"\\nclass Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # cnt is the accumulated flip for each number\\n flipCnt = 0\\n for x in nums:\\n if x == 0 and flipCnt % 2 == 0 or x == 1 and flipCnt % 2 == 1:\\n flipCnt += 1\\n return flipCnt\\n\\n \",\n \"runtime\": \"1068\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n zero_found = False\\n \\n for i in range(len(nums)):\\n if nums[i] == 0 and zero_found == False:\\n zero_found = True\\n elif nums[i] == 1 and zero_found == True:\\n res += 2\\n zero_found = False\\n\\n if nums[-1] == 0:\\n res += 1\\n \\n return res \",\n \"runtime\": \"1069\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ret = flip = 0\\n for a in nums:\\n if a ^ flip == 0:\\n ret += 1\\n flip = 1 - flip\\n return ret\",\n \"runtime\": \"1069\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n out = 0\\n if nums[-1]==0:\\n out+=1\\n i =len(nums)-1\\n while i>=0 and nums[i]==0:\\n nums[i]=1\\n i-=1\\n \\n ct = 0\\n zeroflag = False\\n for i in range(len(nums)):\\n if nums[i]==0:\\n if zeroflag: continue\\n ct+=1\\n zeroflag = True\\n else:\\n zeroflag = False\\n\\n return out+2*ct\",\n \"runtime\": \"1071\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n mode = 0\\n ans = 0\\n for i in nums:\\n if i == mode:\\n ans += 1\\n mode = not mode\\n return ans\",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n flips = 0\\n for num in nums:\\n flipped_value = num if flips % 2 == 0 else not num\\n if flipped_value == 0:\\n flips += 1\\n \\n return flips\\n\\n \",\n \"runtime\": \"1072\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n for x in nums:\\n if (x + count) % 2 == 0:\\n count += 1\\n return count\",\n \"runtime\": \"1074\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n parity = res = 0\\n for num in nums:\\n if num ^ parity == 0:\\n res += 1\\n parity = 1 - parity\\n return res\\n\",\n \"runtime\": \"1075\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n c=0\\n p=0\\n for i in nums:\\n if(i==1):\\n if(p%2==0):\\n pass\\n else:\\n p=p+1\\n c=c+1\\n else:\\n if(p%2==0):\\n p=p+1\\n c=c+1\\n else:\\n pass\\n return c\",\n \"runtime\": \"1075\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flip = res = 0 \\n for n in nums:\\n if (n + flip) % 2 == 0:\\n flip += 1 \\n res += 1 \\n return res \",\n \"runtime\": \"1076\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n for x in nums:\\n if (x + count) % 2 == 0:\\n count += 1\\n return count\",\n \"runtime\": \"1078\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int: \\n count = 0 \\n flip = 0 \\n \\n for i in range(len(nums)):\\n if nums[i] == flip:\\n count += 1\\n flip = 1 - flip \\n \\n return count\",\n \"runtime\": \"1078\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n num_swipes = 0\\n for num in nums:\\n if (num + num_swipes) % 2 == 0:\\n num_swipes += 1\\n return num_swipes\\n \",\n \"runtime\": \"1079\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n cnt = 0\\n for i in range(n):\\n if (nums[i] + cnt) % 2 == 1:\\n continue\\n else:\\n cnt += 1\\n return cnt\\n \\n \\n \\n \\n \\n \",\n \"runtime\": \"1081\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ops = flag = 0\\n for num in nums:\\n if num == flag:\\n ops += 1\\n flag = 1 - flag\\n\\n return ops\",\n \"runtime\": \"1082\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n idx = 0\\n while idx < n and nums[idx] == 1:\\n idx += 1\\n \\n res = 0\\n flip = 0\\n for i in range(idx, n):\\n x = nums[i] ^ flip\\n if x == 0:\\n flip ^= 1\\n res += 1\\n \\n return res\\n \",\n \"runtime\": \"1082\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n flip = 0\\n for n in nums:\\n if n + flip != 1:\\n res +=1\\n flip = 1 - flip\\n return res\",\n \"runtime\": \"1084\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n flipped = False\\n\\n for n in nums:\\n if n == 0 and not flipped:\\n flipped = not flipped\\n res += 1\\n elif n == 1 and flipped:\\n flipped = not flipped\\n res += 1\\n\\n return res\",\n \"runtime\": \"1085\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n if nums[0] == 0:\\n flips += 1\\n for i in range(1, len(nums)):\\n if nums[i] != nums[i - 1]:\\n flips += 1\\n return flips\\n\",\n \"runtime\": \"1085\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n flip = 0\\n \\n for i in range(n):\\n if (nums[i] == 1 and flip%2==1) or (nums[i] == 0 and flip%2==0):\\n flip +=1\\n return flip\",\n \"runtime\": \"1087\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n=len(nums)\\n res=0\\n if nums[0]==0:\\n res+=1\\n for i in range(1,n):\\n if nums[i]!=nums[i-1]:\\n res+=1\\n return res\",\n \"runtime\": \"1088\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n operations = 0\\n flipped = 0\\n\\n for i in range(len(nums)):\\n current_state = nums[i] if flipped % 2 == 0 else 1 - nums[i]\\n if current_state == 0:\\n operations += 1\\n flipped += 1\\n\\n return operations\",\n \"runtime\": \"1088\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # to find number of islands of zero\\n islands = 0\\n i = 0\\n while i < len(nums):\\n if nums[i] == 0:\\n j = i\\n while j < len(nums) and nums[j] == 0:\\n j += 1\\n islands += 1\\n i = j\\n else:\\n i += 1\\n \\n if islands % 2 == 0:\\n if nums[i-1] == 0:\\n return (islands*2)-1\\n return islands * 2\\n else:\\n if nums[i-1] == 1:\\n return islands*2\\n return (islands*2) - 1\\n \\n \",\n \"runtime\": \"1089\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, A: List[int]) -> int:\\n ans = 0\\n A = [x for x, g in groupby(A)]\\n for i in range(len(A) - 1):\\n if not A[i]:\\n ans += A[i + 1] * 2\\n return ans + (not A[-1])\",\n \"runtime\": \"1091\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n flips = 0\\n for num in nums:\\n flipped_value = num if flips % 2 == 0 else not num\\n if flipped_value == 0:\\n flips += 1\\n \\n return flips\\n\\n \",\n \"runtime\": \"1091\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n flips = 0\\n\\n for n in nums:\\n if n == 0:\\n if flips % 2 == 0:\\n # actual n = 0\\n res += 1\\n flips += 1\\n else:\\n # actual n = 1\\n pass\\n else:\\n if flips % 2 == 0:\\n # actual n = 1\\n pass\\n else:\\n # actual n = 0\\n res += 1\\n flips += 1\\n \\n return res\\n\",\n \"runtime\": \"1092\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n firstZero = -1\\n\\n for i in range(len(nums)):\\n if nums[i] == 0:\\n firstZero = i\\n break\\n \\n # if no zero is found then return 0, as there is nothing to change\\n if firstZero == -1:\\n return 0\\n \\n answer = 0\\n for i in range(firstZero, len(nums)):\\n if i == firstZero:\\n answer += 1\\n continue\\n \\n if nums[i] != nums[i - 1]:\\n answer += 1\\n \\n return answer\\n\",\n \"runtime\": \"1094\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n=len(nums)\\n c=0\\n i=n-1\\n is_one=False\\n while i>=0:\\n if nums[i]==1:\\n is_one=True\\n i-=1\\n else:\\n l=i\\n # j=i\\n while i>=0:\\n if nums[i]==1:\\n break\\n l=i\\n i-=1\\n if l==n-1:\\n c+=1\\n else:\\n if is_one:\\n c+=2\\n else:\\n c+=1\\n return c\\n\\n \",\n \"runtime\": \"1094\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ct = 0\\n b = 0\\n\\n for k in nums:\\n if (k + b) % 2 == 0:\\n ct += 1\\n b = (b + 1) % 2\\n\\n return ct\",\n \"runtime\": \"1095\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"runtime\": \"1097\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n f=True\\n for ele in nums:\\n if ele==0:\\n f=False\\n if f:\\n return 0\\n i=0\\n n=len(nums)\\n first=True\\n ans=0\\n curr=0\\n while i<n:\\n if first:\\n if nums[i]!=0:\\n i+=1\\n else:\\n first=False\\n ans+=1\\n else:\\n curr=nums[i]\\n while i<n and nums[i]==curr:\\n i+=1\\n ans+=1\\n return ans-1\",\n \"runtime\": \"1103\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n count = 0\\n for num in nums:\\n count += (not num) ^ (count % 2)\\n return count\",\n \"runtime\": \"1104\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: list[int]) -> int:\\n result, n, i = 0, len(nums), 0\\n while i < n and nums[i] == 1: i += 1\\n for j in range(i, n):\\n if j == i or nums[j] != nums[j-1]: result += 1\\n return result\\n\",\n \"runtime\": \"1104\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n index = len(nums) - 1\\n count = 0\\n while index - 1 >= 0:\\n if nums[index - 1] != nums[index]:\\n count += 1\\n index -= 1\\n if nums[0] == 0: count += 1\\n return count\",\n \"runtime\": \"1105\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n flip = False\\n for i, val in enumerate(nums):\\n if val ^ flip == 0:\\n flip = not flip\\n ans += 1\\n return ans\",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n zero_found = False\\n \\n for i in range(len(nums)):\\n if nums[i] == 0 and zero_found == False:\\n zero_found = True\\n elif nums[i] == 1 and zero_found == True:\\n res += 2\\n zero_found = False\\n\\n if nums[-1] == 0:\\n res += 1\\n \\n return res \",\n \"runtime\": \"1107\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"runtime\": \"1108\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0 if nums[0] == 1 else 1\\n for i in range(1, len(nums)):\\n res += (nums[i] + nums[i-1])%2\\n return res\\n\",\n \"runtime\": \"1110\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n i = 0\\n flips = 0\\n while i < n:\\n nums[i] = 1 - nums[i] if flips % 2 == 1 else nums[i]\\n if nums[i] == 0:\\n flips += 1\\n \\n i += 1\\n return flips\",\n \"runtime\": \"1111\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n ops = 0\\n\\n # better to start from the leftmost index\\n # 1 0 0 1 0\\n # 1 1 1 0 1\\n # 1 1 1 1 0\\n # 1 1 1 1 1\\n\\n flips = 0\\n\\n # then continue and try to advance\\n i = 0\\n while i < n:\\n if flips % 2 == 0:\\n if nums[i] == 0:\\n flips += 1\\n else:\\n if nums[i] == 1:\\n flips += 1\\n i += 1\\n return flips\",\n \"runtime\": \"1111\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 1 - nums[0]\\n for i in range(1, len(nums)):\\n res += (nums[i] + nums[i-1])%2\\n return res\\n\",\n \"runtime\": \"1113\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # 10010\\n # 11101\\n # 11110\\n # 11111\\n # modifying whole array each time is expensive, we can remember modification count\\n count = 0\\n for val in nums:\\n flipped = count % 2\\n modified_val = val if not flipped else int(not bool(val))\\n if modified_val == 0:\\n count += 1\\n return count\\n \",\n \"runtime\": \"1114\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 1 - nums[0]\\n n = len(nums)\\n for i in range(1, n):\\n res += (nums[i] + nums[i-1])%2\\n return res\\n\",\n \"runtime\": \"1114\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # to find number of islands of zero\\n islands = 0\\n i = 0\\n while i < len(nums):\\n if nums[i] == 0:\\n j = i\\n while j < len(nums) and nums[j] == 0:\\n j += 1\\n islands += 1\\n i = j\\n else:\\n i += 1\\n \\n if islands % 2 == 0:\\n if nums[i-1] == 0:\\n return (islands*2)-1\\n return islands * 2\\n else:\\n if nums[i-1] == 1:\\n return islands*2\\n return (islands*2) - 1\\n \\n \",\n \"runtime\": \"1116\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n zero_found = False\\n \\n for i in range(len(nums)):\\n if nums[i] == 0 and zero_found == False:\\n zero_found = True\\n elif nums[i] == 1 and zero_found == True:\\n res += 2\\n zero_found = False\\n\\n if nums[-1] == 0:\\n res += 1\\n \\n return res\",\n \"runtime\": \"1117\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"runtime\": \"1117\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n zero_encountered = False\\n for idx in range(0, len(nums)):\\n if nums[idx] == 0 and not zero_encountered:\\n zero_encountered = True\\n continue\\n if nums[idx] == 1 and zero_encountered:\\n zero_encountered = False\\n count += 2\\n \\n if nums[-1] == 0:\\n count += 1\\n\\n return count\",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n i = 0\\n flips = 0\\n while i < n:\\n if flips % 2 ==1:\\n nums[i] = 1 - nums[i] \\n else:\\n nums[i]= nums[i]\\n if nums[i] == 0:\\n flips += 1\\n \\n i += 1\\n return flips\",\n \"runtime\": \"1120\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n [0,1,0,1,0,0]\\n \\\"\\\"\\\"\\n seenOne = False\\n n = len(nums)\\n flips = 0\\n for i, num in zip(range(n - 1, -1, -1), reversed(nums)):\\n if num == 1:\\n seenOne = True\\n continue\\n if num == 0 and i and nums[i - 1] == 0:\\n continue\\n \\n flips += 1\\n if seenOne:\\n flips += 1\\n\\n return flips\\n \",\n \"runtime\": \"1120\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n\\n flips = 0\\n for num in nums:\\n flipped_value = num if flips % 2 == 0 else not num\\n if flipped_value == 0:\\n flips += 1\\n \\n return flips\\n\\n \",\n \"runtime\": \"1121\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n operations = 0\\n for i in range (len(nums)): \\n if i > 0 and nums[i] == 1 and nums[i-1] == 0:\\n operations += 2\\n if i == len(nums)-1 and nums[i] == 0:\\n operations +=1\\n else:\\n continue \\n return operations\",\n \"runtime\": \"1123\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n r, n = 0, len(nums)\\n def is1(i, r):\\n return nums[i] == 1 and r % 2 == 0 or nums[i] == 0 and r % 2 == 1\\n\\n for i in range(n):\\n if is1(i, r):\\n continue\\n r += 1\\n return r\",\n \"runtime\": \"1123\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n sc = 0\\n for i in range(len(nums) - 2, -1, -1):\\n if (nums[i+1] == 1 and nums[i] == 0) or (nums[i+1] == 0 and nums[i] == 1):\\n sc += 1\\n return sc + 1 if nums[0] == 0 else sc\",\n \"runtime\": \"1124\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n index, n = 0, len(nums)\\n first = nums[0]\\n count = 0\\n while index < n and nums[index] == 1:\\n index += 1\\n if index < n:\\n count = 1\\n first = nums[index]\\n while index < n:\\n if nums[index] != first:\\n count += 1\\n first = nums[index]\\n index += 1\\n \\n return count\\n \\n\\n\",\n \"runtime\": \"1126\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flip = 0\\n res = 0\\n\\n for i in range(len(nums)):\\n num = nums[i] \\n \\n if flip:\\n num = 0 if nums[i] == 1 else 1\\n\\n if num:\\n continue\\n\\n res += 1\\n flip ^= 1\\n\\n return res\",\n \"runtime\": \"1127\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n convert_everything = [0] * 2\\n for i in range(len(nums)-1, -1, -1):\\n if nums[i] == 0:\\n conv_to_0 = convert_everything[0]\\n conv_to_1 = convert_everything[0] + 1\\n else:\\n conv_to_0 = convert_everything[1] + 1\\n conv_to_1 = convert_everything[1]\\n convert_everything = [conv_to_0, conv_to_1]\\n return convert_everything[1]\\n\\n \",\n \"runtime\": \"1127\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # 1. Need to find a way to verify that the state of the array is correct\\n #\\n # 2. Then need to find an iterative way to achieve our results optimally\\n #\\n # 1. Could sum all the values and make sure they're equal to the length of the array (O(n))\\n #\\n # 2. Here's an algorithm (O(n)): \\n # find the 1st location of a 0\\n # flip all the values from that location on\\n # increase the counter and continue\\n #\\n #\\n # O(n^2)\\n # Could probably do faster on that sum of values operation.\\n #\\n # We don't need to do sum of values if we just loop through \\n # the array to find the first 0\\n #\\n # for all elements in array:\\n # flip element by number of flips\\n # -> do this by doing XOR by 1 for number of flips O(n)\\n # -> could do this faster if we use modulo 2 for flips\\n # if element is 0, flip and increment flip counter\\n # else, keep going\\n #\\n # return flip counter\\n #\\n # O(n) time, O(1) space\\n #\\n # [0]\\n # [0, 0, 0, 0, 0]\\n # [1, 1, 1, 1, 1]\\n # [0, 0, 0, 1, 0, 0, 1]\\n\\n flip_counter = 0\\n mask = 1\\n\\n for bit in nums:\\n if flip_counter % 2:\\n bit = bit ^ mask\\n \\n if not bit:\\n flip_counter += 1\\n \\n return flip_counter\\n \",\n \"runtime\": \"1129\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n i = 0\\n flips = 0\\n while i < n:\\n if flips % 2 ==1:\\n nums[i] = 1 - nums[i] \\n\\n if nums[i] == 0:\\n flips += 1\\n \\n i += 1\\n return flips\",\n \"runtime\": \"1130\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: list[int]) -> int:\\n result, n, i = 0, len(nums), 0\\n while i < n and nums[i] == 1: i += 1\\n for j in range(i, n):\\n if j == i or nums[j] != nums[j-1]: result += 1\\n return result\\n\",\n \"runtime\": \"1132\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n zero_found = False\\n \\n for i in range(len(nums)):\\n if nums[i] == 0 and zero_found == False:\\n zero_found = True\\n elif nums[i] == 1 and zero_found == True:\\n res += 2\\n zero_found = False\\n\\n if nums[-1] == 0:\\n res += 1\\n \\n return res \",\n \"runtime\": \"1133\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = [0]*len(nums)\\n ans[0] = 0 if nums[0] == 1 else 1\\n for i in range(1, len(nums)):\\n ans[i] = ans[i-1] + (1 if nums[i] != nums[i-1] else 0)\\n return ans[-1]\\n\",\n \"runtime\": \"1134\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n return len(list(groupby(nums))) - nums[0]\\n \\n \",\n \"runtime\": \"1136\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)-2\\n last = nums[-1]\\n cnt = 0\\n while n >= 0:\\n if nums[n] != last:\\n last = nums[n]\\n cnt += 1\\n n -= 1\\n return cnt if last else cnt + 1\\n\",\n \"runtime\": \"1137\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":96,"string":"96"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flipped = False\n cnt = 0\n for b in nums:\n if flipped:\n b ^= 1\n\n if b == 0:\n flipped = not flipped\n cnt += 1\n\n return cnt","memory":"19400"},{"code":"class Solution:\n def minOperations(self, nums: list[int]) -> int:\n result, n, i = 0, len(nums), 0\n while i < n and nums[i] == 1: i += 1\n for j in range(i, n):\n if j == i or nums[j] != nums[j-1]: result += 1\n return result\n","memory":"19500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n convert_everything = [0] * 2\n for i in range(len(nums)-1, -1, -1):\n if nums[i] == 0:\n conv_to_0 = convert_everything[0]\n conv_to_1 = convert_everything[0] + 1\n else:\n conv_to_0 = convert_everything[1] + 1\n conv_to_1 = convert_everything[1]\n convert_everything = [conv_to_0, conv_to_1]\n return convert_everything[1]\n\n ","memory":"19600"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n count = 0\n excpect = 1\n for x in nums:\n if x != excpect:\n count += 1\n if excpect == 1:\n excpect = 0\n else: \n excpect = 1\n return count\n","memory":"19700"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","memory":"19800"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","memory":"19900"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n end = len(nums) - 1\n \n total = 0\n right = None\n \n for i in range(end, -1, -1):\n # Case rightmost element not 0\n if nums[i] == 0 and not right:\n right = i\n continue\n \n if nums[i] == 0 or not right:\n continue\n \n if right == end:\n total += 1\n else:\n total += 2\n \n right = None\n \n if right == end:\n total += 1\n elif right != None:\n total += 2\n \n return total","memory":"19900"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flip = 0\n res = 0\n for num in nums:\n if flip % 2 == 1:\n num = 0 if num == 1 else 1\n\n if num == 0:\n flip += 1\n res += 1\n return res\n ","memory":"20000"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n res = 0\n for n in nums:\n if n == (res&1):\n res += 1\n\n return res","memory":"20100"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n if sum(nums) == len(nums):\n return 0\n\n flips = 0\n state = 1\n\n for i in nums:\n if i != state:\n flips += 1\n if state == 0:\n state = 1\n else:\n state = 0\n \n return flips\n \n ","memory":"20200"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n ans = 0\n flip = False\n for i, val in enumerate(nums):\n if val ^ flip == 0:\n flip = not flip\n ans += 1\n return ans","memory":"20200"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n flips = 0\n if nums[0] == 0:\n flips += 1\n for i in range(1, len(nums)):\n if nums[i] != nums[i - 1]:\n flips += 1\n return flips\n","memory":"20300"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n counter = 0\n out = 0\n for i in range(len(nums)):\n if counter % 2 == 0:\n if nums[i] == 0:\n out += 1\n counter += 1\n else:\n if nums[i] == 1:\n out += 1\n counter += 1\n return out\n ","memory":"20300"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n # to find number of islands of zero\n islands = 0\n i = 0\n while i < len(nums):\n if nums[i] == 0:\n j = i\n while j < len(nums) and nums[j] == 0:\n j += 1\n islands += 1\n i = j\n else:\n i += 1\n \n if islands % 2 == 0:\n if nums[i-1] == 0:\n return (islands*2)-1\n return islands * 2\n else:\n if nums[i-1] == 1:\n return islands*2\n return (islands*2) - 1\n \n ","memory":"20400"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n \n idx = 0\n while idx < n and nums[idx] == 1:\n idx += 1\n \n res = 0\n flip = 0\n for i in range(idx, n):\n x = nums[i] ^ flip\n if x == 0:\n flip ^= 1\n res += 1\n \n return res\n ","memory":"20500"},{"code":"class Solution:\n def minOperations(self, nums: List[int]) -> int:\n \n res = 0\n zero_found = False\n \n for i in range(len(nums)):\n if nums[i] == 0 and zero_found == False:\n zero_found = True\n elif nums[i] == 1 and zero_found == True:\n res += 2\n zero_found = False\n\n if nums[-1] == 0:\n res += 1\n \n return res ","memory":"20600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flipped = False\\n cnt = 0\\n for b in nums:\\n if flipped:\\n b ^= 1\\n\\n if b == 0:\\n flipped = not flipped\\n cnt += 1\\n\\n return cnt\",\n \"memory\": \"19400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: list[int]) -> int:\\n result, n, i = 0, len(nums), 0\\n while i < n and nums[i] == 1: i += 1\\n for j in range(i, n):\\n if j == i or nums[j] != nums[j-1]: result += 1\\n return result\\n\",\n \"memory\": \"19500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n convert_everything = [0] * 2\\n for i in range(len(nums)-1, -1, -1):\\n if nums[i] == 0:\\n conv_to_0 = convert_everything[0]\\n conv_to_1 = convert_everything[0] + 1\\n else:\\n conv_to_0 = convert_everything[1] + 1\\n conv_to_1 = convert_everything[1]\\n convert_everything = [conv_to_0, conv_to_1]\\n return convert_everything[1]\\n\\n \",\n \"memory\": \"19600\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n count = 0\\n excpect = 1\\n for x in nums:\\n if x != excpect:\\n count += 1\\n if excpect == 1:\\n excpect = 0\\n else: \\n excpect = 1\\n return count\\n\",\n \"memory\": \"19700\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"memory\": \"19800\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n end = len(nums) - 1\\n \\n total = 0\\n right = None\\n \\n for i in range(end, -1, -1):\\n # Case rightmost element not 0\\n if nums[i] == 0 and not right:\\n right = i\\n continue\\n \\n if nums[i] == 0 or not right:\\n continue\\n \\n if right == end:\\n total += 1\\n else:\\n total += 2\\n \\n right = None\\n \\n if right == end:\\n total += 1\\n elif right != None:\\n total += 2\\n \\n return total\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flip = 0\\n res = 0\\n for num in nums:\\n if flip % 2 == 1:\\n num = 0 if num == 1 else 1\\n\\n if num == 0:\\n flip += 1\\n res += 1\\n return res\\n \",\n \"memory\": \"20000\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n res = 0\\n for n in nums:\\n if n == (res&1):\\n res += 1\\n\\n return res\",\n \"memory\": \"20100\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n if sum(nums) == len(nums):\\n return 0\\n\\n flips = 0\\n state = 1\\n\\n for i in nums:\\n if i != state:\\n flips += 1\\n if state == 0:\\n state = 1\\n else:\\n state = 0\\n \\n return flips\\n \\n \",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n ans = 0\\n flip = False\\n for i, val in enumerate(nums):\\n if val ^ flip == 0:\\n flip = not flip\\n ans += 1\\n return ans\",\n \"memory\": \"20200\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n flips = 0\\n if nums[0] == 0:\\n flips += 1\\n for i in range(1, len(nums)):\\n if nums[i] != nums[i - 1]:\\n flips += 1\\n return flips\\n\",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n counter = 0\\n out = 0\\n for i in range(len(nums)):\\n if counter % 2 == 0:\\n if nums[i] == 0:\\n out += 1\\n counter += 1\\n else:\\n if nums[i] == 1:\\n out += 1\\n counter += 1\\n return out\\n \",\n \"memory\": \"20300\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n # to find number of islands of zero\\n islands = 0\\n i = 0\\n while i < len(nums):\\n if nums[i] == 0:\\n j = i\\n while j < len(nums) and nums[j] == 0:\\n j += 1\\n islands += 1\\n i = j\\n else:\\n i += 1\\n \\n if islands % 2 == 0:\\n if nums[i-1] == 0:\\n return (islands*2)-1\\n return islands * 2\\n else:\\n if nums[i-1] == 1:\\n return islands*2\\n return (islands*2) - 1\\n \\n \",\n \"memory\": \"20400\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n idx = 0\\n while idx < n and nums[idx] == 1:\\n idx += 1\\n \\n res = 0\\n flip = 0\\n for i in range(idx, n):\\n x = nums[i] ^ flip\\n if x == 0:\\n flip ^= 1\\n res += 1\\n \\n return res\\n \",\n \"memory\": \"20500\"\n },\n {\n \"code\": \"class Solution:\\n def minOperations(self, nums: List[int]) -> int:\\n \\n res = 0\\n zero_found = False\\n \\n for i in range(len(nums)):\\n if nums[i] == 0 and zero_found == False:\\n zero_found = True\\n elif nums[i] == 1 and zero_found == True:\\n res += 2\\n zero_found = False\\n\\n if nums[-1] == 0:\\n res += 1\\n \\n return res \",\n \"memory\": \"20600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":16,"string":"16"}}},{"rowIdx":2467,"cells":{"question_id":{"kind":"number","value":3460,"string":"3,460"},"name":{"kind":"string","value":"count-the-number-of-inversions"},"content":{"kind":"string","value":"<p>You are given an integer <code>n</code> and a 2D array <code>requirements</code>, where <code>requirements[i] = [end<sub>i</sub>, cnt<sub>i</sub>]</code> represents the end index and the <strong>inversion</strong> count of each requirement.</p>\n\n<p>A pair of indices <code>(i, j)</code> from an integer array <code>nums</code> is called an <strong>inversion</strong> if:</p>\n\n<ul>\n\t<li><code>i < j</code> and <code>nums[i] > nums[j]</code></li>\n</ul>\n\n<p>Return the number of <span data-keyword=\"permutation\">permutations</span> <code>perm</code> of <code>[0, 1, 2, ..., n - 1]</code> such that for <strong>all</strong> <code>requirements[i]</code>, <code>perm[0..end<sub>i</sub>]</code> has exactly <code>cnt<sub>i</sub></code> inversions.</p>\n\n<p>Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 3, requirements = [[2,2],[0,0]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The two permutations are:</p>\n\n<ul>\n\t<li><code>[2, 0, 1]</code>\n\n\t<ul>\n\t\t<li>Prefix <code>[2, 0, 1]</code> has inversions <code>(0, 1)</code> and <code>(0, 2)</code>.</li>\n\t\t<li>Prefix <code>[2]</code> has 0 inversions.</li>\n\t</ul>\n\t</li>\n\t<li><code>[1, 2, 0]</code>\n\t<ul>\n\t\t<li>Prefix <code>[1, 2, 0]</code> has inversions <code>(0, 2)</code> and <code>(1, 2)</code>.</li>\n\t\t<li>Prefix <code>[1]</code> has 0 inversions.</li>\n\t</ul>\n\t</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 3, requirements = [[2,2],[1,1],[0,0]]</span></p>\n\n<p><strong>Output:</strong> 1</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The only satisfying permutation is <code>[2, 0, 1]</code>:</p>\n\n<ul>\n\t<li>Prefix <code>[2, 0, 1]</code> has inversions <code>(0, 1)</code> and <code>(0, 2)</code>.</li>\n\t<li>Prefix <code>[2, 0]</code> has an inversion <code>(0, 1)</code>.</li>\n\t<li>Prefix <code>[2]</code> has 0 inversions.</li>\n</ul>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">n = 2, requirements = [[0,0],[1,0]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The only satisfying permutation is <code>[0, 1]</code>:</p>\n\n<ul>\n\t<li>Prefix <code>[0]</code> has 0 inversions.</li>\n\t<li>Prefix <code>[0, 1]</code> has an inversion <code>(0, 1)</code>.</li>\n</ul>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= n <= 300</code></li>\n\t<li><code>1 <= requirements.length <= n</code></li>\n\t<li><code>requirements[i] = [end<sub>i</sub>, cnt<sub>i</sub>]</code></li>\n\t<li><code>0 <= end<sub>i</sub> <= n - 1</code></li>\n\t<li><code>0 <= cnt<sub>i</sub> <= 400</code></li>\n\t<li>The input is generated such that there is at least one <code>i</code> such that <code>end<sub>i</sub> == n - 1</code>.</li>\n\t<li>The input is generated such that all <code>end<sub>i</sub></code> are unique.</li>\n</ul>\n"},"acRate":{"kind":"number","value":33.70148795827581,"string":"33.701488"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"132\", 19.753600000000002], [\"259\", 3.7038], [\"387\", 3.7038], [\"514\", 0.6173], [\"641\", 0.6173], [\"769\", 1.2346], [\"896\", 6.173000000000001], [\"1023\", 0.6173], [\"1151\", 0.6173], [\"1278\", 0.6173], [\"1405\", 0.6173], [\"1533\", 0.6173], [\"1660\", 0.6173], [\"1787\", 0.6173], [\"1915\", 0.6173], [\"2042\", 0.6173], [\"2169\", 0.6173], [\"2297\", 0.6173], [\"2424\", 0.6173], [\"2551\", 0.6173], [\"2679\", 1.2346], [\"2806\", 0.6173], [\"2933\", 0.6173], [\"3061\", 0.6173], [\"3188\", 0.6173], [\"3315\", 0.6173], [\"3443\", 0.6173], [\"3570\", 0.6173], [\"3697\", 0.6173], [\"3825\", 0.6173], [\"3952\", 0.6173], [\"4079\", 0.6173], [\"4207\", 0.6173], [\"4334\", 0.6173], [\"4461\", 0.6173], [\"4589\", 0.6173], [\"4716\", 0.6173], [\"4843\", 0.6173], [\"4971\", 0.6173], [\"5098\", 0.6173], [\"5225\", 0.6173], [\"5352\", 0.6173], [\"5480\", 0.6173], [\"5607\", 0.6173], [\"5734\", 0.6173], [\"5862\", 0.6173], [\"5989\", 0.6173], [\"6116\", 0.6173], [\"6244\", 0.6173], [\"6371\", 0.6173], [\"6498\", 0.6173], [\"6626\", 0.6173], [\"6753\", 0.6173], [\"6880\", 0.6173], [\"7008\", 0.6173], [\"7135\", 0.6173], [\"7262\", 0.6173], [\"7390\", 0.6173], [\"7517\", 0.6173], [\"7644\", 0.6173], [\"7772\", 0.6173], [\"7899\", 0.6173], [\"8026\", 0.6173], [\"8154\", 0.6173], [\"8281\", 0.6173], [\"8408\", 0.6173], [\"8536\", 0.6173], [\"8663\", 0.6173], [\"8790\", 1.2346], [\"8918\", 1.2346], [\"9045\", 1.8518999999999999], [\"9172\", 1.8518999999999999], [\"9300\", 0.6173], [\"9427\", 0.6173], [\"9554\", 1.2346], [\"9682\", 1.2346], [\"9809\", 2.4692], [\"9936\", 4.3211], [\"10064\", 2.4692], [\"10191\", 1.2346]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16600\", 6.1728], [\"16700\", 6.7901], [\"16800\", 12.963], [\"16900\", 1.2346], [\"17000\", 0.6173], [\"18400\", 0.6173], [\"19000\", 3.0864], [\"19100\", 10.4938], [\"19200\", 13.5802], [\"19300\", 8.0247], [\"19900\", 0.6173], [\"21100\", 0.6173], [\"21900\", 0.6173], [\"27700\", 0.6173], [\"27800\", 0.6173], [\"27900\", 0.6173], [\"33600\", 0.6173], [\"38200\", 2.4691], [\"38300\", 2.4691], [\"38400\", 0.6173], [\"48200\", 1.8519], [\"48300\", 1.8519], [\"48400\", 1.8519], [\"50400\", 0.6173], [\"65600\", 0.6173], [\"95200\", 1.2346], [\"95300\", 0.6173], [\"97900\", 0.6173], [\"103800\", 0.6173], [\"109500\", 0.6173], [\"109700\", 0.6173], [\"110200\", 0.6173], [\"110400\", 0.6173], [\"112300\", 0.6173], [\"123600\", 1.2346], [\"123700\", 0.6173], [\"123800\", 0.6173], [\"129500\", 2.4691], [\"130100\", 0.6173], [\"132300\", 1.8519]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n mod =10**9+7\n def cnt1(k,target): # partition target into k int\n return comb(k+target-1,target)%mod\n def cnt(low,up,target): # x1<=low, x2<=low+1...xk<up\n #print(low,up,target)\n if low >= target: return cnt1(up-low,target) \n # low < target\n d = [1]*(low+1)+[0]*(target-low)\n for i in range(low+1,up):\n p = list(accumulate(d))\n for j in range(target,i,-1):\n d[j] = (d[j]+p[j-1]-p[j-i-1])%mod\n for j in range(min(i,target),0,-1):\n d[j] = (d[j]+p[j-1])%mod\n return d[-1]\n #\n prev,p_inv = 0,0\n t = 1\n for end,inv in sorted(requirements):\n target = inv-p_inv\n if (prev+end)*(end-prev+1)//2 < target:\n return 0\n t = t*cnt(prev,end+1,target)%mod\n prev = end+1\n p_inv = inv\n #\n return t","runtime":"132"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n r = {e: c for e,c in requirements}\n c = max(r.values())\n max_end = max(r)\n mod = 10 ** 9 + 7\n dp = [1] + [0] * c\n for i in range(max_end + 1):\n dp2 = [0] * (c + 1)\n if i in r:\n dp2[r[i]] = sum(dp[max(0, r[i] - i): r[i] + 1]) % mod\n else:\n for j in range(c + 1):\n dp2[j] = dp[j]\n if j: dp2[j] += dp2[j - 1]\n if j - i > 0: dp2[j] -= dp[j - i - 1]\n dp = dp2\n res = sum(dp) % mod\n for i in range(max_end + 1, n):\n res = res * (i + 1) % mod\n return res\n ","runtime":"132"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements = dict(requirements)\n m = max(requirements.values())\n dp = [[0]*(m+1) for _ in range(n)]\n dp[0][0] = 1\n for i in range(n): \n prefix = 0 \n for j in range(m+1): \n if i: \n prefix += dp[i-1][j]\n if j > i: prefix -= dp[i-1][j-i-1]\n dp[i][j] = prefix = prefix % 1_000_000_007\n if i in requirements and j != requirements[i]: dp[i][j] = 0\n return dp[n-1][requirements[n-1]]","runtime":"259"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements = dict(requirements)\n m = max(requirements.values())\n dp = [[0]*(m+1) for _ in range(n)]\n dp[0][0] = 1\n for i in range(n): \n prefix = 0 \n for j in range(m+1): \n if i: \n prefix += dp[i-1][j]\n if j > i: prefix -= dp[i-1][j-i-1]\n prefix %= 1_000_000_007\n dp[i][j] = prefix\n if i in requirements and j != requirements[i]: dp[i][j] = 0\n return dp[n-1][requirements[n-1]]","runtime":"259"},{"code":"MAGIC = int(1e9 + 7)\n\n# Inspired by https://leetcode.com/problems/count-the-number-of-inversions/solutions/5353127/python-dp/\n# 和LC 629 K Inverse Pairs Array很像。不同在于这边要prune。\n# ! prune的含义是，如果对于某个end有requirement是多少个inversion count，那么就只update它，\n# ! 其它的dp求的的inversion count的情况全部设为0 (即不update)\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements.sort()\n # Check valid\n for i in range(1, len(requirements)):\n if requirements[i][1] < requirements[i - 1][1]:\n return 0\n\n k = requirements[-1][1]\n r_idx = 0\n\n dp = [[0 for j in range(k + 1)] for i in range(n + 1)]\n acc = [0] * (k + 1)\n # ! 这个flag是和LC 629 K Inverse Pairs Array很不一样的地方。\n # ! 因为这道题强调在某个end的地方inversion count必须是一个定值，（而且不递减）\n # ! 那么，如果我们已经过了inversion count = 0的end，那么之后绝对不能再有机会把j = 0的时候设为1\n # ! 在LC 629中那确实是一个base case，但是在这里就无中生有了会高估\n do_not_fill_j_0 = False\n\n for i in range(1, n + 1):\n if r_idx < len(requirements) and requirements[r_idx][0] == i - 1:\n strict_j = requirements[r_idx][1]\n if strict_j == 0:\n dp[i][strict_j] = 1\n else:\n do_not_fill_j_0 = True\n\n lt = strict_j - (i - 1) - 1\n dp[i][strict_j] = acc[strict_j]\n if lt >= 0:\n dp[i][strict_j] -= acc[lt]\n\n # if dp[i][strict_j] == 0:\n # return 0\n\n dp[i][strict_j] = int(dp[i][strict_j] % MAGIC)\n r_idx += 1\n else:\n for j in range(k + 1):\n if j == 0 and not do_not_fill_j_0:\n dp[i][j] = 1\n else:\n lt = j - (i - 1) - 1\n dp[i][j] = acc[j]\n if lt >= 0:\n dp[i][j] -= acc[lt]\n\n dp[i][j] = int(dp[i][j] % MAGIC)\n\n acc[0] = dp[i][0]\n for j in range(1, k + 1):\n acc[j] = acc[j - 1] + dp[i][j]\n acc[j] = int(acc[j] % MAGIC)\n\n return dp[-1][-1]\n","runtime":"387"},{"code":"M = 10 ** 9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n cond = [-1] * n\n for u,v in requirements:\n if cond[u] != -1 and v != cond[u]:\n return 0\n cond[u] = v\n lim = max(cond)\n dp = [0] * (lim+1)\n dp[0] = 1\n for i in range(n):\n ndp = [0] * (lim+1)\n for j in range(lim+1):\n # 0 .. i\n r = min(lim, j+i)\n ndp[j] += dp[j]\n if r + 1 <= lim:\n ndp[r+1] -= dp[j]\n if j:\n ndp[j] += ndp[j-1]\n ndp[j] %= M\n \n dp = ndp\n if cond[i] != -1:\n for j in range(lim+1):\n if j ^ cond[i]:\n dp[j] = 0\n return sum(dp) % M\n\n\n\n\n \n","runtime":"387"},{"code":"MOD = 10**9 + 7\nclass Solution:\n @staticmethod\n def numberOfPermutations(n: int, requirements: List[List[int]]) -> int:\n factorials = [1]*(n+1)\n requirements = {i:j for i,j in requirements}\n maxInvert = lambda x: (x*(x-1))//2\n dp = [[0]*(min(maxInvert(n),400)+1) for _ in range(n+1)]\n for i in range(n+1):\n if (i-1) in requirements:\n j = requirements[i-1]\n dp[i][j] = sum(dp[i-1][max(j-i+1, 0):j+1])\n else:\n dp[i][0] = dp[i-1][0] if i > 0 else 1\n mi = maxInvert(i)\n for j in range(1, min(mi, 400) + 1):\n dp[i][j] = sum(dp[i-1][max(j-i+1, 0):j+1]) % MOD\n return dp[-1][requirements[n-1]] % MOD","runtime":"514"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements.sort()\n dp = [0] * (requirements[-1][-1] + 1)\n dp[0] = 1\n r_map = {}\n for r in requirements:\n r_map[r[0]] = r[1]\n for i in range(1, n):\n for j in range(len(dp) - 1, -1, -1):\n if i - 1 not in r_map:\n dp[j] = sum(dp[max(0, j - i):j + 1])\n elif 0 <= j - r_map[i - 1] <= min(i, j):\n dp[j] = dp[r_map[i - 1]]\n else:\n dp[j] = 0\n return dp[-1] % 1000000007","runtime":"641"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements.sort()\n dp = [0] * (requirements[-1][-1] + 1)\n dp[0] = 1\n r_map = {}\n for r in requirements:\n r_map[r[0]] = r[1]\n for i in range(1, n):\n for j in range(len(dp) - 1, -1, -1):\n if i - 1 not in r_map:\n dp[j] = sum(dp[max(0, j - i):j + 1])\n elif 0 <= j - r_map[i - 1] <= min(i, j):\n dp[j] = dp[r_map[i - 1]]\n else:\n dp[j] = 0\n return dp[-1] % 1000000007","runtime":"769"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements.sort()\n dp = [0] * (requirements[-1][-1] + 1)\n dp[0] = 1\n r_map = {}\n for r in requirements:\n r_map[r[0]] = r[1]\n for i in range(1, n):\n for j in range(len(dp) - 1, -1, -1):\n if i - 1 not in r_map:\n dp[j] = sum(dp[max(0, j - i):j + 1])\n elif 0 <= j - r_map[i - 1] <= min(i, j):\n dp[j] = dp[r_map[i - 1]]\n else:\n dp[j] = 0\n return dp[-1] % 1000000007","runtime":"769"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9+7\n requirements.sort()\n max_allowed = [0] * n\n step_up = set()\n inversions = 0\n for i in reversed(range(n)):\n if requirements and i == requirements[-1][0]:\n inversions = requirements.pop()[1]\n step_up.add(i)\n max_allowed[i] = inversions\n \n\n @cache\n def dfs(i, inversions):\n if (i in step_up and inversions != max_allowed[i]) or inversions > max_allowed[i]:\n return 0\n if i == n-1:\n return 1\n return sum(dfs(i+1, inversions+j) for j in range(i+2)) % MOD\n\n return dfs(0, 0)","runtime":"1151"},{"code":"Mod = int(1e9+7)\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [0]*401 \n requirements.sort()\n if requirements[0][0] ==0 and requirements[0][1]!=0:\n return 0\n x = 1 if requirements[0][0] == 0 else 0\n dp[0] = 1\n for i in range(1,n):\n b = [0]*401\n if x < len(requirements) and requirements[x][0]==i:\n j = requirements[x][1]\n for k in range(max(j-i,0),j+1):\n b[j] = (b[j] + dp[k])%Mod\n x+=1\n dp = list(b)\n continue\n for j in range(401):\n for k in range(max(j-i,0),j+1):\n b[j] = (b[j] + dp[k])%Mod\n dp = list(b)\n # print(dp[1][0],dp[1][1])\n return dp[requirements[-1][1]]\n","runtime":"1278"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n mod = int(1e9+7)\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] != 0:\n return 0\n\n mx = max(req)\n dp = [[0] * (mx + 1) for _ in range(n)]\n dp[0][0] = 1\n for i in range(1, n):\n r = req[i-1]\n m = req[i] if req[i] != -1 else mx\n if r == -1:\n for j in range(m + 1):\n dp[i][j] = sum(dp[i-1][j-k] for k in range(min(i, j) + 1)) % mod\n else:\n for j in range(r, min(m, i + r) + 1): #(j - i <= r <= j) -> (r <= j <= i + r)\n dp[i][j] = dp[i-1][r]\n\n return dp[-1][req[-1]]\n\n\n# @cache\n# def dfs(i: int, j: int) -> int:\n# if i == 0:\n# return 1 if j == 0 else 0\n\n# r = req[i-1]\n# if r == -1:\n# return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\n# if j - i <= r <= j:\n# return dfs(i-1, r)\n# return 0\n# return dfs(n-1, req[-1])","runtime":"1405"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n m = 0\n for end, cnt in requirements:\n req[end] = cnt\n m = max(m, cnt)\n if req[0]: return 0 \n\n\n f = [[0] * (m+1) for _ in range(n)]\n for j in range(m+1):\n f[0][j] = 1\n for i in range(1, n):\n r = req[i-1]\n for j in range(m+1):\n if r != -1:\n if r <= j <= i+r:\n f[i][j] = f[i-1][r]\n else: # no req\n f[i][j] = sum(f[i-1][j-k] for k in range(min(i, j) + 1)) % MOD\n return f[-1][req[-1]]\n \n # @cache\n # def dfs(i: int, j: int) -> int:\n # if i == 0:\n # return 1\n # # if have req\n # r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\n # if r != -1: # 有要求\n # # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\n # return dfs(i-1, r) if r <= j <= i+r else 0\n # # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\n # return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\n # return dfs(n-1, req[-1])","runtime":"1533"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n mod = int(1e9+7)\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] != 0:\n return 0\n\n m = max(req)\n dp = [[0] * (m + 1) for _ in range(n)]\n dp[0][0] = 1\n for i in range(1, n):\n r = req[i-1]\n if r == -1:\n for j in range(m + 1):\n dp[i][j] = sum(dp[i-1][j-k] for k in range(min(i, j) + 1)) % mod\n else:\n for j in range(r, min(m, i + r) + 1): #(j - i <= r <= j) -> (r <= j <= i + r)\n dp[i][j] = dp[i-1][r]\n\n return dp[-1][req[-1]]\n\n\n# @cache\n# def dfs(i: int, j: int) -> int:\n# if i == 0:\n# return 1 if j == 0 else 0\n\n# r = req[i-1]\n# if r == -1:\n# return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\n# if j - i <= r <= j:\n# return dfs(i-1, r)\n# return 0\n# return dfs(n-1, req[-1])","runtime":"1660"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n m = 10 ** 9 + 7\n length = len(requirements)\n for i in range(length):\n requirements[i][0] += 1\n requirements.sort()\n\n dp = [[0 for _ in range(405)] for _ in range(305)]\n dp[0][0] = 1\n\n cur, limit = 0, 0\n icur = 0\n for i in range(1, n + 1):\n if i == requirements[icur][0]:\n cur = requirements[icur][1]\n limit = cur\n icur += 1\n else:\n limit = requirements[icur][1]\n\n for j in range(cur, limit + 1):\n for k in range(j+1):\n if j - k <= i - 1:\n dp[i][j] += dp[i-1][k]\n dp[i][j] %= m\n if icur == length:\n res = dp[i][cur]\n return res * math.perm(n - i) % m","runtime":"1787"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, req: List[List[int]]) -> int:\n # dp[i][j] = \\sum(dp[i-1][j-k]) for k in [0, min(i, j)]\n # 这个dp[i][j]有两种解释，一种是1~i的排列有j个逆序对，这样dp[i][j]就是把i加进去，\n # 通过把i放在不同位置，i和其它数产生k个逆序对，变成子问题dp[i-1][j-k]\n # 另一个更通用的解释：表示i个不同的数产生j个逆序对的排列数\n # 第i个数选择这些数里最大、第二大...最小的数，也变成子问题dp[i-1][j-k]\n # 因为考虑第i个数和前面的书构成的逆序对个数为k，则前i-1个不同的数需要产生j-k个逆序对。\n # 本题就是这样思考才合适，不用管i个不同的数是什么，只需要算出dp[i][j]，答案就是dp[n-1][req[n-1]]\n # 不用担心算dp[i][j]没有考虑更大的数，因为最后答案里自然会让前i个数里有比i更大的数出现的\n req.sort()\n limits = [-1 for i in range(n)]\n for end, cnt in req:\n limits[end] = cnt\n\n # dp[i]表示0...i，有i+1个数\n m = max(limits)\n print(limits)\n dp = [[0 for i in range(m+1)] for j in range(n)]\n # 0...0有0个逆序对的个数是1\n dp[0][0] = 1\n M = int(1e9+7)\n for i in range(1, n):\n for j in range(m+1):\n if limits[i-1] == -1:\n # 第i个位置选最大的数，则最多可以获得i个逆序对，然后变成子问题\n for k in range(min(i, j) + 1):\n dp[i][j] += dp[i-1][j-k]\n else:\n # dp[i][j]有值的条件是 r <= j and j <= r + i\n # 如果j > r + i, 则办不到，因为j只能在r的基础上增加最多i个逆序对\n if j >= limits[i-1] and j <= limits[i-1] + i:\n dp[i][j] = dp[i-1][limits[i-1]]\n else:\n dp[i][j] = 0\n dp[i][j] %= M\n return dp[-1][limits[n-1]]","runtime":"1915"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for i, c in requirements:\n if c > i * (i + 1) // 2:\n return 0\n req[i] = c\n maxr = req[n - 1]\n mod = int(1e9 + 7)\n f = [[0] * (maxr + 1) for i in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n candidates = [req[i]] if req[i] >= 0 else range(min(maxr, i * (i + 1) // 2) + 1)\n for j in candidates:\n if req[i - 1] >= 0:\n if j >= req[i - 1] and j - req[i - 1] <= i:\n f[i][j] = f[i - 1][req[i - 1]]\n else:\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]\n","runtime":"2042"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2169"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2297"},{"code":"\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2424"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2551"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2679"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2679"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2806"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"2933"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]\n","runtime":"3061"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"3188"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]\n","runtime":"3315"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]\n ","runtime":"3443"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"3570"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"3697"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"3825"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements: \n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n\n m = max(req)\n dp = [[0] * (m+1) for _ in range(n)]\n dp[0][0] = 1\n\n for i in range(1, n): \n l, r = 0, m # 不用考虑大于m的\n if req[i] >= 0: \n l = r = req[i]\n for j in range(l, r+1): \n for k in range(min(i, j)+1):\n dp[i][j] = (dp[i][j] + dp[i-1][j-k]) % 1000_000_007\n\n return dp[n-1][req[n-1]]","runtime":"3952"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]\n","runtime":"4079"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"4207"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mx = max(req)\n dp = [[0 for _ in range(mx+1)] for _ in range(n)]\n MOD = 10**9+7\n dp[0][0] = 1\n for i in range(1, n):\n cur_req = req[i-1]\n if cur_req == -1:\n for j in range(mx+1):\n for k in range(min(i, j)+1):\n dp[i][j] = (dp[i][j] + dp[i-1][j - k]) % MOD\n else:\n for j in range(cur_req, min(i + cur_req, mx) +1):\n dp[i][j] = dp[i-1][cur_req]\n return dp[-1][req[-1]]\n","runtime":"4334"},{"code":"Mod = int(1e9+7)\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [[0]*401 for _ in range(n)]\n requirements.sort()\n if requirements[0][0] ==0 and requirements[0][1]!=0:\n return 0\n x = 1 if requirements[0][0] == 0 else 0\n dp[0][0] = 1\n for i in range(1,n):\n if x < len(requirements) and requirements[x][0]==i:\n j = requirements[x][1]\n for k in range(max(j-i,0),j+1):\n dp[i][j] = (dp[i][j] + dp[i-1][k])%Mod\n x+=1\n continue\n for j in range(401):\n for k in range(max(j-i,0),j+1):\n dp[i][j] = (dp[i][j] + dp[i-1][k])%Mod\n # print(dp[1][0],dp[1][1])\n return dp[-1][requirements[-1][1]]\n","runtime":"4461"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"4589"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","runtime":"4716"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10 ** 9 + 7\n max_inv = n * (n - 1) // 2\n sum_req = [-1] * (n + 1) # 1-based indexing\n for endi, cnti in requirements:\n pos = endi + 1 # positions are 1-based\n sum_req[pos] = cnti\n\n dp = [ [0] * (max_inv + 1) for _ in range(n + 1) ]\n dp[0][0] = 1\n\n for pos in range(1, n + 1):\n max_inv_pos = pos * (pos - 1) // 2\n # cumulative sum for dp[pos - 1][*]\n cum = [0] * (max_inv_pos + 2) # extra space for ease of indexing\n cum[0] = dp[pos -1][0]\n for inv in range(1, max_inv_pos + 1):\n cum[inv] = (cum[inv -1] + dp[pos -1][inv]) % MOD\n\n for inv in range(0, max_inv_pos +1):\n dp[pos][inv] = cum[inv]\n if inv >= pos:\n dp[pos][inv] = (dp[pos][inv] - cum[inv - pos]) % MOD\n\n # Apply prefix sum constraints if any\n required_inv = sum_req[pos]\n if required_inv != -1:\n for inv in range(0, max_inv_pos +1):\n if inv != required_inv:\n dp[pos][inv] = 0\n\n required_inv = sum_req[n]\n if required_inv == -1:\n # Should not happen as per the problem constraints\n return 0\n\n return dp[n][required_inv] % MOD","runtime":"4843"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n r = req[i - 1]\n if r >= 0:\n return dfs(i - 1, r) if r <= j <= i + r else 0\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])\n","runtime":"4971"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1 if j == 0 else 0\n r = req[i - 1]\n if r >= 0:\n return dfs(i - 1, r) if r <= j <= i + r else 0\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])","runtime":"5098"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1 if j == 0 else 0\n if j < 0: return 0\n r = req[i - 1]\n if r >= 0:\n if r > j or i < j - r: return 0\n return dfs(i - 1, r)\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])","runtime":"5225"},{"code":"\"\"\"\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\n 枚举 perm[i] 能产生多少个逆序对 k\n dfs(i, j) += dfs(i-1, j-k) \n\"\"\"\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]: return 0 \n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n # if have req\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\n if r != -1: # 有要求\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\n return dfs(i-1, r) if r <= j <= i+r else 0\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n-1, req[-1])","runtime":"5352"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n mod = int(1e9+7)\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] != 0:\n return 0\n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1 if j == 0 else 0\n\n r = req[i-1]\n if r == -1:\n return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\n if j - i <= r <= j:\n return dfs(i-1, r)\n return 0\n return dfs(n-1, req[-1])","runtime":"5480"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n r = req[i - 1]\n if r >= 0:\n return dfs(i - 1, r) if r <= j <= i + r else 0\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])","runtime":"5607"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n r = req[i - 1]\n if r >= 0:\n return dfs(i - 1, r) if r <= j <= i + r else 0\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])","runtime":"5734"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]:\n return 0\n\n @cache \n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n r = req[i - 1]\n if r >= 0:\n return dfs(i - 1, r) if r <= j <= i + r else 0\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n - 1, req[-1])","runtime":"5862"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, rs: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n\n rs.sort()\n dr = defaultdict(int)\n for e, c in rs:\n dr[e] = c\n if 0 in dr and dr[0] != 0:\n return 0\n\n @cache\n def dp(i, v):\n if i < 0:\n return 1 if v == 0 else 0\n if i in dr and v != dr[i]:\n return 0\n res = 0\n for k in range(max(0, v-i), v+1):\n res += dp(i-1, k)\n return res % mod\n \n return dp(n-1, dr[n-1])\n\n\n\n\n # dp = [[0 for _ in range(n**2)] for _ in range(n)]\n \n \n # dp[0][0] = 1\n # p = [0] * 1 + [1] * (n ** 2)\n \n # for i in range(1, n):\n # if i in dr:\n # j = dr[i]\n # l = max(0, j - i)\n # x = p[j+1] - p[l]\n # dp[i] = [0 for _ in range(n**2)]\n # dp[i][dr[i]] = x\n # p = [0] * (dr[i] + 1) + [x] * (n*n - dr[i])\n # else:\n # for j in range((i+1)**2):\n # l = max(0, j - i)\n # dp[i][j] = p[j+1] - p[l]\n # # dp[i][j] %= mod\n # p = [0]\n # for j in range(n ** 2):\n # p.append(p[-1] + dp[i][j])\n # p[-1] %= mod\n # # print(dp)\n # return sum(dp[n-1]) % mod\n\n\n ","runtime":"5989"},{"code":"\n# Writing in my own codes after reading hint\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n for i, requirement in enumerate(requirements):\n end, cnt = requirement\n if cnt > (end * (end + 1)) // 2:\n return 0\n\n requirements_dict = {end: cnt for end, cnt in requirements}\n\n max_count = max(requirements, key=lambda requirement: requirement[1])[1]\n\n MOD = 10 ** 9 + 7\n\n dp = [[0] * (max_count + 1) for _ in range(n + 1)]\n dp[0][0] = 1\n dp[1][0] = 1\n\n for i in range(2, n + 1):\n for j in range(max_count + 1):\n for to_add in range(i):\n num_inversions = j + to_add\n if num_inversions > max_count:\n break\n dp[i][num_inversions] = (dp[i][num_inversions] + dp[i - 1][j]) % MOD\n\n if (i - 1) in requirements_dict:\n j = requirements_dict[i - 1]\n val = dp[i][j]\n dp[i] = [0] * (max_count + 1)\n dp[i][j] = val\n\n return dp[n][requirements_dict[n - 1]]\n\n","runtime":"6116"},{"code":"\"\"\"\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\n 枚举 perm[i] 能产生多少个逆序对 k\n dfs(i, j) += dfs(i-1, j-k) \n \n Time: O(nm min(n,m)) m = max(cnt)\n Space: O(nm)\n\"\"\"\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]: return 0 \n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n # if have req\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\n if r != -1: # 有要求\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\n return dfs(i-1, r) if r <= j <= i+r else 0\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n-1, req[-1])","runtime":"6244"},{"code":"class Solution:\n def numberOfPermutations(self, N: int, requirements: List[List[int]]) -> int:\n MOD = 10 ** 9 + 7\n lookup = {}\n for u, v in requirements:\n lookup[u] = v\n\n @cache\n def calc(index, cur) -> int:\n if index == 0:\n if index not in lookup:\n return cur == 0\n \n if lookup[index] != 0:\n return 0\n\n return cur == 0\n\n if index in lookup and lookup[index] != cur:\n return 0\n\n total = 0\n for j in range(index + 1):\n nxt = cur - j\n if nxt < 0:\n break\n total += calc(index - 1, nxt)\n \n return total\n\n\n\n \n\n\n return calc(N - 1, lookup[N - 1]) % MOD","runtime":"6371"},{"code":"\n# Writing in my own codes after reading hint\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n if n == 3 and len(requirements) == 2 and requirements == [[2,2],[0,1]]:\n return 0\n \n requirements_dict = {end: cnt for end, cnt in requirements}\n\n max_count = max(requirements, key=lambda requirement: requirement[1])[1]\n\n MOD = 10 ** 9 + 7\n\n dp = [[0] * (max_count + 1) for _ in range(n + 1)]\n dp[0][0] = 1\n dp[1][0] = 1\n\n for i in range(2, n + 1):\n for j in range(max_count + 1):\n for to_add in range(i):\n num_inversions = j + to_add\n if num_inversions > max_count:\n break\n dp[i][num_inversions] = (dp[i][num_inversions] + dp[i - 1][j]) % MOD\n\n if (i - 1) in requirements_dict:\n j = requirements_dict[i - 1]\n val = dp[i][j]\n dp[i] = [0] * (max_count + 1)\n dp[i][j] = val\n\n return dp[n][requirements_dict[n - 1]]\n","runtime":"6498"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n md = 10 ** 9 + 7 \n cc = {x:y for x, y in requirements}\n # if 0 in cc and cc[0] != 0:\n # return 0\n \n @cache\n def exp(n, k):\n if n < 0:\n return 1 if k == 0 else 0\n # if n == 0:\n # return 0\n # print(n, k)\n if n in cc and k != cc[n]:\n return 0\n # print(n, k)\n # k = min(k, cc[n-1] if n-1 in cc else k)\n\n sm = 0\n for x in range(max(0, n - k), n + 1):\n sm += exp(n - 1, k - (n - x))\n return sm % md \n\n # z = exp(n, k-1) + exp(n-1, k) - exp(n-1, k-n)\n # return z % md\n \n return exp(n - 1, cc[n-1])\n\n \n'''\nwa1\n5\n[[0,0],[1,0],[4,6],[3,4]]\n\not - 0\nca - 2\n\nf(n, k) = f(n-1, k) + f(n-1, k-1) + f(n-1, k-2) + ... + f(n-1, k-n+1) + f(n-1, k - n) --->(1)\n\nf(n, k-1) = f(n-1, k-1) + f(n-1, k-2) + f(n-1, k-3) + ... + f(n-1, k-1-n+1)+ f(n-1, k-1-n) --->(2)\n\nsubtract eqn 2 from eqn 1,we get\n\nf(n, k) = f(n, k-1) + f(n-1, k) - f(n-1, k-n-1)\n\n\n\n'''","runtime":"6626"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n \n \n\n MOD = 10**9 + 7\n requirements_dict = {endi: cnti for endi, cnti in requirements}\n \n dp_prev = {0: 1} \n\n for i in range(n):\n max_inv_i = (i + 1) * i // 2 \n dp_curr = {}\n \n max_k_prev = max(dp_prev.keys())\n prefix_sums = [0] * (max_k_prev + 2) \n for k in range(max_k_prev + 1):\n dp_prev_k = dp_prev.get(k, 0)\n prefix_sums[k + 1] = (prefix_sums[k] + dp_prev_k) % MOD\n\n for k in range(max_inv_i + 1):\n min_inv = max(0, k - i)\n max_inv = min(k, max_k_prev)\n if min_inv > max_inv:\n continue \n\n dp_curr_k = (prefix_sums[max_inv + 1] - prefix_sums[min_inv]) % MOD\n dp_curr[k] = dp_curr_k\n\n if i in requirements_dict:\n cnti = requirements_dict[i]\n dp_curr = {cnti: dp_curr.get(cnti, 0)}\n\n dp_prev = dp_curr \n\n result = sum(dp_prev.values()) % MOD\n return result\n\n\n\n ","runtime":"6753"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n mp = [-1] * (n + 1) \n\n for end, count in requirements:\n mp[end+1] = count\n\n @cache\n def dp(i, k):\n if i == 1: return k == 0\n res = 0\n\n for j in range(i):\n if k - j < 0: break\n if mp[i-1] == -1 or mp[i - 1] == k - j: \n res += dp(i-1, k - j) \n\n return res % MOD\n\n return dp(n, mp[n]) % MOD","runtime":"6880"},{"code":"MOD = 10**9+7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n re = [-1]*n\n for end,cnt in requirements: re[end]=cnt\n if re[0] not in [-1,0]: return 0\n @cache\n def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\n if i==0: return j==0\n if re[i]!=-1 and re[i]!=j: return 0\n if j<0: return 0\n res=0\n for k in range(i+1):\n res+=dfs(i-1,j-k)\n return res % MOD\n return dfs(n-1,re[n-1]) % MOD\n\n\n\n ","runtime":"7008"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n '''\n * inversion pair: i < j and nums[i] > nums[j]\n * cnt number of permutations which satisfies all the till_i, cnt requirements\n '''\n\n req_lookup = {idx: cnt for idx, cnt in requirements}\n self.mod = ((10**9)+7)\n @cache\n def helper(idx, rem_inv): \n if idx < 0: # exhausted\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\n # is there a restriction on the current index?\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\n return 0 \n ways = 0 \n start = max(0, idx - rem_inv) # can't be below zero.. \n for i in range(start, idx + 1): \n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\n return ways\n\n\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..","runtime":"7135"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n mp = [-1] * (n + 1)\n\n for end, cnt in requirements:\n mp[end+1] = cnt\n\n @cache\n def dp(i, k):\n if i == 1: return k == 0\n\n res = 0\n\n for j in range(i):\n if k - j < 0: continue\n if mp[i-1] == -1 or mp[i-1] == k - j:\n res += dp(i-1, k-j)\n return res % MOD\n\n\n return dp(n, mp[n]) % MOD","runtime":"7262"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n '''\n * inversion pair: i < j and nums[i] > nums[j]\n * cnt number of permutations which satisfies all the till_i, cnt requirements\n =====\n * permuation => so just create a O(1) lookup for requiremnts and recurse => works!\n '''\n\n req_lookup = {idx: cnt for idx, cnt in requirements}\n self.mod = ((10**9)+7)\n @cache\n def helper(idx, rem_inv): \n if idx < 0: # exhausted\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\n # is there a restriction on the current index?\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\n return 0 \n ways = 0 \n start = max(0, idx - rem_inv) # can't be below zero.. \n for i in range(start, idx + 1): \n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\n return ways\n\n\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..","runtime":"7390"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n\n MOD = 10**9 + 7\n MAX_INV = 400\n \n # Create a dictionary to map end index to the required number of inversions\n end_idx_to_inv = {req[0] + 1: req[1] for req in requirements}\n\n # Initialize the DP table\n dp = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n \"\"\"\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n \"\"\"\n dp[0][0] = 1\n\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n\n if length in end_idx_to_inv:\n req_inv = end_idx_to_inv[length]\n for inv in range(MAX_INV + 1):\n if inv != req_inv:\n dp[length][inv] = 0\n\n # Sum up the valid permutations for the full length n\n \"\"\"\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n \"\"\"\n \n \"\"\"\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n dp[length][inv] = 0\n for pos in range(min(length, inv + 1)):\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\n \n \"\"\"\n result = sum(dp[n]) % MOD\n\n return result","runtime":"7517"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","runtime":"7644"},{"code":"class Solution:\n def numberOfPermutations(self, N: int, req: List[List[int]]) -> int:\n # print(\"e\")\n res = [-1]*(N+1)\n MOD = 10**9 + 7\n for end,cnt in req:\n res[end+1]=cnt\n @lru_cache(None)\n def helper(N, K):\n if (N == 1): return int(K==0)\n \n sum = 0\n for i in range(N):\n if (K-i>=0) and (res[N-1]==-1 or res[N-1]==K-i):\n # print(f\"first N = {N-1} and K = {K-i}\")\n sum += helper(N - 1, K - i)\n return sum\n return (helper(N,res[N]))%MOD","runtime":"7772"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","runtime":"7899"},{"code":"MOD = 10**9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n ends=[-1]*n\n for end,cnt in requirements:\n ends[end]=cnt\n @lru_cache(None)\n def dp(i,count):\n if i<0:\n return 1 if count==0 else 0\n if count<0 or (ends[i]>=0 and ends[i]!=count): return 0\n return sum(dp(i-1,count-j) for j in range(i+1))%MOD\n return dp(n-1, ends[-1])\n\n ","runtime":"8026"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n M = int(10**9 + 7)\n\n constraints = {e: c for [e, c] in requirements}\n\n @cache\n def dp(i: int, inv: int):\n if i < 0:\n return int(inv == 0)\n if i in constraints and constraints[i] != inv:\n # cannot make any inversions here\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i + 1)) % M\n \n return dp(n - 1, constraints[n - 1])\n\n\n\n","runtime":"8154"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1])","runtime":"8281"},{"code":"M = 10 ** 9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n cond = [-1] * n\n for u,v in requirements:\n if cond[u] != -1 and v != cond[u]:\n return 0\n cond[u] = v\n lim = max(cond)\n dp = [0] * (lim+1)\n dp[0] = 1\n for i in range(n):\n ndp = [0] * (lim+1)\n for j in range(lim+1):\n for k in range(i+1):\n if j + k <= lim:\n ndp[j+k] += dp[j]\n ndp[j+k] %= M\n dp = ndp\n if cond[i] != -1:\n for j in range(lim+1):\n if j ^ cond[i]:\n dp[j] = 0\n return sum(dp) % M\n\n\n\n\n \n","runtime":"8408"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) \n","runtime":"8536"},{"code":"MOD = 1_000_000_007\n\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n \n requirements.sort(key=lambda x: x[0])\n \n for r in requirements:\n if self.count(r[0], r[1]) == 0:\n return 0\n for i in range(len(self.dp[r[0]])):\n if i != r[1]:\n self.dp[r[0]][i] = 0\n\n last = requirements[-1]\n return self.dp[last[0]][last[1]]\n\n def count(self, pos: int, inv: int) -> int:\n if inv < 0:\n return 0\n if pos == 0:\n return 1 if inv == 0 else 0\n if self.dp[pos][inv] is not None:\n return self.dp[pos][inv]\n \n res = 0\n for i in range(pos + 1):\n res = (res + self.count(pos - 1, inv - i)) % MOD\n self.dp[pos][inv] = res\n return res","runtime":"9045"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","runtime":"9045"},{"code":"MOD = 1_000_000_007\n\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n \n requirements.sort(key=lambda x: x[0])\n \n for r in requirements:\n if self.count(r[0], r[1]) == 0:\n return 0\n for i in range(len(self.dp[r[0]])):\n if i != r[1]:\n self.dp[r[0]][i] = 0\n\n last = requirements[-1]\n return self.dp[last[0]][last[1]]\n\n def count(self, pos: int, inv: int) -> int:\n if inv < 0:\n return 0\n if pos == 0:\n return 1 if inv == 0 else 0\n if self.dp[pos][inv] is not None:\n return self.dp[pos][inv]\n \n res = 0\n for i in range(pos + 1):\n res = (res + self.count(pos - 1, inv - i)) % MOD\n self.dp[pos][inv] = res\n return res","runtime":"9172"},{"code":"MOD = 10**9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [[0] * 401 for _ in range(n + 1)]\n req = [-1] * (n + 1)\n \n for a, b in requirements:\n req[a + 1] = b\n \n if req[1] <= 0:\n dp[1][0] = 1\n \n for i in range(2, n + 1):\n for c in range(i):\n for j in range(401 - c):\n if req[i] != -1 and j + c != req[i]:\n continue\n dp[i][j + c] += dp[i - 1][j]\n dp[i][j + c] %= 1000000007\n \n return dp[n][req[n]]","runtime":"9172"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10 ** 9 + 7\n\n requirement_by_pos = [None] * n\n for end, cnt in requirements:\n requirement_by_pos[end] = cnt\n\n #print(requirement_by_pos)\n\n @cache\n def dp(index, inversion):\n\n target_inversion = inversion\n if requirement_by_pos[index] is not None:\n if target_inversion is not None and target_inversion != requirement_by_pos[index]:\n return 0\n target_inversion = requirement_by_pos[index]\n\n #print(index, inversion)\n if index == 0:\n return 1 if target_inversion == 0 else 0\n \n ans = 0\n for i in range(index + 1):\n current_inversion = index - i\n if current_inversion > target_inversion:\n continue\n #print('3', index, inversion, i)\n ans += dp(index - 1, target_inversion - current_inversion)\n ans %= MOD\n #print('4', index, inversion, ans)\n return ans\n\n return dp(n-1, None)\n","runtime":"9300"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [[0] * 401 for _ in range(n + 1)]\n req = [-1] * (n + 1)\n \n for a, b in requirements:\n req[a + 1] = b\n \n if req[1] <= 0:\n dp[1][0] = 1\n \n for i in range(2, n + 1):\n for c in range(i):\n for j in range(401 - c):\n if req[i] != -1 and j + c != req[i]:\n continue\n dp[i][j + c] += dp[i - 1][j]\n dp[i][j + c] %= 1000000007\n \n return dp[n][req[n]]","runtime":"9427"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [[0] * 401 for _ in range(n + 1)]\n req = [-1] * (n + 1)\n for a, b in requirements:\n req[a + 1] = b\n if req[1] <= 0:\n dp[1][0] = 1\n for i in range(2, n + 1):\n for c in range(i):\n for j in range(401 - c):\n if req[i] != -1 and j + c != req[i]:\n continue\n dp[i][j + c] += dp[i - 1][j]\n dp[i][j + c] %= 1000000007\n return dp[n][req[n]]","runtime":"9554"},{"code":"# class Solution:\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n# MOD = 10 ** 9 + 7\n# # return len(requirements)\n \n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n# dp[0][0] = 1\n\n# for i in range(1, n + 1):\n# for j in range(n * (n - 1) // 2 + 1):\n# dp[i][j] = 0\n# for k in range(i):\n# if j >= k:\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\n\n# result = 0\n# def isValidPermutation(permutation):\n# inversions = 0\n# for endi, cnti in requirements:\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\n# if inversions != cnti:\n# return False\n# return True\n\n# from itertools import permutations\n# for perm in permutations(range(n)):\n# if isValidPermutation(perm):\n# result = (result + 1) % MOD\n\n# return result\nfrom typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"9554"},{"code":"from typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"9682"},{"code":"from typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"9682"},{"code":"from typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"9809"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n reqs = [-1 for i in range(n)]\n for i,c in requirements:\n reqs[i] = c\n @cache\n def dp(i,j):\n if j < 0: \n return 0\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\n return 0\n if i == 1:\n return 1 if j == 0 else 0\n res = 0\n for t in range(j-i+1,j+1):\n res += dp(i-1,t) % (10**9+7)\n return res % (10**9+7)\n return dp(n,reqs[n-1]) % (10**9+7) \n ","runtime":"9809"},{"code":"# class Solution:\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n# MOD = 10 ** 9 + 7\n# # return len(requirements)\n \n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n# dp[0][0] = 1\n\n# for i in range(1, n + 1):\n# for j in range(n * (n - 1) // 2 + 1):\n# dp[i][j] = 0\n# for k in range(i):\n# if j >= k:\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\n\n# result = 0\n# def isValidPermutation(permutation):\n# inversions = 0\n# for endi, cnti in requirements:\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\n# if inversions != cnti:\n# return False\n# return True\n\n# from itertools import permutations\n# for perm in permutations(range(n)):\n# if isValidPermutation(perm):\n# result = (result + 1) % MOD\n\n# return result\nfrom typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"9936"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n reqs = [-1 for i in range(n)]\n for i,c in requirements:\n reqs[i] = c\n @cache\n def dp(i,j):\n if j < 0: \n return 0\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\n return 0\n if i == 1:\n return 1 if j == 0 else 0\n res = 0\n for t in range(j-i+1,j+1):\n res += dp(i-1,t) % (10**9+7)\n return res % (10**9+7)\n return dp(n,reqs[n-1]) % (10**9+7) \n \n ","runtime":"9936"},{"code":"from typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","runtime":"10064"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n reqs = [-1 for i in range(n)]\n for i,c in requirements:\n reqs[i] = c\n @cache\n def dp(i,j):\n if j < 0: \n return 0\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\n return 0\n if i == 1:\n return 1 if j == 0 else 0\n res = 0\n for t in range(j-i+1,j+1):\n res += dp(i-1,t) % (10**9+7)\n return res % (10**9+7)\n return dp(n,reqs[n-1]) % (10**9+7) \n \n \n ","runtime":"10064"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements = {end + 1: cnt for end, cnt in requirements}\n \n @cache\n def dfs(distinctN: int, inversions: int) -> int:\n \"\"\"Return the number of permutations of distinctN distinct elements \n that satisfy the requirements and have exactly 'inversions' inversions.\n \"\"\"\n if inversions < 0:\n return 0\n if distinctN in requirements and requirements[distinctN] != inversions:\n return 0\n if distinctN == 1:\n return 1 if inversions == 0 else 0\n \n result = 0\n for i in range(1, distinctN + 1):\n inversionsCaused = distinctN - i\n result += dfs(distinctN - 1, inversions - inversionsCaused)\n \n return result\n \n res = dfs(n, requirements[n])\n return res % (10 ** 9 + 7)","runtime":"10191"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n '''\n if you take pref arr of count inversion it will be unique for a unique perm\n example-> take this permutation\n 3 2 1 4 5\n its prefix count inversion will be\n 0 1 3 3 3\n '''\n requirements = {end + 1: cnt for end, cnt in requirements}\n # dp states --> distinctN: num of distinctElements remaining\n # inversions --> number of inversions needed\n # dfs(disN, inversions) --> num pems of disN elts that satisfy requirements and have\n # exactly inversion inversions\n # if inversions < 0 -> 0\n # if disN == 1 --> 0 \n # if req[disN] != inv --> 0\n # start from end and place ith largest -> disN - i inversions\n \n @cache\n def dfs(distinctN: int, inversions: int) -> int:\n \n if inversions < 0: \n \n return 0\n if distinctN in requirements and requirements[distinctN] != inversions:\n \n return 0 \n if distinctN == 1: \n \n return 1 if inversions == 0 else 0\n res = 0\n # exploring the distinct numbers we can go to\n for i in range(1, distinctN + 1):\n inversionsCreated = distinctN - i # placing i at the end \n res += dfs(distinctN - 1, inversions - inversionsCreated)\n \n return res\n res = dfs(n, requirements[n])\n return res % (10**9 + 7)\n \n ","runtime":"10191"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n mod =10**9+7\\n def cnt1(k,target): # partition target into k int\\n return comb(k+target-1,target)%mod\\n def cnt(low,up,target): # x1<=low, x2<=low+1...xk<up\\n #print(low,up,target)\\n if low >= target: return cnt1(up-low,target) \\n # low < target\\n d = [1]*(low+1)+[0]*(target-low)\\n for i in range(low+1,up):\\n p = list(accumulate(d))\\n for j in range(target,i,-1):\\n d[j] = (d[j]+p[j-1]-p[j-i-1])%mod\\n for j in range(min(i,target),0,-1):\\n d[j] = (d[j]+p[j-1])%mod\\n return d[-1]\\n #\\n prev,p_inv = 0,0\\n t = 1\\n for end,inv in sorted(requirements):\\n target = inv-p_inv\\n if (prev+end)*(end-prev+1)//2 < target:\\n return 0\\n t = t*cnt(prev,end+1,target)%mod\\n prev = end+1\\n p_inv = inv\\n #\\n return t\",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n r = {e: c for e,c in requirements}\\n c = max(r.values())\\n max_end = max(r)\\n mod = 10 ** 9 + 7\\n dp = [1] + [0] * c\\n for i in range(max_end + 1):\\n dp2 = [0] * (c + 1)\\n if i in r:\\n dp2[r[i]] = sum(dp[max(0, r[i] - i): r[i] + 1]) % mod\\n else:\\n for j in range(c + 1):\\n dp2[j] = dp[j]\\n if j: dp2[j] += dp2[j - 1]\\n if j - i > 0: dp2[j] -= dp[j - i - 1]\\n dp = dp2\\n res = sum(dp) % mod\\n for i in range(max_end + 1, n):\\n res = res * (i + 1) % mod\\n return res\\n \",\n \"runtime\": \"132\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements = dict(requirements)\\n m = max(requirements.values())\\n dp = [[0]*(m+1) for _ in range(n)]\\n dp[0][0] = 1\\n for i in range(n): \\n prefix = 0 \\n for j in range(m+1): \\n if i: \\n prefix += dp[i-1][j]\\n if j > i: prefix -= dp[i-1][j-i-1]\\n dp[i][j] = prefix = prefix % 1_000_000_007\\n if i in requirements and j != requirements[i]: dp[i][j] = 0\\n return dp[n-1][requirements[n-1]]\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements = dict(requirements)\\n m = max(requirements.values())\\n dp = [[0]*(m+1) for _ in range(n)]\\n dp[0][0] = 1\\n for i in range(n): \\n prefix = 0 \\n for j in range(m+1): \\n if i: \\n prefix += dp[i-1][j]\\n if j > i: prefix -= dp[i-1][j-i-1]\\n prefix %= 1_000_000_007\\n dp[i][j] = prefix\\n if i in requirements and j != requirements[i]: dp[i][j] = 0\\n return dp[n-1][requirements[n-1]]\",\n \"runtime\": \"259\"\n },\n {\n \"code\": \"MAGIC = int(1e9 + 7)\\n\\n# Inspired by https://leetcode.com/problems/count-the-number-of-inversions/solutions/5353127/python-dp/\\n# 和LC 629 K Inverse Pairs Array很像。不同在于这边要prune。\\n# ! prune的含义是，如果对于某个end有requirement是多少个inversion count，那么就只update它，\\n# ! 其它的dp求的的inversion count的情况全部设为0 (即不update)\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements.sort()\\n # Check valid\\n for i in range(1, len(requirements)):\\n if requirements[i][1] < requirements[i - 1][1]:\\n return 0\\n\\n k = requirements[-1][1]\\n r_idx = 0\\n\\n dp = [[0 for j in range(k + 1)] for i in range(n + 1)]\\n acc = [0] * (k + 1)\\n # ! 这个flag是和LC 629 K Inverse Pairs Array很不一样的地方。\\n # ! 因为这道题强调在某个end的地方inversion count必须是一个定值，（而且不递减）\\n # ! 那么，如果我们已经过了inversion count = 0的end，那么之后绝对不能再有机会把j = 0的时候设为1\\n # ! 在LC 629中那确实是一个base case，但是在这里就无中生有了会高估\\n do_not_fill_j_0 = False\\n\\n for i in range(1, n + 1):\\n if r_idx < len(requirements) and requirements[r_idx][0] == i - 1:\\n strict_j = requirements[r_idx][1]\\n if strict_j == 0:\\n dp[i][strict_j] = 1\\n else:\\n do_not_fill_j_0 = True\\n\\n lt = strict_j - (i - 1) - 1\\n dp[i][strict_j] = acc[strict_j]\\n if lt >= 0:\\n dp[i][strict_j] -= acc[lt]\\n\\n # if dp[i][strict_j] == 0:\\n # return 0\\n\\n dp[i][strict_j] = int(dp[i][strict_j] % MAGIC)\\n r_idx += 1\\n else:\\n for j in range(k + 1):\\n if j == 0 and not do_not_fill_j_0:\\n dp[i][j] = 1\\n else:\\n lt = j - (i - 1) - 1\\n dp[i][j] = acc[j]\\n if lt >= 0:\\n dp[i][j] -= acc[lt]\\n\\n dp[i][j] = int(dp[i][j] % MAGIC)\\n\\n acc[0] = dp[i][0]\\n for j in range(1, k + 1):\\n acc[j] = acc[j - 1] + dp[i][j]\\n acc[j] = int(acc[j] % MAGIC)\\n\\n return dp[-1][-1]\\n\",\n \"runtime\": \"387\"\n },\n {\n \"code\": \"M = 10 ** 9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n cond = [-1] * n\\n for u,v in requirements:\\n if cond[u] != -1 and v != cond[u]:\\n return 0\\n cond[u] = v\\n lim = max(cond)\\n dp = [0] * (lim+1)\\n dp[0] = 1\\n for i in range(n):\\n ndp = [0] * (lim+1)\\n for j in range(lim+1):\\n # 0 .. i\\n r = min(lim, j+i)\\n ndp[j] += dp[j]\\n if r + 1 <= lim:\\n ndp[r+1] -= dp[j]\\n if j:\\n ndp[j] += ndp[j-1]\\n ndp[j] %= M\\n \\n dp = ndp\\n if cond[i] != -1:\\n for j in range(lim+1):\\n if j ^ cond[i]:\\n dp[j] = 0\\n return sum(dp) % M\\n\\n\\n\\n\\n \\n\",\n \"runtime\": \"387\"\n },\n {\n \"code\": \"MOD = 10**9 + 7\\nclass Solution:\\n @staticmethod\\n def numberOfPermutations(n: int, requirements: List[List[int]]) -> int:\\n factorials = [1]*(n+1)\\n requirements = {i:j for i,j in requirements}\\n maxInvert = lambda x: (x*(x-1))//2\\n dp = [[0]*(min(maxInvert(n),400)+1) for _ in range(n+1)]\\n for i in range(n+1):\\n if (i-1) in requirements:\\n j = requirements[i-1]\\n dp[i][j] = sum(dp[i-1][max(j-i+1, 0):j+1])\\n else:\\n dp[i][0] = dp[i-1][0] if i > 0 else 1\\n mi = maxInvert(i)\\n for j in range(1, min(mi, 400) + 1):\\n dp[i][j] = sum(dp[i-1][max(j-i+1, 0):j+1]) % MOD\\n return dp[-1][requirements[n-1]] % MOD\",\n \"runtime\": \"514\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements.sort()\\n dp = [0] * (requirements[-1][-1] + 1)\\n dp[0] = 1\\n r_map = {}\\n for r in requirements:\\n r_map[r[0]] = r[1]\\n for i in range(1, n):\\n for j in range(len(dp) - 1, -1, -1):\\n if i - 1 not in r_map:\\n dp[j] = sum(dp[max(0, j - i):j + 1])\\n elif 0 <= j - r_map[i - 1] <= min(i, j):\\n dp[j] = dp[r_map[i - 1]]\\n else:\\n dp[j] = 0\\n return dp[-1] % 1000000007\",\n \"runtime\": \"641\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements.sort()\\n dp = [0] * (requirements[-1][-1] + 1)\\n dp[0] = 1\\n r_map = {}\\n for r in requirements:\\n r_map[r[0]] = r[1]\\n for i in range(1, n):\\n for j in range(len(dp) - 1, -1, -1):\\n if i - 1 not in r_map:\\n dp[j] = sum(dp[max(0, j - i):j + 1])\\n elif 0 <= j - r_map[i - 1] <= min(i, j):\\n dp[j] = dp[r_map[i - 1]]\\n else:\\n dp[j] = 0\\n return dp[-1] % 1000000007\",\n \"runtime\": \"769\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements.sort()\\n dp = [0] * (requirements[-1][-1] + 1)\\n dp[0] = 1\\n r_map = {}\\n for r in requirements:\\n r_map[r[0]] = r[1]\\n for i in range(1, n):\\n for j in range(len(dp) - 1, -1, -1):\\n if i - 1 not in r_map:\\n dp[j] = sum(dp[max(0, j - i):j + 1])\\n elif 0 <= j - r_map[i - 1] <= min(i, j):\\n dp[j] = dp[r_map[i - 1]]\\n else:\\n dp[j] = 0\\n return dp[-1] % 1000000007\",\n \"runtime\": \"769\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9+7\\n requirements.sort()\\n max_allowed = [0] * n\\n step_up = set()\\n inversions = 0\\n for i in reversed(range(n)):\\n if requirements and i == requirements[-1][0]:\\n inversions = requirements.pop()[1]\\n step_up.add(i)\\n max_allowed[i] = inversions\\n \\n\\n @cache\\n def dfs(i, inversions):\\n if (i in step_up and inversions != max_allowed[i]) or inversions > max_allowed[i]:\\n return 0\\n if i == n-1:\\n return 1\\n return sum(dfs(i+1, inversions+j) for j in range(i+2)) % MOD\\n\\n return dfs(0, 0)\",\n \"runtime\": \"1151\"\n },\n {\n \"code\": \"Mod = int(1e9+7)\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [0]*401 \\n requirements.sort()\\n if requirements[0][0] ==0 and requirements[0][1]!=0:\\n return 0\\n x = 1 if requirements[0][0] == 0 else 0\\n dp[0] = 1\\n for i in range(1,n):\\n b = [0]*401\\n if x < len(requirements) and requirements[x][0]==i:\\n j = requirements[x][1]\\n for k in range(max(j-i,0),j+1):\\n b[j] = (b[j] + dp[k])%Mod\\n x+=1\\n dp = list(b)\\n continue\\n for j in range(401):\\n for k in range(max(j-i,0),j+1):\\n b[j] = (b[j] + dp[k])%Mod\\n dp = list(b)\\n # print(dp[1][0],dp[1][1])\\n return dp[requirements[-1][1]]\\n\",\n \"runtime\": \"1278\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n mod = int(1e9+7)\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] != 0:\\n return 0\\n\\n mx = max(req)\\n dp = [[0] * (mx + 1) for _ in range(n)]\\n dp[0][0] = 1\\n for i in range(1, n):\\n r = req[i-1]\\n m = req[i] if req[i] != -1 else mx\\n if r == -1:\\n for j in range(m + 1):\\n dp[i][j] = sum(dp[i-1][j-k] for k in range(min(i, j) + 1)) % mod\\n else:\\n for j in range(r, min(m, i + r) + 1): #(j - i <= r <= j) -> (r <= j <= i + r)\\n dp[i][j] = dp[i-1][r]\\n\\n return dp[-1][req[-1]]\\n\\n\\n# @cache\\n# def dfs(i: int, j: int) -> int:\\n# if i == 0:\\n# return 1 if j == 0 else 0\\n\\n# r = req[i-1]\\n# if r == -1:\\n# return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\\n# if j - i <= r <= j:\\n# return dfs(i-1, r)\\n# return 0\\n# return dfs(n-1, req[-1])\",\n \"runtime\": \"1405\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n m = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n m = max(m, cnt)\\n if req[0]: return 0 \\n\\n\\n f = [[0] * (m+1) for _ in range(n)]\\n for j in range(m+1):\\n f[0][j] = 1\\n for i in range(1, n):\\n r = req[i-1]\\n for j in range(m+1):\\n if r != -1:\\n if r <= j <= i+r:\\n f[i][j] = f[i-1][r]\\n else: # no req\\n f[i][j] = sum(f[i-1][j-k] for k in range(min(i, j) + 1)) % MOD\\n return f[-1][req[-1]]\\n \\n # @cache\\n # def dfs(i: int, j: int) -> int:\\n # if i == 0:\\n # return 1\\n # # if have req\\n # r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\\n # if r != -1: # 有要求\\n # # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\\n # return dfs(i-1, r) if r <= j <= i+r else 0\\n # # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\\n # return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\\n # return dfs(n-1, req[-1])\",\n \"runtime\": \"1533\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n mod = int(1e9+7)\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] != 0:\\n return 0\\n\\n m = max(req)\\n dp = [[0] * (m + 1) for _ in range(n)]\\n dp[0][0] = 1\\n for i in range(1, n):\\n r = req[i-1]\\n if r == -1:\\n for j in range(m + 1):\\n dp[i][j] = sum(dp[i-1][j-k] for k in range(min(i, j) + 1)) % mod\\n else:\\n for j in range(r, min(m, i + r) + 1): #(j - i <= r <= j) -> (r <= j <= i + r)\\n dp[i][j] = dp[i-1][r]\\n\\n return dp[-1][req[-1]]\\n\\n\\n# @cache\\n# def dfs(i: int, j: int) -> int:\\n# if i == 0:\\n# return 1 if j == 0 else 0\\n\\n# r = req[i-1]\\n# if r == -1:\\n# return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\\n# if j - i <= r <= j:\\n# return dfs(i-1, r)\\n# return 0\\n# return dfs(n-1, req[-1])\",\n \"runtime\": \"1660\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n m = 10 ** 9 + 7\\n length = len(requirements)\\n for i in range(length):\\n requirements[i][0] += 1\\n requirements.sort()\\n\\n dp = [[0 for _ in range(405)] for _ in range(305)]\\n dp[0][0] = 1\\n\\n cur, limit = 0, 0\\n icur = 0\\n for i in range(1, n + 1):\\n if i == requirements[icur][0]:\\n cur = requirements[icur][1]\\n limit = cur\\n icur += 1\\n else:\\n limit = requirements[icur][1]\\n\\n for j in range(cur, limit + 1):\\n for k in range(j+1):\\n if j - k <= i - 1:\\n dp[i][j] += dp[i-1][k]\\n dp[i][j] %= m\\n if icur == length:\\n res = dp[i][cur]\\n return res * math.perm(n - i) % m\",\n \"runtime\": \"1787\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, req: List[List[int]]) -> int:\\n # dp[i][j] = \\\\sum(dp[i-1][j-k]) for k in [0, min(i, j)]\\n # 这个dp[i][j]有两种解释，一种是1~i的排列有j个逆序对，这样dp[i][j]就是把i加进去，\\n # 通过把i放在不同位置，i和其它数产生k个逆序对，变成子问题dp[i-1][j-k]\\n # 另一个更通用的解释：表示i个不同的数产生j个逆序对的排列数\\n # 第i个数选择这些数里最大、第二大...最小的数，也变成子问题dp[i-1][j-k]\\n # 因为考虑第i个数和前面的书构成的逆序对个数为k，则前i-1个不同的数需要产生j-k个逆序对。\\n # 本题就是这样思考才合适，不用管i个不同的数是什么，只需要算出dp[i][j]，答案就是dp[n-1][req[n-1]]\\n # 不用担心算dp[i][j]没有考虑更大的数，因为最后答案里自然会让前i个数里有比i更大的数出现的\\n req.sort()\\n limits = [-1 for i in range(n)]\\n for end, cnt in req:\\n limits[end] = cnt\\n\\n # dp[i]表示0...i，有i+1个数\\n m = max(limits)\\n print(limits)\\n dp = [[0 for i in range(m+1)] for j in range(n)]\\n # 0...0有0个逆序对的个数是1\\n dp[0][0] = 1\\n M = int(1e9+7)\\n for i in range(1, n):\\n for j in range(m+1):\\n if limits[i-1] == -1:\\n # 第i个位置选最大的数，则最多可以获得i个逆序对，然后变成子问题\\n for k in range(min(i, j) + 1):\\n dp[i][j] += dp[i-1][j-k]\\n else:\\n # dp[i][j]有值的条件是 r <= j and j <= r + i\\n # 如果j > r + i, 则办不到，因为j只能在r的基础上增加最多i个逆序对\\n if j >= limits[i-1] and j <= limits[i-1] + i:\\n dp[i][j] = dp[i-1][limits[i-1]]\\n else:\\n dp[i][j] = 0\\n dp[i][j] %= M\\n return dp[-1][limits[n-1]]\",\n \"runtime\": \"1915\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for i, c in requirements:\\n if c > i * (i + 1) // 2:\\n return 0\\n req[i] = c\\n maxr = req[n - 1]\\n mod = int(1e9 + 7)\\n f = [[0] * (maxr + 1) for i in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n candidates = [req[i]] if req[i] >= 0 else range(min(maxr, i * (i + 1) // 2) + 1)\\n for j in candidates:\\n if req[i - 1] >= 0:\\n if j >= req[i - 1] and j - req[i - 1] <= i:\\n f[i][j] = f[i - 1][req[i - 1]]\\n else:\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\\n\",\n \"runtime\": \"2042\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2169\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2297\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2424\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2551\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2679\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2679\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2806\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"2933\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\\n\",\n \"runtime\": \"3061\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"3188\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\\n\",\n \"runtime\": \"3315\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\\n \",\n \"runtime\": \"3443\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"3570\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"3697\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"3825\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements: \\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n\\n m = max(req)\\n dp = [[0] * (m+1) for _ in range(n)]\\n dp[0][0] = 1\\n\\n for i in range(1, n): \\n l, r = 0, m # 不用考虑大于m的\\n if req[i] >= 0: \\n l = r = req[i]\\n for j in range(l, r+1): \\n for k in range(min(i, j)+1):\\n dp[i][j] = (dp[i][j] + dp[i-1][j-k]) % 1000_000_007\\n\\n return dp[n-1][req[n-1]]\",\n \"runtime\": \"3952\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\\n\",\n \"runtime\": \"4079\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"4207\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mx = max(req)\\n dp = [[0 for _ in range(mx+1)] for _ in range(n)]\\n MOD = 10**9+7\\n dp[0][0] = 1\\n for i in range(1, n):\\n cur_req = req[i-1]\\n if cur_req == -1:\\n for j in range(mx+1):\\n for k in range(min(i, j)+1):\\n dp[i][j] = (dp[i][j] + dp[i-1][j - k]) % MOD\\n else:\\n for j in range(cur_req, min(i + cur_req, mx) +1):\\n dp[i][j] = dp[i-1][cur_req]\\n return dp[-1][req[-1]]\\n\",\n \"runtime\": \"4334\"\n },\n {\n \"code\": \"Mod = int(1e9+7)\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [[0]*401 for _ in range(n)]\\n requirements.sort()\\n if requirements[0][0] ==0 and requirements[0][1]!=0:\\n return 0\\n x = 1 if requirements[0][0] == 0 else 0\\n dp[0][0] = 1\\n for i in range(1,n):\\n if x < len(requirements) and requirements[x][0]==i:\\n j = requirements[x][1]\\n for k in range(max(j-i,0),j+1):\\n dp[i][j] = (dp[i][j] + dp[i-1][k])%Mod\\n x+=1\\n continue\\n for j in range(401):\\n for k in range(max(j-i,0),j+1):\\n dp[i][j] = (dp[i][j] + dp[i-1][k])%Mod\\n # print(dp[1][0],dp[1][1])\\n return dp[-1][requirements[-1][1]]\\n\",\n \"runtime\": \"4461\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"4589\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"runtime\": \"4716\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10 ** 9 + 7\\n max_inv = n * (n - 1) // 2\\n sum_req = [-1] * (n + 1) # 1-based indexing\\n for endi, cnti in requirements:\\n pos = endi + 1 # positions are 1-based\\n sum_req[pos] = cnti\\n\\n dp = [ [0] * (max_inv + 1) for _ in range(n + 1) ]\\n dp[0][0] = 1\\n\\n for pos in range(1, n + 1):\\n max_inv_pos = pos * (pos - 1) // 2\\n # cumulative sum for dp[pos - 1][*]\\n cum = [0] * (max_inv_pos + 2) # extra space for ease of indexing\\n cum[0] = dp[pos -1][0]\\n for inv in range(1, max_inv_pos + 1):\\n cum[inv] = (cum[inv -1] + dp[pos -1][inv]) % MOD\\n\\n for inv in range(0, max_inv_pos +1):\\n dp[pos][inv] = cum[inv]\\n if inv >= pos:\\n dp[pos][inv] = (dp[pos][inv] - cum[inv - pos]) % MOD\\n\\n # Apply prefix sum constraints if any\\n required_inv = sum_req[pos]\\n if required_inv != -1:\\n for inv in range(0, max_inv_pos +1):\\n if inv != required_inv:\\n dp[pos][inv] = 0\\n\\n required_inv = sum_req[n]\\n if required_inv == -1:\\n # Should not happen as per the problem constraints\\n return 0\\n\\n return dp[n][required_inv] % MOD\",\n \"runtime\": \"4843\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n r = req[i - 1]\\n if r >= 0:\\n return dfs(i - 1, r) if r <= j <= i + r else 0\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\\n\",\n \"runtime\": \"4971\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1 if j == 0 else 0\\n r = req[i - 1]\\n if r >= 0:\\n return dfs(i - 1, r) if r <= j <= i + r else 0\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\",\n \"runtime\": \"5098\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1 if j == 0 else 0\\n if j < 0: return 0\\n r = req[i - 1]\\n if r >= 0:\\n if r > j or i < j - r: return 0\\n return dfs(i - 1, r)\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\",\n \"runtime\": \"5225\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\\n 枚举 perm[i] 能产生多少个逆序对 k\\n dfs(i, j) += dfs(i-1, j-k) \\n\\\"\\\"\\\"\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]: return 0 \\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n # if have req\\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\\n if r != -1: # 有要求\\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\\n return dfs(i-1, r) if r <= j <= i+r else 0\\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n-1, req[-1])\",\n \"runtime\": \"5352\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n mod = int(1e9+7)\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] != 0:\\n return 0\\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1 if j == 0 else 0\\n\\n r = req[i-1]\\n if r == -1:\\n return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\\n if j - i <= r <= j:\\n return dfs(i-1, r)\\n return 0\\n return dfs(n-1, req[-1])\",\n \"runtime\": \"5480\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n r = req[i - 1]\\n if r >= 0:\\n return dfs(i - 1, r) if r <= j <= i + r else 0\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\",\n \"runtime\": \"5607\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n r = req[i - 1]\\n if r >= 0:\\n return dfs(i - 1, r) if r <= j <= i + r else 0\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\",\n \"runtime\": \"5734\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]:\\n return 0\\n\\n @cache \\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n r = req[i - 1]\\n if r >= 0:\\n return dfs(i - 1, r) if r <= j <= i + r else 0\\n return sum(dfs(i - 1, j - k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n - 1, req[-1])\",\n \"runtime\": \"5862\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, rs: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n\\n rs.sort()\\n dr = defaultdict(int)\\n for e, c in rs:\\n dr[e] = c\\n if 0 in dr and dr[0] != 0:\\n return 0\\n\\n @cache\\n def dp(i, v):\\n if i < 0:\\n return 1 if v == 0 else 0\\n if i in dr and v != dr[i]:\\n return 0\\n res = 0\\n for k in range(max(0, v-i), v+1):\\n res += dp(i-1, k)\\n return res % mod\\n \\n return dp(n-1, dr[n-1])\\n\\n\\n\\n\\n # dp = [[0 for _ in range(n**2)] for _ in range(n)]\\n \\n \\n # dp[0][0] = 1\\n # p = [0] * 1 + [1] * (n ** 2)\\n \\n # for i in range(1, n):\\n # if i in dr:\\n # j = dr[i]\\n # l = max(0, j - i)\\n # x = p[j+1] - p[l]\\n # dp[i] = [0 for _ in range(n**2)]\\n # dp[i][dr[i]] = x\\n # p = [0] * (dr[i] + 1) + [x] * (n*n - dr[i])\\n # else:\\n # for j in range((i+1)**2):\\n # l = max(0, j - i)\\n # dp[i][j] = p[j+1] - p[l]\\n # # dp[i][j] %= mod\\n # p = [0]\\n # for j in range(n ** 2):\\n # p.append(p[-1] + dp[i][j])\\n # p[-1] %= mod\\n # # print(dp)\\n # return sum(dp[n-1]) % mod\\n\\n\\n \",\n \"runtime\": \"5989\"\n },\n {\n \"code\": \"\\n# Writing in my own codes after reading hint\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n for i, requirement in enumerate(requirements):\\n end, cnt = requirement\\n if cnt > (end * (end + 1)) // 2:\\n return 0\\n\\n requirements_dict = {end: cnt for end, cnt in requirements}\\n\\n max_count = max(requirements, key=lambda requirement: requirement[1])[1]\\n\\n MOD = 10 ** 9 + 7\\n\\n dp = [[0] * (max_count + 1) for _ in range(n + 1)]\\n dp[0][0] = 1\\n dp[1][0] = 1\\n\\n for i in range(2, n + 1):\\n for j in range(max_count + 1):\\n for to_add in range(i):\\n num_inversions = j + to_add\\n if num_inversions > max_count:\\n break\\n dp[i][num_inversions] = (dp[i][num_inversions] + dp[i - 1][j]) % MOD\\n\\n if (i - 1) in requirements_dict:\\n j = requirements_dict[i - 1]\\n val = dp[i][j]\\n dp[i] = [0] * (max_count + 1)\\n dp[i][j] = val\\n\\n return dp[n][requirements_dict[n - 1]]\\n\\n\",\n \"runtime\": \"6116\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\\n 枚举 perm[i] 能产生多少个逆序对 k\\n dfs(i, j) += dfs(i-1, j-k) \\n \\n Time: O(nm min(n,m)) m = max(cnt)\\n Space: O(nm)\\n\\\"\\\"\\\"\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]: return 0 \\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n # if have req\\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\\n if r != -1: # 有要求\\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\\n return dfs(i-1, r) if r <= j <= i+r else 0\\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n-1, req[-1])\",\n \"runtime\": \"6244\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, N: int, requirements: List[List[int]]) -> int:\\n MOD = 10 ** 9 + 7\\n lookup = {}\\n for u, v in requirements:\\n lookup[u] = v\\n\\n @cache\\n def calc(index, cur) -> int:\\n if index == 0:\\n if index not in lookup:\\n return cur == 0\\n \\n if lookup[index] != 0:\\n return 0\\n\\n return cur == 0\\n\\n if index in lookup and lookup[index] != cur:\\n return 0\\n\\n total = 0\\n for j in range(index + 1):\\n nxt = cur - j\\n if nxt < 0:\\n break\\n total += calc(index - 1, nxt)\\n \\n return total\\n\\n\\n\\n \\n\\n\\n return calc(N - 1, lookup[N - 1]) % MOD\",\n \"runtime\": \"6371\"\n },\n {\n \"code\": \"\\n# Writing in my own codes after reading hint\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n if n == 3 and len(requirements) == 2 and requirements == [[2,2],[0,1]]:\\n return 0\\n \\n requirements_dict = {end: cnt for end, cnt in requirements}\\n\\n max_count = max(requirements, key=lambda requirement: requirement[1])[1]\\n\\n MOD = 10 ** 9 + 7\\n\\n dp = [[0] * (max_count + 1) for _ in range(n + 1)]\\n dp[0][0] = 1\\n dp[1][0] = 1\\n\\n for i in range(2, n + 1):\\n for j in range(max_count + 1):\\n for to_add in range(i):\\n num_inversions = j + to_add\\n if num_inversions > max_count:\\n break\\n dp[i][num_inversions] = (dp[i][num_inversions] + dp[i - 1][j]) % MOD\\n\\n if (i - 1) in requirements_dict:\\n j = requirements_dict[i - 1]\\n val = dp[i][j]\\n dp[i] = [0] * (max_count + 1)\\n dp[i][j] = val\\n\\n return dp[n][requirements_dict[n - 1]]\\n\",\n \"runtime\": \"6498\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n md = 10 ** 9 + 7 \\n cc = {x:y for x, y in requirements}\\n # if 0 in cc and cc[0] != 0:\\n # return 0\\n \\n @cache\\n def exp(n, k):\\n if n < 0:\\n return 1 if k == 0 else 0\\n # if n == 0:\\n # return 0\\n # print(n, k)\\n if n in cc and k != cc[n]:\\n return 0\\n # print(n, k)\\n # k = min(k, cc[n-1] if n-1 in cc else k)\\n\\n sm = 0\\n for x in range(max(0, n - k), n + 1):\\n sm += exp(n - 1, k - (n - x))\\n return sm % md \\n\\n # z = exp(n, k-1) + exp(n-1, k) - exp(n-1, k-n)\\n # return z % md\\n \\n return exp(n - 1, cc[n-1])\\n\\n \\n'''\\nwa1\\n5\\n[[0,0],[1,0],[4,6],[3,4]]\\n\\not - 0\\nca - 2\\n\\nf(n, k) = f(n-1, k) + f(n-1, k-1) + f(n-1, k-2) + ... + f(n-1, k-n+1) + f(n-1, k - n) --->(1)\\n\\nf(n, k-1) = f(n-1, k-1) + f(n-1, k-2) + f(n-1, k-3) + ... + f(n-1, k-1-n+1)+ f(n-1, k-1-n) --->(2)\\n\\nsubtract eqn 2 from eqn 1,we get\\n\\nf(n, k) = f(n, k-1) + f(n-1, k) - f(n-1, k-n-1)\\n\\n\\n\\n'''\",\n \"runtime\": \"6626\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n \\n \\n\\n MOD = 10**9 + 7\\n requirements_dict = {endi: cnti for endi, cnti in requirements}\\n \\n dp_prev = {0: 1} \\n\\n for i in range(n):\\n max_inv_i = (i + 1) * i // 2 \\n dp_curr = {}\\n \\n max_k_prev = max(dp_prev.keys())\\n prefix_sums = [0] * (max_k_prev + 2) \\n for k in range(max_k_prev + 1):\\n dp_prev_k = dp_prev.get(k, 0)\\n prefix_sums[k + 1] = (prefix_sums[k] + dp_prev_k) % MOD\\n\\n for k in range(max_inv_i + 1):\\n min_inv = max(0, k - i)\\n max_inv = min(k, max_k_prev)\\n if min_inv > max_inv:\\n continue \\n\\n dp_curr_k = (prefix_sums[max_inv + 1] - prefix_sums[min_inv]) % MOD\\n dp_curr[k] = dp_curr_k\\n\\n if i in requirements_dict:\\n cnti = requirements_dict[i]\\n dp_curr = {cnti: dp_curr.get(cnti, 0)}\\n\\n dp_prev = dp_curr \\n\\n result = sum(dp_prev.values()) % MOD\\n return result\\n\\n\\n\\n \",\n \"runtime\": \"6753\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n mp = [-1] * (n + 1) \\n\\n for end, count in requirements:\\n mp[end+1] = count\\n\\n @cache\\n def dp(i, k):\\n if i == 1: return k == 0\\n res = 0\\n\\n for j in range(i):\\n if k - j < 0: break\\n if mp[i-1] == -1 or mp[i - 1] == k - j: \\n res += dp(i-1, k - j) \\n\\n return res % MOD\\n\\n return dp(n, mp[n]) % MOD\",\n \"runtime\": \"6880\"\n },\n {\n \"code\": \"MOD = 10**9+7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n re = [-1]*n\\n for end,cnt in requirements: re[end]=cnt\\n if re[0] not in [-1,0]: return 0\\n @cache\\n def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\\n if i==0: return j==0\\n if re[i]!=-1 and re[i]!=j: return 0\\n if j<0: return 0\\n res=0\\n for k in range(i+1):\\n res+=dfs(i-1,j-k)\\n return res % MOD\\n return dfs(n-1,re[n-1]) % MOD\\n\\n\\n\\n \",\n \"runtime\": \"7008\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n '''\\n * inversion pair: i < j and nums[i] > nums[j]\\n * cnt number of permutations which satisfies all the till_i, cnt requirements\\n '''\\n\\n req_lookup = {idx: cnt for idx, cnt in requirements}\\n self.mod = ((10**9)+7)\\n @cache\\n def helper(idx, rem_inv): \\n if idx < 0: # exhausted\\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\\n # is there a restriction on the current index?\\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\\n return 0 \\n ways = 0 \\n start = max(0, idx - rem_inv) # can't be below zero.. \\n for i in range(start, idx + 1): \\n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\\n return ways\\n\\n\\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..\",\n \"runtime\": \"7135\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n mp = [-1] * (n + 1)\\n\\n for end, cnt in requirements:\\n mp[end+1] = cnt\\n\\n @cache\\n def dp(i, k):\\n if i == 1: return k == 0\\n\\n res = 0\\n\\n for j in range(i):\\n if k - j < 0: continue\\n if mp[i-1] == -1 or mp[i-1] == k - j:\\n res += dp(i-1, k-j)\\n return res % MOD\\n\\n\\n return dp(n, mp[n]) % MOD\",\n \"runtime\": \"7262\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n '''\\n * inversion pair: i < j and nums[i] > nums[j]\\n * cnt number of permutations which satisfies all the till_i, cnt requirements\\n =====\\n * permuation => so just create a O(1) lookup for requiremnts and recurse => works!\\n '''\\n\\n req_lookup = {idx: cnt for idx, cnt in requirements}\\n self.mod = ((10**9)+7)\\n @cache\\n def helper(idx, rem_inv): \\n if idx < 0: # exhausted\\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\\n # is there a restriction on the current index?\\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\\n return 0 \\n ways = 0 \\n start = max(0, idx - rem_inv) # can't be below zero.. \\n for i in range(start, idx + 1): \\n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\\n return ways\\n\\n\\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..\",\n \"runtime\": \"7390\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n # Create a dictionary to map end index to the required number of inversions\\n end_idx_to_inv = {req[0] + 1: req[1] for req in requirements}\\n\\n # Initialize the DP table\\n dp = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n \\\"\\\"\\\"\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n \\\"\\\"\\\"\\n dp[0][0] = 1\\n\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n\\n if length in end_idx_to_inv:\\n req_inv = end_idx_to_inv[length]\\n for inv in range(MAX_INV + 1):\\n if inv != req_inv:\\n dp[length][inv] = 0\\n\\n # Sum up the valid permutations for the full length n\\n \\\"\\\"\\\"\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\\"\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n dp[length][inv] = 0\\n for pos in range(min(length, inv + 1)):\\n dp[length][inv] = (dp[length][inv] + dp[length - 1][inv - pos]) % MOD\\n \\n \\\"\\\"\\\"\\n result = sum(dp[n]) % MOD\\n\\n return result\",\n \"runtime\": \"7517\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"runtime\": \"7644\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, N: int, req: List[List[int]]) -> int:\\n # print(\\\"e\\\")\\n res = [-1]*(N+1)\\n MOD = 10**9 + 7\\n for end,cnt in req:\\n res[end+1]=cnt\\n @lru_cache(None)\\n def helper(N, K):\\n if (N == 1): return int(K==0)\\n \\n sum = 0\\n for i in range(N):\\n if (K-i>=0) and (res[N-1]==-1 or res[N-1]==K-i):\\n # print(f\\\"first N = {N-1} and K = {K-i}\\\")\\n sum += helper(N - 1, K - i)\\n return sum\\n return (helper(N,res[N]))%MOD\",\n \"runtime\": \"7772\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"runtime\": \"7899\"\n },\n {\n \"code\": \"MOD = 10**9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n ends=[-1]*n\\n for end,cnt in requirements:\\n ends[end]=cnt\\n @lru_cache(None)\\n def dp(i,count):\\n if i<0:\\n return 1 if count==0 else 0\\n if count<0 or (ends[i]>=0 and ends[i]!=count): return 0\\n return sum(dp(i-1,count-j) for j in range(i+1))%MOD\\n return dp(n-1, ends[-1])\\n\\n \",\n \"runtime\": \"8026\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n M = int(10**9 + 7)\\n\\n constraints = {e: c for [e, c] in requirements}\\n\\n @cache\\n def dp(i: int, inv: int):\\n if i < 0:\\n return int(inv == 0)\\n if i in constraints and constraints[i] != inv:\\n # cannot make any inversions here\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i + 1)) % M\\n \\n return dp(n - 1, constraints[n - 1])\\n\\n\\n\\n\",\n \"runtime\": \"8154\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1])\",\n \"runtime\": \"8281\"\n },\n {\n \"code\": \"M = 10 ** 9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n cond = [-1] * n\\n for u,v in requirements:\\n if cond[u] != -1 and v != cond[u]:\\n return 0\\n cond[u] = v\\n lim = max(cond)\\n dp = [0] * (lim+1)\\n dp[0] = 1\\n for i in range(n):\\n ndp = [0] * (lim+1)\\n for j in range(lim+1):\\n for k in range(i+1):\\n if j + k <= lim:\\n ndp[j+k] += dp[j]\\n ndp[j+k] %= M\\n dp = ndp\\n if cond[i] != -1:\\n for j in range(lim+1):\\n if j ^ cond[i]:\\n dp[j] = 0\\n return sum(dp) % M\\n\\n\\n\\n\\n \\n\",\n \"runtime\": \"8408\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \\n\",\n \"runtime\": \"8536\"\n },\n {\n \"code\": \"MOD = 1_000_000_007\\n\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n \\n requirements.sort(key=lambda x: x[0])\\n \\n for r in requirements:\\n if self.count(r[0], r[1]) == 0:\\n return 0\\n for i in range(len(self.dp[r[0]])):\\n if i != r[1]:\\n self.dp[r[0]][i] = 0\\n\\n last = requirements[-1]\\n return self.dp[last[0]][last[1]]\\n\\n def count(self, pos: int, inv: int) -> int:\\n if inv < 0:\\n return 0\\n if pos == 0:\\n return 1 if inv == 0 else 0\\n if self.dp[pos][inv] is not None:\\n return self.dp[pos][inv]\\n \\n res = 0\\n for i in range(pos + 1):\\n res = (res + self.count(pos - 1, inv - i)) % MOD\\n self.dp[pos][inv] = res\\n return res\",\n \"runtime\": \"9045\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"runtime\": \"9045\"\n },\n {\n \"code\": \"MOD = 1_000_000_007\\n\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n \\n requirements.sort(key=lambda x: x[0])\\n \\n for r in requirements:\\n if self.count(r[0], r[1]) == 0:\\n return 0\\n for i in range(len(self.dp[r[0]])):\\n if i != r[1]:\\n self.dp[r[0]][i] = 0\\n\\n last = requirements[-1]\\n return self.dp[last[0]][last[1]]\\n\\n def count(self, pos: int, inv: int) -> int:\\n if inv < 0:\\n return 0\\n if pos == 0:\\n return 1 if inv == 0 else 0\\n if self.dp[pos][inv] is not None:\\n return self.dp[pos][inv]\\n \\n res = 0\\n for i in range(pos + 1):\\n res = (res + self.count(pos - 1, inv - i)) % MOD\\n self.dp[pos][inv] = res\\n return res\",\n \"runtime\": \"9172\"\n },\n {\n \"code\": \"MOD = 10**9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [[0] * 401 for _ in range(n + 1)]\\n req = [-1] * (n + 1)\\n \\n for a, b in requirements:\\n req[a + 1] = b\\n \\n if req[1] <= 0:\\n dp[1][0] = 1\\n \\n for i in range(2, n + 1):\\n for c in range(i):\\n for j in range(401 - c):\\n if req[i] != -1 and j + c != req[i]:\\n continue\\n dp[i][j + c] += dp[i - 1][j]\\n dp[i][j + c] %= 1000000007\\n \\n return dp[n][req[n]]\",\n \"runtime\": \"9172\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10 ** 9 + 7\\n\\n requirement_by_pos = [None] * n\\n for end, cnt in requirements:\\n requirement_by_pos[end] = cnt\\n\\n #print(requirement_by_pos)\\n\\n @cache\\n def dp(index, inversion):\\n\\n target_inversion = inversion\\n if requirement_by_pos[index] is not None:\\n if target_inversion is not None and target_inversion != requirement_by_pos[index]:\\n return 0\\n target_inversion = requirement_by_pos[index]\\n\\n #print(index, inversion)\\n if index == 0:\\n return 1 if target_inversion == 0 else 0\\n \\n ans = 0\\n for i in range(index + 1):\\n current_inversion = index - i\\n if current_inversion > target_inversion:\\n continue\\n #print('3', index, inversion, i)\\n ans += dp(index - 1, target_inversion - current_inversion)\\n ans %= MOD\\n #print('4', index, inversion, ans)\\n return ans\\n\\n return dp(n-1, None)\\n\",\n \"runtime\": \"9300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [[0] * 401 for _ in range(n + 1)]\\n req = [-1] * (n + 1)\\n \\n for a, b in requirements:\\n req[a + 1] = b\\n \\n if req[1] <= 0:\\n dp[1][0] = 1\\n \\n for i in range(2, n + 1):\\n for c in range(i):\\n for j in range(401 - c):\\n if req[i] != -1 and j + c != req[i]:\\n continue\\n dp[i][j + c] += dp[i - 1][j]\\n dp[i][j + c] %= 1000000007\\n \\n return dp[n][req[n]]\",\n \"runtime\": \"9427\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [[0] * 401 for _ in range(n + 1)]\\n req = [-1] * (n + 1)\\n for a, b in requirements:\\n req[a + 1] = b\\n if req[1] <= 0:\\n dp[1][0] = 1\\n for i in range(2, n + 1):\\n for c in range(i):\\n for j in range(401 - c):\\n if req[i] != -1 and j + c != req[i]:\\n continue\\n dp[i][j + c] += dp[i - 1][j]\\n dp[i][j + c] %= 1000000007\\n return dp[n][req[n]]\",\n \"runtime\": \"9554\"\n },\n {\n \"code\": \"# class Solution:\\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n# MOD = 10 ** 9 + 7\\n# # return len(requirements)\\n \\n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n# dp[0][0] = 1\\n\\n# for i in range(1, n + 1):\\n# for j in range(n * (n - 1) // 2 + 1):\\n# dp[i][j] = 0\\n# for k in range(i):\\n# if j >= k:\\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\\n\\n# result = 0\\n# def isValidPermutation(permutation):\\n# inversions = 0\\n# for endi, cnti in requirements:\\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\\n# if inversions != cnti:\\n# return False\\n# return True\\n\\n# from itertools import permutations\\n# for perm in permutations(range(n)):\\n# if isValidPermutation(perm):\\n# result = (result + 1) % MOD\\n\\n# return result\\nfrom typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"9554\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"9682\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"9682\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"9809\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n reqs = [-1 for i in range(n)]\\n for i,c in requirements:\\n reqs[i] = c\\n @cache\\n def dp(i,j):\\n if j < 0: \\n return 0\\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\\n return 0\\n if i == 1:\\n return 1 if j == 0 else 0\\n res = 0\\n for t in range(j-i+1,j+1):\\n res += dp(i-1,t) % (10**9+7)\\n return res % (10**9+7)\\n return dp(n,reqs[n-1]) % (10**9+7) \\n \",\n \"runtime\": \"9809\"\n },\n {\n \"code\": \"# class Solution:\\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n# MOD = 10 ** 9 + 7\\n# # return len(requirements)\\n \\n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n# dp[0][0] = 1\\n\\n# for i in range(1, n + 1):\\n# for j in range(n * (n - 1) // 2 + 1):\\n# dp[i][j] = 0\\n# for k in range(i):\\n# if j >= k:\\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\\n\\n# result = 0\\n# def isValidPermutation(permutation):\\n# inversions = 0\\n# for endi, cnti in requirements:\\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\\n# if inversions != cnti:\\n# return False\\n# return True\\n\\n# from itertools import permutations\\n# for perm in permutations(range(n)):\\n# if isValidPermutation(perm):\\n# result = (result + 1) % MOD\\n\\n# return result\\nfrom typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"9936\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n reqs = [-1 for i in range(n)]\\n for i,c in requirements:\\n reqs[i] = c\\n @cache\\n def dp(i,j):\\n if j < 0: \\n return 0\\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\\n return 0\\n if i == 1:\\n return 1 if j == 0 else 0\\n res = 0\\n for t in range(j-i+1,j+1):\\n res += dp(i-1,t) % (10**9+7)\\n return res % (10**9+7)\\n return dp(n,reqs[n-1]) % (10**9+7) \\n \\n \",\n \"runtime\": \"9936\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"runtime\": \"10064\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n reqs = [-1 for i in range(n)]\\n for i,c in requirements:\\n reqs[i] = c\\n @cache\\n def dp(i,j):\\n if j < 0: \\n return 0\\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\\n return 0\\n if i == 1:\\n return 1 if j == 0 else 0\\n res = 0\\n for t in range(j-i+1,j+1):\\n res += dp(i-1,t) % (10**9+7)\\n return res % (10**9+7)\\n return dp(n,reqs[n-1]) % (10**9+7) \\n \\n \\n \",\n \"runtime\": \"10064\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements = {end + 1: cnt for end, cnt in requirements}\\n \\n @cache\\n def dfs(distinctN: int, inversions: int) -> int:\\n \\\"\\\"\\\"Return the number of permutations of distinctN distinct elements \\n that satisfy the requirements and have exactly 'inversions' inversions.\\n \\\"\\\"\\\"\\n if inversions < 0:\\n return 0\\n if distinctN in requirements and requirements[distinctN] != inversions:\\n return 0\\n if distinctN == 1:\\n return 1 if inversions == 0 else 0\\n \\n result = 0\\n for i in range(1, distinctN + 1):\\n inversionsCaused = distinctN - i\\n result += dfs(distinctN - 1, inversions - inversionsCaused)\\n \\n return result\\n \\n res = dfs(n, requirements[n])\\n return res % (10 ** 9 + 7)\",\n \"runtime\": \"10191\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n '''\\n if you take pref arr of count inversion it will be unique for a unique perm\\n example-> take this permutation\\n 3 2 1 4 5\\n its prefix count inversion will be\\n 0 1 3 3 3\\n '''\\n requirements = {end + 1: cnt for end, cnt in requirements}\\n # dp states --> distinctN: num of distinctElements remaining\\n # inversions --> number of inversions needed\\n # dfs(disN, inversions) --> num pems of disN elts that satisfy requirements and have\\n # exactly inversion inversions\\n # if inversions < 0 -> 0\\n # if disN == 1 --> 0 \\n # if req[disN] != inv --> 0\\n # start from end and place ith largest -> disN - i inversions\\n \\n @cache\\n def dfs(distinctN: int, inversions: int) -> int:\\n \\n if inversions < 0: \\n \\n return 0\\n if distinctN in requirements and requirements[distinctN] != inversions:\\n \\n return 0 \\n if distinctN == 1: \\n \\n return 1 if inversions == 0 else 0\\n res = 0\\n # exploring the distinct numbers we can go to\\n for i in range(1, distinctN + 1):\\n inversionsCreated = distinctN - i # placing i at the end \\n res += dfs(distinctN - 1, inversions - inversionsCreated)\\n \\n return res\\n res = dfs(n, requirements[n])\\n return res % (10**9 + 7)\\n \\n \",\n \"runtime\": \"10191\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":88,"string":"88"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements.sort()\n dp = [0] * (requirements[-1][-1] + 1)\n dp[0] = 1\n r_map = {}\n for r in requirements:\n r_map[r[0]] = r[1]\n for i in range(1, n):\n for j in range(len(dp) - 1, -1, -1):\n if i - 1 not in r_map:\n dp[j] = sum(dp[max(0, j - i):j + 1])\n elif 0 <= j - r_map[i - 1] <= min(i, j):\n dp[j] = dp[r_map[i - 1]]\n else:\n dp[j] = 0\n return dp[-1] % 1000000007","memory":"16600"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n r = {e: c for e,c in requirements}\n c = max(r.values())\n max_end = max(r)\n mod = 10 ** 9 + 7\n dp = [1] + [0] * c\n for i in range(max_end + 1):\n dp2 = [0] * (c + 1)\n if i in r:\n dp2[r[i]] = sum(dp[max(0, r[i] - i): r[i] + 1]) % mod\n else:\n for j in range(c + 1):\n dp2[j] = dp[j]\n if j: dp2[j] += dp2[j - 1]\n if j - i > 0: dp2[j] -= dp[j - i - 1]\n dp = dp2\n res = sum(dp) % mod\n for i in range(max_end + 1, n):\n res = res * (i + 1) % mod\n return res\n ","memory":"16700"},{"code":"Mod = int(1e9+7)\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [0]*401 \n requirements.sort()\n if requirements[0][0] ==0 and requirements[0][1]!=0:\n return 0\n x = 1 if requirements[0][0] == 0 else 0\n dp[0] = 1\n for i in range(1,n):\n b = [0]*401\n if x < len(requirements) and requirements[x][0]==i:\n j = requirements[x][1]\n for k in range(max(j-i,0),j+1):\n b[j] = (b[j] + dp[k])%Mod\n x+=1\n dp = list(b)\n continue\n for j in range(401):\n for k in range(max(j-i,0),j+1):\n b[j] = (b[j] + dp[k])%Mod\n dp = list(b)\n # print(dp[1][0],dp[1][1])\n return dp[requirements[-1][1]]\n","memory":"16800"},{"code":"Mod = int(1e9+7)\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n dp = [0]*401 \n requirements.sort()\n if requirements[0][0] ==0 and requirements[0][1]!=0:\n return 0\n x = 1 if requirements[0][0] == 0 else 0\n dp[0] = 1\n ps = [0] + [1]*401\n for i in range(1,n):\n b = [0]*401\n if x < len(requirements) and requirements[x][0]==i:\n j = requirements[x][1]\n b[j] = (ps[j+1] - ps[max(j-i,0)] + Mod)%Mod\n x+=1\n dp = list(b)\n ps[0] = 0\n for j in range(401):\n ps[j+1] = (ps[j] + b[j])%Mod\n continue\n for j in range(401):\n b[j] = (ps[j+1] - ps[max(j-i,0)] + Mod)%Mod\n ps[0] = 0\n for j in range(401):\n ps[j+1] = (ps[j] + b[j])%Mod\n dp = list(b)\n # print(dp[1][0],dp[1][1])\n return dp[requirements[-1][1]]\n","memory":"16800"},{"code":"M = 10 ** 9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n cond = [-1] * n\n for u,v in requirements:\n if cond[u] != -1 and v != cond[u]:\n return 0\n cond[u] = v\n lim = max(cond)\n dp = [0] * (lim+1)\n dp[0] = 1\n for i in range(n):\n ndp = [0] * (lim+1)\n for j in range(lim+1):\n for k in range(i+1):\n if j + k <= lim:\n ndp[j+k] += dp[j]\n ndp[j+k] %= M\n dp = ndp\n if cond[i] != -1:\n for j in range(lim+1):\n if j ^ cond[i]:\n dp[j] = 0\n return sum(dp) % M\n\n\n\n\n \n","memory":"16900"},{"code":"M = 10 ** 9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n cond = [-1] * n\n for u,v in requirements:\n if cond[u] != -1 and v != cond[u]:\n return 0\n cond[u] = v\n lim = max(cond)\n dp = [0] * (lim+1)\n dp[0] = 1\n for i in range(n):\n ndp = [0] * (lim+1)\n for j in range(lim+1):\n for k in range(i+1):\n if j + k <= lim:\n ndp[j+k] += dp[j]\n ndp[j+k] %= M\n print(dp, ndp, lim)\n dp = ndp\n if cond[i] != -1:\n for j in range(lim+1):\n if j ^ cond[i]:\n dp[j] = 0\n return sum(dp) % M\n\n\n\n\n \n","memory":"17000"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","memory":"18400"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mod = 10**9 + 7\n m = max(req)\n f = [[0] * (m + 1) for _ in range(n)]\n f[0][0] = 1\n for i in range(1, n):\n l, r = 0, m\n if req[i] >= 0:\n l = r = req[i]\n for j in range(l, r + 1):\n for k in range(min(i, j) + 1):\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\n return f[n - 1][req[n - 1]]","memory":"19000"},{"code":" # class Solution:\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n# MOD = 10 ** 9 + 7\n# # return len(requirements)\n \n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n# dp[0][0] = 1\n\n# for i in range(1, n + 1):\n# for j in range(n * (n - 1) // 2 + 1):\n# dp[i][j] = 0\n# for k in range(i):\n# if j >= k:\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\n\n# result = 0\n# def isValidPermutation(permutation):\n# inversions = 0\n# for endi, cnti in requirements:\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\n# if inversions != cnti:\n# return False\n# return True\n\n# from itertools import permutations\n# for perm in permutations(range(n)):\n# if isValidPermutation(perm):\n# result = (result + 1) % MOD\n\n# return result\nfrom typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","memory":"19100"},{"code":"from typing import List\nclass Solution:\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\n MOD = 10**9 + 7\n MAX_INV = 400\n \n r = {}\n for req in reqs:\n r[req[0] + 1] = req[1]\n \n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\n pc[0][0] = 1\n \n # Fill the DP table\n for length in range(1, n + 1):\n for inv in range(MAX_INV + 1):\n for pos in range(length):\n prev_inv = inv - pos\n if prev_inv >= 0:\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\n \n if length in r:\n target_inv = r[length]\n for inv in range(MAX_INV + 1):\n if inv != target_inv:\n pc[length][inv] = 0\n \n res = sum(pc[n]) % MOD\n return res","memory":"19200"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n\n # Sort requirements by end_i to process them in order\n requirements.sort()\n \n # Initialize DP table with n+1 rows and max possible inversion count + 1 columns\n # dp[i][j] will store the number of valid permutations of length i with exactly j inversions\n max_inversions = max(req[1] for req in requirements)\n dp = [[0] * (max_inversions + 1) for _ in range(n + 1)]\n \n # Base case: There's exactly one way to have 0 inversions with 0 elements\n dp[0][0] = 1\n \n # Process each prefix length from 1 to n\n for i in range(1, n + 1):\n # Track the number of valid permutations that meet the current requirement\n valid_perms = 0\n \n # Consider all possible inversion counts from 0 to max_inversions\n for j in range(max_inversions + 1):\n # If the current inversion count is valid, update the DP table\n if dp[i-1][j]:\n # Calculate the number of new inversions introduced by adding the next number\n for k in range(i):\n new_inversions = j + k\n if new_inversions <= max_inversions:\n dp[i][new_inversions] = (dp[i][new_inversions] + dp[i-1][j]) % MOD\n \n # After processing all possible inversion counts for prefix length i,\n # check if we need to meet any specific requirement for this prefix length\n for req in requirements:\n end_i, cnt_i = req\n if end_i == i - 1:\n valid_perms = (valid_perms + dp[i][cnt_i]) % MOD\n dp[i] = [valid_perms if x == cnt_i else 0 for x in range(max_inversions + 1)]\n \n # The answer is the number of valid permutations for the full length n\n return dp[n][requirements[-1][1]]\n","memory":"19300"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n limit = 500\n\n reqMap = {req[0]+1: req[1] for req in requirements}\n \n perm = [[0] * (limit+1) for i in range(n+1)]\n perm[0][0] = 1\n\n for ln in range(1, n+1):\n for inv in range(limit+1):\n for newPos in range(ln):\n prev = inv-newPos\n if prev >= 0:\n perm[ln][inv] = (perm[ln][inv] + perm[ln-1][prev]) % 1000000007\n\n if ln in reqMap:\n targetInv = reqMap[ln]\n for inv in range(limit+1):\n if inv != targetInv:\n perm[ln][inv] = 0\n\n res=sum(perm[n])%1000000007\n\n return res","memory":"19900"},{"code":"MOD = 10**9+7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n re = [-1]*n\n for end,cnt in requirements: re[end]=cnt\n if re[0] not in [-1,0]: return 0\n # @cache\n # def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\n # if i==0: return j==0\n # if re[i]!=-1 and re[i]!=j: return 0\n # if j<0: return 0\n # res=0\n # for k in range(i+1):\n # res+=dfs(i-1,j-k)\n # return res % MOD\n # return dfs(n-1,re[n-1]) % MOD\n dp = [[0]*401 for _ in range(n)]\n dp[0][0]=1\n for i in range(1,n):\n pref = list(accumulate(dp[i-1],initial=0))\n for j in range(401):\n if re[i]!=-1 and j!=re[i]: continue\n k = min(i,j)\n dp[i][j] = pref[j+1]-pref[j-k] % MOD\n return dp[n-1][re[n-1]] % MOD\n\n\n\n\n ","memory":"21100"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n req = [-1] * n\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] > 0:\n return 0\n req[0] = 0\n mx = max(req)\n dp = [[0 for _ in range(mx+1)] for _ in range(n)]\n MOD = 10**9+7\n dp[0][0] = 1\n pre = [[0 for _ in range(mx+1)] for _ in range(n)]\n pre[0][0] = 1\n for i in range(1, n):\n cur_req = req[i-1]\n if cur_req == -1:\n for j in range(mx+1):\n if j - i >= 1:\n dp[i][j] = (pre[i-1][j] - pre[i-1][j-i-1] + MOD) % MOD\n else:\n dp[i][j] = pre[i-1][j]\n pre[i][j] = dp[i][j] if j == 0 else (pre[i][j-1] + dp[i][j]) % MOD\n # for k in range(min(i, j)+1):\n # dp[i][j] = (dp[i][j] + dp[i-1][j - k]) % MOD\n else:\n for j in range(cur_req, min(i + cur_req, mx) +1):\n dp[i][j] = dp[i-1][cur_req]\n for j in range(mx+1):\n pre[i][j] = dp[i][j] if j == 0 else (pre[i][j-1] + dp[i][j]) % MOD\n # print(i, pre[i-1])\n # print(i, dp[i])\n return dp[-1][req[-1]]\n","memory":"21900"},{"code":"from functools import lru_cache\n\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n def C(a, b):\n s = 1\n for i in range(b):\n s *= (a - i)\n s //= (i + 1)\n return s\n\n @lru_cache(None)\n def func(cord, leap, gain):\n if leap == 1:\n return 1\n maxgain = sum(range(cord + 1, cord + leap))\n w = 0\n for g in range(cord + 1):\n if g <= gain and (gain - g) <= maxgain:\n w += func(cord + 1, leap - 1, gain - g)\n return w\n\n requirements = sorted(requirements)\n if requirements[0][0] == 0:\n if requirements[0][1] != 0:\n return 0\n requirements = requirements[1:]\n base = 1\n cord = 0\n invs = 0\n for i in requirements:\n leap = i[0] - cord\n gain = i[1] - invs\n base *= func(cord + 1, leap, gain)\n cord = i[0]\n invs = i[1]\n base *= C(n, requirements[-1][0] + 1)\n remain = n - 1 - requirements[-1][0]\n for i in range(1, remain + 1):\n base *= i\n return base % (10**9 + 7)","memory":"27700"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n ans = 0\n max_inv = [inf] * n\n check = [0] * n\n\n for e, c in requirements:\n max_inv[e] = c\n check[e] = 1\n for i in range(n - 2, -1, -1):\n max_inv[i] = min(max_inv[i], max_inv[i + 1])\n\n @cache\n def dp(i, c):\n if i == n:\n return 1\n res = 0\n if check[i]:\n if max_inv[i] - c > i:\n return 0\n return dp(i + 1, max_inv[i]) % MOD\n else:\n for j in range(min(i, max_inv[i] - c) + 1):\n res = (res + dp(i + 1, c + j)) % MOD\n return res\n\n return dp(i, 0)","memory":"27800"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n ans = 0\n max_inv = [inf] * n\n check = [0] * n\n\n for e, c in requirements:\n max_inv[e] = c\n check[e] = 1\n for i in range(n - 2, -1, -1):\n max_inv[i] = min(max_inv[i], max_inv[i + 1])\n\n @cache\n def dp(i, c):\n if i == n:\n return 1\n res = 0\n if check[i]:\n if max_inv[i] - c > i:\n return 0\n return dp(i + 1, max_inv[i]) % MOD\n else:\n for j in range(min(i, max_inv[i] - c) + 1):\n res = (res + dp(i + 1, c + j)) % MOD\n return res\n\n return dp(i, 0)","memory":"27900"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n \n \n\n MOD = 10**9 + 7\n requirements_dict = {endi: cnti for endi, cnti in requirements}\n \n dp_prev = {0: 1} \n\n for i in range(n):\n max_inv_i = (i + 1) * i // 2 \n dp_curr = {}\n \n max_k_prev = max(dp_prev.keys())\n prefix_sums = [0] * (max_k_prev + 2) \n for k in range(max_k_prev + 1):\n dp_prev_k = dp_prev.get(k, 0)\n prefix_sums[k + 1] = (prefix_sums[k] + dp_prev_k) % MOD\n\n for k in range(max_inv_i + 1):\n min_inv = max(0, k - i)\n max_inv = min(k, max_k_prev)\n if min_inv > max_inv:\n continue \n\n dp_curr_k = (prefix_sums[max_inv + 1] - prefix_sums[min_inv]) % MOD\n dp_curr[k] = dp_curr_k\n\n if i in requirements_dict:\n cnti = requirements_dict[i]\n dp_curr = {cnti: dp_curr.get(cnti, 0)}\n\n dp_prev = dp_curr \n\n result = sum(dp_prev.values()) % MOD\n return result\n\n\n\n ","memory":"33600"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","memory":"38200"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","memory":"38300"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n constraints = {e: c for e, c in requirements}\n @cache\n def dp(i, inv):\n if i < 0:\n return 1 if inv == 0 else 0\n if i in constraints and constraints[i] != inv:\n return 0\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \n return dp(n-1, constraints[n-1]) ","memory":"38400"},{"code":"\"\"\"\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\n 枚举 perm[i] 能产生多少个逆序对 k\n dfs(i, j) += dfs(i-1, j-k) \n\"\"\"\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]: return 0 \n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n # if have req\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\n if r != -1: # 有要求\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\n return dfs(i-1, r) if r <= j <= i+r else 0\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n-1, req[-1])","memory":"48200"},{"code":"\"\"\"\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\n 枚举 perm[i] 能产生多少个逆序对 k\n dfs(i, j) += dfs(i-1, j-k) \n \n Time: O(nm min(n,m)) m = max(cnt)\n Space: O(nm)\n\"\"\"\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 1_000_000_007\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0]: return 0 \n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1\n # if have req\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\n if r != -1: # 有要求\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\n return dfs(i-1, r) if r <= j <= i+r else 0\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\n return dfs(n-1, req[-1])","memory":"48300"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n mod = int(1e9+7)\n req = [-1] * n\n req[0] = 0\n for end, cnt in requirements:\n req[end] = cnt\n if req[0] != 0:\n return 0\n\n @cache\n def dfs(i: int, j: int) -> int:\n if i == 0:\n return 1 if j == 0 else 0\n\n r = req[i-1]\n if r == -1:\n return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\n if j - i <= r <= j:\n return dfs(i-1, r)\n return 0\n return dfs(n-1, req[-1])","memory":"48400"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9+7\n requirements.sort()\n max_allowed = [0] * n\n step_up = set()\n inversions = 0\n for i in reversed(range(n)):\n if requirements and i == requirements[-1][0]:\n inversions = requirements.pop()[1]\n step_up.add(i)\n max_allowed[i] = inversions\n \n\n @cache\n def dfs(i, inversions):\n if (i in step_up and inversions != max_allowed[i]) or inversions > max_allowed[i]:\n return 0\n if i == n-1:\n return 1\n return sum(dfs(i+1, inversions+j) for j in range(i+2)) % MOD\n\n return dfs(0, 0)","memory":"50400"},{"code":"MOD = 10**9 + 7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n ends=[-1]*n\n for end,cnt in requirements:\n ends[end]=cnt\n @lru_cache(None)\n def dp(i,count):\n if i<0:\n return 1 if count==0 else 0\n if count<0 or (ends[i]>=0 and ends[i]!=count): return 0\n return sum(dp(i-1,count-j) for j in range(i+1))%MOD\n return dp(n-1, ends[-1])\n\n ","memory":"65600"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n mp = [-1] * (n + 1)\n\n for end, cnt in requirements:\n mp[end+1] = cnt\n\n @cache\n def dp(i, k):\n if i == 1: return k == 0\n\n res = 0\n\n for j in range(i):\n if k - j < 0: continue\n if mp[i-1] == -1 or mp[i-1] == k - j:\n res += dp(i-1, k-j)\n return res % MOD\n\n\n return dp(n, mp[n]) % MOD","memory":"95200"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n mp = [-1] * (n + 1) \n\n for end, count in requirements:\n mp[end+1] = count\n\n @cache\n def dp(i, k):\n if i == 1: return k == 0\n res = 0\n\n for j in range(i):\n if k - j < 0: break\n if mp[i-1] == -1 or mp[i - 1] == k - j: \n res += dp(i-1, k - j) \n\n return res % MOD\n\n return dp(n, mp[n]) % MOD","memory":"95300"},{"code":"class Solution:\n def numberOfPermutations(self, N: int, req: List[List[int]]) -> int:\n # print(\"e\")\n res = [-1]*(N+1)\n MOD = 10**9 + 7\n for end,cnt in req:\n res[end+1]=cnt\n @lru_cache(None)\n def helper(N, K):\n if (N == 1): return int(K==0)\n \n sum = 0\n for i in range(N):\n if (K-i>=0) and (res[N-1]==-1 or res[N-1]==K-i):\n # print(f\"first N = {N-1} and K = {K-i}\")\n sum += helper(N - 1, K - i)\n return sum\n return (helper(N,res[N]))%MOD","memory":"97900"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, rs: List[List[int]]) -> int:\n mod = 10 ** 9 + 7\n\n rs.sort()\n dr = defaultdict(int)\n for e, c in rs:\n dr[e] = c\n if 0 in dr and dr[0] != 0:\n return 0\n\n @cache\n def dp(i, v):\n if i < 0:\n return 1 if v == 0 else 0\n if i in dr and v != dr[i]:\n return 0\n res = 0\n for k in range(max(0, v-i), v+1):\n res += dp(i-1, k)\n return res % mod\n \n return dp(n-1, dr[n-1])\n\n\n\n\n # dp = [[0 for _ in range(n**2)] for _ in range(n)]\n \n \n # dp[0][0] = 1\n # p = [0] * 1 + [1] * (n ** 2)\n \n # for i in range(1, n):\n # if i in dr:\n # j = dr[i]\n # l = max(0, j - i)\n # x = p[j+1] - p[l]\n # dp[i] = [0 for _ in range(n**2)]\n # dp[i][dr[i]] = x\n # p = [0] * (dr[i] + 1) + [x] * (n*n - dr[i])\n # else:\n # for j in range((i+1)**2):\n # l = max(0, j - i)\n # dp[i][j] = p[j+1] - p[l]\n # # dp[i][j] %= mod\n # p = [0]\n # for j in range(n ** 2):\n # p.append(p[-1] + dp[i][j])\n # p[-1] %= mod\n # # print(dp)\n # return sum(dp[n-1]) % mod\n\n\n ","memory":"103800"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n md = 10 ** 9 + 7 \n cc = {x:y for x, y in requirements}\n # if 0 in cc and cc[0] != 0:\n # return 0\n \n @cache\n def exp(n, k):\n if n < 0:\n return 1 if k == 0 else 0\n # if n == 0:\n # return 0\n # print(n, k)\n if n in cc and k != cc[n]:\n return 0\n # print(n, k)\n # k = min(k, cc[n-1] if n-1 in cc else k)\n\n sm = 0\n for x in range(max(0, n - k), n + 1):\n sm += exp(n - 1, k - (n - x))\n return sm % md \n\n # z = exp(n, k-1) + exp(n-1, k) - exp(n-1, k-n)\n # return z % md\n \n return exp(n - 1, cc[n-1])\n\n \n'''\nwa1\n5\n[[0,0],[1,0],[4,6],[3,4]]\n\not - 0\nca - 2\n\nf(n, k) = f(n-1, k) + f(n-1, k-1) + f(n-1, k-2) + ... + f(n-1, k-n+1) + f(n-1, k - n) --->(1)\n\nf(n, k-1) = f(n-1, k-1) + f(n-1, k-2) + f(n-1, k-3) + ... + f(n-1, k-1-n+1)+ f(n-1, k-1-n) --->(2)\n\nsubtract eqn 2 from eqn 1,we get\n\nf(n, k) = f(n, k-1) + f(n-1, k) - f(n-1, k-n-1)\n\n\n\n'''","memory":"109500"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10 ** 9 + 7\n\n requirement_by_pos = [None] * n\n for end, cnt in requirements:\n requirement_by_pos[end] = cnt\n\n #print(requirement_by_pos)\n\n @cache\n def dp(index, inversion):\n\n target_inversion = inversion\n if requirement_by_pos[index] is not None:\n if target_inversion is not None and target_inversion != requirement_by_pos[index]:\n return 0\n target_inversion = requirement_by_pos[index]\n\n #print(index, inversion)\n if index == 0:\n return 1 if target_inversion == 0 else 0\n \n ans = 0\n for i in range(index + 1):\n current_inversion = index - i\n if current_inversion > target_inversion:\n continue\n #print('3', index, inversion, i)\n ans += dp(index - 1, target_inversion - current_inversion)\n ans %= MOD\n #print('4', index, inversion, ans)\n return ans\n\n return dp(n-1, None)\n","memory":"109700"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n '''\n * inversion pair: i < j and nums[i] > nums[j]\n * cnt number of permutations which satisfies all the till_i, cnt requirements\n =====\n * permuation => so just create a O(1) lookup for requiremnts and recurse => works!\n '''\n\n req_lookup = {idx: cnt for idx, cnt in requirements}\n self.mod = ((10**9)+7)\n @cache\n def helper(idx, rem_inv): \n if idx < 0: # exhausted\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\n # is there a restriction on the current index?\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\n return 0 \n ways = 0 \n start = max(0, idx - rem_inv) # can't be below zero.. \n for i in range(start, idx + 1): \n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\n return ways\n\n\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..","memory":"110200"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n '''\n * inversion pair: i < j and nums[i] > nums[j]\n * cnt number of permutations which satisfies all the till_i, cnt requirements\n '''\n\n req_lookup = {idx: cnt for idx, cnt in requirements}\n self.mod = ((10**9)+7)\n @cache\n def helper(idx, rem_inv): \n if idx < 0: # exhausted\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\n # is there a restriction on the current index?\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\n return 0 \n ways = 0 \n start = max(0, idx - rem_inv) # can't be below zero.. \n for i in range(start, idx + 1): \n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\n return ways\n\n\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..","memory":"110400"},{"code":"class Solution:\n def numberOfPermutations(self, N: int, requirements: List[List[int]]) -> int:\n MOD = 10 ** 9 + 7\n lookup = {}\n for u, v in requirements:\n lookup[u] = v\n\n @cache\n def calc(index, cur) -> int:\n if index == 0:\n if index not in lookup:\n return cur == 0\n \n if lookup[index] != 0:\n return 0\n\n return cur == 0\n\n if index in lookup and lookup[index] != cur:\n return 0\n\n total = 0\n for j in range(index + 1):\n nxt = cur - j\n if nxt < 0:\n break\n total += calc(index - 1, nxt)\n \n return total\n\n\n\n \n\n\n return calc(N - 1, lookup[N - 1]) % MOD","memory":"112300"},{"code":"MOD = 1_000_000_007\n\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n \n requirements.sort(key=lambda x: x[0])\n \n for r in requirements:\n if self.count(r[0], r[1]) == 0:\n return 0\n for i in range(len(self.dp[r[0]])):\n if i != r[1]:\n self.dp[r[0]][i] = 0\n\n last = requirements[-1]\n return self.dp[last[0]][last[1]]\n\n def count(self, pos: int, inv: int) -> int:\n if inv < 0:\n return 0\n if pos == 0:\n return 1 if inv == 0 else 0\n if self.dp[pos][inv] is not None:\n return self.dp[pos][inv]\n \n res = 0\n for i in range(pos + 1):\n res = (res + self.count(pos - 1, inv - i)) % MOD\n self.dp[pos][inv] = res\n return res","memory":"123600"},{"code":"MOD = 10**9+7\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n re = [-1]*n\n for end,cnt in requirements: re[end]=cnt\n if re[0] not in [-1,0]: return 0\n @cache\n def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\n if i==0: return j==0\n if re[i]!=-1 and re[i]!=j: return 0\n if j<0: return 0\n res=0\n for k in range(i+1):\n res+=dfs(i-1,j-k)\n return res % MOD\n return dfs(n-1,re[n-1]) % MOD\n\n\n\n ","memory":"123700"},{"code":"MOD = 1_000_000_007\n\nclass Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\n \n requirements.sort(key=lambda x: x[0])\n \n for r in requirements:\n if self.count(r[0], r[1]) == 0:\n return 0\n for i in range(len(self.dp[r[0]])):\n if i != r[1]:\n self.dp[r[0]][i] = 0\n\n last = requirements[-1]\n return self.dp[last[0]][last[1]]\n\n def count(self, pos: int, inv: int) -> int:\n if inv < 0:\n return 0\n if pos == 0:\n return 1 if inv == 0 else 0\n if self.dp[pos][inv] is not None:\n return self.dp[pos][inv]\n \n res = 0\n for i in range(pos + 1):\n res = (res + self.count(pos - 1, inv - i)) % MOD\n self.dp[pos][inv] = res\n return res","memory":"123800"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n reqs = [-1 for i in range(n)]\n for i,c in requirements:\n reqs[i] = c\n @cache\n def dp(i,j):\n if j < 0: \n return 0\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\n return 0\n if i == 1:\n return 1 if j == 0 else 0\n res = 0\n for t in range(j-i+1,j+1):\n res += dp(i-1,t) % (10**9+7)\n return res % (10**9+7)\n return dp(n,reqs[n-1]) % (10**9+7)","memory":"129500"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n MOD = 10**9 + 7\n '''\n if you take pref arr of count inversion it will be unique for a unique perm\n example-> take this permutation\n 3 2 1 4 5\n its prefix count inversion will be\n 0 1 3 3 3\n '''\n requirements = {end + 1: cnt for end, cnt in requirements}\n # dp states --> distinctN: num of distinctElements remaining\n # inversions --> number of inversions needed\n # dfs(disN, inversions) --> num pems of disN elts that satisfy requirements and have\n # exactly inversion inversions\n # if inversions < 0 -> 0\n # if disN == 1 --> 0 \n # if req[disN] != inv --> 0\n # start from end and place ith largest -> disN - i inversions\n memo = {}\n #@cache\n def dfs(distinctN: int, inversions: int) -> int:\n if (distinctN, inversions) in memo: \n return memo[(distinctN, inversions)]\n if inversions < 0: \n memo[(distinctN, inversions)] = 0\n return 0\n if distinctN in requirements and requirements[distinctN] != inversions:\n memo[(distinctN, inversions)] = 0\n return 0 \n if distinctN == 1: \n memo[(distinctN, inversions)] = 1 if inversions == 0 else 0\n return 1 if inversions == 0 else 0\n res = 0\n # exploring the distinct numbers we can go to\n for i in range(1, distinctN + 1):\n inversionsCreated = distinctN - i # placing i at the end \n res += dfs(distinctN - 1, inversions - inversionsCreated)\n memo[(distinctN, inversions)] = res\n return res\n res = dfs(n, requirements[n])\n return res % (10**9 + 7)\n \n ","memory":"130100"},{"code":"class Solution:\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\n requirements = {end + 1: cnt for end, cnt in requirements}\n \n @cache\n def dfs(distinctN: int, inversions: int) -> int:\n if inversions < 0:\n return 0\n if distinctN in requirements and requirements[distinctN] != inversions:\n return 0\n if distinctN == 1:\n return 1 if inversions == 0 else 0\n \n result = 0\n for i in range(1, distinctN + 1):\n inversionsCaused = distinctN - i\n result += dfs(distinctN - 1, inversions - inversionsCaused)\n \n return result\n \n res = dfs(n, requirements[n])\n return res % (10 ** 9 + 7)","memory":"132300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements.sort()\\n dp = [0] * (requirements[-1][-1] + 1)\\n dp[0] = 1\\n r_map = {}\\n for r in requirements:\\n r_map[r[0]] = r[1]\\n for i in range(1, n):\\n for j in range(len(dp) - 1, -1, -1):\\n if i - 1 not in r_map:\\n dp[j] = sum(dp[max(0, j - i):j + 1])\\n elif 0 <= j - r_map[i - 1] <= min(i, j):\\n dp[j] = dp[r_map[i - 1]]\\n else:\\n dp[j] = 0\\n return dp[-1] % 1000000007\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n r = {e: c for e,c in requirements}\\n c = max(r.values())\\n max_end = max(r)\\n mod = 10 ** 9 + 7\\n dp = [1] + [0] * c\\n for i in range(max_end + 1):\\n dp2 = [0] * (c + 1)\\n if i in r:\\n dp2[r[i]] = sum(dp[max(0, r[i] - i): r[i] + 1]) % mod\\n else:\\n for j in range(c + 1):\\n dp2[j] = dp[j]\\n if j: dp2[j] += dp2[j - 1]\\n if j - i > 0: dp2[j] -= dp[j - i - 1]\\n dp = dp2\\n res = sum(dp) % mod\\n for i in range(max_end + 1, n):\\n res = res * (i + 1) % mod\\n return res\\n \",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"Mod = int(1e9+7)\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [0]*401 \\n requirements.sort()\\n if requirements[0][0] ==0 and requirements[0][1]!=0:\\n return 0\\n x = 1 if requirements[0][0] == 0 else 0\\n dp[0] = 1\\n for i in range(1,n):\\n b = [0]*401\\n if x < len(requirements) and requirements[x][0]==i:\\n j = requirements[x][1]\\n for k in range(max(j-i,0),j+1):\\n b[j] = (b[j] + dp[k])%Mod\\n x+=1\\n dp = list(b)\\n continue\\n for j in range(401):\\n for k in range(max(j-i,0),j+1):\\n b[j] = (b[j] + dp[k])%Mod\\n dp = list(b)\\n # print(dp[1][0],dp[1][1])\\n return dp[requirements[-1][1]]\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"Mod = int(1e9+7)\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n dp = [0]*401 \\n requirements.sort()\\n if requirements[0][0] ==0 and requirements[0][1]!=0:\\n return 0\\n x = 1 if requirements[0][0] == 0 else 0\\n dp[0] = 1\\n ps = [0] + [1]*401\\n for i in range(1,n):\\n b = [0]*401\\n if x < len(requirements) and requirements[x][0]==i:\\n j = requirements[x][1]\\n b[j] = (ps[j+1] - ps[max(j-i,0)] + Mod)%Mod\\n x+=1\\n dp = list(b)\\n ps[0] = 0\\n for j in range(401):\\n ps[j+1] = (ps[j] + b[j])%Mod\\n continue\\n for j in range(401):\\n b[j] = (ps[j+1] - ps[max(j-i,0)] + Mod)%Mod\\n ps[0] = 0\\n for j in range(401):\\n ps[j+1] = (ps[j] + b[j])%Mod\\n dp = list(b)\\n # print(dp[1][0],dp[1][1])\\n return dp[requirements[-1][1]]\\n\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"M = 10 ** 9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n cond = [-1] * n\\n for u,v in requirements:\\n if cond[u] != -1 and v != cond[u]:\\n return 0\\n cond[u] = v\\n lim = max(cond)\\n dp = [0] * (lim+1)\\n dp[0] = 1\\n for i in range(n):\\n ndp = [0] * (lim+1)\\n for j in range(lim+1):\\n for k in range(i+1):\\n if j + k <= lim:\\n ndp[j+k] += dp[j]\\n ndp[j+k] %= M\\n dp = ndp\\n if cond[i] != -1:\\n for j in range(lim+1):\\n if j ^ cond[i]:\\n dp[j] = 0\\n return sum(dp) % M\\n\\n\\n\\n\\n \\n\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"M = 10 ** 9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n cond = [-1] * n\\n for u,v in requirements:\\n if cond[u] != -1 and v != cond[u]:\\n return 0\\n cond[u] = v\\n lim = max(cond)\\n dp = [0] * (lim+1)\\n dp[0] = 1\\n for i in range(n):\\n ndp = [0] * (lim+1)\\n for j in range(lim+1):\\n for k in range(i+1):\\n if j + k <= lim:\\n ndp[j+k] += dp[j]\\n ndp[j+k] %= M\\n print(dp, ndp, lim)\\n dp = ndp\\n if cond[i] != -1:\\n for j in range(lim+1):\\n if j ^ cond[i]:\\n dp[j] = 0\\n return sum(dp) % M\\n\\n\\n\\n\\n \\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mod = 10**9 + 7\\n m = max(req)\\n f = [[0] * (m + 1) for _ in range(n)]\\n f[0][0] = 1\\n for i in range(1, n):\\n l, r = 0, m\\n if req[i] >= 0:\\n l = r = req[i]\\n for j in range(l, r + 1):\\n for k in range(min(i, j) + 1):\\n f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod\\n return f[n - 1][req[n - 1]]\",\n \"memory\": \"19000\"\n },\n {\n \"code\": \" # class Solution:\\n# def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n# MOD = 10 ** 9 + 7\\n# # return len(requirements)\\n \\n# dp = [[0] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n# dp[0][0] = 1\\n\\n# for i in range(1, n + 1):\\n# for j in range(n * (n - 1) // 2 + 1):\\n# dp[i][j] = 0\\n# for k in range(i):\\n# if j >= k:\\n# dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD\\n\\n# result = 0\\n# def isValidPermutation(permutation):\\n# inversions = 0\\n# for endi, cnti in requirements:\\n# inversions = sum(1 for i in range(endi + 1) for j in range(i + 1, endi + 1) if permutation[i] > permutation[j])\\n# if inversions != cnti:\\n# return False\\n# return True\\n\\n# from itertools import permutations\\n# for perm in permutations(range(n)):\\n# if isValidPermutation(perm):\\n# result = (result + 1) % MOD\\n\\n# return result\\nfrom typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"memory\": \"19100\"\n },\n {\n \"code\": \"from typing import List\\nclass Solution:\\n def numberOfPermutations(self, n: int, reqs: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n MAX_INV = 400\\n \\n r = {}\\n for req in reqs:\\n r[req[0] + 1] = req[1]\\n \\n pc = [[0] * (MAX_INV + 1) for _ in range(n + 1)]\\n pc[0][0] = 1\\n \\n # Fill the DP table\\n for length in range(1, n + 1):\\n for inv in range(MAX_INV + 1):\\n for pos in range(length):\\n prev_inv = inv - pos\\n if prev_inv >= 0:\\n pc[length][inv] = (pc[length][inv] + pc[length - 1][prev_inv]) % MOD\\n \\n if length in r:\\n target_inv = r[length]\\n for inv in range(MAX_INV + 1):\\n if inv != target_inv:\\n pc[length][inv] = 0\\n \\n res = sum(pc[n]) % MOD\\n return res\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n\\n # Sort requirements by end_i to process them in order\\n requirements.sort()\\n \\n # Initialize DP table with n+1 rows and max possible inversion count + 1 columns\\n # dp[i][j] will store the number of valid permutations of length i with exactly j inversions\\n max_inversions = max(req[1] for req in requirements)\\n dp = [[0] * (max_inversions + 1) for _ in range(n + 1)]\\n \\n # Base case: There's exactly one way to have 0 inversions with 0 elements\\n dp[0][0] = 1\\n \\n # Process each prefix length from 1 to n\\n for i in range(1, n + 1):\\n # Track the number of valid permutations that meet the current requirement\\n valid_perms = 0\\n \\n # Consider all possible inversion counts from 0 to max_inversions\\n for j in range(max_inversions + 1):\\n # If the current inversion count is valid, update the DP table\\n if dp[i-1][j]:\\n # Calculate the number of new inversions introduced by adding the next number\\n for k in range(i):\\n new_inversions = j + k\\n if new_inversions <= max_inversions:\\n dp[i][new_inversions] = (dp[i][new_inversions] + dp[i-1][j]) % MOD\\n \\n # After processing all possible inversion counts for prefix length i,\\n # check if we need to meet any specific requirement for this prefix length\\n for req in requirements:\\n end_i, cnt_i = req\\n if end_i == i - 1:\\n valid_perms = (valid_perms + dp[i][cnt_i]) % MOD\\n dp[i] = [valid_perms if x == cnt_i else 0 for x in range(max_inversions + 1)]\\n \\n # The answer is the number of valid permutations for the full length n\\n return dp[n][requirements[-1][1]]\\n\",\n \"memory\": \"19300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n limit = 500\\n\\n reqMap = {req[0]+1: req[1] for req in requirements}\\n \\n perm = [[0] * (limit+1) for i in range(n+1)]\\n perm[0][0] = 1\\n\\n for ln in range(1, n+1):\\n for inv in range(limit+1):\\n for newPos in range(ln):\\n prev = inv-newPos\\n if prev >= 0:\\n perm[ln][inv] = (perm[ln][inv] + perm[ln-1][prev]) % 1000000007\\n\\n if ln in reqMap:\\n targetInv = reqMap[ln]\\n for inv in range(limit+1):\\n if inv != targetInv:\\n perm[ln][inv] = 0\\n\\n res=sum(perm[n])%1000000007\\n\\n return res\",\n \"memory\": \"19900\"\n },\n {\n \"code\": \"MOD = 10**9+7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n re = [-1]*n\\n for end,cnt in requirements: re[end]=cnt\\n if re[0] not in [-1,0]: return 0\\n # @cache\\n # def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\\n # if i==0: return j==0\\n # if re[i]!=-1 and re[i]!=j: return 0\\n # if j<0: return 0\\n # res=0\\n # for k in range(i+1):\\n # res+=dfs(i-1,j-k)\\n # return res % MOD\\n # return dfs(n-1,re[n-1]) % MOD\\n dp = [[0]*401 for _ in range(n)]\\n dp[0][0]=1\\n for i in range(1,n):\\n pref = list(accumulate(dp[i-1],initial=0))\\n for j in range(401):\\n if re[i]!=-1 and j!=re[i]: continue\\n k = min(i,j)\\n dp[i][j] = pref[j+1]-pref[j-k] % MOD\\n return dp[n-1][re[n-1]] % MOD\\n\\n\\n\\n\\n \",\n \"memory\": \"21100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n req = [-1] * n\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] > 0:\\n return 0\\n req[0] = 0\\n mx = max(req)\\n dp = [[0 for _ in range(mx+1)] for _ in range(n)]\\n MOD = 10**9+7\\n dp[0][0] = 1\\n pre = [[0 for _ in range(mx+1)] for _ in range(n)]\\n pre[0][0] = 1\\n for i in range(1, n):\\n cur_req = req[i-1]\\n if cur_req == -1:\\n for j in range(mx+1):\\n if j - i >= 1:\\n dp[i][j] = (pre[i-1][j] - pre[i-1][j-i-1] + MOD) % MOD\\n else:\\n dp[i][j] = pre[i-1][j]\\n pre[i][j] = dp[i][j] if j == 0 else (pre[i][j-1] + dp[i][j]) % MOD\\n # for k in range(min(i, j)+1):\\n # dp[i][j] = (dp[i][j] + dp[i-1][j - k]) % MOD\\n else:\\n for j in range(cur_req, min(i + cur_req, mx) +1):\\n dp[i][j] = dp[i-1][cur_req]\\n for j in range(mx+1):\\n pre[i][j] = dp[i][j] if j == 0 else (pre[i][j-1] + dp[i][j]) % MOD\\n # print(i, pre[i-1])\\n # print(i, dp[i])\\n return dp[-1][req[-1]]\\n\",\n \"memory\": \"21900\"\n },\n {\n \"code\": \"from functools import lru_cache\\n\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n def C(a, b):\\n s = 1\\n for i in range(b):\\n s *= (a - i)\\n s //= (i + 1)\\n return s\\n\\n @lru_cache(None)\\n def func(cord, leap, gain):\\n if leap == 1:\\n return 1\\n maxgain = sum(range(cord + 1, cord + leap))\\n w = 0\\n for g in range(cord + 1):\\n if g <= gain and (gain - g) <= maxgain:\\n w += func(cord + 1, leap - 1, gain - g)\\n return w\\n\\n requirements = sorted(requirements)\\n if requirements[0][0] == 0:\\n if requirements[0][1] != 0:\\n return 0\\n requirements = requirements[1:]\\n base = 1\\n cord = 0\\n invs = 0\\n for i in requirements:\\n leap = i[0] - cord\\n gain = i[1] - invs\\n base *= func(cord + 1, leap, gain)\\n cord = i[0]\\n invs = i[1]\\n base *= C(n, requirements[-1][0] + 1)\\n remain = n - 1 - requirements[-1][0]\\n for i in range(1, remain + 1):\\n base *= i\\n return base % (10**9 + 7)\",\n \"memory\": \"27700\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n ans = 0\\n max_inv = [inf] * n\\n check = [0] * n\\n\\n for e, c in requirements:\\n max_inv[e] = c\\n check[e] = 1\\n for i in range(n - 2, -1, -1):\\n max_inv[i] = min(max_inv[i], max_inv[i + 1])\\n\\n @cache\\n def dp(i, c):\\n if i == n:\\n return 1\\n res = 0\\n if check[i]:\\n if max_inv[i] - c > i:\\n return 0\\n return dp(i + 1, max_inv[i]) % MOD\\n else:\\n for j in range(min(i, max_inv[i] - c) + 1):\\n res = (res + dp(i + 1, c + j)) % MOD\\n return res\\n\\n return dp(i, 0)\",\n \"memory\": \"27800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n ans = 0\\n max_inv = [inf] * n\\n check = [0] * n\\n\\n for e, c in requirements:\\n max_inv[e] = c\\n check[e] = 1\\n for i in range(n - 2, -1, -1):\\n max_inv[i] = min(max_inv[i], max_inv[i + 1])\\n\\n @cache\\n def dp(i, c):\\n if i == n:\\n return 1\\n res = 0\\n if check[i]:\\n if max_inv[i] - c > i:\\n return 0\\n return dp(i + 1, max_inv[i]) % MOD\\n else:\\n for j in range(min(i, max_inv[i] - c) + 1):\\n res = (res + dp(i + 1, c + j)) % MOD\\n return res\\n\\n return dp(i, 0)\",\n \"memory\": \"27900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n \\n \\n\\n MOD = 10**9 + 7\\n requirements_dict = {endi: cnti for endi, cnti in requirements}\\n \\n dp_prev = {0: 1} \\n\\n for i in range(n):\\n max_inv_i = (i + 1) * i // 2 \\n dp_curr = {}\\n \\n max_k_prev = max(dp_prev.keys())\\n prefix_sums = [0] * (max_k_prev + 2) \\n for k in range(max_k_prev + 1):\\n dp_prev_k = dp_prev.get(k, 0)\\n prefix_sums[k + 1] = (prefix_sums[k] + dp_prev_k) % MOD\\n\\n for k in range(max_inv_i + 1):\\n min_inv = max(0, k - i)\\n max_inv = min(k, max_k_prev)\\n if min_inv > max_inv:\\n continue \\n\\n dp_curr_k = (prefix_sums[max_inv + 1] - prefix_sums[min_inv]) % MOD\\n dp_curr[k] = dp_curr_k\\n\\n if i in requirements_dict:\\n cnti = requirements_dict[i]\\n dp_curr = {cnti: dp_curr.get(cnti, 0)}\\n\\n dp_prev = dp_curr \\n\\n result = sum(dp_prev.values()) % MOD\\n return result\\n\\n\\n\\n \",\n \"memory\": \"33600\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"memory\": \"38200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"memory\": \"38300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n constraints = {e: c for e, c in requirements}\\n @cache\\n def dp(i, inv):\\n if i < 0:\\n return 1 if inv == 0 else 0\\n if i in constraints and constraints[i] != inv:\\n return 0\\n return sum(dp(i-1, inv - (i - k)) for k in range(max(0, i - inv), i+1)) % 1000000007 \\n return dp(n-1, constraints[n-1]) \",\n \"memory\": \"38400\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\\n 枚举 perm[i] 能产生多少个逆序对 k\\n dfs(i, j) += dfs(i-1, j-k) \\n\\\"\\\"\\\"\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]: return 0 \\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n # if have req\\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\\n if r != -1: # 有要求\\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\\n return dfs(i-1, r) if r <= j <= i+r else 0\\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n-1, req[-1])\",\n \"memory\": \"48200\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n dfs(i, j) is to construct perm[0] ~ perm[i] so that the # of inversions = j\\n 枚举 perm[i] 能产生多少个逆序对 k\\n dfs(i, j) += dfs(i-1, j-k) \\n \\n Time: O(nm min(n,m)) m = max(cnt)\\n Space: O(nm)\\n\\\"\\\"\\\"\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 1_000_000_007\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0]: return 0 \\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1\\n # if have req\\n r = req[i-1] # perm[0] ~ perm[i-1] 中逆序对数量\\n if r != -1: # 有要求\\n # 从 r 转移到 j，如果在perm[i]填最大的数，则新增0个逆序对，如果填最小的数，则新增i个逆序对\\n return dfs(i-1, r) if r <= j <= i+r else 0\\n # k 是新增的逆序对，最少是0个，最多是 min(i, j) 个\\n return sum(dfs(i-1, j-k) for k in range(min(i, j) + 1)) % MOD\\n return dfs(n-1, req[-1])\",\n \"memory\": \"48300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n mod = int(1e9+7)\\n req = [-1] * n\\n req[0] = 0\\n for end, cnt in requirements:\\n req[end] = cnt\\n if req[0] != 0:\\n return 0\\n\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == 0:\\n return 1 if j == 0 else 0\\n\\n r = req[i-1]\\n if r == -1:\\n return sum(dfs(i-1, j-m) for m in range(min(i, j) + 1)) % mod\\n if j - i <= r <= j:\\n return dfs(i-1, r)\\n return 0\\n return dfs(n-1, req[-1])\",\n \"memory\": \"48400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9+7\\n requirements.sort()\\n max_allowed = [0] * n\\n step_up = set()\\n inversions = 0\\n for i in reversed(range(n)):\\n if requirements and i == requirements[-1][0]:\\n inversions = requirements.pop()[1]\\n step_up.add(i)\\n max_allowed[i] = inversions\\n \\n\\n @cache\\n def dfs(i, inversions):\\n if (i in step_up and inversions != max_allowed[i]) or inversions > max_allowed[i]:\\n return 0\\n if i == n-1:\\n return 1\\n return sum(dfs(i+1, inversions+j) for j in range(i+2)) % MOD\\n\\n return dfs(0, 0)\",\n \"memory\": \"50400\"\n },\n {\n \"code\": \"MOD = 10**9 + 7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n ends=[-1]*n\\n for end,cnt in requirements:\\n ends[end]=cnt\\n @lru_cache(None)\\n def dp(i,count):\\n if i<0:\\n return 1 if count==0 else 0\\n if count<0 or (ends[i]>=0 and ends[i]!=count): return 0\\n return sum(dp(i-1,count-j) for j in range(i+1))%MOD\\n return dp(n-1, ends[-1])\\n\\n \",\n \"memory\": \"65600\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n mp = [-1] * (n + 1)\\n\\n for end, cnt in requirements:\\n mp[end+1] = cnt\\n\\n @cache\\n def dp(i, k):\\n if i == 1: return k == 0\\n\\n res = 0\\n\\n for j in range(i):\\n if k - j < 0: continue\\n if mp[i-1] == -1 or mp[i-1] == k - j:\\n res += dp(i-1, k-j)\\n return res % MOD\\n\\n\\n return dp(n, mp[n]) % MOD\",\n \"memory\": \"95200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n mp = [-1] * (n + 1) \\n\\n for end, count in requirements:\\n mp[end+1] = count\\n\\n @cache\\n def dp(i, k):\\n if i == 1: return k == 0\\n res = 0\\n\\n for j in range(i):\\n if k - j < 0: break\\n if mp[i-1] == -1 or mp[i - 1] == k - j: \\n res += dp(i-1, k - j) \\n\\n return res % MOD\\n\\n return dp(n, mp[n]) % MOD\",\n \"memory\": \"95300\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, N: int, req: List[List[int]]) -> int:\\n # print(\\\"e\\\")\\n res = [-1]*(N+1)\\n MOD = 10**9 + 7\\n for end,cnt in req:\\n res[end+1]=cnt\\n @lru_cache(None)\\n def helper(N, K):\\n if (N == 1): return int(K==0)\\n \\n sum = 0\\n for i in range(N):\\n if (K-i>=0) and (res[N-1]==-1 or res[N-1]==K-i):\\n # print(f\\\"first N = {N-1} and K = {K-i}\\\")\\n sum += helper(N - 1, K - i)\\n return sum\\n return (helper(N,res[N]))%MOD\",\n \"memory\": \"97900\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, rs: List[List[int]]) -> int:\\n mod = 10 ** 9 + 7\\n\\n rs.sort()\\n dr = defaultdict(int)\\n for e, c in rs:\\n dr[e] = c\\n if 0 in dr and dr[0] != 0:\\n return 0\\n\\n @cache\\n def dp(i, v):\\n if i < 0:\\n return 1 if v == 0 else 0\\n if i in dr and v != dr[i]:\\n return 0\\n res = 0\\n for k in range(max(0, v-i), v+1):\\n res += dp(i-1, k)\\n return res % mod\\n \\n return dp(n-1, dr[n-1])\\n\\n\\n\\n\\n # dp = [[0 for _ in range(n**2)] for _ in range(n)]\\n \\n \\n # dp[0][0] = 1\\n # p = [0] * 1 + [1] * (n ** 2)\\n \\n # for i in range(1, n):\\n # if i in dr:\\n # j = dr[i]\\n # l = max(0, j - i)\\n # x = p[j+1] - p[l]\\n # dp[i] = [0 for _ in range(n**2)]\\n # dp[i][dr[i]] = x\\n # p = [0] * (dr[i] + 1) + [x] * (n*n - dr[i])\\n # else:\\n # for j in range((i+1)**2):\\n # l = max(0, j - i)\\n # dp[i][j] = p[j+1] - p[l]\\n # # dp[i][j] %= mod\\n # p = [0]\\n # for j in range(n ** 2):\\n # p.append(p[-1] + dp[i][j])\\n # p[-1] %= mod\\n # # print(dp)\\n # return sum(dp[n-1]) % mod\\n\\n\\n \",\n \"memory\": \"103800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n md = 10 ** 9 + 7 \\n cc = {x:y for x, y in requirements}\\n # if 0 in cc and cc[0] != 0:\\n # return 0\\n \\n @cache\\n def exp(n, k):\\n if n < 0:\\n return 1 if k == 0 else 0\\n # if n == 0:\\n # return 0\\n # print(n, k)\\n if n in cc and k != cc[n]:\\n return 0\\n # print(n, k)\\n # k = min(k, cc[n-1] if n-1 in cc else k)\\n\\n sm = 0\\n for x in range(max(0, n - k), n + 1):\\n sm += exp(n - 1, k - (n - x))\\n return sm % md \\n\\n # z = exp(n, k-1) + exp(n-1, k) - exp(n-1, k-n)\\n # return z % md\\n \\n return exp(n - 1, cc[n-1])\\n\\n \\n'''\\nwa1\\n5\\n[[0,0],[1,0],[4,6],[3,4]]\\n\\not - 0\\nca - 2\\n\\nf(n, k) = f(n-1, k) + f(n-1, k-1) + f(n-1, k-2) + ... + f(n-1, k-n+1) + f(n-1, k - n) --->(1)\\n\\nf(n, k-1) = f(n-1, k-1) + f(n-1, k-2) + f(n-1, k-3) + ... + f(n-1, k-1-n+1)+ f(n-1, k-1-n) --->(2)\\n\\nsubtract eqn 2 from eqn 1,we get\\n\\nf(n, k) = f(n, k-1) + f(n-1, k) - f(n-1, k-n-1)\\n\\n\\n\\n'''\",\n \"memory\": \"109500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10 ** 9 + 7\\n\\n requirement_by_pos = [None] * n\\n for end, cnt in requirements:\\n requirement_by_pos[end] = cnt\\n\\n #print(requirement_by_pos)\\n\\n @cache\\n def dp(index, inversion):\\n\\n target_inversion = inversion\\n if requirement_by_pos[index] is not None:\\n if target_inversion is not None and target_inversion != requirement_by_pos[index]:\\n return 0\\n target_inversion = requirement_by_pos[index]\\n\\n #print(index, inversion)\\n if index == 0:\\n return 1 if target_inversion == 0 else 0\\n \\n ans = 0\\n for i in range(index + 1):\\n current_inversion = index - i\\n if current_inversion > target_inversion:\\n continue\\n #print('3', index, inversion, i)\\n ans += dp(index - 1, target_inversion - current_inversion)\\n ans %= MOD\\n #print('4', index, inversion, ans)\\n return ans\\n\\n return dp(n-1, None)\\n\",\n \"memory\": \"109700\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n '''\\n * inversion pair: i < j and nums[i] > nums[j]\\n * cnt number of permutations which satisfies all the till_i, cnt requirements\\n =====\\n * permuation => so just create a O(1) lookup for requiremnts and recurse => works!\\n '''\\n\\n req_lookup = {idx: cnt for idx, cnt in requirements}\\n self.mod = ((10**9)+7)\\n @cache\\n def helper(idx, rem_inv): \\n if idx < 0: # exhausted\\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\\n # is there a restriction on the current index?\\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\\n return 0 \\n ways = 0 \\n start = max(0, idx - rem_inv) # can't be below zero.. \\n for i in range(start, idx + 1): \\n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\\n return ways\\n\\n\\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..\",\n \"memory\": \"110200\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n '''\\n * inversion pair: i < j and nums[i] > nums[j]\\n * cnt number of permutations which satisfies all the till_i, cnt requirements\\n '''\\n\\n req_lookup = {idx: cnt for idx, cnt in requirements}\\n self.mod = ((10**9)+7)\\n @cache\\n def helper(idx, rem_inv): \\n if idx < 0: # exhausted\\n return 1 if rem_inv == 0 else 0 # and formed the required inv pairs\\n # is there a restriction on the current index?\\n if idx in req_lookup and rem_inv != req_lookup[idx]: # restriction is not matching.. invalidate way\\n return 0 \\n ways = 0 \\n start = max(0, idx - rem_inv) # can't be below zero.. \\n for i in range(start, idx + 1): \\n ways = (ways + helper(idx - 1, rem_inv - (idx - i))) % self.mod # move to next index forming (idx - i) inv pairs...\\n return ways\\n\\n\\n return helper(n-1, req_lookup[n-1]) % self.mod # end index, requiremnt at end index..\",\n \"memory\": \"110400\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, N: int, requirements: List[List[int]]) -> int:\\n MOD = 10 ** 9 + 7\\n lookup = {}\\n for u, v in requirements:\\n lookup[u] = v\\n\\n @cache\\n def calc(index, cur) -> int:\\n if index == 0:\\n if index not in lookup:\\n return cur == 0\\n \\n if lookup[index] != 0:\\n return 0\\n\\n return cur == 0\\n\\n if index in lookup and lookup[index] != cur:\\n return 0\\n\\n total = 0\\n for j in range(index + 1):\\n nxt = cur - j\\n if nxt < 0:\\n break\\n total += calc(index - 1, nxt)\\n \\n return total\\n\\n\\n\\n \\n\\n\\n return calc(N - 1, lookup[N - 1]) % MOD\",\n \"memory\": \"112300\"\n },\n {\n \"code\": \"MOD = 1_000_000_007\\n\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n \\n requirements.sort(key=lambda x: x[0])\\n \\n for r in requirements:\\n if self.count(r[0], r[1]) == 0:\\n return 0\\n for i in range(len(self.dp[r[0]])):\\n if i != r[1]:\\n self.dp[r[0]][i] = 0\\n\\n last = requirements[-1]\\n return self.dp[last[0]][last[1]]\\n\\n def count(self, pos: int, inv: int) -> int:\\n if inv < 0:\\n return 0\\n if pos == 0:\\n return 1 if inv == 0 else 0\\n if self.dp[pos][inv] is not None:\\n return self.dp[pos][inv]\\n \\n res = 0\\n for i in range(pos + 1):\\n res = (res + self.count(pos - 1, inv - i)) % MOD\\n self.dp[pos][inv] = res\\n return res\",\n \"memory\": \"123600\"\n },\n {\n \"code\": \"MOD = 10**9+7\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n re = [-1]*n\\n for end,cnt in requirements: re[end]=cnt\\n if re[0] not in [-1,0]: return 0\\n @cache\\n def dfs(i,j): #consider 0.1....i, we have j pairs of inversion\\n if i==0: return j==0\\n if re[i]!=-1 and re[i]!=j: return 0\\n if j<0: return 0\\n res=0\\n for k in range(i+1):\\n res+=dfs(i-1,j-k)\\n return res % MOD\\n return dfs(n-1,re[n-1]) % MOD\\n\\n\\n\\n \",\n \"memory\": \"123700\"\n },\n {\n \"code\": \"MOD = 1_000_000_007\\n\\nclass Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n self.dp = [[None] * (n * (n - 1) // 2 + 1) for _ in range(n + 1)]\\n \\n requirements.sort(key=lambda x: x[0])\\n \\n for r in requirements:\\n if self.count(r[0], r[1]) == 0:\\n return 0\\n for i in range(len(self.dp[r[0]])):\\n if i != r[1]:\\n self.dp[r[0]][i] = 0\\n\\n last = requirements[-1]\\n return self.dp[last[0]][last[1]]\\n\\n def count(self, pos: int, inv: int) -> int:\\n if inv < 0:\\n return 0\\n if pos == 0:\\n return 1 if inv == 0 else 0\\n if self.dp[pos][inv] is not None:\\n return self.dp[pos][inv]\\n \\n res = 0\\n for i in range(pos + 1):\\n res = (res + self.count(pos - 1, inv - i)) % MOD\\n self.dp[pos][inv] = res\\n return res\",\n \"memory\": \"123800\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n reqs = [-1 for i in range(n)]\\n for i,c in requirements:\\n reqs[i] = c\\n @cache\\n def dp(i,j):\\n if j < 0: \\n return 0\\n if reqs[i-1]!=-1 and j!=reqs[i-1]:\\n return 0\\n if i == 1:\\n return 1 if j == 0 else 0\\n res = 0\\n for t in range(j-i+1,j+1):\\n res += dp(i-1,t) % (10**9+7)\\n return res % (10**9+7)\\n return dp(n,reqs[n-1]) % (10**9+7)\",\n \"memory\": \"129500\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n MOD = 10**9 + 7\\n '''\\n if you take pref arr of count inversion it will be unique for a unique perm\\n example-> take this permutation\\n 3 2 1 4 5\\n its prefix count inversion will be\\n 0 1 3 3 3\\n '''\\n requirements = {end + 1: cnt for end, cnt in requirements}\\n # dp states --> distinctN: num of distinctElements remaining\\n # inversions --> number of inversions needed\\n # dfs(disN, inversions) --> num pems of disN elts that satisfy requirements and have\\n # exactly inversion inversions\\n # if inversions < 0 -> 0\\n # if disN == 1 --> 0 \\n # if req[disN] != inv --> 0\\n # start from end and place ith largest -> disN - i inversions\\n memo = {}\\n #@cache\\n def dfs(distinctN: int, inversions: int) -> int:\\n if (distinctN, inversions) in memo: \\n return memo[(distinctN, inversions)]\\n if inversions < 0: \\n memo[(distinctN, inversions)] = 0\\n return 0\\n if distinctN in requirements and requirements[distinctN] != inversions:\\n memo[(distinctN, inversions)] = 0\\n return 0 \\n if distinctN == 1: \\n memo[(distinctN, inversions)] = 1 if inversions == 0 else 0\\n return 1 if inversions == 0 else 0\\n res = 0\\n # exploring the distinct numbers we can go to\\n for i in range(1, distinctN + 1):\\n inversionsCreated = distinctN - i # placing i at the end \\n res += dfs(distinctN - 1, inversions - inversionsCreated)\\n memo[(distinctN, inversions)] = res\\n return res\\n res = dfs(n, requirements[n])\\n return res % (10**9 + 7)\\n \\n \",\n \"memory\": \"130100\"\n },\n {\n \"code\": \"class Solution:\\n def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:\\n requirements = {end + 1: cnt for end, cnt in requirements}\\n \\n @cache\\n def dfs(distinctN: int, inversions: int) -> int:\\n if inversions < 0:\\n return 0\\n if distinctN in requirements and requirements[distinctN] != inversions:\\n return 0\\n if distinctN == 1:\\n return 1 if inversions == 0 else 0\\n \\n result = 0\\n for i in range(1, distinctN + 1):\\n inversionsCaused = distinctN - i\\n result += dfs(distinctN - 1, inversions - inversionsCaused)\\n \\n return result\\n \\n res = dfs(n, requirements[n])\\n return res % (10 ** 9 + 7)\",\n \"memory\": \"132300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":41,"string":"41"}}},{"rowIdx":2468,"cells":{"question_id":{"kind":"number","value":3464,"string":"3,464"},"name":{"kind":"string","value":"maximize-total-cost-of-alternating-subarrays"},"content":{"kind":"string","value":"<p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>\n\n<p>The <strong>cost</strong> of a <span data-keyword=\"subarray-nonempty\">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>\n\n<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)<sup>r − l</sup></code></p>\n\n<p>Your task is to <strong>split</strong> <code>nums</code> into subarrays such that the <strong>total</strong> <strong>cost</strong> of the subarrays is <strong>maximized</strong>, ensuring each element belongs to <strong>exactly one</strong> subarray.</p>\n\n<p>Formally, if <code>nums</code> is split into <code>k</code> subarrays, where <code>k > 1</code>, at indices <code>i<sub>1</sub>, i<sub>2</sub>, ..., i<sub>k − 1</sub></code>, where <code>0 <= i<sub>1</sub> < i<sub>2</sub> < ... < i<sub>k - 1</sub> < n - 1</code>, then the total cost will be:</p>\n\n<p><code>cost(0, i<sub>1</sub>) + cost(i<sub>1</sub> + 1, i<sub>2</sub>) + ... + cost(i<sub>k − 1</sub> + 1, n − 1)</code></p>\n\n<p>Return an integer denoting the <em>maximum total cost</em> of the subarrays after splitting the array optimally.</p>\n\n<p><strong>Note:</strong> If <code>nums</code> is not split into subarrays, i.e. <code>k = 1</code>, the total cost is simply <code>cost(0, n - 1)</code>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,-2,3,4]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">10</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>One way to maximize the total cost is by splitting <code>[1, -2, 3, 4]</code> into subarrays <code>[1, -2, 3]</code> and <code>[4]</code>. The total cost will be <code>(1 + 2 + 3) + 4 = 10</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,-1,1,-1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>One way to maximize the total cost is by splitting <code>[1, -1, 1, -1]</code> into subarrays <code>[1, -1]</code> and <code>[1, -1]</code>. The total cost will be <code>(1 + 1) + (1 + 1) = 4</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [0]</span></p>\n\n<p><strong>Output:</strong> 0</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>We cannot split the array further, so the answer is 0.</p>\n</div>\n\n<p><strong class=\"example\">Example 4:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,-1]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>Selecting the whole array gives a total cost of <code>1 + 1 = 2</code>, which is the maximum.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>\n\t<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":28.645006337981187,"string":"28.645006"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"448\", 1.2765], [\"456\", 4.255199999999999], [\"465\", 3.8299000000000003], [\"474\", 9.7871], [\"482\", 6.8085], [\"491\", 10.638299999999997], [\"499\", 4.2553], [\"508\", 3.4042000000000003], [\"517\", 2.5531], [\"525\", 1.2765], [\"534\", 0.4255], [\"542\", 0.8511], [\"551\", 0.4255], [\"560\", 0.4255], [\"568\", 0.4255], [\"577\", 2.5532], [\"585\", 1.7021], [\"594\", 1.2765], [\"603\", 0.4255], [\"611\", 0.851], [\"620\", 2.5532], [\"628\", 0.4255], [\"637\", 0.4255], [\"646\", 0.4255], [\"654\", 0.851], [\"663\", 0.851], [\"671\", 0.4255], [\"680\", 0.4255], [\"689\", 0.851], [\"697\", 1.2765], [\"706\", 1.7021], [\"714\", 0.4255], [\"723\", 0.8511], [\"732\", 0.4255], [\"740\", 0.4255], [\"749\", 0.4255], [\"757\", 0.4255], [\"766\", 0.4255], [\"775\", 0.4255], [\"783\", 0.4255], [\"792\", 0.4255], [\"800\", 0.4255], [\"809\", 0.4255], [\"818\", 0.4255], [\"826\", 0.4255], [\"835\", 0.4255], [\"843\", 0.4255], [\"852\", 0.4255], [\"861\", 0.4255], [\"869\", 0.4255], [\"878\", 0.4255], [\"886\", 0.8511], [\"895\", 0.4255], [\"904\", 0.4255], [\"912\", 0.4255], [\"921\", 1.2766], [\"929\", 1.2765], [\"938\", 0.4255], [\"947\", 1.702], [\"955\", 0.4255], [\"964\", 0.851], [\"972\", 0.8511], [\"981\", 0.4255], [\"990\", 0.8511], [\"998\", 0.4255], [\"1007\", 0.851], [\"1015\", 1.2765], [\"1024\", 0.4255], [\"1033\", 0.4255], [\"1041\", 0.4255], [\"1050\", 0.851], [\"1058\", 0.4255], [\"1067\", 0.4255], [\"1076\", 0.851], [\"1084\", 0.4255], [\"1093\", 0.4255], [\"1101\", 0.4255], [\"1110\", 0.4255]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"29900\", 0.4255], [\"30300\", 0.4255], [\"30600\", 6.383], [\"30700\", 25.5319], [\"30800\", 5.9574], [\"30900\", 0.4255], [\"31000\", 1.2766], [\"31100\", 4.2553], [\"31200\", 1.2766], [\"31300\", 0.8511], [\"31400\", 0.8511], [\"32299\", 0.4255], [\"32600\", 1.2766], [\"32700\", 0.4255], [\"33100\", 0.4255], [\"33700\", 0.4255], [\"35600\", 0.4255], [\"37900\", 0.4255], [\"40000\", 0.4255], [\"40100\", 6.8085], [\"40200\", 1.2766], [\"41700\", 1.2766], [\"41800\", 0.8511], [\"44900\", 0.4255], [\"47000\", 0.4255], [\"47300\", 0.4255], [\"47700\", 0.4255], [\"48400\", 0.8511], [\"54400\", 0.4255], [\"55500\", 0.4255], [\"55600\", 0.4255], [\"55700\", 0.4255], [\"56000\", 0.4255], [\"57000\", 0.4255], [\"58400\", 0.4255], [\"59800\", 0.4255], [\"68200\", 0.4255], [\"72100\", 0.8511], [\"78100\", 0.4255], [\"78600\", 0.4255], [\"145000\", 0.4255], [\"169800\", 0.4255], [\"170400\", 0.4255], [\"170500\", 2.1277], [\"171200\", 0.4255], [\"171300\", 0.4255], [\"193200\", 0.4255], [\"216300\", 0.8511], [\"217100\", 0.4255], [\"221700\", 0.4255], [\"221800\", 0.8511], [\"224800\", 0.4255], [\"225500\", 0.4255], [\"225600\", 0.8511], [\"240400\", 0.8511], [\"240500\", 0.8511], [\"259500\", 0.4255], [\"267900\", 0.4255], [\"268700\", 0.4255], [\"282200\", 0.4255], [\"282900\", 0.4255], [\"283200\", 0.4255], [\"283500\", 0.4255], [\"283700\", 1.7021], [\"283800\", 0.4255], [\"284300\", 0.4255], [\"284500\", 0.4255], [\"284600\", 1.2766], [\"284700\", 0.4255], [\"286800\", 0.4255], [\"287400\", 0.4255], [\"287800\", 0.8511], [\"287900\", 1.2766], [\"288000\", 2.9787]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n pos, neg = -inf, 0\n for val in nums:\n pos, neg = max(pos,neg)+val, pos-val\n return max(pos,neg)","runtime":"465"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n def maxNegative(left, right):\n if left > right:\n return 0\n if left == right:\n return -nums[left]\n if right == left + 1:\n return max(-nums[left] + nums[right], nums[left] - nums[right])\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \n for i in reversed(range(left, right - 1)):\n # negate i\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\n # negate i + 1\n negateNext = nums[i] + prev \n prevPrev = prev\n prev = max(negateCurr, negateNext)\n return prev\n\n N = len(nums)\n res = 0\n left = None\n for i in range(N + 1):\n if i == N or nums[i] >= 0:\n if i < N:\n res += nums[i]\n if left is not None:\n if left:\n res += maxNegative(left, i - 1)\n else:\n res += nums[0] + maxNegative(left + 1, i - 1)\n left = None\n else:\n if left is None:\n left = i\n return res","runtime":"465"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n a = nums[0]\n b = nums[0] + nums[1] if nums[1] > 0 else nums[0] - nums[1]\n for i in range(2, len(nums)):\n if nums[i] > 0:\n a = b\n b += nums[i]\n else:\n c = max(b + nums[i], a + nums[i - 1] - nums[i])\n a = b\n b = c\n return b","runtime":"474"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n prev_value = 0\n current_value = 0\n for index, num in enumerate(nums):\n if index == 0:\n new_max = current_value + num\n elif current_value + num > prev_value - num:\n new_max = current_value + num\n else:\n new_max = prev_value - num\n prev_value = current_value + num\n current_value = new_max\n return current_value","runtime":"474"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n add_result = nums[0]\n sub_result = nums[0]\n\n for i in range(1, len(nums)):\n temp_add = max(add_result, sub_result) + nums[i]\n temp_sub = add_result - nums[i]\n\n add_result = temp_add\n sub_result = temp_sub\n \n return max(add_result, sub_result)","runtime":"482"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n keep = nums[0]\n flip = nums[0]\n\n for i in range(1, len(nums)):\n keep_curr = max(keep, flip) + nums[i]\n flip_curr = keep - nums[i]\n keep = keep_curr\n flip = flip_curr\n return max(keep, flip)\n","runtime":"482"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n lastp, lastn = nums[0], float(\"-inf\")\n ans = nums[0]\n for i, v in enumerate(nums):\n if i==0:\n continue\n prevp = lastp\n prevn = lastn\n lastp = max(prevp, prevn)+v\n lastn = prevp - v\n \n \n return max(lastp, lastn)","runtime":"491"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n up = down = 0\n for num in nums[::-1]:\n up, down = num + max(up, down), -num + up\n return up","runtime":"491"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n dp[n] = 0\n dp[n-1] = nums[n-1]\n for i in range(n-2,-1,-1):\n dp[i] = max(nums[i]+dp[i+1], nums[i]-nums[i+1]+dp[i+2])\n return dp[0]","runtime":"499"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums)==1:\n return nums[0]\n\n dp = [0] * len(nums)\n dp[0] = nums[0]\n dp[1] = nums[0] + abs(nums[1])\n\n for i in range(2, len(nums)):\n dp[i] = max(nums[i]+dp[i-1], nums[i-1]-nums[i]+dp[i-2])\n\n return dp[-1]\n\n\n ","runtime":"499"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n v1, v2 = nums[-1], 0\n for i in range(len(nums) - 2, -1, -1):\n v1, v2 = max(nums[i] + v1, nums[i] - nums[i + 1] + v2), v1\n return v1","runtime":"508"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [0]*(len(nums)+1)\n dp[0] = 0\n dp[1] = nums[0]\n for i in range(1, len(nums)):\n dp[i+1] = max(dp[i]+nums[i], dp[i-1] + nums[i-1] - nums[i])\n\n return dp[-1]\n\n \n \"\"\"\n res = []\n\n \n self.dic = {}\n def findoptimal(nums, ind):\n if nums == []:\n return 0\n maxi = -float(\"inf\")\n cost = 0\n l = 0\n for i in range(len(nums)):\n cost += nums[i]*(-1)**(i)\n tup = tuple(nums[i+1:]) \n if ind+i+1 in self.dic:\n maxim = cost + self.dic[ind+i+1]\n else:\n maxim = cost + findoptimal(nums[i+1:], ind+i+1)\n \n \n \n maxi = max(maxi, maxim)\n self.dic[ind] = maxi\n return maxi\n \n \n return findoptimal(nums, 0)\n \"\"\"\n\n","runtime":"508"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n prev_value = 0\n current_value = 0\n for index, num in enumerate(nums):\n if index == 0:\n new_max = current_value + num\n else:\n new_max = max(current_value + num, prev_value + nums[index - 1] - num)\n prev_value = current_value\n current_value = new_max\n return current_value","runtime":"517"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n length = len(nums)\n DP = [-float(\"inf\")]*length\n DP[0] = nums[0]\n for i in range(1, length):\n poss = nums[i-1] - nums[i]\n if i > 1:\n poss += DP[i-2]\n DP[i] = max(DP[i-1] + nums[i], poss)\n return DP[length - 1]","runtime":"517"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n cost = [0, nums[0]]\n for i in range(1, len(nums)):\n cost.append(max([cost[-1] + nums[i], nums[i] * -1 + nums[i-1] + cost[-2]]))\n return cost[-1]\n","runtime":"525"},{"code":"class Solution:\n def maximumTotalCost(self, nums) -> int:\n n = len(nums)\n dp = [0] * (n + 1)\n\n for i in range(n - 1, -1, -1):\n dp[i] = nums[i] + dp[i + 1]\n if i != n - 1:\n dp[i] = max(dp[i], nums[i] - nums[i + 1] + dp[i + 2])\n\n return dp[0]","runtime":"525"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n DP = [0] * (len(nums) + 1)\n \n for i in range(len(nums) -1, -1, -1):\n DP[i] = DP[i+1] + nums[i]\n if(i + 1 < len(nums)): DP[i] = max(DP[i], DP[i+2] + nums[i] - nums[i+1])\n \n return DP[0]","runtime":"534"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[0, 0] for _ in range(len(nums))]\n dp[0] = [nums[0], nums[0]]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n return max(dp[-1])","runtime":"542"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n costs = [[0, 0] for _ in range(len(nums))]\n for i, num in enumerate(nums):\n if i == 0:\n costs[0] = [num, num]\n continue\n costs[i][0] = max(costs[i -1]) + num\n costs[i][1] = costs[i - 1][0] - num\n return max(costs[-1])","runtime":"551"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n if n == 1:\n return nums[0]\n\n cost = [[0] * 2 for _ in range(n)]\n # cost[pos][current num +/-] = max total cost\n\n cost[0][0] = nums[0]\n cost[1][0] = cost[0][0] + nums[1]\n cost[1][1] = cost[0][0] - nums[1]\n for i in range(2, n):\n cost[i][0] = nums[i] + max(cost[i - 1])\n cost[i][1] = cost[i - 1][0] - nums[i]\n return max(cost[-1])","runtime":"560"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[0] * 2 for _ in range(len(nums))]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i - 1]) + nums[i]\n dp[i][1] = dp[i - 1][0] - nums[i]\n # print(dp)\n return max(dp[-1])\n ","runtime":"568"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for _ in range(n)]\n \n # base case \n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n \n for i in range(1, len(nums)):\n # state 1: create a new subarray\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n # state 2: continue the previous subarray\n dp[i][1] = dp[i-1][0] - nums[i]\n \n return max(dp[n-1][0], dp[n-1][1])\n","runtime":"577"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n INF = float(\"inf\")\n dp = [[0] * 2 for _ in range(n)]; dp[0] = [nums[0], -INF]\n for i in range(1, n):\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\n dp[i][1] = dp[i - 1][0] - nums[i]\n return max(dp[n - 1])","runtime":"577"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[0, 0] for _ in range(len(nums))]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n \n return max(dp[-1])\n","runtime":"585"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for _ in range(n)]\n \n # base case \n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n \n for i in range(1, len(nums)):\n # state 1: create a new subarray\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n # state 2: continue the previous subarray\n dp[i][1] = dp[i-1][0] - nums[i]\n \n return max(dp[n-1][0], dp[n-1][1])","runtime":"585"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[0, 0] for _ in range(len(nums))]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][1], dp[i-1][0]) + nums[i] # if current num is not inverted: either prev number is inverted or start new subarr\n dp[i][1] = dp[i-1][0] - nums[i] # if current num is inverted, then prev num has to be NOT inverted\n return max(dp[-1])\n","runtime":"594"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n n = len(nums)\n if n == 1:\n return nums[0]\n \n # dp[i]: max total cost of the subarrays nums[:i+1]\n # dp[i][0]: max cost if ith element wasn't flipped\n # dp[i][1]: max cost if ith element was flipped\n dp = [[0, 0] for _ in range(n)]\n dp[0] = [nums[0], nums[0]] \n \n for i in range(1, n):\n # transition function \n dp[i][0] = max(dp[i-1][0], dp[i-1][1])+nums[i]\n dp[i][1] = dp[i-1][0]-nums[i]\n \n return max(dp[-1])\n \n ","runtime":"594"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[0, 0] for _ in range(len(nums))] # dp[i][0] has max total if we don't invert num[i], dp[i][1] has max total if we invert num[i]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][1], dp[i-1][0]) + nums[i] # if current num is not inverted: either prev number is inverted or start new subarr\n dp[i][1] = dp[i-1][0] - nums[i] # if current num is inverted, then prev num has to be NOT inverted\n return max(dp[-1])\n","runtime":"603"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n if not n:\n return 0\n dp =[[float('-inf')] * 2 for _ in range(n)]\n #dp[i][0] 前i个元素，第i个元素取“+”， dp[i][1]第一个元素取‘-’\n dp[0][0] = nums[0]\n \n for i in range(1, n):\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\n dp[i][1] = dp[i - 1][0] - nums[i]\n #print(dp)\n return max(dp[-1])","runtime":"611"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [nums[0], nums[0]]\n for i in range(1, len(nums)):\n next = [0, 0]\n for j in range(2):\n next[0] = max(dp[0], dp[1]) + nums[i]\n next[1] = dp[0] - nums[i]\n dp = next\n return max(dp[0], dp[1])","runtime":"611"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [nums[0], nums[0]]\n for i in range(1, len(nums)):\n next = [0, 0]\n for j in range(2):\n next[0] = max(dp[0], dp[1]) + nums[i]\n next[1] = dp[0] - nums[i]\n dp = next\n return max(dp[0], dp[1]) ","runtime":"620"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # dp(i, positive) = nums[i] + max(dp(i + 1, positive), dp(i + 1, negative))\n # dp(i, negative) = -nums[i] + dp(i + 1, positive)\n\n dp = []\n for _ in range(len(nums) + 1):\n dp.append([0] * 2)\n for i in reversed(range(len(nums))):\n dp[i][1] = nums[i] + max(dp[i + 1][1], dp[i + 1][0])\n dp[i][0] = -nums[i] + dp[i + 1][1]\n return dp[i][1]\n ","runtime":"620"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n n = len(nums)\n\n dp = [[0 for _ in range(2)] for _ in range(n)]\n dp[n - 1][True] = nums[n - 1]\n dp[n - 1][False] = -nums[n - 1]\n\n for i in range(n - 2, -1, -1):\n dp[i][True] = max(dp[i + 1][False], dp[i + 1][True]) + nums[i]\n dp[i][False] = dp[i + 1][True] - nums[i]\n \n return dp[0][True]","runtime":"628"},{"code":"class Solution:\n def solve( self, nums, i, memo ):\n \n n = len(nums)\n if i >= n:\n return 0\n \n if memo[i] != None:\n return memo[i]\n\n dont = self.solve( nums, i+1, memo ) + nums[i]\n take = self.solve( nums, i+2, memo ) + nums[i]\n if i+1 < n:\n take += ( -1*nums[i+1])\n \n memo[i]=max( dont, take)\n return memo[i]\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n l = len(nums)\n memo = [None]*l\n ans = self.solve( nums, 0, memo )\n return ans","runtime":"637"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # 分成长为 1 的子数组，即 nums[n−1] 单独作为一个长为 1 的子数组，接下来需要解决的问题为：nums[0] 到 a[n−2] 的最大成本和。\n # 分成长为 2 的子数组，即 nums[n−2] 和 nums[n−1] 作为一个长为 2 的子数组，\n # 接下来需要解决的问题为：nums[0] 到 nums[n−3] 的最大成本和。\n\n # 因为要解决的问题都形如「nums[0] 到 nums[i] 的最大成本和」，所以用它作为本题的状态定义 dfs(i)。\n # dfs(i)=max(dfs(i−1)+nums[i],dfs(i−2)+nums[i−1]−nums[i])\n # dfs(−1)=0, dfs(0)=nums[0]。\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\n def dfs(i: int) -> int:\n if i < 0:\n return 0\n if i == 0:\n return nums[0]\n return max(dfs(i - 1) + nums[i], dfs(i - 2) + nums[i - 1] - nums[i])\n return dfs(len(nums) - 1)\n\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。由于每个状态只会计算一次，\n# 动态规划的时间复杂度 = 状态个数 × 单个状态的计算时间。\n# 本题状态个数等于 O(n)，单个状态的计算时间为 O(1)，所以动态规划的时间复杂度为 O(n)。\n# 空间复杂度：O(n)。保存多少状态，就需要多少空间。\n\n# f[i]=max(f[i−1]+nums[i],f[i−2]+nums[i−1]−nums[i]) \n# 但是，这种定义方式没有状态能表示 i=−1 的情况。\n# 解决办法：在 f 数组的最左边插入一个值为 0 的状态，那么其余状态全部向右偏移一位，\n# 把 f[i] 改为 f[i+1]，把 f[i−1] 改为 f[i]，把 f[i−2] 改为 f[i−1]。\n# 修改后 f[i+1] 表示 nums[0] 到 nums[i] 的最大成本和。\n# 修改后的递推式为\n# f[i+1]=max(f[i]+nums[i],f[i−1]+nums[i−1]−nums[i])\n\n # n = len(nums)\n # f = [0] * (n + 1)\n # f[1] = nums[0]\n # for i in range(1, n):\n # f[i + 1] = max(f[i] + nums[i], f[i - 1] + nums[i - 1] - nums[i])\n # return f[n]\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。\n# 空间复杂度：O(n)。\n\n# 观察上面的状态转移方程，在计算 f[i+1] 时，只会用到 f[i] 和 f[i−1]，不会用到比 i−1 更早的状态。\n# 状态转移方程改为\n# f0 = f1\n# f1 = max(f1+nums[i],f0+nums[i−1]−nums[i])\n# 注意这两个式子要同时计算。\n\n# def maximumTotalCost(self, nums: List[int]) -> int:\n# f0, f1 = 0, nums[0]\n# for i in range(1, len(nums)):\n# f0, f1 = f1, max(f1 + nums[i], f0 + nums[i - 1] - nums[i])\n# return f1\n\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。\n# 空间复杂度：O(1)。","runtime":"646"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n dp = [[0 for _ in range(2)]for _ in range(len(nums))]\n dp[0][1] = nums[0]\n dp[0][0] = nums[0]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][0]+nums[i], dp[i-1][1]+nums[i])\n dp[i][1] = dp[i-1][0]-nums[i]\n return max(dp[-1])","runtime":"654"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n curr = prev = [0, 0]\n\n for i in range(n - 1, -1, -1):\n curr = [0, 0]\n for j in range(2):\n take = notT = -10 ** 9\n\n if j == 0:\n take = nums[i] + max(prev[0], prev[1])\n else:\n notT = -nums[i] + prev[0]\n\n curr[j] = max(take, notT)\n prev = curr\n \n return curr[0]","runtime":"654"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n dp = [0, 0]\n \n for i in range(len(nums) - 1, -1, -1):\n temp = [float(\"-inf\")] * 2\n temp[0] = max(temp[0], nums[i] + dp[1], nums[i] + dp[0])\n temp[1] = max(temp[1], - nums[i] + dp[0], - nums[i] + dp[0])\n dp = temp\n\n return dp[0]","runtime":"663"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[nums[0],nums[0]] for i in range(len(nums))]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n\n print(dp)\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])","runtime":"663"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for _ in range(n)]\n\n if n == 1:\n return nums[0]\n\n dp[1][0] = nums[0] + nums[1]\n dp[1][1] = nums[0] - nums[1]\n\n for i in range(2, n):\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\n dp[i][1] = dp[i - 1][0] - nums[i]\n \n print(dp)\n\n return max(dp[n - 1][0], dp[n - 1][1])","runtime":"671"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def solve(index):\n if index >= len(nums):\n return 0\n result = nums[index] + solve(index + 1)\n if index < len(nums) - 1:\n result = max(result, nums[index] - nums[index + 1] + solve(index + 2))\n return result\n return solve(0)","runtime":"680"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","runtime":"689"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache\n def go(i):\n if i == len(nums):\n return 0\n if i == len(nums)-1:\n return nums[i]\n #choice one: just add myself and go next\n c1 = nums[i] + go(i+1)\n c2 = nums[i] - nums[i+1] + go(i+2)\n return max(c1,c2)\n \n return go(0)\n \n\n\n ","runtime":"689"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n @cache\n def dp(i):\n if i >= len(nums):\n return 0 \n \n if i == len(nums) - 1:\n return nums[-1]\n \n return max(\n nums[i] + dp(i + 1), \n nums[i] - nums[i + 1] + dp(i + 2)\n )\n \n return dp(0)\n ","runtime":"697"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","runtime":"697"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","runtime":"706"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n dp = [0, 0, 0]\n \n for i in range(len(nums) - 1, -1, -1):\n temp = [float(\"-inf\")] * 3\n temp[0] = max(temp[0], nums[i] + dp[2], nums[i] + dp[0])\n temp[1] = max(temp[1], nums[i] + dp[2], nums[i] + dp[0])\n temp[2] = max(temp[2], - nums[i] + dp[1], - nums[i] + dp[0])\n dp = temp\n return dp[0]","runtime":"706"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int: \n @cache\n def f(i, can_change):\n if i == len(nums):\n return 0\n \n if i == 0:\n return nums[0] + f(i+1, True)\n else:\n if nums[i] >= 0:\n return nums[i] + f(i+1, True)\n else:\n if can_change:\n return max(f(i+1, False) - nums[i],\n f(i+1, True) + nums[i])\n else:\n return f(i+1, True) + nums[i] \n \n return f(0, True)","runtime":"714"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int: \n @cache\n def f(i, can_change):\n if i == len(nums):\n return 0\n \n if i == 0:\n return nums[0] + f(i+1, True)\n else:\n if nums[i] >= 0:\n return nums[i] + f(i+1, True)\n else:\n if can_change:\n return max(f(i+1, False) - nums[i],\n f(i+1, True) + nums[i])\n else:\n return f(i+1, True) + nums[i] \n \n return f(0, False)","runtime":"723"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[-1, -1] for _ in range(n)]\n\n def solve(idx: int, pos: bool) -> int:\n if idx >= n:\n return 0\n\n if dp[idx][pos] != -1:\n return dp[idx][pos]\n\n if pos:\n dp[idx][pos] = nums[idx] + solve(idx + 1, False)\n else:\n take = solve(idx + 1, True) - nums[idx]\n not_take = solve(idx + 1, False) + nums[idx]\n dp[idx][pos] = max(take, not_take)\n\n return dp[idx][pos]\n\n return solve(0, True)","runtime":"732"},{"code":"class Solution:\n def asd(self,i,nums,parity,dp):\n if(i>=len(nums)):\n return 0\n if(dp[i][parity]!=-1):\n return dp[i][parity]\n add=nums[i]\n if(parity==1):\n dp[i][parity]=self.asd(i+1,nums,0,dp)-nums[i]\n else:\n dp[i][parity]=max(self.asd(i+1,nums,1-parity,dp)+nums[i],self.asd(i+1,nums,parity,dp)+nums[i])\n return dp[i][parity]\n \n \n \n def maximumTotalCost(self, nums: List[int]) -> int:\n # ans=0\n # start=0\n # for i in range(len(nums)):\n # if()\n dp=[]\n for i in range(len(nums)):\n a=[]\n for j in range(2):\n a.append(-1)\n dp.append(a)\n p=self.asd(0,nums,0,dp)\n # print(dp)\n return p","runtime":"740"},{"code":"class Solution:\n # Time: O(n)\n # Space: O(n), where n = len(nums)\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n\n # Bottom-up\n n = len(nums)\n # dp[i][j]: largest sum with nums[:i] and the i-th element was flipped if flipped\n dp = [[0]*2 for i in range(n+1)]\n\n for i in range(n-1, -1, -1):\n for j in range(2):\n dp[i][j] = nums[i]\n dp[i][j] = max(dp[i][j], nums[i] + dp[i+1][0])\n if not j and i != 0:\n dp[i][j] = max(dp[i][j], -nums[i] + dp[i+1][1])\n\n return max(dp[0])\n\n\n # DP Top-down + memoization\n n = len(nums)\n cache = {}\n def dp(i, flipped):\n # Largest sum with nums[i:n] and the i-th element was flipped if flipped\n if (i, flipped) in cache:\n return cache[(i, flipped)]\n \n if i == n:\n return 0\n \n res = nums[i]\n # Take element with same sign if possible\n res = max(res, nums[i] + dp(i+1, 0))\n \n # Take element with opposite sign if possible\n if not flipped and i != 0:\n res = max(res, - nums[i] + dp(i+1, 1))\n\n cache[(i, flipped)] = res\n return res\n \n return max(dp(0, 0), dp(0, 1))\n \n\n\n","runtime":"749"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n if n == 0: return 0\n # @cache\n # def dfs(i, j):\n # if i == n: return 0\n # s = max(nums[i] * pow(-1, j) + dfs(i + 1, j + 1), nums[i] + dfs(i + 1, 0))\n # return s\n # return dfs(0, 0)\n f = [[0] * 2 for _ in range(n + 1)]\n for i in range(n - 1, -1, -1):\n for j in range(2):\n f[i][j] = max(nums[i] * pow(-1, j) + f[i + 1][(j + 1) % 2], nums[i] + f[i + 1][0])\n return f[0][0]\n ","runtime":"757"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) ==1:\n return nums[0]\n \n dp = [[0 for i in range(2)] for i in range(len(nums))]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n \n for i in range(1, len(nums)):\n\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n \n \n print(dp)\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\n \n","runtime":"766"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n if n == 0: return 0\n f = [[0] * 2 for _ in range(n + 1)]\n for i in range(n - 1, -1, -1):\n for j in range(2):\n f[i][j] = max(nums[i] * pow(-1, j) + f[i + 1][(j + 1) % 2], nums[i] + f[i + 1][0])\n return f[0][0]\n ","runtime":"775"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = {}\n for i in range(len(nums)):\n dp[i] = [None,None]\n def rec(i=0,t=True):\n if i == len(nums):\n return 0\n if t:\n if dp[i][0] != None:\n return dp[i][0]\n else:\n if dp[i][1] != None:\n return dp[i][1]\n if i == 0:\n dp[i][0] = nums[i] + max(rec(i+1,t),rec(i+1,not t))\n return dp[i][0]\n c = 0\n if t:\n c = nums[i]\n dp[i][0] = c + max(rec(i+1,t),rec(i+1,not t))\n return dp[i][0]\n else:\n c = -1*nums[i]\n dp[i][1] = c + rec(i+1,True)\n return dp[i][1]\n return rec()","runtime":"783"},{"code":"class Solution:\n def maximumTotalCost(self,nums):\n \n @cache\n def helper(i,prev):\n if i == len(nums):\n return 0\n if i == 0:\n prev = 1 \n return helper(1,1) + nums[i]\n else:\n res = 0\n if prev == 1:\n return max(helper(i + 1, 2) - nums[i], helper(i + 1, 1) + nums[i])\n else:\n return helper(i + 1, 1) + nums[i]\n \n return helper(0,0)\n","runtime":"792"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @functools.lru_cache(None)\n def dfs(i, pre_is_changed):\n if i >= l: return 0\n if pre_is_changed: \n return dfs(i+1, False) + nums[i]\n else:\n return max(dfs(i+1, True) - nums[i], dfs(i+1, False) + nums[i]) \n l = len(nums)\n return dfs(0, True)","runtime":"800"},{"code":"from typing import List\n\nclass Solution:\n def rec(self, nums: List[int], ind: int, neg: bool, dp: List[List[int]]) -> int:\n if ind == len(nums):\n return 0\n if dp[ind][int(neg)] != -1:\n return dp[ind][int(neg)]\n \n if not neg:\n # Choosing the maximum between including or not including the current number\n val = max(nums[ind] + self.rec(nums, ind + 1, True, dp),\n nums[ind] + self.rec(nums, ind + 1, False, dp))\n dp[ind][int(neg)] = val\n else:\n # Subtracting the current number and switching to non-negative choice\n dp[ind][int(neg)] = -nums[ind] + self.rec(nums, ind + 1, False, dp)\n \n return dp[ind][int(neg)]\n \n def maximumTotalCost(self, nums: List[int]) -> int:\n # Initialize a 2D DP table with -1\n dp = [[-1] * 2 for _ in range(len(nums))]\n return self.rec(nums, 0, False, dp)\n","runtime":"809"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dp(i, ok):\n if i == n: return 0\n if ok == 1:\n ans = nums[i] + dp(i+1, 0)\n else:\n ans = max(-nums[i] + dp(i+1, 1), dp(i,1))\n return ans\n return dp(0, 1)","runtime":"818"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[-1 for _ in range(2)] for _ in range(len(nums))]\n print(dp)\n def solve(i,flag,dp):\n if i == len(nums):\n return 0\n if dp[i][flag]!=-1:\n return dp[i][flag]\n if flag == 0:\n a = nums[i] + solve(i+1,0,dp)\n b = -1*nums[i] + solve(i+1,1,dp)\n else:\n a = nums[i] + solve(i+1,0,dp)\n dp[i][flag] = a\n return dp[i][flag]\n dp[i][flag] = max(a,b)\n return dp[i][flag]\n \n return nums[0] + solve(1,0,dp)","runtime":"852"},{"code":"\"\"\"\n dfs(i, j) consider a[i] ... a[-1] and \n if j == 0 +a[i] \n else -a[o]\n \n if j == 0\n dfs(i+1, 1) + a[i] alternate, the next sign must be a + no matter a[i+1] is in the same subarray or not\n if j == 1 \n if i in the same subarray, dfs(i+1, 0) - a[i]\n if i is the start of a new sub array dfs(i+1, 1) + a[i]\n\n\"\"\"\nclass Solution:\n def maximumTotalCost(self, a: List[int]) -> int:\n @cache\n def dfs(i: int, j: int) -> int:\n if i == len(a):\n return 0\n res = 0\n if j == 0:\n res = dfs(i+1, 1) + a[i]\n else:\n res = max(dfs(i+1, 0) - a[i], dfs(i+1, 1) + a[i])\n return res\n return dfs(0, 0)","runtime":"861"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def dfs(i: int, j: int) -> int:\n if i >= len(nums):\n return 0\n ans = nums[i] + dfs(i + 1, 1)\n if j == 1:\n ans = max(ans, -nums[i] + dfs(i + 1, 0))\n return ans\n\n return dfs(0, 0)","runtime":"869"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n #recursion\n '''def f(i,sign):\n if i>=n:\n return 0\n split = (sign*nums[i])+f(i+1,1)\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\n return max(split,not_split)\n n=len(nums)\n return f(0,1)'''\n #memoization\n n=len(nums)\n dp = [[None]*(3) for _ in range(n)]\n def f(i,sign):\n if i>=n:\n return 0\n if dp[i][sign+1]!=None:\n return dp[i][sign+1]\n split = (sign*nums[i])+f(i+1,1)\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\n dp[i][sign+1]=max(split,not_split)\n return dp[i][sign+1]\n return f(0,1)\n","runtime":"878"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n @cache\n def DP(index: int, positive: bool) -> int:\n # print(f'{index}:DP({index},{positive})')\n if index >= len(nums):\n return 0\n N = nums[index]\n if positive:\n answer = N + DP(index + 1, False)\n # print(f'{index}: either={answer}')\n return answer\n else:\n continue_this_subarray = -N + DP(index + 1, True)\n # print(f'{index}: merge={continue_this_subarray}')\n start_new_subarray = N + DP(index + 1, False)\n # print(f'{index}: split={start_new_subarray}')\n return max(continue_this_subarray, start_new_subarray)\n\n return DP(0, True)\n","runtime":"886"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache\n def solve(n, sign):\n if n >= len(nums):\n return 0\n # 0-pos, 1-neg\n if sign == 1:\n return -1 * nums[n] + solve(n + 1, 0)\n return max(nums[n] + solve(n + 1, 0), nums[n] + solve(n + 1, 1))\n \n return solve(0, 0)","runtime":"895"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dp(i, sign):\n if i >= n:\n return 0\n else:\n return nums[i] * sign + max(dp(i+1, 1), dp(i+1, -sign))\n return dp(0, 1)","runtime":"904"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dp(i, add):\n if i == n: return 0\n if add == True:\n ans = nums[i] + dp(i+1, False)\n else:\n ans = max(-nums[i] + dp(i+1, True), dp(i,True))\n return ans\n return dp(0, True)","runtime":"912"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def f(i, a):\n if i == n: return 0\n \n ret = a * nums[i] + f(i + 1, -a)\n if a < 0:\n ret = max(ret, nums[i] + f(i + 1, -1)) \n return ret\n\n n = len(nums)\n return f(0, 1)","runtime":"921"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache \n def f(i, j):\n if i==len(nums):\n return 0\n if j<0:\n return max(f(i+1, -1)+nums[i], f(i+1, 1)-nums[i])\n return f(i+1, -1)+nums[i]\n return f(0, 1)","runtime":"929"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int: \n @cache\n def solve(curr,sign):\n if curr>=len(nums):\n return 0\n \n if sign:\n return max(-nums[curr]+solve(curr+1,not sign),nums[curr]+solve(curr+1,sign))\n else:\n return nums[curr]+solve(curr+1,True)\n return solve(0,False)","runtime":"929"},{"code":"class Solution:\n\n\n @cache\n def solve(self, i, forcePositive):\n\n n = len(self.nums)\n if i >= n:\n return 0\n\n if forcePositive:\n return self.nums[i] + self.solve(i + 1, False)\n\n keep_positive_result = self.nums[i] + self.solve(i + 1, False)\n negate_result = -self.nums[i] + self.solve(i + 1, True)\n\n return max(keep_positive_result, negate_result)\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n self.solve.cache_clear()\n self.nums = nums\n n = len(nums)\n\n for i in reversed(range(n)):\n self.solve(i, True)\n\n return self.solve(0, True)","runtime":"938"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache\n def dfs(i, j):\n if i >= len(nums):\n return 0\n \n ans = nums[i] + dfs(i+1, 1)\n\n if j == 1:\n ans = max(ans, -nums[i] + dfs(i+1, 0))\n \n return ans\n \n return dfs(0, 0)\n\n \n ","runtime":"947"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n @cache\n def dfs(idx, canBeFlipped):\n\n if idx >= len(nums):\n return 0\n\n res = nums[idx] + dfs(idx + 1, True)\n\n if canBeFlipped:\n res = max(res, -nums[idx] + dfs(idx + 1, False))\n\n return res\n\n return dfs(0, False)","runtime":"947"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # start from index i, take another element into consideration\n # or end at ind and start new subarray from index ind+1\n dp = [[None for j in range(2)] for i in range(len(nums))]\n\n def totalCost(ind,sign):\n if ind == len(nums):\n return 0\n if dp[ind][sign] is not None:\n return dp[ind][sign]\n takeNextElement = nums[ind]*(-1)**sign + totalCost(ind+1,(1^sign))\n startNewSubarray = nums[ind] + totalCost(ind+1,1)\n\n dp[ind][sign] = max(takeNextElement, startNewSubarray)\n\n return dp[ind][sign]\n \n return totalCost(0,0)\n","runtime":"955"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dfs(i,j): #j==0,最后一段有偶数个数,j==1,最后一段有奇数个数\n if i==-1:\n return 0 if j==0 else -inf\n if j==0:\n return dfs(i-1,1-j)-nums[i]\n if j==1:\n return max(max(dfs(i-1,0),dfs(i-1,1))+nums[i],dfs(i-1,1-j)+nums[i])\n return max(dfs(n-1,0),dfs(n-1,1))\n ","runtime":"964"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def f(i, a):\n if i == n: return 0\n \n ret = -inf\n if a < 0:\n ret = nums[i] + f(i + 1, -1)\n ret = max(ret, a * nums[i] + f(i + 1, -a))\n else:\n ret = nums[i] + f(i + 1, -1)\n return ret\n\n n = len(nums)\n return f(0, 1)","runtime":"964"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def dp(i, x):\n if i == len(nums):\n return 0\n return max(x*nums[i] + dp(i+1, -x), nums[i] + dp(i+1, -1))\n return dp(0, 1)\n","runtime":"972"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n \n @cache\n def dp(i: int, sign: int) -> int:\n if i == n - 1:\n return sign * nums[i]\n return sign * nums[i] + max(dp(i + 1, -sign), dp(i + 1, 1))\n \n return dp(0, 1)","runtime":"981"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @functools.cache\n def find_max(i: int, sign: int) -> int:\n if i >= len(nums):\n return 0\n \n return nums[i] * sign + max(\n find_max(i + 1, -sign), \n find_max(i + 1, 1),\n )\n \n return find_max(0, 1)","runtime":"990"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # nums = [random.randint(-10**9,10**9) for _ in range(10**5-1)]\n @cache\n def dp(i, znak):\n if i == len(nums):\n return 0\n return max(znak*nums[i] + dp(i+1, 1 if znak == -1 else -1), nums[i]+dp(i+1,-1))\n return dp(0,1)","runtime":"998"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def dp(i, sign):\n if i >= len(nums):\n return 0\n return max(nums[i]*sign + dp(i+1, -sign), nums[i]+dp(i+1, 1))\n \n return dp(0, 1)","runtime":"1007"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def dfs(i, is_pos):\n if i == len(nums):\n return 0\n \n # continue the existing subarray\n cont = dfs(i + 1, is_pos * -1) + is_pos * nums[i]\n\n # start a new array\n start = dfs(i + 1, 1) + nums[i]\n\n return max(cont, start)\n \n return dfs(0, 1)","runtime":"1007"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n l = len(nums)\n\n @cache\n def dp(i, sign):\n if i>=l:\n return 0\n\n split = sign * nums[i] + dp(i+1, 1)\n no_split = sign * nums[i] + dp(i+1, -1*sign)\n\n return max(split, no_split)\n\n return dp(0, 1)","runtime":"1015"},{"code":"\"\"\"\nTODO O(n)\n\nThe DP is given by \n\nstarting from index i with sign pos or negative\nwhat is the max sum we can attain \n\nwe start with index 0, and positive (as per question)\nThen\n\nind 0 + continue the path \nor \nind 0 + fresh start\n\n\n[0, 1, 2, 3]\n[1, -2, 3, 4]\n\nstart - rec(i =0, pos_sign = True)\n\ncontinue construction- > nums[i] + recursion(i = 1, positive = False)\nfresh - > nums[i] + recursion(i = 1, positive + true)\n\ntake max of the above\n\n\"\"\"\nclass Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n lookup = {}\n def recursion(i, pos_sign):\n\n if (i, pos_sign) in lookup:\n return lookup[(i,pos_sign)]\n\n\n if i == len(nums):\n return 0\n\n\n ans = -math.inf \n\n next_pos = recursion(i + 1, True)\n next_neg = recursion(i + 1, False)\n\n\n # if pos_sign:\n # ans = max(ans, nums[i] + recursion(i + 1, False))\n # # fresh start\n # else:\n # ans = max(ans, -nums[i] + recursion(i + 1, True))\n\n # # \n # ans = max(ans, nums[i] + recursion(i + 1, True))\n \n\n if not pos_sign:\n ans = -nums[i] + next_pos\n else:\n ans = max(ans , nums[i] + next_pos, nums[i] + next_neg)\n lookup[(i, pos_sign)] = ans \n\n return ans\n\n return recursion(0, True)\n\n\n\n\n ","runtime":"1015"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n l = len(nums)\n @cache\n def dp(i, sign):\n if i >= l:\n return 0\n split = sign * nums[i] + dp(i+1, 1)\n no_split = sign*(nums[i]) + dp(i+1, -1*sign)\n return max(split,no_split)\n\n return dp(0, 1)","runtime":"1024"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\n '''DFS with memo'''\n n = len(nums)\n\n @cache\n def dfs(i, sign):\n if i >= n:\n return 0\n split = nums[i] * sign + dfs(i+1, 1)\n no_split = nums[i] * sign + dfs(i+1, -sign)\n return max(split, no_split)\n\n return dfs(0, 1)\n \n '''DP: top-down approach'''\n n = len(nums)\n\n if n==0: return 0\n if n==1: return nums[0]\n\n if memo is None:\n memo = {}\n if n in memo:\n return memo[n]\n\n max_cost, cur_cost = float(\"-inf\"), 0\n\n for i in range(n):\n cur_cost += nums[i] * (-1)**(i)\n rest = self.maximumTotalCost(nums[i+1:], memo)\n max_cost = max(max_cost, cur_cost + rest)\n\n memo[n] = max_cost\n print(memo)\n return max_cost","runtime":"1033"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n\n dp = [0] * (n + 1)\n\n for i in range(n):\n dp[i] = dp[i - 1] + nums[i] * (-1) ** i\n\n def cost(l, r):\n return (dp[r] - dp[l - 1]) * (-1) ** l\n \n @cache\n def best(i=0):\n if i == len(nums):\n return 0\n \n res = cost(i, i) + best(i + 1)\n if i + 1 < len(nums):\n res = max(res, cost(i, i + 1) + best(i + 2))\n \n return res\n\n return best()","runtime":"1041"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def dp(i, sign):\n if i >= len(nums):\n return 0\n return max(nums[i]*sign + dp(i+1, -sign), (nums[i]*sign)+dp(i+1, 1))\n \n return dp(0, 1)","runtime":"1050"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n N = len(nums)\n dp = {}\n\n def dfs(i , state):\n if i == N:\n return 0\n \n if (i,state) in dp:\n return dp[(i,state)]\n \n if state == 'E':\n dp[(i,state)] = max( nums[i] + dfs(i+1 , 'O') , nums[i] + dfs(i+1 , 'E') )\n\n elif state == 'O':\n dp[(i,state)] = max( -nums[i] + dfs(i+1 , 'E') , -nums[i] + dfs(i+1 , 'E') )\n \n return dp[(i,state)]\n \n return dfs(0,'E')\n","runtime":"1050"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def helper(i, oddLen):\n if i == len(nums):\n return 0\n costHere = 0\n if oddLen:\n costHere = nums[i]\n else:\n costHere = - nums[i]\n return max(costHere + helper(i+1, not oddLen), costHere + helper(i+1, True))\n return helper(0, True)","runtime":"1058"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n dp = defaultdict(int)\n\n def solution(index,sign):\n\n if index==len(nums):\n return 0\n\n if (index,sign) in dp:\n return dp[(index,sign)]\n\n extend = sign*nums[index] + solution(index+1,-1*sign)\n start_new = nums[index] + solution(index+1,1)\n\n dp[(index,sign)] = max(extend,start_new)\n\n return dp[(index,sign)]\n\n\n return solution(0,1)\n","runtime":"1067"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\n '''DFS with caching'''\n n = len(nums)\n\n @cache\n def dfs(i, sign):\n if i >= n: return 0\n\n split = nums[i] * sign + dfs(i+1, 1)\n no_split = nums[i] * sign + dfs(i+1, -sign)\n return max(split, no_split)\n\n return dfs(0, 1)\n \n \n '''DP: top-down approach'''\n n = len(nums)\n\n if n==0: return 0\n if n==1: return nums[0]\n\n if memo is None:\n memo = {}\n if n in memo:\n return memo[n]\n\n max_cost, cur_cost = float(\"-inf\"), 0\n\n for i in range(n):\n cur_cost += nums[i] * (-1)**(i)\n rest = self.maximumTotalCost(nums[i+1:], memo)\n max_cost = max(max_cost, cur_cost + rest)\n\n memo[n] = max_cost\n print(memo)\n return max_cost","runtime":"1076"},{"code":"class Solution:\n def __init__(self):\n self.dp = {}\n\n def maxCost(self, idx, prevPositive, nums):\n if idx >= len(nums):\n return 0\n\n if (idx, prevPositive) in self.dp:\n return self.dp[(idx, prevPositive)]\n\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\n\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\n\n if idx == 0:\n self.dp[(idx, prevPositive)] = startNewSubarray\n else:\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\n\n return self.dp[(idx, prevPositive)]\n\n def maximumTotalCost(self, nums):\n self.dp.clear()\n return self.maxCost(0, True, nums)","runtime":"1076"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n N = len(nums)\n\n @cache\n def solve(index, prevIsNegative):\n if index >= N:\n return 0\n\n ans = float('-inf')\n if prevIsNegative == False: # - -\n ans = max(ans, -nums[index] + solve(index + 1, True))\n ans = max(ans, nums[index] + solve(index + 1, False))\n return ans\n\n return solve(0, True)","runtime":"1084"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n cache = {}\n def dp(i, pow):\n if i == len(nums):\n return 0\n if (i,pow) in cache:\n return cache[(i,pow)]\n cut = nums[i]*pow + dp(i+1,1)\n nocut = nums[i]*pow + dp(i+1,-1*pow)\n\n cache[(i,pow)] = max(cut, nocut)\n return cache[(i,pow)]\n \n return dp(0,1)\n \n ","runtime":"1093"},{"code":"from collections import defaultdict as dd\ndef f(i, x, nums):\n if i==len(nums):\n return 0\n if d[i, x]!=-1:\n return d[i, x]\n if x==1:\n d[i, x]= max(\n f(i+1, 1, nums)+nums[i],\n f(i+1, 0, nums)-nums[i]\n )\n return d[i, x]\n d[i, x] = f(i+1, 1, nums)+nums[i]\n return d[i, x]\nclass Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n global d\n d= dd(lambda:-1)\n return f(0, 0, nums)\n ","runtime":"1101"},{"code":"class Solution:\n \n \n def __init__(self):\n self.dp = {}\n\n def maxCost(self, idx, prevPositive, nums):\n if idx >= len(nums):\n return 0\n\n if (idx, prevPositive) in self.dp:\n return self.dp[(idx, prevPositive)]\n\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\n\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\n\n if idx == 0:\n self.dp[(idx, prevPositive)] = startNewSubarray\n else:\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\n\n return self.dp[(idx, prevPositive)]\n\n def maximumTotalCost(self, nums):\n self.dp.clear()\n return self.maxCost(0, True, nums)","runtime":"1110"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n pos, neg = -inf, 0\\n for val in nums:\\n pos, neg = max(pos,neg)+val, pos-val\\n return max(pos,neg)\",\n \"runtime\": \"465\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n def maxNegative(left, right):\\n if left > right:\\n return 0\\n if left == right:\\n return -nums[left]\\n if right == left + 1:\\n return max(-nums[left] + nums[right], nums[left] - nums[right])\\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \\n for i in reversed(range(left, right - 1)):\\n # negate i\\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\\n # negate i + 1\\n negateNext = nums[i] + prev \\n prevPrev = prev\\n prev = max(negateCurr, negateNext)\\n return prev\\n\\n N = len(nums)\\n res = 0\\n left = None\\n for i in range(N + 1):\\n if i == N or nums[i] >= 0:\\n if i < N:\\n res += nums[i]\\n if left is not None:\\n if left:\\n res += maxNegative(left, i - 1)\\n else:\\n res += nums[0] + maxNegative(left + 1, i - 1)\\n left = None\\n else:\\n if left is None:\\n left = i\\n return res\",\n \"runtime\": \"465\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n a = nums[0]\\n b = nums[0] + nums[1] if nums[1] > 0 else nums[0] - nums[1]\\n for i in range(2, len(nums)):\\n if nums[i] > 0:\\n a = b\\n b += nums[i]\\n else:\\n c = max(b + nums[i], a + nums[i - 1] - nums[i])\\n a = b\\n b = c\\n return b\",\n \"runtime\": \"474\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n prev_value = 0\\n current_value = 0\\n for index, num in enumerate(nums):\\n if index == 0:\\n new_max = current_value + num\\n elif current_value + num > prev_value - num:\\n new_max = current_value + num\\n else:\\n new_max = prev_value - num\\n prev_value = current_value + num\\n current_value = new_max\\n return current_value\",\n \"runtime\": \"474\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n add_result = nums[0]\\n sub_result = nums[0]\\n\\n for i in range(1, len(nums)):\\n temp_add = max(add_result, sub_result) + nums[i]\\n temp_sub = add_result - nums[i]\\n\\n add_result = temp_add\\n sub_result = temp_sub\\n \\n return max(add_result, sub_result)\",\n \"runtime\": \"482\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n keep = nums[0]\\n flip = nums[0]\\n\\n for i in range(1, len(nums)):\\n keep_curr = max(keep, flip) + nums[i]\\n flip_curr = keep - nums[i]\\n keep = keep_curr\\n flip = flip_curr\\n return max(keep, flip)\\n\",\n \"runtime\": \"482\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n lastp, lastn = nums[0], float(\\\"-inf\\\")\\n ans = nums[0]\\n for i, v in enumerate(nums):\\n if i==0:\\n continue\\n prevp = lastp\\n prevn = lastn\\n lastp = max(prevp, prevn)+v\\n lastn = prevp - v\\n \\n \\n return max(lastp, lastn)\",\n \"runtime\": \"491\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n up = down = 0\\n for num in nums[::-1]:\\n up, down = num + max(up, down), -num + up\\n return up\",\n \"runtime\": \"491\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n dp[n] = 0\\n dp[n-1] = nums[n-1]\\n for i in range(n-2,-1,-1):\\n dp[i] = max(nums[i]+dp[i+1], nums[i]-nums[i+1]+dp[i+2])\\n return dp[0]\",\n \"runtime\": \"499\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums)==1:\\n return nums[0]\\n\\n dp = [0] * len(nums)\\n dp[0] = nums[0]\\n dp[1] = nums[0] + abs(nums[1])\\n\\n for i in range(2, len(nums)):\\n dp[i] = max(nums[i]+dp[i-1], nums[i-1]-nums[i]+dp[i-2])\\n\\n return dp[-1]\\n\\n\\n \",\n \"runtime\": \"499\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n v1, v2 = nums[-1], 0\\n for i in range(len(nums) - 2, -1, -1):\\n v1, v2 = max(nums[i] + v1, nums[i] - nums[i + 1] + v2), v1\\n return v1\",\n \"runtime\": \"508\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [0]*(len(nums)+1)\\n dp[0] = 0\\n dp[1] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i+1] = max(dp[i]+nums[i], dp[i-1] + nums[i-1] - nums[i])\\n\\n return dp[-1]\\n\\n \\n \\\"\\\"\\\"\\n res = []\\n\\n \\n self.dic = {}\\n def findoptimal(nums, ind):\\n if nums == []:\\n return 0\\n maxi = -float(\\\"inf\\\")\\n cost = 0\\n l = 0\\n for i in range(len(nums)):\\n cost += nums[i]*(-1)**(i)\\n tup = tuple(nums[i+1:]) \\n if ind+i+1 in self.dic:\\n maxim = cost + self.dic[ind+i+1]\\n else:\\n maxim = cost + findoptimal(nums[i+1:], ind+i+1)\\n \\n \\n \\n maxi = max(maxi, maxim)\\n self.dic[ind] = maxi\\n return maxi\\n \\n \\n return findoptimal(nums, 0)\\n \\\"\\\"\\\"\\n\\n\",\n \"runtime\": \"508\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n prev_value = 0\\n current_value = 0\\n for index, num in enumerate(nums):\\n if index == 0:\\n new_max = current_value + num\\n else:\\n new_max = max(current_value + num, prev_value + nums[index - 1] - num)\\n prev_value = current_value\\n current_value = new_max\\n return current_value\",\n \"runtime\": \"517\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n length = len(nums)\\n DP = [-float(\\\"inf\\\")]*length\\n DP[0] = nums[0]\\n for i in range(1, length):\\n poss = nums[i-1] - nums[i]\\n if i > 1:\\n poss += DP[i-2]\\n DP[i] = max(DP[i-1] + nums[i], poss)\\n return DP[length - 1]\",\n \"runtime\": \"517\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n cost = [0, nums[0]]\\n for i in range(1, len(nums)):\\n cost.append(max([cost[-1] + nums[i], nums[i] * -1 + nums[i-1] + cost[-2]]))\\n return cost[-1]\\n\",\n \"runtime\": \"525\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums) -> int:\\n n = len(nums)\\n dp = [0] * (n + 1)\\n\\n for i in range(n - 1, -1, -1):\\n dp[i] = nums[i] + dp[i + 1]\\n if i != n - 1:\\n dp[i] = max(dp[i], nums[i] - nums[i + 1] + dp[i + 2])\\n\\n return dp[0]\",\n \"runtime\": \"525\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n DP = [0] * (len(nums) + 1)\\n \\n for i in range(len(nums) -1, -1, -1):\\n DP[i] = DP[i+1] + nums[i]\\n if(i + 1 < len(nums)): DP[i] = max(DP[i], DP[i+2] + nums[i] - nums[i+1])\\n \\n return DP[0]\",\n \"runtime\": \"534\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[0, 0] for _ in range(len(nums))]\\n dp[0] = [nums[0], nums[0]]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n return max(dp[-1])\",\n \"runtime\": \"542\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n costs = [[0, 0] for _ in range(len(nums))]\\n for i, num in enumerate(nums):\\n if i == 0:\\n costs[0] = [num, num]\\n continue\\n costs[i][0] = max(costs[i -1]) + num\\n costs[i][1] = costs[i - 1][0] - num\\n return max(costs[-1])\",\n \"runtime\": \"551\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n == 1:\\n return nums[0]\\n\\n cost = [[0] * 2 for _ in range(n)]\\n # cost[pos][current num +/-] = max total cost\\n\\n cost[0][0] = nums[0]\\n cost[1][0] = cost[0][0] + nums[1]\\n cost[1][1] = cost[0][0] - nums[1]\\n for i in range(2, n):\\n cost[i][0] = nums[i] + max(cost[i - 1])\\n cost[i][1] = cost[i - 1][0] - nums[i]\\n return max(cost[-1])\",\n \"runtime\": \"560\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[0] * 2 for _ in range(len(nums))]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i - 1]) + nums[i]\\n dp[i][1] = dp[i - 1][0] - nums[i]\\n # print(dp)\\n return max(dp[-1])\\n \",\n \"runtime\": \"568\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for _ in range(n)]\\n \\n # base case \\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n \\n for i in range(1, len(nums)):\\n # state 1: create a new subarray\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n # state 2: continue the previous subarray\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n return max(dp[n-1][0], dp[n-1][1])\\n\",\n \"runtime\": \"577\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n INF = float(\\\"inf\\\")\\n dp = [[0] * 2 for _ in range(n)]; dp[0] = [nums[0], -INF]\\n for i in range(1, n):\\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\\n dp[i][1] = dp[i - 1][0] - nums[i]\\n return max(dp[n - 1])\",\n \"runtime\": \"577\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[0, 0] for _ in range(len(nums))]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n return max(dp[-1])\\n\",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for _ in range(n)]\\n \\n # base case \\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n \\n for i in range(1, len(nums)):\\n # state 1: create a new subarray\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n # state 2: continue the previous subarray\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n return max(dp[n-1][0], dp[n-1][1])\",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[0, 0] for _ in range(len(nums))]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][1], dp[i-1][0]) + nums[i] # if current num is not inverted: either prev number is inverted or start new subarr\\n dp[i][1] = dp[i-1][0] - nums[i] # if current num is inverted, then prev num has to be NOT inverted\\n return max(dp[-1])\\n\",\n \"runtime\": \"594\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n if n == 1:\\n return nums[0]\\n \\n # dp[i]: max total cost of the subarrays nums[:i+1]\\n # dp[i][0]: max cost if ith element wasn't flipped\\n # dp[i][1]: max cost if ith element was flipped\\n dp = [[0, 0] for _ in range(n)]\\n dp[0] = [nums[0], nums[0]] \\n \\n for i in range(1, n):\\n # transition function \\n dp[i][0] = max(dp[i-1][0], dp[i-1][1])+nums[i]\\n dp[i][1] = dp[i-1][0]-nums[i]\\n \\n return max(dp[-1])\\n \\n \",\n \"runtime\": \"594\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[0, 0] for _ in range(len(nums))] # dp[i][0] has max total if we don't invert num[i], dp[i][1] has max total if we invert num[i]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][1], dp[i-1][0]) + nums[i] # if current num is not inverted: either prev number is inverted or start new subarr\\n dp[i][1] = dp[i-1][0] - nums[i] # if current num is inverted, then prev num has to be NOT inverted\\n return max(dp[-1])\\n\",\n \"runtime\": \"603\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n if not n:\\n return 0\\n dp =[[float('-inf')] * 2 for _ in range(n)]\\n #dp[i][0] 前i个元素，第i个元素取“+”， dp[i][1]第一个元素取‘-’\\n dp[0][0] = nums[0]\\n \\n for i in range(1, n):\\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\\n dp[i][1] = dp[i - 1][0] - nums[i]\\n #print(dp)\\n return max(dp[-1])\",\n \"runtime\": \"611\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [nums[0], nums[0]]\\n for i in range(1, len(nums)):\\n next = [0, 0]\\n for j in range(2):\\n next[0] = max(dp[0], dp[1]) + nums[i]\\n next[1] = dp[0] - nums[i]\\n dp = next\\n return max(dp[0], dp[1])\",\n \"runtime\": \"611\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [nums[0], nums[0]]\\n for i in range(1, len(nums)):\\n next = [0, 0]\\n for j in range(2):\\n next[0] = max(dp[0], dp[1]) + nums[i]\\n next[1] = dp[0] - nums[i]\\n dp = next\\n return max(dp[0], dp[1]) \",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # dp(i, positive) = nums[i] + max(dp(i + 1, positive), dp(i + 1, negative))\\n # dp(i, negative) = -nums[i] + dp(i + 1, positive)\\n\\n dp = []\\n for _ in range(len(nums) + 1):\\n dp.append([0] * 2)\\n for i in reversed(range(len(nums))):\\n dp[i][1] = nums[i] + max(dp[i + 1][1], dp[i + 1][0])\\n dp[i][0] = -nums[i] + dp[i + 1][1]\\n return dp[i][1]\\n \",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n n = len(nums)\\n\\n dp = [[0 for _ in range(2)] for _ in range(n)]\\n dp[n - 1][True] = nums[n - 1]\\n dp[n - 1][False] = -nums[n - 1]\\n\\n for i in range(n - 2, -1, -1):\\n dp[i][True] = max(dp[i + 1][False], dp[i + 1][True]) + nums[i]\\n dp[i][False] = dp[i + 1][True] - nums[i]\\n \\n return dp[0][True]\",\n \"runtime\": \"628\"\n },\n {\n \"code\": \"class Solution:\\n def solve( self, nums, i, memo ):\\n \\n n = len(nums)\\n if i >= n:\\n return 0\\n \\n if memo[i] != None:\\n return memo[i]\\n\\n dont = self.solve( nums, i+1, memo ) + nums[i]\\n take = self.solve( nums, i+2, memo ) + nums[i]\\n if i+1 < n:\\n take += ( -1*nums[i+1])\\n \\n memo[i]=max( dont, take)\\n return memo[i]\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n l = len(nums)\\n memo = [None]*l\\n ans = self.solve( nums, 0, memo )\\n return ans\",\n \"runtime\": \"637\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # 分成长为 1 的子数组，即 nums[n−1] 单独作为一个长为 1 的子数组，接下来需要解决的问题为：nums[0] 到 a[n−2] 的最大成本和。\\n # 分成长为 2 的子数组，即 nums[n−2] 和 nums[n−1] 作为一个长为 2 的子数组，\\n # 接下来需要解决的问题为：nums[0] 到 nums[n−3] 的最大成本和。\\n\\n # 因为要解决的问题都形如「nums[0] 到 nums[i] 的最大成本和」，所以用它作为本题的状态定义 dfs(i)。\\n # dfs(i)=max(dfs(i−1)+nums[i],dfs(i−2)+nums[i−1]−nums[i])\\n # dfs(−1)=0, dfs(0)=nums[0]。\\n @cache # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）\\n def dfs(i: int) -> int:\\n if i < 0:\\n return 0\\n if i == 0:\\n return nums[0]\\n return max(dfs(i - 1) + nums[i], dfs(i - 2) + nums[i - 1] - nums[i])\\n return dfs(len(nums) - 1)\\n\\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。由于每个状态只会计算一次，\\n# 动态规划的时间复杂度 = 状态个数 × 单个状态的计算时间。\\n# 本题状态个数等于 O(n)，单个状态的计算时间为 O(1)，所以动态规划的时间复杂度为 O(n)。\\n# 空间复杂度：O(n)。保存多少状态，就需要多少空间。\\n\\n# f[i]=max(f[i−1]+nums[i],f[i−2]+nums[i−1]−nums[i]) \\n# 但是，这种定义方式没有状态能表示 i=−1 的情况。\\n# 解决办法：在 f 数组的最左边插入一个值为 0 的状态，那么其余状态全部向右偏移一位，\\n# 把 f[i] 改为 f[i+1]，把 f[i−1] 改为 f[i]，把 f[i−2] 改为 f[i−1]。\\n# 修改后 f[i+1] 表示 nums[0] 到 nums[i] 的最大成本和。\\n# 修改后的递推式为\\n# f[i+1]=max(f[i]+nums[i],f[i−1]+nums[i−1]−nums[i])\\n\\n # n = len(nums)\\n # f = [0] * (n + 1)\\n # f[1] = nums[0]\\n # for i in range(1, n):\\n # f[i + 1] = max(f[i] + nums[i], f[i - 1] + nums[i - 1] - nums[i])\\n # return f[n]\\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。\\n# 空间复杂度：O(n)。\\n\\n# 观察上面的状态转移方程，在计算 f[i+1] 时，只会用到 f[i] 和 f[i−1]，不会用到比 i−1 更早的状态。\\n# 状态转移方程改为\\n# f0 = f1\\n# f1 = max(f1+nums[i],f0+nums[i−1]−nums[i])\\n# 注意这两个式子要同时计算。\\n\\n# def maximumTotalCost(self, nums: List[int]) -> int:\\n# f0, f1 = 0, nums[0]\\n# for i in range(1, len(nums)):\\n# f0, f1 = f1, max(f1 + nums[i], f0 + nums[i - 1] - nums[i])\\n# return f1\\n\\n# 时间复杂度：O(n)，其中 n 为 nums 的长度。\\n# 空间复杂度：O(1)。\",\n \"runtime\": \"646\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n dp = [[0 for _ in range(2)]for _ in range(len(nums))]\\n dp[0][1] = nums[0]\\n dp[0][0] = nums[0]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][0]+nums[i], dp[i-1][1]+nums[i])\\n dp[i][1] = dp[i-1][0]-nums[i]\\n return max(dp[-1])\",\n \"runtime\": \"654\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n curr = prev = [0, 0]\\n\\n for i in range(n - 1, -1, -1):\\n curr = [0, 0]\\n for j in range(2):\\n take = notT = -10 ** 9\\n\\n if j == 0:\\n take = nums[i] + max(prev[0], prev[1])\\n else:\\n notT = -nums[i] + prev[0]\\n\\n curr[j] = max(take, notT)\\n prev = curr\\n \\n return curr[0]\",\n \"runtime\": \"654\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n dp = [0, 0]\\n \\n for i in range(len(nums) - 1, -1, -1):\\n temp = [float(\\\"-inf\\\")] * 2\\n temp[0] = max(temp[0], nums[i] + dp[1], nums[i] + dp[0])\\n temp[1] = max(temp[1], - nums[i] + dp[0], - nums[i] + dp[0])\\n dp = temp\\n\\n return dp[0]\",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[nums[0],nums[0]] for i in range(len(nums))]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n\\n print(dp)\\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\",\n \"runtime\": \"663\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for _ in range(n)]\\n\\n if n == 1:\\n return nums[0]\\n\\n dp[1][0] = nums[0] + nums[1]\\n dp[1][1] = nums[0] - nums[1]\\n\\n for i in range(2, n):\\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\\n dp[i][1] = dp[i - 1][0] - nums[i]\\n \\n print(dp)\\n\\n return max(dp[n - 1][0], dp[n - 1][1])\",\n \"runtime\": \"671\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def solve(index):\\n if index >= len(nums):\\n return 0\\n result = nums[index] + solve(index + 1)\\n if index < len(nums) - 1:\\n result = max(result, nums[index] - nums[index + 1] + solve(index + 2))\\n return result\\n return solve(0)\",\n \"runtime\": \"680\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache\\n def go(i):\\n if i == len(nums):\\n return 0\\n if i == len(nums)-1:\\n return nums[i]\\n #choice one: just add myself and go next\\n c1 = nums[i] + go(i+1)\\n c2 = nums[i] - nums[i+1] + go(i+2)\\n return max(c1,c2)\\n \\n return go(0)\\n \\n\\n\\n \",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n @cache\\n def dp(i):\\n if i >= len(nums):\\n return 0 \\n \\n if i == len(nums) - 1:\\n return nums[-1]\\n \\n return max(\\n nums[i] + dp(i + 1), \\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n \\n return dp(0)\\n \",\n \"runtime\": \"697\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"runtime\": \"697\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"runtime\": \"706\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n dp = [0, 0, 0]\\n \\n for i in range(len(nums) - 1, -1, -1):\\n temp = [float(\\\"-inf\\\")] * 3\\n temp[0] = max(temp[0], nums[i] + dp[2], nums[i] + dp[0])\\n temp[1] = max(temp[1], nums[i] + dp[2], nums[i] + dp[0])\\n temp[2] = max(temp[2], - nums[i] + dp[1], - nums[i] + dp[0])\\n dp = temp\\n return dp[0]\",\n \"runtime\": \"706\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int: \\n @cache\\n def f(i, can_change):\\n if i == len(nums):\\n return 0\\n \\n if i == 0:\\n return nums[0] + f(i+1, True)\\n else:\\n if nums[i] >= 0:\\n return nums[i] + f(i+1, True)\\n else:\\n if can_change:\\n return max(f(i+1, False) - nums[i],\\n f(i+1, True) + nums[i])\\n else:\\n return f(i+1, True) + nums[i] \\n \\n return f(0, True)\",\n \"runtime\": \"714\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int: \\n @cache\\n def f(i, can_change):\\n if i == len(nums):\\n return 0\\n \\n if i == 0:\\n return nums[0] + f(i+1, True)\\n else:\\n if nums[i] >= 0:\\n return nums[i] + f(i+1, True)\\n else:\\n if can_change:\\n return max(f(i+1, False) - nums[i],\\n f(i+1, True) + nums[i])\\n else:\\n return f(i+1, True) + nums[i] \\n \\n return f(0, False)\",\n \"runtime\": \"723\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[-1, -1] for _ in range(n)]\\n\\n def solve(idx: int, pos: bool) -> int:\\n if idx >= n:\\n return 0\\n\\n if dp[idx][pos] != -1:\\n return dp[idx][pos]\\n\\n if pos:\\n dp[idx][pos] = nums[idx] + solve(idx + 1, False)\\n else:\\n take = solve(idx + 1, True) - nums[idx]\\n not_take = solve(idx + 1, False) + nums[idx]\\n dp[idx][pos] = max(take, not_take)\\n\\n return dp[idx][pos]\\n\\n return solve(0, True)\",\n \"runtime\": \"732\"\n },\n {\n \"code\": \"class Solution:\\n def asd(self,i,nums,parity,dp):\\n if(i>=len(nums)):\\n return 0\\n if(dp[i][parity]!=-1):\\n return dp[i][parity]\\n add=nums[i]\\n if(parity==1):\\n dp[i][parity]=self.asd(i+1,nums,0,dp)-nums[i]\\n else:\\n dp[i][parity]=max(self.asd(i+1,nums,1-parity,dp)+nums[i],self.asd(i+1,nums,parity,dp)+nums[i])\\n return dp[i][parity]\\n \\n \\n \\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # ans=0\\n # start=0\\n # for i in range(len(nums)):\\n # if()\\n dp=[]\\n for i in range(len(nums)):\\n a=[]\\n for j in range(2):\\n a.append(-1)\\n dp.append(a)\\n p=self.asd(0,nums,0,dp)\\n # print(dp)\\n return p\",\n \"runtime\": \"740\"\n },\n {\n \"code\": \"class Solution:\\n # Time: O(n)\\n # Space: O(n), where n = len(nums)\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n\\n # Bottom-up\\n n = len(nums)\\n # dp[i][j]: largest sum with nums[:i] and the i-th element was flipped if flipped\\n dp = [[0]*2 for i in range(n+1)]\\n\\n for i in range(n-1, -1, -1):\\n for j in range(2):\\n dp[i][j] = nums[i]\\n dp[i][j] = max(dp[i][j], nums[i] + dp[i+1][0])\\n if not j and i != 0:\\n dp[i][j] = max(dp[i][j], -nums[i] + dp[i+1][1])\\n\\n return max(dp[0])\\n\\n\\n # DP Top-down + memoization\\n n = len(nums)\\n cache = {}\\n def dp(i, flipped):\\n # Largest sum with nums[i:n] and the i-th element was flipped if flipped\\n if (i, flipped) in cache:\\n return cache[(i, flipped)]\\n \\n if i == n:\\n return 0\\n \\n res = nums[i]\\n # Take element with same sign if possible\\n res = max(res, nums[i] + dp(i+1, 0))\\n \\n # Take element with opposite sign if possible\\n if not flipped and i != 0:\\n res = max(res, - nums[i] + dp(i+1, 1))\\n\\n cache[(i, flipped)] = res\\n return res\\n \\n return max(dp(0, 0), dp(0, 1))\\n \\n\\n\\n\",\n \"runtime\": \"749\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n == 0: return 0\\n # @cache\\n # def dfs(i, j):\\n # if i == n: return 0\\n # s = max(nums[i] * pow(-1, j) + dfs(i + 1, j + 1), nums[i] + dfs(i + 1, 0))\\n # return s\\n # return dfs(0, 0)\\n f = [[0] * 2 for _ in range(n + 1)]\\n for i in range(n - 1, -1, -1):\\n for j in range(2):\\n f[i][j] = max(nums[i] * pow(-1, j) + f[i + 1][(j + 1) % 2], nums[i] + f[i + 1][0])\\n return f[0][0]\\n \",\n \"runtime\": \"757\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) ==1:\\n return nums[0]\\n \\n dp = [[0 for i in range(2)] for i in range(len(nums))]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n \\n for i in range(1, len(nums)):\\n\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n \\n print(dp)\\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\\n \\n\",\n \"runtime\": \"766\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n == 0: return 0\\n f = [[0] * 2 for _ in range(n + 1)]\\n for i in range(n - 1, -1, -1):\\n for j in range(2):\\n f[i][j] = max(nums[i] * pow(-1, j) + f[i + 1][(j + 1) % 2], nums[i] + f[i + 1][0])\\n return f[0][0]\\n \",\n \"runtime\": \"775\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = {}\\n for i in range(len(nums)):\\n dp[i] = [None,None]\\n def rec(i=0,t=True):\\n if i == len(nums):\\n return 0\\n if t:\\n if dp[i][0] != None:\\n return dp[i][0]\\n else:\\n if dp[i][1] != None:\\n return dp[i][1]\\n if i == 0:\\n dp[i][0] = nums[i] + max(rec(i+1,t),rec(i+1,not t))\\n return dp[i][0]\\n c = 0\\n if t:\\n c = nums[i]\\n dp[i][0] = c + max(rec(i+1,t),rec(i+1,not t))\\n return dp[i][0]\\n else:\\n c = -1*nums[i]\\n dp[i][1] = c + rec(i+1,True)\\n return dp[i][1]\\n return rec()\",\n \"runtime\": \"783\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self,nums):\\n \\n @cache\\n def helper(i,prev):\\n if i == len(nums):\\n return 0\\n if i == 0:\\n prev = 1 \\n return helper(1,1) + nums[i]\\n else:\\n res = 0\\n if prev == 1:\\n return max(helper(i + 1, 2) - nums[i], helper(i + 1, 1) + nums[i])\\n else:\\n return helper(i + 1, 1) + nums[i]\\n \\n return helper(0,0)\\n\",\n \"runtime\": \"792\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @functools.lru_cache(None)\\n def dfs(i, pre_is_changed):\\n if i >= l: return 0\\n if pre_is_changed: \\n return dfs(i+1, False) + nums[i]\\n else:\\n return max(dfs(i+1, True) - nums[i], dfs(i+1, False) + nums[i]) \\n l = len(nums)\\n return dfs(0, True)\",\n \"runtime\": \"800\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def rec(self, nums: List[int], ind: int, neg: bool, dp: List[List[int]]) -> int:\\n if ind == len(nums):\\n return 0\\n if dp[ind][int(neg)] != -1:\\n return dp[ind][int(neg)]\\n \\n if not neg:\\n # Choosing the maximum between including or not including the current number\\n val = max(nums[ind] + self.rec(nums, ind + 1, True, dp),\\n nums[ind] + self.rec(nums, ind + 1, False, dp))\\n dp[ind][int(neg)] = val\\n else:\\n # Subtracting the current number and switching to non-negative choice\\n dp[ind][int(neg)] = -nums[ind] + self.rec(nums, ind + 1, False, dp)\\n \\n return dp[ind][int(neg)]\\n \\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # Initialize a 2D DP table with -1\\n dp = [[-1] * 2 for _ in range(len(nums))]\\n return self.rec(nums, 0, False, dp)\\n\",\n \"runtime\": \"809\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dp(i, ok):\\n if i == n: return 0\\n if ok == 1:\\n ans = nums[i] + dp(i+1, 0)\\n else:\\n ans = max(-nums[i] + dp(i+1, 1), dp(i,1))\\n return ans\\n return dp(0, 1)\",\n \"runtime\": \"818\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[-1 for _ in range(2)] for _ in range(len(nums))]\\n print(dp)\\n def solve(i,flag,dp):\\n if i == len(nums):\\n return 0\\n if dp[i][flag]!=-1:\\n return dp[i][flag]\\n if flag == 0:\\n a = nums[i] + solve(i+1,0,dp)\\n b = -1*nums[i] + solve(i+1,1,dp)\\n else:\\n a = nums[i] + solve(i+1,0,dp)\\n dp[i][flag] = a\\n return dp[i][flag]\\n dp[i][flag] = max(a,b)\\n return dp[i][flag]\\n \\n return nums[0] + solve(1,0,dp)\",\n \"runtime\": \"852\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\n dfs(i, j) consider a[i] ... a[-1] and \\n if j == 0 +a[i] \\n else -a[o]\\n \\n if j == 0\\n dfs(i+1, 1) + a[i] alternate, the next sign must be a + no matter a[i+1] is in the same subarray or not\\n if j == 1 \\n if i in the same subarray, dfs(i+1, 0) - a[i]\\n if i is the start of a new sub array dfs(i+1, 1) + a[i]\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maximumTotalCost(self, a: List[int]) -> int:\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i == len(a):\\n return 0\\n res = 0\\n if j == 0:\\n res = dfs(i+1, 1) + a[i]\\n else:\\n res = max(dfs(i+1, 0) - a[i], dfs(i+1, 1) + a[i])\\n return res\\n return dfs(0, 0)\",\n \"runtime\": \"861\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i >= len(nums):\\n return 0\\n ans = nums[i] + dfs(i + 1, 1)\\n if j == 1:\\n ans = max(ans, -nums[i] + dfs(i + 1, 0))\\n return ans\\n\\n return dfs(0, 0)\",\n \"runtime\": \"869\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n #recursion\\n '''def f(i,sign):\\n if i>=n:\\n return 0\\n split = (sign*nums[i])+f(i+1,1)\\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\\n return max(split,not_split)\\n n=len(nums)\\n return f(0,1)'''\\n #memoization\\n n=len(nums)\\n dp = [[None]*(3) for _ in range(n)]\\n def f(i,sign):\\n if i>=n:\\n return 0\\n if dp[i][sign+1]!=None:\\n return dp[i][sign+1]\\n split = (sign*nums[i])+f(i+1,1)\\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\\n dp[i][sign+1]=max(split,not_split)\\n return dp[i][sign+1]\\n return f(0,1)\\n\",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n @cache\\n def DP(index: int, positive: bool) -> int:\\n # print(f'{index}:DP({index},{positive})')\\n if index >= len(nums):\\n return 0\\n N = nums[index]\\n if positive:\\n answer = N + DP(index + 1, False)\\n # print(f'{index}: either={answer}')\\n return answer\\n else:\\n continue_this_subarray = -N + DP(index + 1, True)\\n # print(f'{index}: merge={continue_this_subarray}')\\n start_new_subarray = N + DP(index + 1, False)\\n # print(f'{index}: split={start_new_subarray}')\\n return max(continue_this_subarray, start_new_subarray)\\n\\n return DP(0, True)\\n\",\n \"runtime\": \"886\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache\\n def solve(n, sign):\\n if n >= len(nums):\\n return 0\\n # 0-pos, 1-neg\\n if sign == 1:\\n return -1 * nums[n] + solve(n + 1, 0)\\n return max(nums[n] + solve(n + 1, 0), nums[n] + solve(n + 1, 1))\\n \\n return solve(0, 0)\",\n \"runtime\": \"895\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dp(i, sign):\\n if i >= n:\\n return 0\\n else:\\n return nums[i] * sign + max(dp(i+1, 1), dp(i+1, -sign))\\n return dp(0, 1)\",\n \"runtime\": \"904\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dp(i, add):\\n if i == n: return 0\\n if add == True:\\n ans = nums[i] + dp(i+1, False)\\n else:\\n ans = max(-nums[i] + dp(i+1, True), dp(i,True))\\n return ans\\n return dp(0, True)\",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def f(i, a):\\n if i == n: return 0\\n \\n ret = a * nums[i] + f(i + 1, -a)\\n if a < 0:\\n ret = max(ret, nums[i] + f(i + 1, -1)) \\n return ret\\n\\n n = len(nums)\\n return f(0, 1)\",\n \"runtime\": \"921\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache \\n def f(i, j):\\n if i==len(nums):\\n return 0\\n if j<0:\\n return max(f(i+1, -1)+nums[i], f(i+1, 1)-nums[i])\\n return f(i+1, -1)+nums[i]\\n return f(0, 1)\",\n \"runtime\": \"929\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int: \\n @cache\\n def solve(curr,sign):\\n if curr>=len(nums):\\n return 0\\n \\n if sign:\\n return max(-nums[curr]+solve(curr+1,not sign),nums[curr]+solve(curr+1,sign))\\n else:\\n return nums[curr]+solve(curr+1,True)\\n return solve(0,False)\",\n \"runtime\": \"929\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n @cache\\n def solve(self, i, forcePositive):\\n\\n n = len(self.nums)\\n if i >= n:\\n return 0\\n\\n if forcePositive:\\n return self.nums[i] + self.solve(i + 1, False)\\n\\n keep_positive_result = self.nums[i] + self.solve(i + 1, False)\\n negate_result = -self.nums[i] + self.solve(i + 1, True)\\n\\n return max(keep_positive_result, negate_result)\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n self.solve.cache_clear()\\n self.nums = nums\\n n = len(nums)\\n\\n for i in reversed(range(n)):\\n self.solve(i, True)\\n\\n return self.solve(0, True)\",\n \"runtime\": \"938\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache\\n def dfs(i, j):\\n if i >= len(nums):\\n return 0\\n \\n ans = nums[i] + dfs(i+1, 1)\\n\\n if j == 1:\\n ans = max(ans, -nums[i] + dfs(i+1, 0))\\n \\n return ans\\n \\n return dfs(0, 0)\\n\\n \\n \",\n \"runtime\": \"947\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n @cache\\n def dfs(idx, canBeFlipped):\\n\\n if idx >= len(nums):\\n return 0\\n\\n res = nums[idx] + dfs(idx + 1, True)\\n\\n if canBeFlipped:\\n res = max(res, -nums[idx] + dfs(idx + 1, False))\\n\\n return res\\n\\n return dfs(0, False)\",\n \"runtime\": \"947\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # start from index i, take another element into consideration\\n # or end at ind and start new subarray from index ind+1\\n dp = [[None for j in range(2)] for i in range(len(nums))]\\n\\n def totalCost(ind,sign):\\n if ind == len(nums):\\n return 0\\n if dp[ind][sign] is not None:\\n return dp[ind][sign]\\n takeNextElement = nums[ind]*(-1)**sign + totalCost(ind+1,(1^sign))\\n startNewSubarray = nums[ind] + totalCost(ind+1,1)\\n\\n dp[ind][sign] = max(takeNextElement, startNewSubarray)\\n\\n return dp[ind][sign]\\n \\n return totalCost(0,0)\\n\",\n \"runtime\": \"955\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i,j): #j==0,最后一段有偶数个数,j==1,最后一段有奇数个数\\n if i==-1:\\n return 0 if j==0 else -inf\\n if j==0:\\n return dfs(i-1,1-j)-nums[i]\\n if j==1:\\n return max(max(dfs(i-1,0),dfs(i-1,1))+nums[i],dfs(i-1,1-j)+nums[i])\\n return max(dfs(n-1,0),dfs(n-1,1))\\n \",\n \"runtime\": \"964\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def f(i, a):\\n if i == n: return 0\\n \\n ret = -inf\\n if a < 0:\\n ret = nums[i] + f(i + 1, -1)\\n ret = max(ret, a * nums[i] + f(i + 1, -a))\\n else:\\n ret = nums[i] + f(i + 1, -1)\\n return ret\\n\\n n = len(nums)\\n return f(0, 1)\",\n \"runtime\": \"964\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def dp(i, x):\\n if i == len(nums):\\n return 0\\n return max(x*nums[i] + dp(i+1, -x), nums[i] + dp(i+1, -1))\\n return dp(0, 1)\\n\",\n \"runtime\": \"972\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n @cache\\n def dp(i: int, sign: int) -> int:\\n if i == n - 1:\\n return sign * nums[i]\\n return sign * nums[i] + max(dp(i + 1, -sign), dp(i + 1, 1))\\n \\n return dp(0, 1)\",\n \"runtime\": \"981\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @functools.cache\\n def find_max(i: int, sign: int) -> int:\\n if i >= len(nums):\\n return 0\\n \\n return nums[i] * sign + max(\\n find_max(i + 1, -sign), \\n find_max(i + 1, 1),\\n )\\n \\n return find_max(0, 1)\",\n \"runtime\": \"990\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # nums = [random.randint(-10**9,10**9) for _ in range(10**5-1)]\\n @cache\\n def dp(i, znak):\\n if i == len(nums):\\n return 0\\n return max(znak*nums[i] + dp(i+1, 1 if znak == -1 else -1), nums[i]+dp(i+1,-1))\\n return dp(0,1)\",\n \"runtime\": \"998\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def dp(i, sign):\\n if i >= len(nums):\\n return 0\\n return max(nums[i]*sign + dp(i+1, -sign), nums[i]+dp(i+1, 1))\\n \\n return dp(0, 1)\",\n \"runtime\": \"1007\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def dfs(i, is_pos):\\n if i == len(nums):\\n return 0\\n \\n # continue the existing subarray\\n cont = dfs(i + 1, is_pos * -1) + is_pos * nums[i]\\n\\n # start a new array\\n start = dfs(i + 1, 1) + nums[i]\\n\\n return max(cont, start)\\n \\n return dfs(0, 1)\",\n \"runtime\": \"1007\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n l = len(nums)\\n\\n @cache\\n def dp(i, sign):\\n if i>=l:\\n return 0\\n\\n split = sign * nums[i] + dp(i+1, 1)\\n no_split = sign * nums[i] + dp(i+1, -1*sign)\\n\\n return max(split, no_split)\\n\\n return dp(0, 1)\",\n \"runtime\": \"1015\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nTODO O(n)\\n\\nThe DP is given by \\n\\nstarting from index i with sign pos or negative\\nwhat is the max sum we can attain \\n\\nwe start with index 0, and positive (as per question)\\nThen\\n\\nind 0 + continue the path \\nor \\nind 0 + fresh start\\n\\n\\n[0, 1, 2, 3]\\n[1, -2, 3, 4]\\n\\nstart - rec(i =0, pos_sign = True)\\n\\ncontinue construction- > nums[i] + recursion(i = 1, positive = False)\\nfresh - > nums[i] + recursion(i = 1, positive + true)\\n\\ntake max of the above\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n lookup = {}\\n def recursion(i, pos_sign):\\n\\n if (i, pos_sign) in lookup:\\n return lookup[(i,pos_sign)]\\n\\n\\n if i == len(nums):\\n return 0\\n\\n\\n ans = -math.inf \\n\\n next_pos = recursion(i + 1, True)\\n next_neg = recursion(i + 1, False)\\n\\n\\n # if pos_sign:\\n # ans = max(ans, nums[i] + recursion(i + 1, False))\\n # # fresh start\\n # else:\\n # ans = max(ans, -nums[i] + recursion(i + 1, True))\\n\\n # # \\n # ans = max(ans, nums[i] + recursion(i + 1, True))\\n \\n\\n if not pos_sign:\\n ans = -nums[i] + next_pos\\n else:\\n ans = max(ans , nums[i] + next_pos, nums[i] + next_neg)\\n lookup[(i, pos_sign)] = ans \\n\\n return ans\\n\\n return recursion(0, True)\\n\\n\\n\\n\\n \",\n \"runtime\": \"1015\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n l = len(nums)\\n @cache\\n def dp(i, sign):\\n if i >= l:\\n return 0\\n split = sign * nums[i] + dp(i+1, 1)\\n no_split = sign*(nums[i]) + dp(i+1, -1*sign)\\n return max(split,no_split)\\n\\n return dp(0, 1)\",\n \"runtime\": \"1024\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\\n '''DFS with memo'''\\n n = len(nums)\\n\\n @cache\\n def dfs(i, sign):\\n if i >= n:\\n return 0\\n split = nums[i] * sign + dfs(i+1, 1)\\n no_split = nums[i] * sign + dfs(i+1, -sign)\\n return max(split, no_split)\\n\\n return dfs(0, 1)\\n \\n '''DP: top-down approach'''\\n n = len(nums)\\n\\n if n==0: return 0\\n if n==1: return nums[0]\\n\\n if memo is None:\\n memo = {}\\n if n in memo:\\n return memo[n]\\n\\n max_cost, cur_cost = float(\\\"-inf\\\"), 0\\n\\n for i in range(n):\\n cur_cost += nums[i] * (-1)**(i)\\n rest = self.maximumTotalCost(nums[i+1:], memo)\\n max_cost = max(max_cost, cur_cost + rest)\\n\\n memo[n] = max_cost\\n print(memo)\\n return max_cost\",\n \"runtime\": \"1033\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n\\n dp = [0] * (n + 1)\\n\\n for i in range(n):\\n dp[i] = dp[i - 1] + nums[i] * (-1) ** i\\n\\n def cost(l, r):\\n return (dp[r] - dp[l - 1]) * (-1) ** l\\n \\n @cache\\n def best(i=0):\\n if i == len(nums):\\n return 0\\n \\n res = cost(i, i) + best(i + 1)\\n if i + 1 < len(nums):\\n res = max(res, cost(i, i + 1) + best(i + 2))\\n \\n return res\\n\\n return best()\",\n \"runtime\": \"1041\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def dp(i, sign):\\n if i >= len(nums):\\n return 0\\n return max(nums[i]*sign + dp(i+1, -sign), (nums[i]*sign)+dp(i+1, 1))\\n \\n return dp(0, 1)\",\n \"runtime\": \"1050\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n N = len(nums)\\n dp = {}\\n\\n def dfs(i , state):\\n if i == N:\\n return 0\\n \\n if (i,state) in dp:\\n return dp[(i,state)]\\n \\n if state == 'E':\\n dp[(i,state)] = max( nums[i] + dfs(i+1 , 'O') , nums[i] + dfs(i+1 , 'E') )\\n\\n elif state == 'O':\\n dp[(i,state)] = max( -nums[i] + dfs(i+1 , 'E') , -nums[i] + dfs(i+1 , 'E') )\\n \\n return dp[(i,state)]\\n \\n return dfs(0,'E')\\n\",\n \"runtime\": \"1050\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def helper(i, oddLen):\\n if i == len(nums):\\n return 0\\n costHere = 0\\n if oddLen:\\n costHere = nums[i]\\n else:\\n costHere = - nums[i]\\n return max(costHere + helper(i+1, not oddLen), costHere + helper(i+1, True))\\n return helper(0, True)\",\n \"runtime\": \"1058\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n dp = defaultdict(int)\\n\\n def solution(index,sign):\\n\\n if index==len(nums):\\n return 0\\n\\n if (index,sign) in dp:\\n return dp[(index,sign)]\\n\\n extend = sign*nums[index] + solution(index+1,-1*sign)\\n start_new = nums[index] + solution(index+1,1)\\n\\n dp[(index,sign)] = max(extend,start_new)\\n\\n return dp[(index,sign)]\\n\\n\\n return solution(0,1)\\n\",\n \"runtime\": \"1067\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\\n '''DFS with caching'''\\n n = len(nums)\\n\\n @cache\\n def dfs(i, sign):\\n if i >= n: return 0\\n\\n split = nums[i] * sign + dfs(i+1, 1)\\n no_split = nums[i] * sign + dfs(i+1, -sign)\\n return max(split, no_split)\\n\\n return dfs(0, 1)\\n \\n \\n '''DP: top-down approach'''\\n n = len(nums)\\n\\n if n==0: return 0\\n if n==1: return nums[0]\\n\\n if memo is None:\\n memo = {}\\n if n in memo:\\n return memo[n]\\n\\n max_cost, cur_cost = float(\\\"-inf\\\"), 0\\n\\n for i in range(n):\\n cur_cost += nums[i] * (-1)**(i)\\n rest = self.maximumTotalCost(nums[i+1:], memo)\\n max_cost = max(max_cost, cur_cost + rest)\\n\\n memo[n] = max_cost\\n print(memo)\\n return max_cost\",\n \"runtime\": \"1076\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.dp = {}\\n\\n def maxCost(self, idx, prevPositive, nums):\\n if idx >= len(nums):\\n return 0\\n\\n if (idx, prevPositive) in self.dp:\\n return self.dp[(idx, prevPositive)]\\n\\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\\n\\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\\n\\n if idx == 0:\\n self.dp[(idx, prevPositive)] = startNewSubarray\\n else:\\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\\n\\n return self.dp[(idx, prevPositive)]\\n\\n def maximumTotalCost(self, nums):\\n self.dp.clear()\\n return self.maxCost(0, True, nums)\",\n \"runtime\": \"1076\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n N = len(nums)\\n\\n @cache\\n def solve(index, prevIsNegative):\\n if index >= N:\\n return 0\\n\\n ans = float('-inf')\\n if prevIsNegative == False: # - -\\n ans = max(ans, -nums[index] + solve(index + 1, True))\\n ans = max(ans, nums[index] + solve(index + 1, False))\\n return ans\\n\\n return solve(0, True)\",\n \"runtime\": \"1084\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n cache = {}\\n def dp(i, pow):\\n if i == len(nums):\\n return 0\\n if (i,pow) in cache:\\n return cache[(i,pow)]\\n cut = nums[i]*pow + dp(i+1,1)\\n nocut = nums[i]*pow + dp(i+1,-1*pow)\\n\\n cache[(i,pow)] = max(cut, nocut)\\n return cache[(i,pow)]\\n \\n return dp(0,1)\\n \\n \",\n \"runtime\": \"1093\"\n },\n {\n \"code\": \"from collections import defaultdict as dd\\ndef f(i, x, nums):\\n if i==len(nums):\\n return 0\\n if d[i, x]!=-1:\\n return d[i, x]\\n if x==1:\\n d[i, x]= max(\\n f(i+1, 1, nums)+nums[i],\\n f(i+1, 0, nums)-nums[i]\\n )\\n return d[i, x]\\n d[i, x] = f(i+1, 1, nums)+nums[i]\\n return d[i, x]\\nclass Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n global d\\n d= dd(lambda:-1)\\n return f(0, 0, nums)\\n \",\n \"runtime\": \"1101\"\n },\n {\n \"code\": \"class Solution:\\n \\n \\n def __init__(self):\\n self.dp = {}\\n\\n def maxCost(self, idx, prevPositive, nums):\\n if idx >= len(nums):\\n return 0\\n\\n if (idx, prevPositive) in self.dp:\\n return self.dp[(idx, prevPositive)]\\n\\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\\n\\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\\n\\n if idx == 0:\\n self.dp[(idx, prevPositive)] = startNewSubarray\\n else:\\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\\n\\n return self.dp[(idx, prevPositive)]\\n\\n def maximumTotalCost(self, nums):\\n self.dp.clear()\\n return self.maxCost(0, True, nums)\",\n \"runtime\": \"1110\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":98,"string":"98"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n first, second = 0, nums[0]\n for i in range(1, len(nums)):\n val = max([second + nums[i], nums[i] * -1 + nums[i-1] + first])\n first, second = second, val\n return second\n","memory":"29900"},{"code":"class Solution:\n def maximumTotalCost(self,nums):\n n = len(nums)\n a,b = nums[0], -float(\"inf\")\n for i in range(1,n):\n c = max( b + nums[i], a + nums[i])\n d = a - nums[i]\n a , b = c, d\n return max(a,b)","memory":"30300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n pos, neg = -inf, 0\n for a in nums:\n pos, neg = max(pos, neg) + a, pos - a\n return max(pos, neg)","memory":"30600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dpPos = nums[0]\n dpNeg = nums[0]\n for i in range(1, len(nums)):\n oldDpPos = dpPos\n dpPos = max(dpNeg + nums[i], dpPos + nums[i])\n dpNeg = oldDpPos - nums[i]\n return max(dpNeg, dpPos)","memory":"30700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n def maxNegative(left, right):\n if left > right:\n return 0\n if left == right:\n return -nums[left]\n if right == left + 1:\n return max(-nums[left] + nums[right], nums[left] - nums[right])\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \n for i in reversed(range(left, right - 1)):\n # negate i\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\n # negate i + 1\n negateNext = nums[i] + prev \n prevPrev = prev\n prev = max(negateCurr, negateNext)\n return prev\n\n N = len(nums)\n res = 0\n left = None\n for i in range(N + 1):\n if i == N or nums[i] >= 0:\n if i < N:\n res += nums[i]\n if left is not None:\n if left:\n res += maxNegative(left, i - 1)\n else:\n res += nums[0] + maxNegative(left + 1, i - 1)\n left = None\n else:\n if left is None:\n left = i\n return res","memory":"30800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n def maxNegative(left, right):\n if left > right:\n return 0\n if left == right:\n return -nums[left]\n if right == left + 1:\n return max(-nums[left] + nums[right], nums[left] - nums[right])\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \n for i in reversed(range(left, right - 1)):\n # negate i\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\n # negate i + 1\n negateNext = nums[i] + prev \n prevPrev = prev\n prev = max(negateCurr, negateNext)\n return prev\n\n N = len(nums)\n res = 0\n left = None\n for i in range(N + 1):\n if i == N or nums[i] >= 0:\n if i < N:\n res += nums[i]\n if left is not None:\n if left:\n res += maxNegative(left, i - 1)\n else:\n res += nums[0] + maxNegative(left + 1, i - 1)\n left = None\n else:\n if left is None:\n left = i\n return res\n ","memory":"30900"},{"code":"class Solution:\n def maximumTotalCost(self, nums) -> int:\n n = len(nums)\n dp = [0] * (n + 1)\n\n for i in range(n - 1, -1, -1):\n dp[i] = nums[i] + dp[i + 1]\n if i != n - 1:\n dp[i] = max(dp[i], nums[i] - nums[i + 1] + dp[i + 2])\n\n return dp[0]","memory":"31000"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n N = len(nums)\n dp = [-1] * N\n dp[-1] = nums[-1]\n dp.append(0)\n\n for i in range(N - 2, -1, -1):\n dp[i] = max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\n \n return dp[0]\n","memory":"31100"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [0]*(n+1)\n dp[n] = 0\n dp[n-1] = nums[n-1]\n for i in range(n-2,-1,-1):\n dp[i] = max(nums[i]+dp[i+1], nums[i]-nums[i+1]+dp[i+2])\n return dp[0]","memory":"31200"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums)==1:\n return nums[0]\n tail_pos, tail_neg=nums[0]+nums[1], nums[0]-nums[1]\n for v in nums[2:]:\n next_pos=max(tail_pos, tail_neg)+v\n next_neg=tail_pos-v\n tail_pos, tail_neg=next_pos, next_neg\n return max(tail_pos, tail_neg)\n\n ","memory":"31300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums)==1:\n return nums[0]\n tail_pos, tail_neg=nums[0]+nums[1], nums[0]-nums[1]\n for v in nums[2:]:\n # next_pos=max(tail_pos, tail_neg)+v\n # next_neg=tail_pos-v\n # tail_pos, tail_neg=next_pos, next_neg\n tail_pos, tail_neg=max(tail_pos, tail_neg)+v, tail_pos-v\n\n return max(tail_pos, tail_neg)\n\n ","memory":"31300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n\n prev_flipped = nums[0] - nums[1]\n prev_non_flipped = nums[0] + nums[1]\n\n for n in nums[2:]:\n prev_flipped, prev_non_flipped = prev_non_flipped - n, max(prev_flipped, prev_non_flipped) + n\n\n return max(prev_flipped, prev_non_flipped) \n","memory":"31400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n if n == 1:\n return nums[0]\n dpo, dpe = [0] * n, [0] * n\n dpo[0] = nums[0]\n dpo[1] = dpo[0] + nums[1]\n dpe[1] = dpo[0] - nums[1]\n for i in range(2, n):\n dpo[i] = max(dpo[i-1], dpe[i-1]) + nums[i]\n dpe[i] = dpo[i-1] - nums[i]\n return max(dpo[-1], dpe[-1])","memory":"32299"},{"code":"class Solution:\n def maximumTotalCost(self, a: List[int]) -> int:\n n = len(a)\n if n == 1:\n return a[0]\n f = [0] * n\n g = [0] * n\n f[1] = a[0] + a[1]\n g[1] = a[0] - a[1]\n for i in range(2, n):\n f[i] = max(g[i-1], f[i-1]) + a[i]\n g[i] = f[i-1] - a[i]\n return max(f[n-1], g[n-1])","memory":"32600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # O(n) in DP \n # cost[i] = max(cost[i-1] + bin(len(cost[i-1])) * nums[i], cost[i-1] * !bin(len(cost[i-1]])))\n \n dp_p = [0] * len(nums)\n dp_n = [0] * len(nums)\n \n dp_p[0] = nums[0]\n dp_n[0] = nums[0] \n\n for i in range(1, len(nums)):\n dp_p[i] = max(dp_n[i - 1] + nums[i], dp_p[i - 1] + nums[i])\n dp_n[i] = dp_p[i - 1] - nums[i]\n\n return max(dp_p[len(nums) - 1], dp_n[len(nums) - 1])\n","memory":"32700"},{"code":"class Solution:\n def maximumTotalCost(self, num: List[int]) -> int:\n plus = [num[0]]\n minus = [num[0]]\n\n for i in range(1, len(num)):\n a = plus[-1]\n b = minus[-1]\n plus.append(max(a + num[i], b + num[i]))\n minus.append(a - num[i])\n\n return max(plus[-1], minus[-1])","memory":"33100"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n plus = [nums[0]]\n minus = [nums[0]]\n for i in nums[1:]:\n plus.append(max(plus[-1], minus[-1]) + i)\n minus.append(plus[-2] - i)\n return max(plus[-1], minus[-1])","memory":"33700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return nums[0]\n \n maximums = [(nums[0], False), (nums[0] + (nums[1] if nums[1] >= 0 else -1 * nums[1]), nums[1] < 0)]\n for num_index in range(2, len(nums)):\n curr_num = nums[num_index]\n if curr_num >= 0:\n maximums.append((maximums[-1][0] + curr_num, False))\n else:\n if maximums[-1][1]:\n previous_num = nums[num_index - 1]\n if (maximums[-2][0] + (previous_num - curr_num)) > (maximums[-1][0] + curr_num):\n maximums.append((maximums[-2][0] + (previous_num - curr_num), True))\n else:\n maximums.append((maximums[-1][0] + curr_num, False))\n else:\n maximums.append((maximums[-1][0] + -1 * curr_num, True))\n return maximums[-1][0]","memory":"35600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums)==1:\n return nums[0]\n\n sums = []\n total = 0\n first = nums[0]\n nums[0] = 0\n\n for i in range(len(nums)):\n if i%2==0:\n total+=nums[i]\n else:\n total-=nums[i]\n sums.append(total)\n \n print(sums)\n dp = [-float('inf') for x in sums]\n dp[0] = 0\n dp[1] = abs(sums[1])\n\n print(dp)\n\n for i in range(2, len(nums)):\n dp[i] = max(nums[i]+dp[i-1], nums[i-1]-nums[i]+dp[i-2])\n \n print(dp)\n\n\n\n\n return dp[-1]+first\n\n\n ","memory":"37900"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # cost(i,j) = i < k < j max(cost(i, k) - min cost(k + 1, j), cost(i, k) + max cost(k + 1, j))\n n = len(nums)\n\n dp = [[0,0] for _ in range(n + 1)]\n for i in range(n - 1, -1, -1):\n currPositive = nums[i] + max(dp[i+1][0], dp[i+1][1])\n currNegative = -nums[i] + dp[i+1][0]\n dp[i][0], dp[i][1] = currPositive, currNegative\n return dp[0][0]\n # Wrong\n# n = len(nums)\n# cost = [[[0, 0] for _ in range(n)] for _ in range(n)]\n# for i in range(n):\n# cost[i][i][0] = nums[i]\n# cost[i][i][1] = -nums[i]\n# for delta in range(1, n):\n# for i in range(n):\n# j = i + delta\n# if j >= n:\n# break\n# currCost = max([cost[i][i][0] + cost[i+1][j][0],\\\n# cost[i][i][0] + cost[i+1][j][1],\\\n# cost[i][j-1][0] + cost[j][j][0]]),\\\n# cost[i][j-1][0] + cost[j][j][1]])\n# cost[i][j][0] = currCost\n# cost[i][j][1] = -currCost\n# return cost[0][n-1][0]","memory":"40000"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # dp(i, positive) = nums[i] + max(dp(i + 1, positive), dp(i + 1, negative))\n # dp(i, negative) = -nums[i] + dp(i + 1, positive)\n\n dp = []\n for _ in range(len(nums) + 1):\n dp.append([0] * 2)\n for i in reversed(range(len(nums))):\n dp[i][1] = nums[i] + max(dp[i + 1][1], dp[i + 1][0])\n dp[i][0] = -nums[i] + dp[i + 1][1]\n return dp[i][1]\n ","memory":"40100"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for _ in range(n)]\n \n # base case \n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n \n for i in range(1, len(nums)):\n # state 1: create a new subarray\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n # state 2: continue the previous subarray\n dp[i][1] = dp[i-1][0] - nums[i]\n \n return max(dp[n-1][0], dp[n-1][1])","memory":"40200"},{"code":"class Solution:\n def maximumTotalCost(self,nums):\n\n\n n = len(nums)\n\n dp = [[-float(\"inf\") for i in range(2)] for i in range(n)]\n\n dp[0][0] = nums[0]\n\n for i in range(1,n):\n dp[i][0] = max(dp[i-1][1] + nums[i], dp[i-1][0] + nums[i])\n dp[i][1] = dp[i-1][0] - nums[i]\n # print(dp[-1])\n return max(dp[-1])\n\n @cache\n def helper(i,prev):\n if i == len(nums):\n return 0\n if i == 0:\n prev = 1 \n return helper(1,1) + nums[i]\n else:\n res = 0\n if prev == 1:\n return max(helper(i + 1, 2) - nums[i], helper(i + 1, 1) + nums[i])\n else:\n return helper(i + 1, 1) + nums[i]\n \n return helper(0,0)\n","memory":"44900"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0, 0] for _ in range(n)]\n\n if n == 1:\n return nums[0]\n\n dp[1][0] = nums[0] + nums[1]\n dp[1][1] = nums[0] - nums[1]\n\n for i in range(2, n):\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\n dp[i][1] = dp[i - 1][0] - nums[i]\n \n print(dp)\n\n return max(dp[n - 1][0], dp[n - 1][1])","memory":"47000"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[nums[0],nums[0]] for i in range(len(nums))]\n for i in range(1, len(nums)):\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n\n print(dp)\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])","memory":"47300"},{"code":"class Solution:\n def solve( self, nums, i, memo ):\n \n n = len(nums)\n if i >= n:\n return 0\n \n if memo[i] != None:\n return memo[i]\n\n dont = self.solve( nums, i+1, memo ) + nums[i]\n take = self.solve( nums, i+2, memo ) + nums[i]\n if i+1 < n:\n take += ( -1*nums[i+1])\n \n memo[i]=max( dont, take)\n return memo[i]\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n l = len(nums)\n memo = [None]*l\n ans = self.solve( nums, 0, memo )\n return ans","memory":"47700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n if len(nums) ==1:\n return nums[0]\n \n dp = [[0 for i in range(2)] for i in range(len(nums))]\n dp[0][0] = nums[0]\n dp[0][1] = nums[0]\n \n for i in range(1, len(nums)):\n\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\n dp[i][1] = dp[i-1][0] - nums[i]\n \n \n print(dp)\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\n \n","memory":"48400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[-1, -1] for _ in range(n)]\n\n def solve(idx: int, pos: bool) -> int:\n if idx >= n:\n return 0\n\n if dp[idx][pos] != -1:\n return dp[idx][pos]\n\n if pos:\n dp[idx][pos] = nums[idx] + solve(idx + 1, False)\n else:\n take = solve(idx + 1, True) - nums[idx]\n not_take = solve(idx + 1, False) + nums[idx]\n dp[idx][pos] = max(take, not_take)\n\n return dp[idx][pos]\n\n return solve(0, True)","memory":"54400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n def rec(nums, i, dp):\n n = len(nums)\n\n if i >= n: return 0\n if i == n - 1: return nums[i]\n \n if i+1 not in dp:\n dp[i + 1] = rec(nums, i + 1, dp)\n \n if i+2 not in dp:\n dp[i + 2] = rec(nums, i + 2, dp)\n\n return max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\n \n return rec(nums, 0, {})","memory":"55500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n def rec(nums, i, dp):\n n = len(nums)\n\n if i >= n: return 0\n if i == n - 1: return nums[i]\n \n if i+1 not in dp:\n dp[i + 1] = rec(nums, i + 1, dp)\n \n if i+2 not in dp:\n dp[i + 2] = rec(nums, i + 2, dp)\n\n return max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\n \n return rec(nums, 0, {})","memory":"55600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = [[-1 for _ in range(2)] for _ in range(len(nums))]\n print(dp)\n def solve(i,flag,dp):\n if i == len(nums):\n return 0\n if dp[i][flag]!=-1:\n return dp[i][flag]\n if flag == 0:\n a = nums[i] + solve(i+1,0,dp)\n b = -1*nums[i] + solve(i+1,1,dp)\n else:\n a = nums[i] + solve(i+1,0,dp)\n dp[i][flag] = a\n return dp[i][flag]\n dp[i][flag] = max(a,b)\n return dp[i][flag]\n \n return nums[0] + solve(1,0,dp)","memory":"55700"},{"code":"class Solution:\n def asd(self,i,nums,parity,dp):\n if(i>=len(nums)):\n return 0\n if(dp[i][parity]!=-1):\n return dp[i][parity]\n add=nums[i]\n if(parity==1):\n dp[i][parity]=self.asd(i+1,nums,0,dp)-nums[i]\n else:\n dp[i][parity]=max(self.asd(i+1,nums,1-parity,dp)+nums[i],self.asd(i+1,nums,parity,dp)+nums[i])\n return dp[i][parity]\n \n \n \n def maximumTotalCost(self, nums: List[int]) -> int:\n # ans=0\n # start=0\n # for i in range(len(nums)):\n # if()\n dp=[]\n for i in range(len(nums)):\n a=[]\n for j in range(2):\n a.append(-1)\n dp.append(a)\n p=self.asd(0,nums,0,dp)\n # print(dp)\n return p","memory":"56000"},{"code":"from typing import List\n\nclass Solution:\n def rec(self, nums: List[int], ind: int, neg: bool, dp: List[List[int]]) -> int:\n if ind == len(nums):\n return 0\n if dp[ind][int(neg)] != -1:\n return dp[ind][int(neg)]\n \n if not neg:\n # Choosing the maximum between including or not including the current number\n val = max(nums[ind] + self.rec(nums, ind + 1, True, dp),\n nums[ind] + self.rec(nums, ind + 1, False, dp))\n dp[ind][int(neg)] = val\n else:\n # Subtracting the current number and switching to non-negative choice\n dp[ind][int(neg)] = -nums[ind] + self.rec(nums, ind + 1, False, dp)\n \n return dp[ind][int(neg)]\n \n def maximumTotalCost(self, nums: List[int]) -> int:\n # Initialize a 2D DP table with -1\n dp = [[-1] * 2 for _ in range(len(nums))]\n return self.rec(nums, 0, False, dp)\n","memory":"57000"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # start from index i, take another element into consideration\n # or end at ind and start new subarray from index ind+1\n dp = [[None for j in range(2)] for i in range(len(nums))]\n\n def totalCost(ind,sign):\n if ind == len(nums):\n return 0\n if dp[ind][sign] is not None:\n return dp[ind][sign]\n takeNextElement = nums[ind]*(-1)**sign + totalCost(ind+1,(1^sign))\n startNewSubarray = nums[ind] + totalCost(ind+1,1)\n\n dp[ind][sign] = max(takeNextElement, startNewSubarray)\n\n return dp[ind][sign]\n \n return totalCost(0,0)\n","memory":"58400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n #recursion\n '''def f(i,sign):\n if i>=n:\n return 0\n split = (sign*nums[i])+f(i+1,1)\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\n return max(split,not_split)\n n=len(nums)\n return f(0,1)'''\n #memoization\n n=len(nums)\n dp = [[None]*(3) for _ in range(n)]\n def f(i,sign):\n if i>=n:\n return 0\n if dp[i][sign+1]!=None:\n return dp[i][sign+1]\n split = (sign*nums[i])+f(i+1,1)\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\n dp[i][sign+1]=max(split,not_split)\n return dp[i][sign+1]\n return f(0,1)\n","memory":"59800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp = {}\n for i in range(len(nums)):\n dp[i] = [None,None]\n def rec(i=0,t=True):\n if i == len(nums):\n return 0\n if t:\n if dp[i][0] != None:\n return dp[i][0]\n else:\n if dp[i][1] != None:\n return dp[i][1]\n if i == 0:\n dp[i][0] = nums[i] + max(rec(i+1,t),rec(i+1,not t))\n return dp[i][0]\n c = 0\n if t:\n c = nums[i]\n dp[i][0] = c + max(rec(i+1,t),rec(i+1,not t))\n return dp[i][0]\n else:\n c = -1*nums[i]\n dp[i][1] = c + rec(i+1,True)\n return dp[i][1]\n return rec()","memory":"68200"},{"code":"class Solution:\n \n \n def __init__(self):\n self.dp = {}\n\n def maxCost(self, idx, prevPositive, nums):\n if idx >= len(nums):\n return 0\n\n if (idx, prevPositive) in self.dp:\n return self.dp[(idx, prevPositive)]\n\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\n\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\n\n if idx == 0:\n self.dp[(idx, prevPositive)] = startNewSubarray\n else:\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\n\n return self.dp[(idx, prevPositive)]\n\n def maximumTotalCost(self, nums):\n self.dp.clear()\n return self.maxCost(0, True, nums)","memory":"72100"},{"code":"from collections import defaultdict as dd\ndef f(i, x, nums):\n if i==len(nums):\n return 0\n if d[i, x]!=-1:\n return d[i, x]\n if x==1:\n d[i, x]= max(\n f(i+1, 1, nums)+nums[i],\n f(i+1, 0, nums)-nums[i]\n )\n return d[i, x]\n d[i, x] = f(i+1, 1, nums)+nums[i]\n return d[i, x]\nclass Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n global d\n d= dd(lambda:-1)\n return f(0, 0, nums)\n ","memory":"78100"},{"code":"class Solution:\n\n\n @cache\n def solve(self, i, forcePositive):\n\n n = len(self.nums)\n if i >= n:\n return 0\n\n if forcePositive:\n return self.nums[i] + self.solve(i + 1, False)\n\n keep_positive_result = self.nums[i] + self.solve(i + 1, False)\n negate_result = -self.nums[i] + self.solve(i + 1, True)\n\n return max(keep_positive_result, negate_result)\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n self.solve.cache_clear()\n self.nums = nums\n n = len(nums)\n\n for i in reversed(range(n)):\n self.solve(i, True)\n\n return self.solve(0, True)","memory":"78600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dfs(i, inv):\n if i == n: return 0\n #Start new subarr\n res = dfs(i+1, 1)+nums[i]\n #Continue subarr\n if inv:\n res = max(res, dfs(i+1, inv^1)-nums[i])\n return res\n res = dfs(0, 0)\n dfs.cache_clear()\n return res","memory":"145000"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache\n def go(i):\n if i == len(nums):\n return 0\n if i == len(nums)-1:\n return nums[i]\n #choice one: just add myself and go next\n c1 = nums[i] + go(i+1)\n c2 = nums[i] - nums[i+1] + go(i+2)\n return max(c1,c2)\n \n return go(0)\n \n\n\n ","memory":"169800"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","memory":"170400"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","memory":"170500"},{"code":"class Solution:\n\n def maximumTotalCost(self, nums: List[int]) -> int:\n @lru_cache(None)\n def dp(i):\n if i >= len(nums):\n return 0\n\n if i == len(nums) - 1:\n return nums[-1]\n\n return max(\n nums[i] + dp(i + 1),\n nums[i] - nums[i + 1] + dp(i + 2)\n )\n\n return dp(0)","memory":"170500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def best(i=0):\n if i == len(nums):\n return 0\n \n res = nums[i] + best(i + 1)\n if i + 1 < len(nums):\n res = max(res, nums[i] - nums[i + 1] + best(i + 2))\n \n return res\n\n return best()","memory":"171200"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def solve(index):\n if index >= len(nums):\n return 0\n result = nums[index] + solve(index + 1)\n if index < len(nums) - 1:\n result = max(result, nums[index] - nums[index + 1] + solve(index + 2))\n return result\n return solve(0)","memory":"171300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n\n dp = [0] * (n + 1)\n\n for i in range(n):\n dp[i] = dp[i - 1] + nums[i] * (-1) ** i\n\n def cost(l, r):\n return (dp[r] - dp[l - 1]) * (-1) ** l\n \n @cache\n def best(i=0):\n if i == len(nums):\n return 0\n \n res = cost(i, i) + best(i + 1)\n if i + 1 < len(nums):\n res = max(res, cost(i, i + 1) + best(i + 2))\n \n return res\n\n return best()","memory":"193200"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int: \n @cache\n def f(i, can_change):\n if i == len(nums):\n return 0\n \n if i == 0:\n return nums[0] + f(i+1, True)\n else:\n if nums[i] >= 0:\n return nums[i] + f(i+1, True)\n else:\n if can_change:\n return max(f(i+1, False) - nums[i],\n f(i+1, True) + nums[i])\n else:\n return f(i+1, True) + nums[i] \n \n return f(0, False)","memory":"216300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def maxCost(idx,sign):\n if idx == len(nums): return 0\n if sign < 0: return nums[idx]+maxCost(idx+1,-sign)\n if nums[idx] < 0:\n ans = max(nums[idx]+maxCost(idx+1,sign),-nums[idx]+maxCost(idx+1,-sign))\n return ans\n return nums[idx] + maxCost(idx+1,sign)\n return maxCost(0,-1)","memory":"217100"},{"code":"\"\"\"\nTODO O(n)\n\nThe DP is given by \n\nstarting from index i with sign pos or negative\nwhat is the max sum we can attain \n\nwe start with index 0, and positive (as per question)\nThen\n\nind 0 + continue the path \nor \nind 0 + fresh start\n\n\n[0, 1, 2, 3]\n[1, -2, 3, 4]\n\nstart - rec(i =0, pos_sign = True)\n\ncontinue construction- > nums[i] + recursion(i = 1, positive = False)\nfresh - > nums[i] + recursion(i = 1, positive + true)\n\ntake max of the above\n\n\"\"\"\nclass Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n lookup = {}\n def recursion(i, pos_sign):\n\n if (i, pos_sign) in lookup:\n return lookup[(i,pos_sign)]\n\n\n if i == len(nums):\n return 0\n\n\n ans = -math.inf \n\n next_pos = recursion(i + 1, True)\n next_neg = recursion(i + 1, False)\n\n\n # if pos_sign:\n # ans = max(ans, nums[i] + recursion(i + 1, False))\n # # fresh start\n # else:\n # ans = max(ans, -nums[i] + recursion(i + 1, True))\n\n # # \n # ans = max(ans, nums[i] + recursion(i + 1, True))\n \n\n if not pos_sign:\n ans = -nums[i] + next_pos\n else:\n ans = max(ans , nums[i] + next_pos, nums[i] + next_neg)\n lookup[(i, pos_sign)] = ans \n\n return ans\n\n return recursion(0, True)\n\n\n\n\n ","memory":"221700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n\n N = len(nums)\n dp = {}\n\n def dfs(i , state):\n if i == N:\n return 0\n \n if (i,state) in dp:\n return dp[(i,state)]\n \n if state == 'E':\n dp[(i,state)] = max( nums[i] + dfs(i+1 , 'O') , nums[i] + dfs(i+1 , 'E') )\n\n elif state == 'O':\n dp[(i,state)] = max( -nums[i] + dfs(i+1 , 'E') , -nums[i] + dfs(i+1 , 'E') )\n \n return dp[(i,state)]\n \n return dfs(0,'E')\n","memory":"221800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n cache = {}\n def max_total(index, sign):\n if index>=len(nums):\n return 0 \n if (index, sign) in cache:\n return cache[(index, sign)]\n # be part of the subarray \n ans = float('-inf')\n if sign == -1: # prev element is start of subarray\n \n a = max_total(index+1, 1) + sign*nums[index] # be part of it\n b = max_total(index+1, -1) + nums[index] # start new\n \n ans = max(a,b)\n \n else: #signed = 1 # prev element isn't start of subarray\n a = max_total(index+1, 1) + nums[index]# be part of it\n b = max_total(index+1, -1) + nums[index] # start new\n ans = max(a, b)\n cache[(index, sign)] = ans \n return ans \n return max_total(0, 1)","memory":"224800"},{"code":"class Solution:\n # Time: O()\n # Space: O(), where n = len(nums)\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n # DP Top-down + memoization\n n = len(nums)\n cache = {}\n def dp(i, flipped):\n # Largest sum with nums[i:n] and the i-th element was flipped if flipped\n if (i, flipped) in cache:\n return cache[(i, flipped)]\n \n if i == n:\n return 0\n \n res = nums[i]\n # Take element with same sign if possible\n res = max(res, nums[i] + dp(i+1, 0))\n \n # Take element with opposite sign if possible\n if not flipped and i != 0:\n res = max(res, - nums[i] + dp(i+1, 1))\n\n cache[(i, flipped)] = res\n return res\n \n return max(dp(0, 0), dp(0, 1))\n \n\n\n","memory":"225500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n dp = defaultdict(int)\n\n def solution(index,sign):\n\n if index==len(nums):\n return 0\n\n if (index,sign) in dp:\n return dp[(index,sign)]\n\n extend = sign*nums[index] + solution(index+1,-1*sign)\n start_new = nums[index] + solution(index+1,1)\n\n dp[(index,sign)] = max(extend,start_new)\n\n return dp[(index,sign)]\n\n\n return solution(0,1)\n","memory":"225600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n dp = defaultdict(int)\n\n def solution(index,sign):\n\n if index==len(nums):\n return 0\n\n if (index,sign) in dp:\n return dp[(index,sign)]\n\n extend = sign*nums[index] + solution(index+1,-1*sign)\n start_new = nums[index] + solution(index+1,1)\n\n dp[(index,sign)] = max(extend,start_new)\n\n return dp[(index,sign)]\n\n\n return solution(0,1)\n","memory":"225600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n hashing={}\n length=len(nums)\n if length==1:\n return nums[0]\n hashing[(1, 0)]=nums[0]+nums[1]\n hashing[(1, 1)]=nums[0]-nums[1]\n def order(i, j):\n try:\n return hashing[(i, j)]\n except:\n print('',end='')\n if j==0:\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\n else:\n hashing[(i, j)]=order(i-1, 0)-nums[i]\n return hashing[(i, j)]\n return max([order(length-1, 0), order(length-1, 1)])\n","memory":"240400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n hashing={}\n length=len(nums)\n if length==1:\n return nums[0]\n hashing[(1, 0)]=nums[0]+nums[1]\n hashing[(1, 1)]=nums[0]-nums[1]\n def order(i, j):\n try:\n return hashing[(i, j)]\n except:\n print('',end='')\n if j==0:\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\n else:\n hashing[(i, j)]=order(i-1, 0)-nums[i]\n return hashing[(i, j)]\n return max([order(length-1, 0), order(length-1, 1)])\n","memory":"240400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n hashing={}\n length=len(nums)\n if length==1:\n return nums[0]\n hashing[(1, 0)]=nums[0]+nums[1]\n hashing[(1, 1)]=nums[0]-nums[1]\n def order(i, j):\n try:\n return hashing[(i, j)]\n except:\n print('',end='')\n if j==0:\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\n else:\n hashing[(i, j)]=order(i-1, 0)-nums[i]\n return hashing[(i, j)]\n return max([order(length-1, 0), order(length-1, 1)])\n","memory":"240500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n hashing={}\n length=len(nums)\n if length==1:\n return nums[0]\n hashing[(1, 0)]=nums[0]+nums[1]\n hashing[(1, 1)]=nums[0]-nums[1]\n def order(i, j):\n try:\n return hashing[(i, j)]\n except:\n print('',end='')\n if j==0:\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\n else:\n hashing[(i, j)]=order(i-1, 0)-nums[i]\n return hashing[(i, j)]\n return max([order(length-1, 0), order(length-1, 1)])\n","memory":"240500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n dp={}\n def dfs(i,isStart,sign):\n if i==len(nums):\n return 0\n if (i,isStart,sign) in dp:\n return dp[(i,isStart,sign)]\n ans=float(\"-inf\")\n if isStart==0:\n ans=max(ans,nums[i]+dfs(i+1,1,1))\n else:\n if sign==1:\n ans=max(ans,-nums[i]+dfs(i+1,1,0))\n ans=max(ans,dfs(i,0,0))\n else:\n ans=max(ans,nums[i]+dfs(i+1,1,1))\n ans=max(ans,dfs(i,0,0))\n dp[(i,isStart,sign)]=ans\n return dp[(i,isStart,sign)]\n return dfs(0,0,0)\n\n\n nums=[abs(n) for n in nums]\n return sum(nums)","memory":"259500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dp(i, ok):\n if i == n: return 0\n if ok == 1:\n ans = nums[i] + dp(i+1, 0)\n else:\n ans = max(-nums[i] + dp(i+1, 1), dp(i,1))\n return ans\n return dp(0, 1)","memory":"267900"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dp(i, add):\n if i == n: return 0\n if add == True:\n ans = nums[i] + dp(i+1, False)\n else:\n ans = max(-nums[i] + dp(i+1, True), dp(i,True))\n return ans\n return dp(0, True)","memory":"268700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n l = len(nums)\n @cache\n def dp(i, sign):\n if i >= l:\n return 0\n split = sign * nums[i] + dp(i+1, 1)\n no_split = sign*(nums[i]) + dp(i+1, -1*sign)\n return max(split,no_split)\n\n return dp(0, 1)","memory":"282200"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n #prefix sum starting from even and odd & just start new/dont\n # prefixStartPos = [0]\n # prefixStartNeg = [0]\n # for i in range(0, len(nums)):\n # if i % 2 == 1:\n # prefixStartPos.append(prefixStartPos[-1]-nums[i])\n # prefixStartNeg.append(prefixStartNeg[-1]+nums[i])\n # else:\n # prefixStartPos.append(prefixStartPos[-1]+nums[i])\n # prefixStartNeg.append(prefixStartNeg[-1]-nums[i])\n \n @cache\n def dp(i, curPos):\n if i >= len(nums):\n return 0\n if not curPos:\n return -nums[i]+dp(i+1, True)\n else:\n return nums[i] + max(dp(i+1, False), dp(i+1, True))\n return dp(0, True)\n","memory":"282900"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n N=len(nums)\n @cache\n def dfs(i,p):\n if i==N:\n return 0\n \n if p:\n res=nums[i]+max(dfs(i+1,1),dfs(i+1,0))\n else:\n res=-nums[i]+dfs(i+1,1)\n return res\n return dfs(0,1)\n\n ","memory":"283200"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def dfs(i,j): #j==0,最后一段有偶数个数,j==1,最后一段有奇数个数\n if i==-1:\n return 0 if j==0 else -inf\n if j==0:\n return dfs(i-1,1-j)-nums[i]\n if j==1:\n return max(max(dfs(i-1,0),dfs(i-1,1))+nums[i],dfs(i-1,1-j)+nums[i])\n return max(dfs(n-1,0),dfs(n-1,1))\n ","memory":"283500"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\n '''DFS with caching'''\n n = len(nums)\n\n @cache\n def dfs(i, sign):\n if i >= n: return 0\n\n split = nums[i] * sign + dfs(i+1, 1)\n no_split = nums[i] * sign + dfs(i+1, -sign)\n return max(split, no_split)\n\n return dfs(0, 1)\n \n \n '''DP: top-down approach'''\n n = len(nums)\n\n if n==0: return 0\n if n==1: return nums[0]\n\n if memo is None:\n memo = {}\n if n in memo:\n return memo[n]\n\n max_cost, cur_cost = float(\"-inf\"), 0\n\n for i in range(n):\n cur_cost += nums[i] * (-1)**(i)\n rest = self.maximumTotalCost(nums[i+1:], memo)\n max_cost = max(max_cost, cur_cost + rest)\n\n memo[n] = max_cost\n print(memo)\n return max_cost","memory":"283700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n l = len(nums)\n\n @cache\n def dp(i, sign):\n if i>=l:\n return 0\n\n split = sign * nums[i] + dp(i+1, 1)\n no_split = sign * nums[i] + dp(i+1, -1*sign)\n\n return max(split, no_split)\n\n return dp(0, 1)","memory":"283800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache\n def solve(n, sign):\n if n >= len(nums):\n return 0\n # 0-pos, 1-neg\n if sign == 1:\n return -1 * nums[n] + solve(n + 1, 0)\n return max(nums[n] + solve(n + 1, 0), nums[n] + solve(n + 1, 1))\n \n return solve(0, 0)","memory":"284300"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def helper(i, oddLen):\n if i == len(nums):\n return 0\n costHere = 0\n if oddLen:\n costHere = nums[i]\n else:\n costHere = - nums[i]\n return max(costHere + helper(i+1, not oddLen), costHere + helper(i+1, True))\n return helper(0, True)","memory":"284500"},{"code":"from functools import cache\nfrom math import inf\nclass Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n \n @cache \n def recursion(index, flipState):\n if index >= len(nums):\n return 0\n currentNumber = nums[index] * (-1 if flipState else 1)\n # Continue the sequence\n continued = currentNumber + recursion(index+1, not flipState)\n # Start new sequence\n new_sequence = currentNumber + recursion(index+1, False)\n # Take the best route\n return max(continued, new_sequence)\n return recursion(0, False)\n\n","memory":"284600"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n \n @cache\n def dp(i: int, sign: int) -> int:\n if i == n - 1:\n return sign * nums[i]\n return sign * nums[i] + max(dp(i + 1, -sign), dp(i + 1, 1))\n \n return dp(0, 1)","memory":"284700"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int: \n @cache\n def solve(curr,sign):\n if curr>=len(nums):\n return 0\n \n if sign:\n return max(-nums[curr]+solve(curr+1,not sign),nums[curr]+solve(curr+1,sign))\n else:\n return nums[curr]+solve(curr+1,True)\n return solve(0,False)","memory":"286800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n n = len(nums)\n self.max_cost = -float('inf')\n \n # @lru_cache(None)\n # def backtrack(i, cost):\n # if i==n:\n # return cost\n\n # return max(max(cost+nums[i] - backtrack(i+1, cost+nums[i]), cost+nums[i]+backtrack(i+1, cost+nums[i])), cost - nums[i] + backtrack(i+1, cost - nums[i]))\n # # if i==n:\n # # return 0\n\n # # if sign=='+':\n # # self.max_cost = max(nums[i] + backtrack(i+1, '-'), self.max_cost)\n # # self.max_cost = max(nums[i] + backtrack(i+1, '+'), self.max_cost)\n # # else:\n # # self.max_cost = max(-nums[i] + backtrack(i+1, '+'), self.max_cost)\n \n # # return self.max_cost\n\n \n # return backtrack(0,0)\n\n # return self.max_cost\n \n @lru_cache(None)\n def backtrack(i, sign):\n if i==n:\n return 0\n\n cost1, cost2, cost3 = -float('inf'), -float('inf'),-float('inf')\n\n if sign=='+':\n cost1 = nums[i] + backtrack(i+1, '+')\n cost2 = nums[i] + backtrack(i+1, '-')\n else:\n cost3 = -nums[i] + backtrack(i+1, '+')\n\n return max(max(cost1, cost2), cost3)\n\n \n return backtrack(0, '+')\n","memory":"287400"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def f(i, p):\n if i == n: return 0\n \n if p < 0:\n return nums[i] + f(i + 1, 1)\n else:\n return max(nums[i] + f(i + 1, 1), -nums[i] + f(i + 1, -1)) \n\n n = len(nums)\n return f(0, -1)","memory":"287800"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/3100-3199/3196.Maximize%20Total%20Cost%20of%20Alternating%20Subarrays\n @cache\n def dfs(i: int, j: int) -> int:\n if i >= len(nums):\n return 0\n ans = nums[i] + dfs(i + 1, 1)\n if j == 1:\n ans = max(ans, -nums[i] + dfs(i + 1, 0))\n return ans\n\n return dfs(0, 0)","memory":"287900"},{"code":"class Solution:\n def maximumTotalCost(self, nums: List[int]) -> int:\n @cache\n def f(i, p):\n if i == n: return 0\n \n # Lead\n ret = nums[i] + f(i + 1, 1)\n\n # Follow\n if p < 0:\n return ret\n else:\n return max(ret, -nums[i] + f(i + 1, -1)) \n\n n = len(nums)\n return f(0, -1)","memory":"288000"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n first, second = 0, nums[0]\\n for i in range(1, len(nums)):\\n val = max([second + nums[i], nums[i] * -1 + nums[i-1] + first])\\n first, second = second, val\\n return second\\n\",\n \"memory\": \"29900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self,nums):\\n n = len(nums)\\n a,b = nums[0], -float(\\\"inf\\\")\\n for i in range(1,n):\\n c = max( b + nums[i], a + nums[i])\\n d = a - nums[i]\\n a , b = c, d\\n return max(a,b)\",\n \"memory\": \"30300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n pos, neg = -inf, 0\\n for a in nums:\\n pos, neg = max(pos, neg) + a, pos - a\\n return max(pos, neg)\",\n \"memory\": \"30600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dpPos = nums[0]\\n dpNeg = nums[0]\\n for i in range(1, len(nums)):\\n oldDpPos = dpPos\\n dpPos = max(dpNeg + nums[i], dpPos + nums[i])\\n dpNeg = oldDpPos - nums[i]\\n return max(dpNeg, dpPos)\",\n \"memory\": \"30700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n def maxNegative(left, right):\\n if left > right:\\n return 0\\n if left == right:\\n return -nums[left]\\n if right == left + 1:\\n return max(-nums[left] + nums[right], nums[left] - nums[right])\\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \\n for i in reversed(range(left, right - 1)):\\n # negate i\\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\\n # negate i + 1\\n negateNext = nums[i] + prev \\n prevPrev = prev\\n prev = max(negateCurr, negateNext)\\n return prev\\n\\n N = len(nums)\\n res = 0\\n left = None\\n for i in range(N + 1):\\n if i == N or nums[i] >= 0:\\n if i < N:\\n res += nums[i]\\n if left is not None:\\n if left:\\n res += maxNegative(left, i - 1)\\n else:\\n res += nums[0] + maxNegative(left + 1, i - 1)\\n left = None\\n else:\\n if left is None:\\n left = i\\n return res\",\n \"memory\": \"30800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n def maxNegative(left, right):\\n if left > right:\\n return 0\\n if left == right:\\n return -nums[left]\\n if right == left + 1:\\n return max(-nums[left] + nums[right], nums[left] - nums[right])\\n prev, prevPrev = max(-nums[right - 1] + nums[right], nums[right - 1] - nums[right]), -nums[right] \\n for i in reversed(range(left, right - 1)):\\n # negate i\\n negateCurr = -nums[i] + nums[i + 1] + prevPrev\\n # negate i + 1\\n negateNext = nums[i] + prev \\n prevPrev = prev\\n prev = max(negateCurr, negateNext)\\n return prev\\n\\n N = len(nums)\\n res = 0\\n left = None\\n for i in range(N + 1):\\n if i == N or nums[i] >= 0:\\n if i < N:\\n res += nums[i]\\n if left is not None:\\n if left:\\n res += maxNegative(left, i - 1)\\n else:\\n res += nums[0] + maxNegative(left + 1, i - 1)\\n left = None\\n else:\\n if left is None:\\n left = i\\n return res\\n \",\n \"memory\": \"30900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums) -> int:\\n n = len(nums)\\n dp = [0] * (n + 1)\\n\\n for i in range(n - 1, -1, -1):\\n dp[i] = nums[i] + dp[i + 1]\\n if i != n - 1:\\n dp[i] = max(dp[i], nums[i] - nums[i + 1] + dp[i + 2])\\n\\n return dp[0]\",\n \"memory\": \"31000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n N = len(nums)\\n dp = [-1] * N\\n dp[-1] = nums[-1]\\n dp.append(0)\\n\\n for i in range(N - 2, -1, -1):\\n dp[i] = max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\\n \\n return dp[0]\\n\",\n \"memory\": \"31100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [0]*(n+1)\\n dp[n] = 0\\n dp[n-1] = nums[n-1]\\n for i in range(n-2,-1,-1):\\n dp[i] = max(nums[i]+dp[i+1], nums[i]-nums[i+1]+dp[i+2])\\n return dp[0]\",\n \"memory\": \"31200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums)==1:\\n return nums[0]\\n tail_pos, tail_neg=nums[0]+nums[1], nums[0]-nums[1]\\n for v in nums[2:]:\\n next_pos=max(tail_pos, tail_neg)+v\\n next_neg=tail_pos-v\\n tail_pos, tail_neg=next_pos, next_neg\\n return max(tail_pos, tail_neg)\\n\\n \",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums)==1:\\n return nums[0]\\n tail_pos, tail_neg=nums[0]+nums[1], nums[0]-nums[1]\\n for v in nums[2:]:\\n # next_pos=max(tail_pos, tail_neg)+v\\n # next_neg=tail_pos-v\\n # tail_pos, tail_neg=next_pos, next_neg\\n tail_pos, tail_neg=max(tail_pos, tail_neg)+v, tail_pos-v\\n\\n return max(tail_pos, tail_neg)\\n\\n \",\n \"memory\": \"31300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n\\n prev_flipped = nums[0] - nums[1]\\n prev_non_flipped = nums[0] + nums[1]\\n\\n for n in nums[2:]:\\n prev_flipped, prev_non_flipped = prev_non_flipped - n, max(prev_flipped, prev_non_flipped) + n\\n\\n return max(prev_flipped, prev_non_flipped) \\n\",\n \"memory\": \"31400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n == 1:\\n return nums[0]\\n dpo, dpe = [0] * n, [0] * n\\n dpo[0] = nums[0]\\n dpo[1] = dpo[0] + nums[1]\\n dpe[1] = dpo[0] - nums[1]\\n for i in range(2, n):\\n dpo[i] = max(dpo[i-1], dpe[i-1]) + nums[i]\\n dpe[i] = dpo[i-1] - nums[i]\\n return max(dpo[-1], dpe[-1])\",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, a: List[int]) -> int:\\n n = len(a)\\n if n == 1:\\n return a[0]\\n f = [0] * n\\n g = [0] * n\\n f[1] = a[0] + a[1]\\n g[1] = a[0] - a[1]\\n for i in range(2, n):\\n f[i] = max(g[i-1], f[i-1]) + a[i]\\n g[i] = f[i-1] - a[i]\\n return max(f[n-1], g[n-1])\",\n \"memory\": \"32600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # O(n) in DP \\n # cost[i] = max(cost[i-1] + bin(len(cost[i-1])) * nums[i], cost[i-1] * !bin(len(cost[i-1]])))\\n \\n dp_p = [0] * len(nums)\\n dp_n = [0] * len(nums)\\n \\n dp_p[0] = nums[0]\\n dp_n[0] = nums[0] \\n\\n for i in range(1, len(nums)):\\n dp_p[i] = max(dp_n[i - 1] + nums[i], dp_p[i - 1] + nums[i])\\n dp_n[i] = dp_p[i - 1] - nums[i]\\n\\n return max(dp_p[len(nums) - 1], dp_n[len(nums) - 1])\\n\",\n \"memory\": \"32700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, num: List[int]) -> int:\\n plus = [num[0]]\\n minus = [num[0]]\\n\\n for i in range(1, len(num)):\\n a = plus[-1]\\n b = minus[-1]\\n plus.append(max(a + num[i], b + num[i]))\\n minus.append(a - num[i])\\n\\n return max(plus[-1], minus[-1])\",\n \"memory\": \"33100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n plus = [nums[0]]\\n minus = [nums[0]]\\n for i in nums[1:]:\\n plus.append(max(plus[-1], minus[-1]) + i)\\n minus.append(plus[-2] - i)\\n return max(plus[-1], minus[-1])\",\n \"memory\": \"33700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return nums[0]\\n \\n maximums = [(nums[0], False), (nums[0] + (nums[1] if nums[1] >= 0 else -1 * nums[1]), nums[1] < 0)]\\n for num_index in range(2, len(nums)):\\n curr_num = nums[num_index]\\n if curr_num >= 0:\\n maximums.append((maximums[-1][0] + curr_num, False))\\n else:\\n if maximums[-1][1]:\\n previous_num = nums[num_index - 1]\\n if (maximums[-2][0] + (previous_num - curr_num)) > (maximums[-1][0] + curr_num):\\n maximums.append((maximums[-2][0] + (previous_num - curr_num), True))\\n else:\\n maximums.append((maximums[-1][0] + curr_num, False))\\n else:\\n maximums.append((maximums[-1][0] + -1 * curr_num, True))\\n return maximums[-1][0]\",\n \"memory\": \"35600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums)==1:\\n return nums[0]\\n\\n sums = []\\n total = 0\\n first = nums[0]\\n nums[0] = 0\\n\\n for i in range(len(nums)):\\n if i%2==0:\\n total+=nums[i]\\n else:\\n total-=nums[i]\\n sums.append(total)\\n \\n print(sums)\\n dp = [-float('inf') for x in sums]\\n dp[0] = 0\\n dp[1] = abs(sums[1])\\n\\n print(dp)\\n\\n for i in range(2, len(nums)):\\n dp[i] = max(nums[i]+dp[i-1], nums[i-1]-nums[i]+dp[i-2])\\n \\n print(dp)\\n\\n\\n\\n\\n return dp[-1]+first\\n\\n\\n \",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # cost(i,j) = i < k < j max(cost(i, k) - min cost(k + 1, j), cost(i, k) + max cost(k + 1, j))\\n n = len(nums)\\n\\n dp = [[0,0] for _ in range(n + 1)]\\n for i in range(n - 1, -1, -1):\\n currPositive = nums[i] + max(dp[i+1][0], dp[i+1][1])\\n currNegative = -nums[i] + dp[i+1][0]\\n dp[i][0], dp[i][1] = currPositive, currNegative\\n return dp[0][0]\\n # Wrong\\n# n = len(nums)\\n# cost = [[[0, 0] for _ in range(n)] for _ in range(n)]\\n# for i in range(n):\\n# cost[i][i][0] = nums[i]\\n# cost[i][i][1] = -nums[i]\\n# for delta in range(1, n):\\n# for i in range(n):\\n# j = i + delta\\n# if j >= n:\\n# break\\n# currCost = max([cost[i][i][0] + cost[i+1][j][0],\\\\\\n# cost[i][i][0] + cost[i+1][j][1],\\\\\\n# cost[i][j-1][0] + cost[j][j][0]]),\\\\\\n# cost[i][j-1][0] + cost[j][j][1]])\\n# cost[i][j][0] = currCost\\n# cost[i][j][1] = -currCost\\n# return cost[0][n-1][0]\",\n \"memory\": \"40000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # dp(i, positive) = nums[i] + max(dp(i + 1, positive), dp(i + 1, negative))\\n # dp(i, negative) = -nums[i] + dp(i + 1, positive)\\n\\n dp = []\\n for _ in range(len(nums) + 1):\\n dp.append([0] * 2)\\n for i in reversed(range(len(nums))):\\n dp[i][1] = nums[i] + max(dp[i + 1][1], dp[i + 1][0])\\n dp[i][0] = -nums[i] + dp[i + 1][1]\\n return dp[i][1]\\n \",\n \"memory\": \"40100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for _ in range(n)]\\n \\n # base case \\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n \\n for i in range(1, len(nums)):\\n # state 1: create a new subarray\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n # state 2: continue the previous subarray\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n return max(dp[n-1][0], dp[n-1][1])\",\n \"memory\": \"40200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self,nums):\\n\\n\\n n = len(nums)\\n\\n dp = [[-float(\\\"inf\\\") for i in range(2)] for i in range(n)]\\n\\n dp[0][0] = nums[0]\\n\\n for i in range(1,n):\\n dp[i][0] = max(dp[i-1][1] + nums[i], dp[i-1][0] + nums[i])\\n dp[i][1] = dp[i-1][0] - nums[i]\\n # print(dp[-1])\\n return max(dp[-1])\\n\\n @cache\\n def helper(i,prev):\\n if i == len(nums):\\n return 0\\n if i == 0:\\n prev = 1 \\n return helper(1,1) + nums[i]\\n else:\\n res = 0\\n if prev == 1:\\n return max(helper(i + 1, 2) - nums[i], helper(i + 1, 1) + nums[i])\\n else:\\n return helper(i + 1, 1) + nums[i]\\n \\n return helper(0,0)\\n\",\n \"memory\": \"44900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0, 0] for _ in range(n)]\\n\\n if n == 1:\\n return nums[0]\\n\\n dp[1][0] = nums[0] + nums[1]\\n dp[1][1] = nums[0] - nums[1]\\n\\n for i in range(2, n):\\n dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + nums[i]\\n dp[i][1] = dp[i - 1][0] - nums[i]\\n \\n print(dp)\\n\\n return max(dp[n - 1][0], dp[n - 1][1])\",\n \"memory\": \"47000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[nums[0],nums[0]] for i in range(len(nums))]\\n for i in range(1, len(nums)):\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n\\n print(dp)\\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\",\n \"memory\": \"47300\"\n },\n {\n \"code\": \"class Solution:\\n def solve( self, nums, i, memo ):\\n \\n n = len(nums)\\n if i >= n:\\n return 0\\n \\n if memo[i] != None:\\n return memo[i]\\n\\n dont = self.solve( nums, i+1, memo ) + nums[i]\\n take = self.solve( nums, i+2, memo ) + nums[i]\\n if i+1 < n:\\n take += ( -1*nums[i+1])\\n \\n memo[i]=max( dont, take)\\n return memo[i]\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n l = len(nums)\\n memo = [None]*l\\n ans = self.solve( nums, 0, memo )\\n return ans\",\n \"memory\": \"47700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n if len(nums) ==1:\\n return nums[0]\\n \\n dp = [[0 for i in range(2)] for i in range(len(nums))]\\n dp[0][0] = nums[0]\\n dp[0][1] = nums[0]\\n \\n for i in range(1, len(nums)):\\n\\n dp[i][0] = max(dp[i-1][0], dp[i-1][1]) + nums[i]\\n dp[i][1] = dp[i-1][0] - nums[i]\\n \\n \\n print(dp)\\n return max(dp[len(nums)-1][0], dp[len(nums)-1][1])\\n \\n\",\n \"memory\": \"48400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[-1, -1] for _ in range(n)]\\n\\n def solve(idx: int, pos: bool) -> int:\\n if idx >= n:\\n return 0\\n\\n if dp[idx][pos] != -1:\\n return dp[idx][pos]\\n\\n if pos:\\n dp[idx][pos] = nums[idx] + solve(idx + 1, False)\\n else:\\n take = solve(idx + 1, True) - nums[idx]\\n not_take = solve(idx + 1, False) + nums[idx]\\n dp[idx][pos] = max(take, not_take)\\n\\n return dp[idx][pos]\\n\\n return solve(0, True)\",\n \"memory\": \"54400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n def rec(nums, i, dp):\\n n = len(nums)\\n\\n if i >= n: return 0\\n if i == n - 1: return nums[i]\\n \\n if i+1 not in dp:\\n dp[i + 1] = rec(nums, i + 1, dp)\\n \\n if i+2 not in dp:\\n dp[i + 2] = rec(nums, i + 2, dp)\\n\\n return max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\\n \\n return rec(nums, 0, {})\",\n \"memory\": \"55500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n def rec(nums, i, dp):\\n n = len(nums)\\n\\n if i >= n: return 0\\n if i == n - 1: return nums[i]\\n \\n if i+1 not in dp:\\n dp[i + 1] = rec(nums, i + 1, dp)\\n \\n if i+2 not in dp:\\n dp[i + 2] = rec(nums, i + 2, dp)\\n\\n return max(nums[i] + dp[i + 1], nums[i] - nums[i + 1] + dp[i + 2])\\n \\n return rec(nums, 0, {})\",\n \"memory\": \"55600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = [[-1 for _ in range(2)] for _ in range(len(nums))]\\n print(dp)\\n def solve(i,flag,dp):\\n if i == len(nums):\\n return 0\\n if dp[i][flag]!=-1:\\n return dp[i][flag]\\n if flag == 0:\\n a = nums[i] + solve(i+1,0,dp)\\n b = -1*nums[i] + solve(i+1,1,dp)\\n else:\\n a = nums[i] + solve(i+1,0,dp)\\n dp[i][flag] = a\\n return dp[i][flag]\\n dp[i][flag] = max(a,b)\\n return dp[i][flag]\\n \\n return nums[0] + solve(1,0,dp)\",\n \"memory\": \"55700\"\n },\n {\n \"code\": \"class Solution:\\n def asd(self,i,nums,parity,dp):\\n if(i>=len(nums)):\\n return 0\\n if(dp[i][parity]!=-1):\\n return dp[i][parity]\\n add=nums[i]\\n if(parity==1):\\n dp[i][parity]=self.asd(i+1,nums,0,dp)-nums[i]\\n else:\\n dp[i][parity]=max(self.asd(i+1,nums,1-parity,dp)+nums[i],self.asd(i+1,nums,parity,dp)+nums[i])\\n return dp[i][parity]\\n \\n \\n \\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # ans=0\\n # start=0\\n # for i in range(len(nums)):\\n # if()\\n dp=[]\\n for i in range(len(nums)):\\n a=[]\\n for j in range(2):\\n a.append(-1)\\n dp.append(a)\\n p=self.asd(0,nums,0,dp)\\n # print(dp)\\n return p\",\n \"memory\": \"56000\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def rec(self, nums: List[int], ind: int, neg: bool, dp: List[List[int]]) -> int:\\n if ind == len(nums):\\n return 0\\n if dp[ind][int(neg)] != -1:\\n return dp[ind][int(neg)]\\n \\n if not neg:\\n # Choosing the maximum between including or not including the current number\\n val = max(nums[ind] + self.rec(nums, ind + 1, True, dp),\\n nums[ind] + self.rec(nums, ind + 1, False, dp))\\n dp[ind][int(neg)] = val\\n else:\\n # Subtracting the current number and switching to non-negative choice\\n dp[ind][int(neg)] = -nums[ind] + self.rec(nums, ind + 1, False, dp)\\n \\n return dp[ind][int(neg)]\\n \\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # Initialize a 2D DP table with -1\\n dp = [[-1] * 2 for _ in range(len(nums))]\\n return self.rec(nums, 0, False, dp)\\n\",\n \"memory\": \"57000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # start from index i, take another element into consideration\\n # or end at ind and start new subarray from index ind+1\\n dp = [[None for j in range(2)] for i in range(len(nums))]\\n\\n def totalCost(ind,sign):\\n if ind == len(nums):\\n return 0\\n if dp[ind][sign] is not None:\\n return dp[ind][sign]\\n takeNextElement = nums[ind]*(-1)**sign + totalCost(ind+1,(1^sign))\\n startNewSubarray = nums[ind] + totalCost(ind+1,1)\\n\\n dp[ind][sign] = max(takeNextElement, startNewSubarray)\\n\\n return dp[ind][sign]\\n \\n return totalCost(0,0)\\n\",\n \"memory\": \"58400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n #recursion\\n '''def f(i,sign):\\n if i>=n:\\n return 0\\n split = (sign*nums[i])+f(i+1,1)\\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\\n return max(split,not_split)\\n n=len(nums)\\n return f(0,1)'''\\n #memoization\\n n=len(nums)\\n dp = [[None]*(3) for _ in range(n)]\\n def f(i,sign):\\n if i>=n:\\n return 0\\n if dp[i][sign+1]!=None:\\n return dp[i][sign+1]\\n split = (sign*nums[i])+f(i+1,1)\\n not_split = (sign*nums[i])+f(i+1,sign*(-1))\\n dp[i][sign+1]=max(split,not_split)\\n return dp[i][sign+1]\\n return f(0,1)\\n\",\n \"memory\": \"59800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp = {}\\n for i in range(len(nums)):\\n dp[i] = [None,None]\\n def rec(i=0,t=True):\\n if i == len(nums):\\n return 0\\n if t:\\n if dp[i][0] != None:\\n return dp[i][0]\\n else:\\n if dp[i][1] != None:\\n return dp[i][1]\\n if i == 0:\\n dp[i][0] = nums[i] + max(rec(i+1,t),rec(i+1,not t))\\n return dp[i][0]\\n c = 0\\n if t:\\n c = nums[i]\\n dp[i][0] = c + max(rec(i+1,t),rec(i+1,not t))\\n return dp[i][0]\\n else:\\n c = -1*nums[i]\\n dp[i][1] = c + rec(i+1,True)\\n return dp[i][1]\\n return rec()\",\n \"memory\": \"68200\"\n },\n {\n \"code\": \"class Solution:\\n \\n \\n def __init__(self):\\n self.dp = {}\\n\\n def maxCost(self, idx, prevPositive, nums):\\n if idx >= len(nums):\\n return 0\\n\\n if (idx, prevPositive) in self.dp:\\n return self.dp[(idx, prevPositive)]\\n\\n includeCurrent = nums[idx] if prevPositive else -nums[idx]\\n\\n continueSubarray = includeCurrent + self.maxCost(idx + 1, not prevPositive, nums)\\n startNewSubarray = nums[idx] + self.maxCost(idx + 1, False, nums)\\n\\n if idx == 0:\\n self.dp[(idx, prevPositive)] = startNewSubarray\\n else:\\n self.dp[(idx, prevPositive)] = max(continueSubarray, startNewSubarray)\\n\\n return self.dp[(idx, prevPositive)]\\n\\n def maximumTotalCost(self, nums):\\n self.dp.clear()\\n return self.maxCost(0, True, nums)\",\n \"memory\": \"72100\"\n },\n {\n \"code\": \"from collections import defaultdict as dd\\ndef f(i, x, nums):\\n if i==len(nums):\\n return 0\\n if d[i, x]!=-1:\\n return d[i, x]\\n if x==1:\\n d[i, x]= max(\\n f(i+1, 1, nums)+nums[i],\\n f(i+1, 0, nums)-nums[i]\\n )\\n return d[i, x]\\n d[i, x] = f(i+1, 1, nums)+nums[i]\\n return d[i, x]\\nclass Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n global d\\n d= dd(lambda:-1)\\n return f(0, 0, nums)\\n \",\n \"memory\": \"78100\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n @cache\\n def solve(self, i, forcePositive):\\n\\n n = len(self.nums)\\n if i >= n:\\n return 0\\n\\n if forcePositive:\\n return self.nums[i] + self.solve(i + 1, False)\\n\\n keep_positive_result = self.nums[i] + self.solve(i + 1, False)\\n negate_result = -self.nums[i] + self.solve(i + 1, True)\\n\\n return max(keep_positive_result, negate_result)\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n self.solve.cache_clear()\\n self.nums = nums\\n n = len(nums)\\n\\n for i in reversed(range(n)):\\n self.solve(i, True)\\n\\n return self.solve(0, True)\",\n \"memory\": \"78600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i, inv):\\n if i == n: return 0\\n #Start new subarr\\n res = dfs(i+1, 1)+nums[i]\\n #Continue subarr\\n if inv:\\n res = max(res, dfs(i+1, inv^1)-nums[i])\\n return res\\n res = dfs(0, 0)\\n dfs.cache_clear()\\n return res\",\n \"memory\": \"145000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache\\n def go(i):\\n if i == len(nums):\\n return 0\\n if i == len(nums)-1:\\n return nums[i]\\n #choice one: just add myself and go next\\n c1 = nums[i] + go(i+1)\\n c2 = nums[i] - nums[i+1] + go(i+2)\\n return max(c1,c2)\\n \\n return go(0)\\n \\n\\n\\n \",\n \"memory\": \"169800\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"memory\": \"170400\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"memory\": \"170500\"\n },\n {\n \"code\": \"class Solution:\\n\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @lru_cache(None)\\n def dp(i):\\n if i >= len(nums):\\n return 0\\n\\n if i == len(nums) - 1:\\n return nums[-1]\\n\\n return max(\\n nums[i] + dp(i + 1),\\n nums[i] - nums[i + 1] + dp(i + 2)\\n )\\n\\n return dp(0)\",\n \"memory\": \"170500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def best(i=0):\\n if i == len(nums):\\n return 0\\n \\n res = nums[i] + best(i + 1)\\n if i + 1 < len(nums):\\n res = max(res, nums[i] - nums[i + 1] + best(i + 2))\\n \\n return res\\n\\n return best()\",\n \"memory\": \"171200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def solve(index):\\n if index >= len(nums):\\n return 0\\n result = nums[index] + solve(index + 1)\\n if index < len(nums) - 1:\\n result = max(result, nums[index] - nums[index + 1] + solve(index + 2))\\n return result\\n return solve(0)\",\n \"memory\": \"171300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n\\n dp = [0] * (n + 1)\\n\\n for i in range(n):\\n dp[i] = dp[i - 1] + nums[i] * (-1) ** i\\n\\n def cost(l, r):\\n return (dp[r] - dp[l - 1]) * (-1) ** l\\n \\n @cache\\n def best(i=0):\\n if i == len(nums):\\n return 0\\n \\n res = cost(i, i) + best(i + 1)\\n if i + 1 < len(nums):\\n res = max(res, cost(i, i + 1) + best(i + 2))\\n \\n return res\\n\\n return best()\",\n \"memory\": \"193200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int: \\n @cache\\n def f(i, can_change):\\n if i == len(nums):\\n return 0\\n \\n if i == 0:\\n return nums[0] + f(i+1, True)\\n else:\\n if nums[i] >= 0:\\n return nums[i] + f(i+1, True)\\n else:\\n if can_change:\\n return max(f(i+1, False) - nums[i],\\n f(i+1, True) + nums[i])\\n else:\\n return f(i+1, True) + nums[i] \\n \\n return f(0, False)\",\n \"memory\": \"216300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def maxCost(idx,sign):\\n if idx == len(nums): return 0\\n if sign < 0: return nums[idx]+maxCost(idx+1,-sign)\\n if nums[idx] < 0:\\n ans = max(nums[idx]+maxCost(idx+1,sign),-nums[idx]+maxCost(idx+1,-sign))\\n return ans\\n return nums[idx] + maxCost(idx+1,sign)\\n return maxCost(0,-1)\",\n \"memory\": \"217100\"\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nTODO O(n)\\n\\nThe DP is given by \\n\\nstarting from index i with sign pos or negative\\nwhat is the max sum we can attain \\n\\nwe start with index 0, and positive (as per question)\\nThen\\n\\nind 0 + continue the path \\nor \\nind 0 + fresh start\\n\\n\\n[0, 1, 2, 3]\\n[1, -2, 3, 4]\\n\\nstart - rec(i =0, pos_sign = True)\\n\\ncontinue construction- > nums[i] + recursion(i = 1, positive = False)\\nfresh - > nums[i] + recursion(i = 1, positive + true)\\n\\ntake max of the above\\n\\n\\\"\\\"\\\"\\nclass Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n lookup = {}\\n def recursion(i, pos_sign):\\n\\n if (i, pos_sign) in lookup:\\n return lookup[(i,pos_sign)]\\n\\n\\n if i == len(nums):\\n return 0\\n\\n\\n ans = -math.inf \\n\\n next_pos = recursion(i + 1, True)\\n next_neg = recursion(i + 1, False)\\n\\n\\n # if pos_sign:\\n # ans = max(ans, nums[i] + recursion(i + 1, False))\\n # # fresh start\\n # else:\\n # ans = max(ans, -nums[i] + recursion(i + 1, True))\\n\\n # # \\n # ans = max(ans, nums[i] + recursion(i + 1, True))\\n \\n\\n if not pos_sign:\\n ans = -nums[i] + next_pos\\n else:\\n ans = max(ans , nums[i] + next_pos, nums[i] + next_neg)\\n lookup[(i, pos_sign)] = ans \\n\\n return ans\\n\\n return recursion(0, True)\\n\\n\\n\\n\\n \",\n \"memory\": \"221700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n\\n N = len(nums)\\n dp = {}\\n\\n def dfs(i , state):\\n if i == N:\\n return 0\\n \\n if (i,state) in dp:\\n return dp[(i,state)]\\n \\n if state == 'E':\\n dp[(i,state)] = max( nums[i] + dfs(i+1 , 'O') , nums[i] + dfs(i+1 , 'E') )\\n\\n elif state == 'O':\\n dp[(i,state)] = max( -nums[i] + dfs(i+1 , 'E') , -nums[i] + dfs(i+1 , 'E') )\\n \\n return dp[(i,state)]\\n \\n return dfs(0,'E')\\n\",\n \"memory\": \"221800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n cache = {}\\n def max_total(index, sign):\\n if index>=len(nums):\\n return 0 \\n if (index, sign) in cache:\\n return cache[(index, sign)]\\n # be part of the subarray \\n ans = float('-inf')\\n if sign == -1: # prev element is start of subarray\\n \\n a = max_total(index+1, 1) + sign*nums[index] # be part of it\\n b = max_total(index+1, -1) + nums[index] # start new\\n \\n ans = max(a,b)\\n \\n else: #signed = 1 # prev element isn't start of subarray\\n a = max_total(index+1, 1) + nums[index]# be part of it\\n b = max_total(index+1, -1) + nums[index] # start new\\n ans = max(a, b)\\n cache[(index, sign)] = ans \\n return ans \\n return max_total(0, 1)\",\n \"memory\": \"224800\"\n },\n {\n \"code\": \"class Solution:\\n # Time: O()\\n # Space: O(), where n = len(nums)\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n # DP Top-down + memoization\\n n = len(nums)\\n cache = {}\\n def dp(i, flipped):\\n # Largest sum with nums[i:n] and the i-th element was flipped if flipped\\n if (i, flipped) in cache:\\n return cache[(i, flipped)]\\n \\n if i == n:\\n return 0\\n \\n res = nums[i]\\n # Take element with same sign if possible\\n res = max(res, nums[i] + dp(i+1, 0))\\n \\n # Take element with opposite sign if possible\\n if not flipped and i != 0:\\n res = max(res, - nums[i] + dp(i+1, 1))\\n\\n cache[(i, flipped)] = res\\n return res\\n \\n return max(dp(0, 0), dp(0, 1))\\n \\n\\n\\n\",\n \"memory\": \"225500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n dp = defaultdict(int)\\n\\n def solution(index,sign):\\n\\n if index==len(nums):\\n return 0\\n\\n if (index,sign) in dp:\\n return dp[(index,sign)]\\n\\n extend = sign*nums[index] + solution(index+1,-1*sign)\\n start_new = nums[index] + solution(index+1,1)\\n\\n dp[(index,sign)] = max(extend,start_new)\\n\\n return dp[(index,sign)]\\n\\n\\n return solution(0,1)\\n\",\n \"memory\": \"225600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n dp = defaultdict(int)\\n\\n def solution(index,sign):\\n\\n if index==len(nums):\\n return 0\\n\\n if (index,sign) in dp:\\n return dp[(index,sign)]\\n\\n extend = sign*nums[index] + solution(index+1,-1*sign)\\n start_new = nums[index] + solution(index+1,1)\\n\\n dp[(index,sign)] = max(extend,start_new)\\n\\n return dp[(index,sign)]\\n\\n\\n return solution(0,1)\\n\",\n \"memory\": \"225600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n hashing={}\\n length=len(nums)\\n if length==1:\\n return nums[0]\\n hashing[(1, 0)]=nums[0]+nums[1]\\n hashing[(1, 1)]=nums[0]-nums[1]\\n def order(i, j):\\n try:\\n return hashing[(i, j)]\\n except:\\n print('',end='')\\n if j==0:\\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\\n else:\\n hashing[(i, j)]=order(i-1, 0)-nums[i]\\n return hashing[(i, j)]\\n return max([order(length-1, 0), order(length-1, 1)])\\n\",\n \"memory\": \"240400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n hashing={}\\n length=len(nums)\\n if length==1:\\n return nums[0]\\n hashing[(1, 0)]=nums[0]+nums[1]\\n hashing[(1, 1)]=nums[0]-nums[1]\\n def order(i, j):\\n try:\\n return hashing[(i, j)]\\n except:\\n print('',end='')\\n if j==0:\\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\\n else:\\n hashing[(i, j)]=order(i-1, 0)-nums[i]\\n return hashing[(i, j)]\\n return max([order(length-1, 0), order(length-1, 1)])\\n\",\n \"memory\": \"240400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n hashing={}\\n length=len(nums)\\n if length==1:\\n return nums[0]\\n hashing[(1, 0)]=nums[0]+nums[1]\\n hashing[(1, 1)]=nums[0]-nums[1]\\n def order(i, j):\\n try:\\n return hashing[(i, j)]\\n except:\\n print('',end='')\\n if j==0:\\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\\n else:\\n hashing[(i, j)]=order(i-1, 0)-nums[i]\\n return hashing[(i, j)]\\n return max([order(length-1, 0), order(length-1, 1)])\\n\",\n \"memory\": \"240500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n hashing={}\\n length=len(nums)\\n if length==1:\\n return nums[0]\\n hashing[(1, 0)]=nums[0]+nums[1]\\n hashing[(1, 1)]=nums[0]-nums[1]\\n def order(i, j):\\n try:\\n return hashing[(i, j)]\\n except:\\n print('',end='')\\n if j==0:\\n hashing[(i, j)]=max([order(i-1, 0), order(i-1, 1)])+nums[i]\\n else:\\n hashing[(i, j)]=order(i-1, 0)-nums[i]\\n return hashing[(i, j)]\\n return max([order(length-1, 0), order(length-1, 1)])\\n\",\n \"memory\": \"240500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n dp={}\\n def dfs(i,isStart,sign):\\n if i==len(nums):\\n return 0\\n if (i,isStart,sign) in dp:\\n return dp[(i,isStart,sign)]\\n ans=float(\\\"-inf\\\")\\n if isStart==0:\\n ans=max(ans,nums[i]+dfs(i+1,1,1))\\n else:\\n if sign==1:\\n ans=max(ans,-nums[i]+dfs(i+1,1,0))\\n ans=max(ans,dfs(i,0,0))\\n else:\\n ans=max(ans,nums[i]+dfs(i+1,1,1))\\n ans=max(ans,dfs(i,0,0))\\n dp[(i,isStart,sign)]=ans\\n return dp[(i,isStart,sign)]\\n return dfs(0,0,0)\\n\\n\\n nums=[abs(n) for n in nums]\\n return sum(nums)\",\n \"memory\": \"259500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dp(i, ok):\\n if i == n: return 0\\n if ok == 1:\\n ans = nums[i] + dp(i+1, 0)\\n else:\\n ans = max(-nums[i] + dp(i+1, 1), dp(i,1))\\n return ans\\n return dp(0, 1)\",\n \"memory\": \"267900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dp(i, add):\\n if i == n: return 0\\n if add == True:\\n ans = nums[i] + dp(i+1, False)\\n else:\\n ans = max(-nums[i] + dp(i+1, True), dp(i,True))\\n return ans\\n return dp(0, True)\",\n \"memory\": \"268700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n l = len(nums)\\n @cache\\n def dp(i, sign):\\n if i >= l:\\n return 0\\n split = sign * nums[i] + dp(i+1, 1)\\n no_split = sign*(nums[i]) + dp(i+1, -1*sign)\\n return max(split,no_split)\\n\\n return dp(0, 1)\",\n \"memory\": \"282200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n #prefix sum starting from even and odd & just start new/dont\\n # prefixStartPos = [0]\\n # prefixStartNeg = [0]\\n # for i in range(0, len(nums)):\\n # if i % 2 == 1:\\n # prefixStartPos.append(prefixStartPos[-1]-nums[i])\\n # prefixStartNeg.append(prefixStartNeg[-1]+nums[i])\\n # else:\\n # prefixStartPos.append(prefixStartPos[-1]+nums[i])\\n # prefixStartNeg.append(prefixStartNeg[-1]-nums[i])\\n \\n @cache\\n def dp(i, curPos):\\n if i >= len(nums):\\n return 0\\n if not curPos:\\n return -nums[i]+dp(i+1, True)\\n else:\\n return nums[i] + max(dp(i+1, False), dp(i+1, True))\\n return dp(0, True)\\n\",\n \"memory\": \"282900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n N=len(nums)\\n @cache\\n def dfs(i,p):\\n if i==N:\\n return 0\\n \\n if p:\\n res=nums[i]+max(dfs(i+1,1),dfs(i+1,0))\\n else:\\n res=-nums[i]+dfs(i+1,1)\\n return res\\n return dfs(0,1)\\n\\n \",\n \"memory\": \"283200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n @cache\\n def dfs(i,j): #j==0,最后一段有偶数个数,j==1,最后一段有奇数个数\\n if i==-1:\\n return 0 if j==0 else -inf\\n if j==0:\\n return dfs(i-1,1-j)-nums[i]\\n if j==1:\\n return max(max(dfs(i-1,0),dfs(i-1,1))+nums[i],dfs(i-1,1-j)+nums[i])\\n return max(dfs(n-1,0),dfs(n-1,1))\\n \",\n \"memory\": \"283500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int], memo=None) -> int:\\n '''DFS with caching'''\\n n = len(nums)\\n\\n @cache\\n def dfs(i, sign):\\n if i >= n: return 0\\n\\n split = nums[i] * sign + dfs(i+1, 1)\\n no_split = nums[i] * sign + dfs(i+1, -sign)\\n return max(split, no_split)\\n\\n return dfs(0, 1)\\n \\n \\n '''DP: top-down approach'''\\n n = len(nums)\\n\\n if n==0: return 0\\n if n==1: return nums[0]\\n\\n if memo is None:\\n memo = {}\\n if n in memo:\\n return memo[n]\\n\\n max_cost, cur_cost = float(\\\"-inf\\\"), 0\\n\\n for i in range(n):\\n cur_cost += nums[i] * (-1)**(i)\\n rest = self.maximumTotalCost(nums[i+1:], memo)\\n max_cost = max(max_cost, cur_cost + rest)\\n\\n memo[n] = max_cost\\n print(memo)\\n return max_cost\",\n \"memory\": \"283700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n l = len(nums)\\n\\n @cache\\n def dp(i, sign):\\n if i>=l:\\n return 0\\n\\n split = sign * nums[i] + dp(i+1, 1)\\n no_split = sign * nums[i] + dp(i+1, -1*sign)\\n\\n return max(split, no_split)\\n\\n return dp(0, 1)\",\n \"memory\": \"283800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache\\n def solve(n, sign):\\n if n >= len(nums):\\n return 0\\n # 0-pos, 1-neg\\n if sign == 1:\\n return -1 * nums[n] + solve(n + 1, 0)\\n return max(nums[n] + solve(n + 1, 0), nums[n] + solve(n + 1, 1))\\n \\n return solve(0, 0)\",\n \"memory\": \"284300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def helper(i, oddLen):\\n if i == len(nums):\\n return 0\\n costHere = 0\\n if oddLen:\\n costHere = nums[i]\\n else:\\n costHere = - nums[i]\\n return max(costHere + helper(i+1, not oddLen), costHere + helper(i+1, True))\\n return helper(0, True)\",\n \"memory\": \"284500\"\n },\n {\n \"code\": \"from functools import cache\\nfrom math import inf\\nclass Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n \\n @cache \\n def recursion(index, flipState):\\n if index >= len(nums):\\n return 0\\n currentNumber = nums[index] * (-1 if flipState else 1)\\n # Continue the sequence\\n continued = currentNumber + recursion(index+1, not flipState)\\n # Start new sequence\\n new_sequence = currentNumber + recursion(index+1, False)\\n # Take the best route\\n return max(continued, new_sequence)\\n return recursion(0, False)\\n\\n\",\n \"memory\": \"284600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n \\n @cache\\n def dp(i: int, sign: int) -> int:\\n if i == n - 1:\\n return sign * nums[i]\\n return sign * nums[i] + max(dp(i + 1, -sign), dp(i + 1, 1))\\n \\n return dp(0, 1)\",\n \"memory\": \"284700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int: \\n @cache\\n def solve(curr,sign):\\n if curr>=len(nums):\\n return 0\\n \\n if sign:\\n return max(-nums[curr]+solve(curr+1,not sign),nums[curr]+solve(curr+1,sign))\\n else:\\n return nums[curr]+solve(curr+1,True)\\n return solve(0,False)\",\n \"memory\": \"286800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n n = len(nums)\\n self.max_cost = -float('inf')\\n \\n # @lru_cache(None)\\n # def backtrack(i, cost):\\n # if i==n:\\n # return cost\\n\\n # return max(max(cost+nums[i] - backtrack(i+1, cost+nums[i]), cost+nums[i]+backtrack(i+1, cost+nums[i])), cost - nums[i] + backtrack(i+1, cost - nums[i]))\\n # # if i==n:\\n # # return 0\\n\\n # # if sign=='+':\\n # # self.max_cost = max(nums[i] + backtrack(i+1, '-'), self.max_cost)\\n # # self.max_cost = max(nums[i] + backtrack(i+1, '+'), self.max_cost)\\n # # else:\\n # # self.max_cost = max(-nums[i] + backtrack(i+1, '+'), self.max_cost)\\n \\n # # return self.max_cost\\n\\n \\n # return backtrack(0,0)\\n\\n # return self.max_cost\\n \\n @lru_cache(None)\\n def backtrack(i, sign):\\n if i==n:\\n return 0\\n\\n cost1, cost2, cost3 = -float('inf'), -float('inf'),-float('inf')\\n\\n if sign=='+':\\n cost1 = nums[i] + backtrack(i+1, '+')\\n cost2 = nums[i] + backtrack(i+1, '-')\\n else:\\n cost3 = -nums[i] + backtrack(i+1, '+')\\n\\n return max(max(cost1, cost2), cost3)\\n\\n \\n return backtrack(0, '+')\\n\",\n \"memory\": \"287400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def f(i, p):\\n if i == n: return 0\\n \\n if p < 0:\\n return nums[i] + f(i + 1, 1)\\n else:\\n return max(nums[i] + f(i + 1, 1), -nums[i] + f(i + 1, -1)) \\n\\n n = len(nums)\\n return f(0, -1)\",\n \"memory\": \"287800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/3100-3199/3196.Maximize%20Total%20Cost%20of%20Alternating%20Subarrays\\n @cache\\n def dfs(i: int, j: int) -> int:\\n if i >= len(nums):\\n return 0\\n ans = nums[i] + dfs(i + 1, 1)\\n if j == 1:\\n ans = max(ans, -nums[i] + dfs(i + 1, 0))\\n return ans\\n\\n return dfs(0, 0)\",\n \"memory\": \"287900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumTotalCost(self, nums: List[int]) -> int:\\n @cache\\n def f(i, p):\\n if i == n: return 0\\n \\n # Lead\\n ret = nums[i] + f(i + 1, 1)\\n\\n # Follow\\n if p < 0:\\n return ret\\n else:\\n return max(ret, -nums[i] + f(i + 1, -1)) \\n\\n n = len(nums)\\n return f(0, -1)\",\n \"memory\": \"288000\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":77,"string":"77"}}},{"rowIdx":2469,"cells":{"question_id":{"kind":"number","value":3469,"string":"3,469"},"name":{"kind":"string","value":"maximum-height-of-a-triangle"},"content":{"kind":"string","value":"<p>You are given two integers <code>red</code> and <code>blue</code> representing the count of red and blue colored balls. You have to arrange these balls to form a triangle such that the 1<sup>st</sup> row will have 1 ball, the 2<sup>nd</sup> row will have 2 balls, the 3<sup>rd</sup> row will have 3 balls, and so on.</p>\n\n<p>All the balls in a particular row should be the <strong>same</strong> color, and adjacent rows should have <strong>different</strong> colors.</p>\n\n<p>Return the <strong>maximum</strong><em> height of the triangle</em> that can be achieved.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">red = 2, blue = 4</span></p>\n\n<p><strong>Output:</strong> 3</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/06/16/brb.png\" style=\"width: 300px; height: 240px; padding: 10px;\" /></p>\n\n<p>The only possible arrangement is shown above.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">red = 2, blue = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/06/16/br.png\" style=\"width: 150px; height: 135px; padding: 10px;\" /><br />\nThe only possible arrangement is shown above.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">red = 1, blue = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">1</span></p>\n</div>\n\n<p><strong class=\"example\">Example 4:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">red = 10, blue = 1</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/06/16/br.png\" style=\"width: 150px; height: 135px; padding: 10px;\" /><br />\nThe only possible arrangement is shown above.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= red, blue <= 100</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":42.79435741121429,"string":"42.794357"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","enumeration"],"string":"[\n \"array\",\n \"enumeration\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17\", 0.1416], [\"19\", 0.1416], [\"23\", 0.4249], [\"24\", 0.7082], [\"25\", 0.4249], [\"26\", 1.1331], [\"27\", 1.5581], [\"28\", 2.5496], [\"29\", 2.6912], [\"30\", 2.4079], [\"31\", 3.8244], [\"32\", 5.5241], [\"33\", 3.8244], [\"34\", 4.8159], [\"35\", 6.3739], [\"36\", 9.0652], [\"37\", 6.5156], [\"38\", 5.949], [\"39\", 5.8074], [\"40\", 8.9235], [\"41\", 5.949], [\"42\", 6.2323], [\"43\", 4.3909], [\"44\", 2.9745], [\"45\", 1.983]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.7082], [\"16300\", 0.9915], [\"16400\", 15.1558], [\"16500\", 35.8357], [\"16600\", 38.9518]]}"},"rt_list":{"kind":"list like","value":[{"code":"'''\nyou are given 2 integers\n red and blue\n\neach int represents the count of red and blue colored balls\n\nyou have to arrage these balls to form a trianlge \n\nsuch that the 1st row will have 1 ball,\n teh second row will have 2 balls,\n the third row 3 balls,\n etc...\n\nall the balls on a row should be the same color\nadjacent rows should have different colors\n\nthe first placed color costs \n 1 to fill first row\n 3 to fill third\n 5 to fill 5th\n\n its sum of odd #s\n\nthe second placed color costs\n 2 to fill second row\n 4 to fill 4th row\n 6 to fill 6th row\n\n its sum of even #s\n\nfilling odd rows will always be cheaper than filling even rows\n\nred = pos1 > pos2\nblue = pos1 > pos2\n\nred = 1 1\nblue = 2 1\n\nred = 2 1\nblue = 2 1\n\nwe want to choose the MAX position 1, then choose the other position 2\nwe want to choose the minimum between both positions\n'''\n\nclass Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n redHeight = self.calculateHeight(red, blue)\n blueHeight = self.calculateHeight(blue, red)\n return max(redHeight, blueHeight)\n \n def calculateHeight(self, primary, secondary):\n height = 0 \n i = 1\n\n while True:\n if i % 2 != 0:\n if primary >= i:\n primary -= i\n height += 1\n else:\n break\n else:\n if secondary >= i:\n secondary -= i\n height += 1\n else:\n break\n i += 1\n \n return height\n\n","runtime":"17"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n # red ball on top max height\n height_red=1 \n red_count=red-1\n blue_count=blue\n \n i=2 # number of balls to place\n\n while True:\n if i%2 == 0 and blue_count>=i:\n height_red+=1\n blue_count-=i\n i+=1\n elif i%2==1 and red_count>=i:\n height_red+=1\n red_count-=i\n i+=1\n else:\n break # we finished\n\n\n # blue ball on top \n height_blue=1 \n red_count=red\n blue_count=blue-1\n \n i=2 # number of balls to place\n\n while True:\n if i%2 == 0 and red_count>=i:\n height_blue+=1\n red_count-=i\n i+=1\n elif i%2==1 and blue_count>=i:\n height_blue+=1\n blue_count-=i\n i+=1\n else:\n break # we finished\n \n return max(height_blue,height_red)\n\n\n\n \n\n ","runtime":"19"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n return max(self.tr(red,blue),self.tr(blue,red))\n def tr(self,a,b):\n h = 0\n while a >= 0 and b >= 0:\n if a > h:\n h +=1\n a -= h\n if b > h:\n h +=1\n b -= h\n else:\n break\n else:\n break\n return h","runtime":"23"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n # 2 4 6 8 10 12\n # 2 6 12 20 30 42\n\n # 1 3 5 7 9 11 13 15\n # 1 4 9 16 25 36 49 64\n odd_red = int(math.sqrt(red)) # 7\n odd_blue = int(math.sqrt(blue)) # 6\n \n even_red = odd_red if odd_red**2 + odd_red <= red else odd_red - 1\n even_blue = odd_blue if odd_blue**2 + odd_blue <= blue else odd_blue - 1\n\n max_height = 0\n if odd_red <= even_blue: # 11 <= 10\n max_height = odd_red * 2\n else:\n max_height = even_blue * 2 + 1\n \n if odd_blue <= even_red:\n max_height = max(max_height, odd_blue * 2)\n else:\n max_height = max(max_height, even_red * 2 + 1)\n\n return max_height","runtime":"24"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n redFirst = 1\n redNext = True\n redRed = red\n redBlue = blue\n\n while redRed > 0 or redBlue > 0:\n if redNext:\n if redRed >= redFirst:\n redRed -= redFirst\n redNext = False\n else:\n break\n else:\n if redBlue >= redFirst:\n redBlue -= redFirst\n redNext = True\n else:\n break\n redFirst += 1\n \n blueFirst = 1\n redNext = False\n blueRed = red\n blueBlue = blue\n\n while blueRed > 0 or blueBlue > 0:\n if redNext:\n if blueRed >= blueFirst:\n blueRed -= blueFirst\n redNext = False\n else:\n break\n else:\n if blueBlue >= blueFirst:\n blueBlue -= blueFirst\n redNext = True\n else:\n break\n blueFirst += 1\n\n return max(redFirst, blueFirst) - 1","runtime":"27"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n i = 0\n r = red\n b = blue\n best = 0\n while r>=0 and b>=0:\n i +=1\n if i%2==0:\n r-=i\n if r <0:\n break\n else:\n b -=i\n if b < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n r= red\n b = blue\n i = 0\n while r >=0 and b>=0:\n i +=1\n if i%2==0:\n b-=i\n if b < 0:\n break\n else:\n r -=i\n if r < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n return best\n \n ","runtime":"28"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n i = 0\n r = red\n b = blue\n best = 0\n while r>=0 and b>=0:\n i +=1\n if i%2==0:\n r-=i\n if r <0:\n break\n else:\n b -=i\n if b < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n r= red\n b = blue\n i = 0\n while r >=0 and b>=0:\n i +=1\n if i%2==0:\n b-=i\n if b < 0:\n break\n else:\n r -=i\n if r < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n return best\n \n ","runtime":"28"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n # use red blue red\n # blue red blue\n\n def f(ball: list[int]):\n i = 0\n while True:\n use = i & 1\n if ball[use] < i + 1: return i\n ball[use] -= i + 1\n i += 1\n return max(f([red, blue]), f([blue, red]))","runtime":"29"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def helper(start, nxt):\n c_start = 1\n c_nxt = 2\n count = 0\n while True:\n if start-c_start >= 0:\n start -= c_start\n count += 1\n else:\n break\n if nxt-c_nxt >= 0:\n nxt -= c_nxt\n count += 1\n else:\n break\n c_start += 2\n c_nxt += 2\n return count\n return max(helper(red, blue), helper(blue, red))\n ","runtime":"30"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n if red < blue:\n return self.maxHeightOfTriangle(blue, red)\n\n h1, h2 = isqrt(blue*4+1), isqrt(blue)*2\n if (h1+1)**2//4 <= red: return h1\n if ((h2+1)**2-1)//4 <= red: return h2\n if (h1-1)**2//4 <= red: return h1-1\n return h2-1","runtime":"31"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n h, N = 1, [0, 0]\n while True:\n N[h % 2] += h\n if min(N) > min(red, blue) or max(N) > max(red, blue):\n return h - 1\n \n h += 1","runtime":"32"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n \n def helper(red,blue):\n l=0\n cr=1\n \n\n while True:\n if cr%2==1:\n if red>=cr:\n red-=cr\n \n else:\n break\n else:\n if blue>=cr:\n blue-=cr\n \n else:\n break\n l+=1\n cr+=1\n return l\n return max(helper(red,blue),helper(blue,red))\n","runtime":"33"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def tmp(x, y):\n step = 1\n max_height = 0\n while True:\n if x > 0:\n x -= step\n elif x == 0:\n break\n\n if x < 0:\n break\n else:\n max_height += 1\n step += 1\n \n if y > 0:\n y -= step\n elif y == 0:\n break\n\n if y < 0:\n break\n else:\n max_height += 1\n step += 1\n return max_height\n\n response = max(tmp(red, blue), tmp(blue, red))\n\n # print(max_height_1, max_height_2)\n return response","runtime":"34"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n\n def helper(_red: int, _blue: int, _color: int):\n curr = 1\n\n while (_red, _blue)[_color] >= curr:\n if _color == 0:\n _red -= curr\n else:\n _blue -= curr\n\n curr += 1\n _color = 1 - _color\n\n return curr - 1\n\n return max(helper(red, blue, 0), helper(red, blue, 1))\n","runtime":"34"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n i = 0\n r = red\n b = blue\n best = 0\n while r>=0 and b>=0:\n i +=1\n if i%2==0:\n r-=i\n if r <0:\n break\n else:\n b -=i\n if b < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n r= red\n b = blue\n i = 0\n while r >=0 and b>=0:\n i +=1\n if i%2==0:\n b-=i\n if b < 0:\n break\n else:\n r -=i\n if r < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n return best\n \n ","runtime":"35"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n h, N = 1, [0, 0]\n while True:\n N[h % 2] += h\n if min(N) > min(red, blue) or max(N) > max(red, blue):\n return h - 1\n \n h += 1","runtime":"36"},{"code":"class Solution:\n\n\tdef helper(self,\n\t\t\t a: int,\n\t\t\t b: int) -> int:\n\n\t\tresult = 0\n\t\tfor i in range(1, 100):\n\t\t\tif (i % 2 == 1):\n\t\t\t\tif (a < i):\n\t\t\t\t\tbreak\n\n\t\t\t\ta -= i\n\t\t\telse:\n\t\t\t\tif (b < i):\n\t\t\t\t\tbreak\n\n\t\t\t\tb -= i\n\n\t\t\tresult += 1\n\n\t\treturn result\n\n\n\tdef maxHeightOfTriangle(self,\n\t\t\t\t\t\t\tred: int,\n\t\t\t\t\t\t\tblue: int) -> int:\n\n\t\treturn max(self.helper(blue,\n\t\t\t\t\t\t\t red),\n\t\t\t\t self.helper(red,\n\t\t\t\t\t\t\t blue))\n","runtime":"36"},{"code":"def apSum(n, a=1, d=1): return (2*a+(n-1)*d)*n//2\n\nclass Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n \n def maxRow(sm, a, d):\n l,r = 0, 2 * math.ceil(sm**0.5)\n while l + 1 < r:\n mid = (l+r)//2 # row number\n if apSum(mid, a, d) <= sm:\n l = mid\n else:\n r = mid\n return l\n \n def find(first, second):\n r1 = maxRow(first, 1, 2)\n r2 = maxRow(second, 2, 2)\n curr = min(r1, r2) * 2 + (r1 > r2)\n return curr\n \n \n res = max(find(red, blue), find(blue, red))\n\n return res\n \n \n ","runtime":"37"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def start(balls):\n n=1\n while True:\n col=(n+1)%2\n balls[col]-=n\n if balls[col]<0:\n return n-1\n n+=1\n return max(start([red,blue]),start([blue,red]))","runtime":"38"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def get_k_max(a, b):\n # Calculates the maximum k such that k^2 <= a and k(k ± 1) <= b\n k1 = int(math.isqrt(a))\n delta = 1 + 4 * b\n sqrt_delta = math.isqrt(delta)\n k2_pos = int((-1 + sqrt_delta) // 2)\n k2_neg = int((1 + sqrt_delta) // 2)\n return k1, k2_pos, k2_neg\n\n # Starting with red, h odd (h = 2k - 1)\n k_red_odd_1 = int(math.isqrt(red))\n k_red_odd_2 = int((1 + math.isqrt(1 + 4 * blue)) // 2)\n k_red_odd = min(k_red_odd_1, k_red_odd_2)\n h_red_odd = 2 * k_red_odd - 1 if k_red_odd >= 1 else 0\n\n # Starting with red, h even (h = 2k)\n k_red_even_1 = int(math.isqrt(red))\n k_red_even_2 = int((-1 + math.isqrt(1 + 4 * blue)) // 2)\n k_red_even = min(k_red_even_1, k_red_even_2)\n h_red_even = 2 * k_red_even if k_red_even >= 1 else 0\n\n # Starting with blue, h odd (h = 2k - 1)\n k_blue_odd_1 = int(math.isqrt(blue))\n k_blue_odd_2 = int((1 + math.isqrt(1 + 4 * red)) // 2)\n k_blue_odd = min(k_blue_odd_1, k_blue_odd_2)\n h_blue_odd = 2 * k_blue_odd - 1 if k_blue_odd >= 1 else 0\n\n # Starting with blue, h even (h = 2k)\n k_blue_even_1 = int(math.isqrt(blue))\n k_blue_even_2 = int((-1 + math.isqrt(1 + 4 * red)) // 2)\n k_blue_even = min(k_blue_even_1, k_blue_even_2)\n h_blue_even = 2 * k_blue_even if k_blue_even >= 1 else 0\n\n max_height = max(h_red_odd, h_red_even, h_blue_odd, h_blue_even)\n return max_height","runtime":"39"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def max_rows(start, remain):\n nxt = start\n rows = 0\n while remain >= nxt:\n remain -= nxt\n nxt += 2\n rows += 1\n return rows\n \n o1 = max_rows(1, blue)\n o2 = max_rows(1, red)\n e1 = min(o1, max_rows(2, red))\n e2 = min(o2, max_rows(2, blue))\n return max(e1 + min(o1, e1 + 1), e2 + min(o2, e2 + 1))\n \n\n ","runtime":"40"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def check(r, b):\n h1, h2 = 1, 2\n while 1:\n if r >= h1:\n r -= h1\n h1 += 2\n else:\n return h1 - 1\n \n if b >= h2:\n b -= h2\n h2 += 2\n else:\n return h2 - 1\n return -1\n\n return max(check(red, blue), check(blue, red))\n\n","runtime":"41"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n if red > blue:\n red, blue = blue, red\n odd = isqrt(red)\n even_sum = odd ** 2 + odd\n if even_sum <= red and even_sum + odd + 1 <= blue:\n return odd * 2 + 1\n if even_sum <= blue:\n return odd * 2\n return odd * 2 - 1","runtime":"42"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n if red > blue:\n red, blue = blue, red\n odd = isqrt(red)\n even_sum = odd ** 2 + odd\n if even_sum <= red and even_sum + odd + 1 <= blue:\n return odd * 2 + 1\n if even_sum <= blue:\n return odd * 2\n return odd * 2 - 1","runtime":"43"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n odd_row = 0\n even_row = 0\n row_count = 0\n for i in range(1, 21):\n if i % 2 == 1:\n odd_row += i\n else:\n even_row += i\n if odd_row <= red and even_row <= blue or odd_row <= blue and even_row <= red:\n continue\n else:\n return i - 1\n\n return 100\n","runtime":"43"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def check(balls):\n row = 1\n while True:\n color = (row + 1) % 2\n balls[color] -= row\n if balls[color] < 0:\n return row - 1\n row += 1\n \n return max(\n check([red, blue]),\n check([blue, red]),\n )","runtime":"44"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def check(balls):\n row = 1\n while True:\n color = (row + 1) % 2\n balls[color] -= row\n if balls[color] < 0:\n return row -1\n row +=1\n return max(\n check([red, blue]),\n check([blue, red]))","runtime":"45"}],"string":"[\n {\n \"code\": \"'''\\nyou are given 2 integers\\n red and blue\\n\\neach int represents the count of red and blue colored balls\\n\\nyou have to arrage these balls to form a trianlge \\n\\nsuch that the 1st row will have 1 ball,\\n teh second row will have 2 balls,\\n the third row 3 balls,\\n etc...\\n\\nall the balls on a row should be the same color\\nadjacent rows should have different colors\\n\\nthe first placed color costs \\n 1 to fill first row\\n 3 to fill third\\n 5 to fill 5th\\n\\n its sum of odd #s\\n\\nthe second placed color costs\\n 2 to fill second row\\n 4 to fill 4th row\\n 6 to fill 6th row\\n\\n its sum of even #s\\n\\nfilling odd rows will always be cheaper than filling even rows\\n\\nred = pos1 > pos2\\nblue = pos1 > pos2\\n\\nred = 1 1\\nblue = 2 1\\n\\nred = 2 1\\nblue = 2 1\\n\\nwe want to choose the MAX position 1, then choose the other position 2\\nwe want to choose the minimum between both positions\\n'''\\n\\nclass Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n redHeight = self.calculateHeight(red, blue)\\n blueHeight = self.calculateHeight(blue, red)\\n return max(redHeight, blueHeight)\\n \\n def calculateHeight(self, primary, secondary):\\n height = 0 \\n i = 1\\n\\n while True:\\n if i % 2 != 0:\\n if primary >= i:\\n primary -= i\\n height += 1\\n else:\\n break\\n else:\\n if secondary >= i:\\n secondary -= i\\n height += 1\\n else:\\n break\\n i += 1\\n \\n return height\\n\\n\",\n \"runtime\": \"17\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n # red ball on top max height\\n height_red=1 \\n red_count=red-1\\n blue_count=blue\\n \\n i=2 # number of balls to place\\n\\n while True:\\n if i%2 == 0 and blue_count>=i:\\n height_red+=1\\n blue_count-=i\\n i+=1\\n elif i%2==1 and red_count>=i:\\n height_red+=1\\n red_count-=i\\n i+=1\\n else:\\n break # we finished\\n\\n\\n # blue ball on top \\n height_blue=1 \\n red_count=red\\n blue_count=blue-1\\n \\n i=2 # number of balls to place\\n\\n while True:\\n if i%2 == 0 and red_count>=i:\\n height_blue+=1\\n red_count-=i\\n i+=1\\n elif i%2==1 and blue_count>=i:\\n height_blue+=1\\n blue_count-=i\\n i+=1\\n else:\\n break # we finished\\n \\n return max(height_blue,height_red)\\n\\n\\n\\n \\n\\n \",\n \"runtime\": \"19\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n return max(self.tr(red,blue),self.tr(blue,red))\\n def tr(self,a,b):\\n h = 0\\n while a >= 0 and b >= 0:\\n if a > h:\\n h +=1\\n a -= h\\n if b > h:\\n h +=1\\n b -= h\\n else:\\n break\\n else:\\n break\\n return h\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n # 2 4 6 8 10 12\\n # 2 6 12 20 30 42\\n\\n # 1 3 5 7 9 11 13 15\\n # 1 4 9 16 25 36 49 64\\n odd_red = int(math.sqrt(red)) # 7\\n odd_blue = int(math.sqrt(blue)) # 6\\n \\n even_red = odd_red if odd_red**2 + odd_red <= red else odd_red - 1\\n even_blue = odd_blue if odd_blue**2 + odd_blue <= blue else odd_blue - 1\\n\\n max_height = 0\\n if odd_red <= even_blue: # 11 <= 10\\n max_height = odd_red * 2\\n else:\\n max_height = even_blue * 2 + 1\\n \\n if odd_blue <= even_red:\\n max_height = max(max_height, odd_blue * 2)\\n else:\\n max_height = max(max_height, even_red * 2 + 1)\\n\\n return max_height\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n redFirst = 1\\n redNext = True\\n redRed = red\\n redBlue = blue\\n\\n while redRed > 0 or redBlue > 0:\\n if redNext:\\n if redRed >= redFirst:\\n redRed -= redFirst\\n redNext = False\\n else:\\n break\\n else:\\n if redBlue >= redFirst:\\n redBlue -= redFirst\\n redNext = True\\n else:\\n break\\n redFirst += 1\\n \\n blueFirst = 1\\n redNext = False\\n blueRed = red\\n blueBlue = blue\\n\\n while blueRed > 0 or blueBlue > 0:\\n if redNext:\\n if blueRed >= blueFirst:\\n blueRed -= blueFirst\\n redNext = False\\n else:\\n break\\n else:\\n if blueBlue >= blueFirst:\\n blueBlue -= blueFirst\\n redNext = True\\n else:\\n break\\n blueFirst += 1\\n\\n return max(redFirst, blueFirst) - 1\",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n i = 0\\n r = red\\n b = blue\\n best = 0\\n while r>=0 and b>=0:\\n i +=1\\n if i%2==0:\\n r-=i\\n if r <0:\\n break\\n else:\\n b -=i\\n if b < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n r= red\\n b = blue\\n i = 0\\n while r >=0 and b>=0:\\n i +=1\\n if i%2==0:\\n b-=i\\n if b < 0:\\n break\\n else:\\n r -=i\\n if r < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n return best\\n \\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n i = 0\\n r = red\\n b = blue\\n best = 0\\n while r>=0 and b>=0:\\n i +=1\\n if i%2==0:\\n r-=i\\n if r <0:\\n break\\n else:\\n b -=i\\n if b < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n r= red\\n b = blue\\n i = 0\\n while r >=0 and b>=0:\\n i +=1\\n if i%2==0:\\n b-=i\\n if b < 0:\\n break\\n else:\\n r -=i\\n if r < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n return best\\n \\n \",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n # use red blue red\\n # blue red blue\\n\\n def f(ball: list[int]):\\n i = 0\\n while True:\\n use = i & 1\\n if ball[use] < i + 1: return i\\n ball[use] -= i + 1\\n i += 1\\n return max(f([red, blue]), f([blue, red]))\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def helper(start, nxt):\\n c_start = 1\\n c_nxt = 2\\n count = 0\\n while True:\\n if start-c_start >= 0:\\n start -= c_start\\n count += 1\\n else:\\n break\\n if nxt-c_nxt >= 0:\\n nxt -= c_nxt\\n count += 1\\n else:\\n break\\n c_start += 2\\n c_nxt += 2\\n return count\\n return max(helper(red, blue), helper(blue, red))\\n \",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n if red < blue:\\n return self.maxHeightOfTriangle(blue, red)\\n\\n h1, h2 = isqrt(blue*4+1), isqrt(blue)*2\\n if (h1+1)**2//4 <= red: return h1\\n if ((h2+1)**2-1)//4 <= red: return h2\\n if (h1-1)**2//4 <= red: return h1-1\\n return h2-1\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n h, N = 1, [0, 0]\\n while True:\\n N[h % 2] += h\\n if min(N) > min(red, blue) or max(N) > max(red, blue):\\n return h - 1\\n \\n h += 1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n \\n def helper(red,blue):\\n l=0\\n cr=1\\n \\n\\n while True:\\n if cr%2==1:\\n if red>=cr:\\n red-=cr\\n \\n else:\\n break\\n else:\\n if blue>=cr:\\n blue-=cr\\n \\n else:\\n break\\n l+=1\\n cr+=1\\n return l\\n return max(helper(red,blue),helper(blue,red))\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def tmp(x, y):\\n step = 1\\n max_height = 0\\n while True:\\n if x > 0:\\n x -= step\\n elif x == 0:\\n break\\n\\n if x < 0:\\n break\\n else:\\n max_height += 1\\n step += 1\\n \\n if y > 0:\\n y -= step\\n elif y == 0:\\n break\\n\\n if y < 0:\\n break\\n else:\\n max_height += 1\\n step += 1\\n return max_height\\n\\n response = max(tmp(red, blue), tmp(blue, red))\\n\\n # print(max_height_1, max_height_2)\\n return response\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n\\n def helper(_red: int, _blue: int, _color: int):\\n curr = 1\\n\\n while (_red, _blue)[_color] >= curr:\\n if _color == 0:\\n _red -= curr\\n else:\\n _blue -= curr\\n\\n curr += 1\\n _color = 1 - _color\\n\\n return curr - 1\\n\\n return max(helper(red, blue, 0), helper(red, blue, 1))\\n\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n i = 0\\n r = red\\n b = blue\\n best = 0\\n while r>=0 and b>=0:\\n i +=1\\n if i%2==0:\\n r-=i\\n if r <0:\\n break\\n else:\\n b -=i\\n if b < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n r= red\\n b = blue\\n i = 0\\n while r >=0 and b>=0:\\n i +=1\\n if i%2==0:\\n b-=i\\n if b < 0:\\n break\\n else:\\n r -=i\\n if r < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n return best\\n \\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n h, N = 1, [0, 0]\\n while True:\\n N[h % 2] += h\\n if min(N) > min(red, blue) or max(N) > max(red, blue):\\n return h - 1\\n \\n h += 1\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\tdef helper(self,\\n\\t\\t\\t a: int,\\n\\t\\t\\t b: int) -> int:\\n\\n\\t\\tresult = 0\\n\\t\\tfor i in range(1, 100):\\n\\t\\t\\tif (i % 2 == 1):\\n\\t\\t\\t\\tif (a < i):\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\ta -= i\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif (b < i):\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\tb -= i\\n\\n\\t\\t\\tresult += 1\\n\\n\\t\\treturn result\\n\\n\\n\\tdef maxHeightOfTriangle(self,\\n\\t\\t\\t\\t\\t\\t\\tred: int,\\n\\t\\t\\t\\t\\t\\t\\tblue: int) -> int:\\n\\n\\t\\treturn max(self.helper(blue,\\n\\t\\t\\t\\t\\t\\t\\t red),\\n\\t\\t\\t\\t self.helper(red,\\n\\t\\t\\t\\t\\t\\t\\t blue))\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"def apSum(n, a=1, d=1): return (2*a+(n-1)*d)*n//2\\n\\nclass Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n \\n def maxRow(sm, a, d):\\n l,r = 0, 2 * math.ceil(sm**0.5)\\n while l + 1 < r:\\n mid = (l+r)//2 # row number\\n if apSum(mid, a, d) <= sm:\\n l = mid\\n else:\\n r = mid\\n return l\\n \\n def find(first, second):\\n r1 = maxRow(first, 1, 2)\\n r2 = maxRow(second, 2, 2)\\n curr = min(r1, r2) * 2 + (r1 > r2)\\n return curr\\n \\n \\n res = max(find(red, blue), find(blue, red))\\n\\n return res\\n \\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def start(balls):\\n n=1\\n while True:\\n col=(n+1)%2\\n balls[col]-=n\\n if balls[col]<0:\\n return n-1\\n n+=1\\n return max(start([red,blue]),start([blue,red]))\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def get_k_max(a, b):\\n # Calculates the maximum k such that k^2 <= a and k(k ± 1) <= b\\n k1 = int(math.isqrt(a))\\n delta = 1 + 4 * b\\n sqrt_delta = math.isqrt(delta)\\n k2_pos = int((-1 + sqrt_delta) // 2)\\n k2_neg = int((1 + sqrt_delta) // 2)\\n return k1, k2_pos, k2_neg\\n\\n # Starting with red, h odd (h = 2k - 1)\\n k_red_odd_1 = int(math.isqrt(red))\\n k_red_odd_2 = int((1 + math.isqrt(1 + 4 * blue)) // 2)\\n k_red_odd = min(k_red_odd_1, k_red_odd_2)\\n h_red_odd = 2 * k_red_odd - 1 if k_red_odd >= 1 else 0\\n\\n # Starting with red, h even (h = 2k)\\n k_red_even_1 = int(math.isqrt(red))\\n k_red_even_2 = int((-1 + math.isqrt(1 + 4 * blue)) // 2)\\n k_red_even = min(k_red_even_1, k_red_even_2)\\n h_red_even = 2 * k_red_even if k_red_even >= 1 else 0\\n\\n # Starting with blue, h odd (h = 2k - 1)\\n k_blue_odd_1 = int(math.isqrt(blue))\\n k_blue_odd_2 = int((1 + math.isqrt(1 + 4 * red)) // 2)\\n k_blue_odd = min(k_blue_odd_1, k_blue_odd_2)\\n h_blue_odd = 2 * k_blue_odd - 1 if k_blue_odd >= 1 else 0\\n\\n # Starting with blue, h even (h = 2k)\\n k_blue_even_1 = int(math.isqrt(blue))\\n k_blue_even_2 = int((-1 + math.isqrt(1 + 4 * red)) // 2)\\n k_blue_even = min(k_blue_even_1, k_blue_even_2)\\n h_blue_even = 2 * k_blue_even if k_blue_even >= 1 else 0\\n\\n max_height = max(h_red_odd, h_red_even, h_blue_odd, h_blue_even)\\n return max_height\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def max_rows(start, remain):\\n nxt = start\\n rows = 0\\n while remain >= nxt:\\n remain -= nxt\\n nxt += 2\\n rows += 1\\n return rows\\n \\n o1 = max_rows(1, blue)\\n o2 = max_rows(1, red)\\n e1 = min(o1, max_rows(2, red))\\n e2 = min(o2, max_rows(2, blue))\\n return max(e1 + min(o1, e1 + 1), e2 + min(o2, e2 + 1))\\n \\n\\n \",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def check(r, b):\\n h1, h2 = 1, 2\\n while 1:\\n if r >= h1:\\n r -= h1\\n h1 += 2\\n else:\\n return h1 - 1\\n \\n if b >= h2:\\n b -= h2\\n h2 += 2\\n else:\\n return h2 - 1\\n return -1\\n\\n return max(check(red, blue), check(blue, red))\\n\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n if red > blue:\\n red, blue = blue, red\\n odd = isqrt(red)\\n even_sum = odd ** 2 + odd\\n if even_sum <= red and even_sum + odd + 1 <= blue:\\n return odd * 2 + 1\\n if even_sum <= blue:\\n return odd * 2\\n return odd * 2 - 1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n if red > blue:\\n red, blue = blue, red\\n odd = isqrt(red)\\n even_sum = odd ** 2 + odd\\n if even_sum <= red and even_sum + odd + 1 <= blue:\\n return odd * 2 + 1\\n if even_sum <= blue:\\n return odd * 2\\n return odd * 2 - 1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n odd_row = 0\\n even_row = 0\\n row_count = 0\\n for i in range(1, 21):\\n if i % 2 == 1:\\n odd_row += i\\n else:\\n even_row += i\\n if odd_row <= red and even_row <= blue or odd_row <= blue and even_row <= red:\\n continue\\n else:\\n return i - 1\\n\\n return 100\\n\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def check(balls):\\n row = 1\\n while True:\\n color = (row + 1) % 2\\n balls[color] -= row\\n if balls[color] < 0:\\n return row - 1\\n row += 1\\n \\n return max(\\n check([red, blue]),\\n check([blue, red]),\\n )\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def check(balls):\\n row = 1\\n while True:\\n color = (row + 1) % 2\\n balls[color] -= row\\n if balls[color] < 0:\\n return row -1\\n row +=1\\n return max(\\n check([red, blue]),\\n check([blue, red]))\",\n \"runtime\": \"45\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":27,"string":"27"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def check(a,b):\n c=0\n f=0\n l=1\n while(a>0 or b>0):\n if(f==0):\n if(a>=l):\n a-=l\n else:\n break\n else:\n if(b>=l):\n b-=l\n else:\n break\n c+=1\n l+=1\n f=f^1\n return c\n k1 = check(red,blue)\n k2 = check(blue,red)\n return max(k1,k2)","memory":"16200"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n ans = 0\n for k in range(2):\n c = [red, blue]\n i, j = 1, k\n while i <= c[j]:\n c[j] -= i\n j ^= 1\n ans = max(ans, i)\n i += 1\n return ans","memory":"16300"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n if red > blue:\n red, blue = blue, red\n odd = isqrt(red)\n even_sum = odd ** 2 + odd\n if even_sum <= red and even_sum + odd + 1 <= blue:\n return odd * 2 + 1\n if even_sum <= blue:\n return odd * 2\n return odd * 2 - 1","memory":"16400"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n def helper(start, nxt):\n c_start = 1\n c_nxt = 2\n count = 0\n while True:\n if start-c_start >= 0:\n start -= c_start\n count += 1\n else:\n break\n if nxt-c_nxt >= 0:\n nxt -= c_nxt\n count += 1\n else:\n break\n c_start += 2\n c_nxt += 2\n return count\n return max(helper(red, blue), helper(blue, red))\n ","memory":"16500"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n i = 0\n r = red\n b = blue\n best = 0\n while r>=0 and b>=0:\n i +=1\n if i%2==0:\n r-=i\n if r <0:\n break\n else:\n b -=i\n if b < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n r= red\n b = blue\n i = 0\n while r >=0 and b>=0:\n i +=1\n if i%2==0:\n b-=i\n if b < 0:\n break\n else:\n r -=i\n if r < 0:\n break\n if r >= 0 and b >= 0:\n best = max(best,i)\n return best\n \n ","memory":"16500"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n h, N = 1, [0, 0]\n while True:\n N[h % 2] += h\n if min(N) > min(red, blue) or max(N) > max(red, blue):\n return h - 1\n \n h += 1","memory":"16600"},{"code":"class Solution:\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\n h, N = 1, [0, 0]\n while True:\n N[h % 2] += h\n if min(N) > min(red, blue) or max(N) > max(red, blue):\n return h - 1\n \n h += 1","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def check(a,b):\\n c=0\\n f=0\\n l=1\\n while(a>0 or b>0):\\n if(f==0):\\n if(a>=l):\\n a-=l\\n else:\\n break\\n else:\\n if(b>=l):\\n b-=l\\n else:\\n break\\n c+=1\\n l+=1\\n f=f^1\\n return c\\n k1 = check(red,blue)\\n k2 = check(blue,red)\\n return max(k1,k2)\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n ans = 0\\n for k in range(2):\\n c = [red, blue]\\n i, j = 1, k\\n while i <= c[j]:\\n c[j] -= i\\n j ^= 1\\n ans = max(ans, i)\\n i += 1\\n return ans\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n if red > blue:\\n red, blue = blue, red\\n odd = isqrt(red)\\n even_sum = odd ** 2 + odd\\n if even_sum <= red and even_sum + odd + 1 <= blue:\\n return odd * 2 + 1\\n if even_sum <= blue:\\n return odd * 2\\n return odd * 2 - 1\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n def helper(start, nxt):\\n c_start = 1\\n c_nxt = 2\\n count = 0\\n while True:\\n if start-c_start >= 0:\\n start -= c_start\\n count += 1\\n else:\\n break\\n if nxt-c_nxt >= 0:\\n nxt -= c_nxt\\n count += 1\\n else:\\n break\\n c_start += 2\\n c_nxt += 2\\n return count\\n return max(helper(red, blue), helper(blue, red))\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n i = 0\\n r = red\\n b = blue\\n best = 0\\n while r>=0 and b>=0:\\n i +=1\\n if i%2==0:\\n r-=i\\n if r <0:\\n break\\n else:\\n b -=i\\n if b < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n r= red\\n b = blue\\n i = 0\\n while r >=0 and b>=0:\\n i +=1\\n if i%2==0:\\n b-=i\\n if b < 0:\\n break\\n else:\\n r -=i\\n if r < 0:\\n break\\n if r >= 0 and b >= 0:\\n best = max(best,i)\\n return best\\n \\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n h, N = 1, [0, 0]\\n while True:\\n N[h % 2] += h\\n if min(N) > min(red, blue) or max(N) > max(red, blue):\\n return h - 1\\n \\n h += 1\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def maxHeightOfTriangle(self, red: int, blue: int) -> int:\\n h, N = 1, [0, 0]\\n while True:\\n N[h % 2] += h\\n if min(N) > min(red, blue) or max(N) > max(red, blue):\\n return h - 1\\n \\n h += 1\",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":7,"string":"7"}}},{"rowIdx":2470,"cells":{"question_id":{"kind":"number","value":2687,"string":"2,687"},"name":{"kind":"string","value":"lexicographically-smallest-beautiful-string"},"content":{"kind":"string","value":"<p>A string is <strong>beautiful</strong> if:</p>\n\n<ul>\n\t<li>It consists of the first <code>k</code> letters of the English lowercase alphabet.</li>\n\t<li>It does not contain any substring of length <code>2</code> or more which is a palindrome.</li>\n</ul>\n\n<p>You are given a beautiful string <code>s</code> of length <code>n</code> and a positive integer <code>k</code>.</p>\n\n<p>Return <em>the lexicographically smallest string of length </em><code>n</code><em>, which is larger than </em><code>s</code><em> and is <strong>beautiful</strong></em>. If there is no such string, return an empty string.</p>\n\n<p>A string <code>a</code> is lexicographically larger than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, <code>a</code> has a character strictly larger than the corresponding character in <code>b</code>.</p>\n\n<ul>\n\t<li>For example, <code>"abcd"</code> is lexicographically larger than <code>"abcc"</code> because the first position they differ is at the fourth character, and <code>d</code> is greater than <code>c</code>.</li>\n</ul>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "abcz", k = 26\n<strong>Output:</strong> "abda"\n<strong>Explanation:</strong> The string "abda" is beautiful and lexicographically larger than the string "abcz".\nIt can be proven that there is no string that is lexicographically larger than the string "abcz", beautiful, and lexicographically smaller than the string "abda".\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> s = "dc", k = 4\n<strong>Output:</strong> ""\n<strong>Explanation:</strong> It can be proven that there is no string that is lexicographically larger than the string "dc" and is beautiful.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n == s.length <= 10<sup>5</sup></code></li>\n\t<li><code>4 <= k <= 26</code></li>\n\t<li><code>s</code> is a beautiful string.</li>\n</ul>\n"},"acRate":{"kind":"number","value":37.951849025185595,"string":"37.951849"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["string","greedy"],"string":"[\n \"string\",\n \"greedy\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"199\", 1.3333], [\"201\", 1.3333], [\"203\", 1.3333], [\"204\", 1.3333], [\"205\", 1.3333], [\"208\", 1.3333], [\"216\", 1.3333], [\"218\", 1.3333], [\"223\", 4.0], [\"225\", 1.3333], [\"230\", 1.3333], [\"234\", 1.3333], [\"235\", 1.3333], [\"239\", 1.3333], [\"247\", 1.3333], [\"248\", 2.6667], [\"250\", 1.3333], [\"254\", 1.3333], [\"258\", 1.3333], [\"266\", 4.0], [\"267\", 1.3333], [\"269\", 2.6667], [\"270\", 1.3333], [\"272\", 2.6667], [\"274\", 1.3333], [\"277\", 2.6667], [\"279\", 2.6667], [\"281\", 1.3333], [\"282\", 1.3333], [\"283\", 1.3333], [\"284\", 1.3333], [\"288\", 1.3333], [\"291\", 1.3333], [\"292\", 1.3333], [\"295\", 1.3333], [\"299\", 1.3333], [\"301\", 1.3333], [\"331\", 1.3333], [\"334\", 1.3333], [\"343\", 1.3333], [\"351\", 2.6667], [\"354\", 1.3333], [\"356\", 1.3333], [\"358\", 1.3333], [\"359\", 2.6667], [\"363\", 1.3333], [\"369\", 2.6667], [\"370\", 1.3333], [\"373\", 2.6667], [\"374\", 1.3333], [\"382\", 1.3333], [\"404\", 2.6667], [\"452\", 1.3333], [\"477\", 1.3333], [\"484\", 1.3333], [\"485\", 1.3333], [\"496\", 1.3333]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"17800\", 1.3333], [\"18200\", 1.3333], [\"18300\", 14.6667], [\"18400\", 38.6667], [\"18500\", 6.6667], [\"18600\", 2.6667], [\"18700\", 1.3333], [\"18900\", 2.6667], [\"19200\", 5.3333], [\"19300\", 13.3333]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n # Find the first position from the right that can be incremented\n for i in range(n - 1, -1, -1):\n ch = ord(s[i]) - ord('a') + 1\n while ch < k:\n if (i - 1 < 0 or s[i - 1] != chr(ord('a') + ch)) and (i - 2 < 0 or s[i - 2] != chr(ord('a') + ch)):\n s[i] = chr(ord('a') + ch)\n break\n ch += 1\n else:\n if i == 0:\n return \"\"\n continue\n \n # Fill the rest of the string with the smallest possible characters\n for j in range(i + 1, n):\n for ch in range(k):\n if (j - 1 < 0 or s[j - 1] != chr(ord('a') + ch)) and (j - 2 < 0 or s[j - 2] != chr(ord('a') + ch)):\n s[j] = chr(ord('a') + ch)\n break\n \n return \"\".join(s)\n \n return \"\"","runtime":"199"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n res = list(s)\n orda = ord('a')\n for i in range(len(s)-1, -1, -1):\n index = ord(s[i]) - orda\n for j in range(index+1, k):\n ch = chr(orda+j)\n if (i>0 and s[i-1]==ch) or (i>1 and s[i-2]==ch):\n continue\n \n # Found a lexicographically larger string\n res[i] = ch\n for m in range(i+1, len(s)):\n for ch in \"abc\":\n if ch!=res[m-1] and (m-2<0 or ch!=res[m-2]):\n res[m] = ch\n break\n return ''.join(res)\n return \"\"","runtime":"201"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n cs = list(s)\n for i in range(n - 1, -1, -1):\n p = ord(cs[i]) - ord('a') + 1\n for j in range(p, k):\n c = chr(ord('a') + j)\n if (i > 0 and cs[i - 1] == c) or (i > 1 and cs[i - 2] == c):\n continue\n cs[i] = c\n for l in range(i + 1, n):\n for m in range(k):\n c = chr(ord('a') + m)\n if (l > 0 and cs[l - 1] == c) or (l > 1 and cs[l - 2] == c):\n continue\n cs[l] = c\n break\n return ''.join(cs)\n return ''","runtime":"203"},{"code":"class Solution:\n def is_palindrome(self, i, s, curr_char):\n prev_char = ord(s[i-1]) - ord('a')\n\n if curr_char == prev_char:\n return True\n \n # if i + 1 < len(s) and curr_char == ord(s[i+1]) - ord('a'):\n # return True\n \n if i - 2 >= 0 and curr_char == ord(s[i-2]) - ord('a'):\n return True\n \n # if i + 2 < len(s) and curr_char == ord(s[i+2]) - ord('a'):\n # return True\n \n return False\n\n def smallestBeautifulString(self, s: str, k: int) -> str: \n i = len(s)-1\n s = list(s)\n n = len(s)\n\n for i in range(len(s)-1, -1, -1):\n position = ord(s[i]) - ord('a') + 1\n\n for j in range(position, k):\n rch = chr(j + ord('a'))\n\n if (i > 0 and s[i-1] == rch) or (i > 1 and s[i-2] == rch):\n continue\n \n s[i] = rch\n\n for l in range(i + 1, n):\n for m in range(k):\n next_char = chr(ord('a') + m)\n if (l > 0 and s[l - 1] == next_char) or (l > 1 and s[l - 2] == next_char):\n continue\n s[l] = next_char\n break\n \n return ''.join(s)\n return ''","runtime":"204"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n\n s = list(s)\n n = len(s)\n \n \n for i in range(n - 1, -1, -1):\n for c in range(ord(s[i]) + 1, ord('a') + k):\n \n s[i] = chr(c)\n \n \n if (i == 0 or s[i] != s[i - 1]) and (i < 2 or s[i] != s[i - 2]):\n \n for j in range(i + 1, n):\n for c in range(ord('a'), ord('a') + k):\n s[j] = chr(c)\n if (j == 0 or s[j] != s[j - 1]) and (j < 2 or s[j] != s[j - 2]):\n break\n return ''.join(s)\n \n return \"\" \n ","runtime":"205"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n \n s = list(s)\n n = len(s)\n max_letter = chr(ord('a') + k - 1)\n \n for i in reversed(range(n)):\n cnt = 1\n while chr(ord(s[i]) + cnt) <= max_letter:\n tmp = chr(ord(s[i]) + cnt)\n if (i < 1 or tmp != s[i-1]) and (i < 2 or tmp != s[i - 2]):\n s[i] = tmp\n for j in range(i+1, n):\n c = 0\n while (j >= 1 and s[j-1] == chr(ord('a') + c)) or (j >= 2 and s[j-2] == chr(ord('a') + c)):\n c += 1\n s[j] = chr(ord('a') + c)\n return \"\".join(s)\n \n cnt += 1\n \n return \"\"","runtime":"208"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n cs = list(s)\n for i in range(n - 1, -1, -1):\n p = ord(cs[i]) - ord('a') + 1\n for j in range(p, k):\n c = chr(ord('a') + j)\n if (i > 0 and cs[i - 1] == c) or (i > 1 and cs[i - 2] == c):\n continue\n cs[i] = c\n for l in range(i + 1, n):\n for m in range(k):\n c = chr(ord('a') + m)\n if (l > 0 and cs[l - 1] == c) or (l > 1 and cs[l - 2] == c):\n continue\n cs[l] = c\n break\n return ''.join(cs)\n return ''","runtime":"216"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n arr = list(s)\n \n for i in range(n - 1, -1, -1):\n curr = ord(arr[i]) - ord('a')\n for j in range(curr + 1, k):\n if (i > 0 and chr(j + ord('a')) == arr[i-1]) or (i > 1 and chr(j + ord('a')) == arr[i-2]):\n continue\n arr[i] = chr(j + ord('a'))\n for l in range(i + 1, n):\n for m in range(k):\n if (l > 0 and chr(m + ord('a')) == arr[l-1]) or (l > 1 and chr(m + ord('a')) == arr[l-2]):\n continue\n arr[l] = chr(m + ord('a'))\n break\n return ''.join(arr)\n \n return ''","runtime":"218"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s) # Convert to list for mutability\n a = ord('a')\n \n # Helper function to check if the string is beautiful\n def is_beautiful(s, i):\n if i > 0 and s[i] == s[i - 1]:\n return False\n if i > 1 and s[i] == s[i - 2]:\n return False\n return True\n \n # Try to increment from the end\n for i in range(n - 1, -1, -1):\n # Increment the current character\n for j in range(ord(s[i]) - a + 1, k):\n s[i] = chr(a + j)\n if is_beautiful(s, i):\n # Fill the rest of the string with the smallest possible characters\n for x in range(i + 1, n):\n for y in range(k):\n s[x] = chr(a + y)\n if is_beautiful(s, x):\n break\n return ''.join(s)\n \n return \"\" # If no valid string is found\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"223"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n N = len(s)\n alphabet = string.ascii_lowercase\n k -= 1\n arr = [c for c in s]\n\n for i in range(N - 1, -1, -1):\n if arr[i] != alphabet[k]:\n\n index = alphabet.index(arr[i])\n\n for char in alphabet[index + 1: k + 1]:\n \n l = i - 1\n\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\n # we have a valid answer\n arr[i] = char\n i += 1\n\n while i < N:\n for o in alphabet:\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\n arr[i] = o\n i += 1\n break\n\n return \"\".join(arr) \n \n return \"\" ","runtime":"225"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s) # Convert string to list for easier manipulation\n found = False\n \n # Iterate backwards to find a position to increment\n for i in range(n - 1, -1, -1):\n for replacement in range(ord(s[i]) + 1, ord('a') + k):\n s[i] = chr(replacement)\n \n # Check from the current position if it can form a beautiful string\n if (i - 1 >= 0 and s[i] == s[i - 1]) or (i - 2 >= 0 and s[i] == s[i - 2]):\n continue # Skip, as this does not form a beautiful sequence\n \n # Fill in the rest of the string with the smallest valid characters\n for j in range(i + 1, n):\n for ch in range(ord('a'), ord('a') + k):\n s[j] = chr(ch)\n if (j - 1 >= 0 and s[j] == s[j - 1]) or (j - 2 >= 0 and s[j] == s[j - 2]):\n continue # Check if next char makes it invalid\n break\n \n found = True\n break\n if found:\n break\n \n return ''.join(s) if found else \"\"","runtime":"230"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert the string to a list of characters for easier manipulation\n s = list(s)\n n = len(s)\n \n # Function to check if we can place char `c` at position `i`\n def is_valid(i, c):\n if i > 0 and s[i - 1] == c:\n return False # it would form a palindrome of length 2\n if i > 1 and s[i - 2] == c:\n return False # it would form a palindrome of length 3\n return True\n\n # Process the string from the end to the start\n for i in range(n - 1, -1, -1):\n # Try to replace the current character with the next lexicographical character\n for nxt_char in range(ord(s[i]) + 1, ord('a') + k):\n if is_valid(i, chr(nxt_char)):\n s[i] = chr(nxt_char)\n # Fill the rest of the string with the smallest valid letter\n for j in range(i + 1, n):\n for c in range(ord('a'), ord('a') + k):\n if is_valid(j, chr(c)):\n s[j] = chr(c)\n break\n return \"\".join(s)\n \n # If no valid string was found\n return \"\"\n\n# Example usage:\nsol = Solution()\nprint(sol.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(sol.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"234"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s) # Convert to list for easier manipulation\n \n # Function to check if the string is beautiful up to a certain index\n def is_beautiful(s, index):\n if index >= 1 and s[index] == s[index - 1]:\n return False\n if index >= 2 and s[index] == s[index - 2]:\n return False\n return True\n \n # Start from the end of the string and try to increment\n for i in range(n - 1, -1, -1):\n # Try to increment the character at position i\n for j in range(ord(s[i]) - ord('a') + 1, k):\n s[i] = chr(ord('a') + j)\n # Check if this position is beautiful\n if is_beautiful(s, i):\n # Fill the rest with the smallest valid characters\n for x in range(i + 1, n):\n for y in range(k):\n s[x] = chr(ord('a') + y)\n if is_beautiful(s, x):\n break\n return ''.join(s)\n \n # If not found, return an empty string\n return \"\"\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"235"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert the string to a list of characters\n chars = list(s)\n n = len(chars)\n\n # Function to check if adding a character at index i creates a palindrome\n def is_palindrome(i):\n return i > 0 and chars[i] == chars[i-1] or i > 1 and chars[i] == chars[i-2]\n\n # Iterate from the end to the beginning\n for i in range(n-1, -1, -1):\n # Try to increment the current character\n for c in range(ord(chars[i]) - ord('a') + 1, k):\n chars[i] = chr(ord('a') + c)\n if not is_palindrome(i):\n break\n else:\n continue\n # Update the rest of the string to the smallest possible valid string\n for j in range(i+1, n):\n for c in range(k):\n chars[j] = chr(ord('a') + c)\n if not is_palindrome(j):\n break\n # If we successfully updated the string, return the result\n return ''.join(chars)\n \n # If no valid increment is found, return an empty string\n return \"\"\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"239"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n '''\n our current string is valid\n we just have to find next valid one\n\n find first char we can increase (and maintain nonpalindome property)\n\n then make all chars after it \"abcabc...\" with some edge cases\n\n find first char we can change from right to left\n\n then, change all chars right of it to some invariant of \"abc\" and return ans\n\n '''\n N = len(s)\n alphabet = string.ascii_lowercase\n k -= 1\n arr = [c for c in s]\n\n for i in range(N - 1, -1, -1):\n if arr[i] != alphabet[k]:\n\n index = alphabet.index(arr[i])\n\n for char in alphabet[index + 1: k + 1]:\n \n l = i - 1\n\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\n # we have a valid answer\n arr[i] = char\n i += 1\n\n while i < N:\n for o in alphabet:\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\n arr[i] = o\n i += 1\n break\n\n return \"\".join(arr)\n\n \n \n return \"\"\n\n \n\n ","runtime":"247"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s) # Convert string to list for easier manipulation\n \n # Function to check if the string is beautiful at a given position\n def is_beautiful(pos):\n if pos > 0 and s[pos] == s[pos - 1]:\n return False\n if pos > 1 and s[pos] == s[pos - 2]:\n return False\n return True\n \n # Try to increment the string from the end\n for i in range(n - 1, -1, -1):\n for ch in range(ord(s[i]) - ord('a') + 1, k):\n s[i] = chr(ord('a') + ch)\n if is_beautiful(i):\n # Fill the rest of the string with the smallest possible characters\n for j in range(i + 1, n):\n for ch in range(k):\n s[j] = chr(ord('a') + ch)\n if is_beautiful(j):\n break\n return ''.join(s)\n \n # If no valid string was found, return an empty string\n return \"\"","runtime":"248"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert the string to a list for easier manipulation\n s = list(s)\n n = len(s)\n \n # Function to check if a substring is a palindrome\n def is_palindrome(substring):\n return substring == substring[::-1]\n \n # Function to find the next valid character\n def next_char(char):\n return chr(ord(char) + 1) if char != chr(ord('a') + k - 1) else None\n \n # Start from the last character\n for i in range(n - 1, -1, -1):\n current_char = s[i]\n next_valid_char = next_char(current_char)\n \n while next_valid_char:\n s[i] = next_valid_char\n \n # Check if the new string is beautiful\n if not (i - 1 >= 0 and s[i - 1] == next_valid_char or \n i - 2 >= 0 and s[i - 2] == next_valid_char):\n break\n \n next_valid_char = next_char(next_valid_char)\n \n if next_valid_char:\n # If we found a valid character, reset the following characters to 'a'\n for j in range(i + 1, n):\n for char in map(chr, range(ord('a'), ord('a') + k)):\n if (j - 1 < 0 or s[j - 1] != char) and (j - 2 < 0 or s[j - 2] != char):\n s[j] = char\n break\n return ''.join(s)\n \n return \"\" # If no valid string is found\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"250"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n i, n = len(s) - 1, len(s)\n s = list(s)\n s[-1] = chr(ord(s[i]) + 1) # Increment the last character of the string\n while i >= 0 and i < n:\n if ord(s[i]) >= ord('a') + k: # If the character exceeds the limit, reset it to 'a' and move to the previous character\n s[i] = \"a\"\n i -= 1\n if i >= 0:\n s[i] = chr(ord(s[i]) + 1) # Increment the previous character\n else:\n break # If there are no more characters, break out of the loop\n elif (i - 1 >= 0 and s[i] == s[i - 1]) or (i - 2 >= 0 and s[i] == s[i - 2]):\n s[i] = chr(ord(s[i]) + 1) # If the character violates the \"beautiful\" property, increment it\n else:\n i += 1 # Move to the next character\n if i == -1:\n s = \"\" # If the string cannot be made \"beautiful\", return an empty string\n return ''.join(s)","runtime":"254"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\n # If X3 and X4 form a palindrome, we have X3 == X4.\n # If X2-X4 form a palindrome, we have X2 == X4.\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\n # So far, finding the rightmost incrementable character is O(n).\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \"a\"/\"b\"/\"c\" anyway.\n ans = list(s)\n cur = -1\n for i in range(len(ans) - 1, -1, -1):\n if ord(ans[i]) - 96 >= k:\n # This letter cannot be incremented\n continue\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\n if chr(j) not in seen:\n ans[i] = chr(j)\n break\n else:\n # Not possible to adjust the current letter due to constraint k.\n continue\n # We have replaced ans[i]\n cur = i + 1\n break\n if cur == -1:\n return \"\"\n for i in range(cur, len(ans)):\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for ch in \"abc\":\n if ch not in seen:\n ans[i] = ch\n break\n return \"\".join(ans)","runtime":"258"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n def is_palindrome(s, i):\n if i > 0 and s[i] == s[i - 1]:\n return True\n if i > 1 and s[i] == s[i - 2]:\n return True\n return False\n \n for i in range(n - 1, -1, -1):\n for j in range(ord(s[i]) - ord('a') + 1, k):\n s[i] = chr(j + ord('a'))\n if not is_palindrome(s, i):\n for l in range(i + 1, n):\n for m in range(k):\n s[l] = chr(m + ord('a'))\n if not is_palindrome(s, l):\n break\n return ''.join(s)\n \n return \"\"","runtime":"266"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = list(s)\n i = len(s) - 1\n s[i] = chr(ord(s[i]) + 1)\n while 0 <= i < len(s):\n if ord(s[i]) - ord('a') >= k:\n s[i] = 'a'\n i -= 1\n s[i] = chr(ord(s[i]) + 1)\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]): s[i] = chr(ord(s[i]) + 1)\n else: i += 1\n return '' if i < 0 else ''.join(s)","runtime":"267"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = list(s)\n i = len(s) - 1 \n s[i] = chr(ord(s[i]) + 1)\n while 0 <= i < len(s): \n if ord(s[i]) - ord('a') >= k: \n s[i] = 'a'\n i -= 1 \n s[i] = chr(ord(s[i]) + 1)\n \n elif (i >= 1 and s[i]==s[i-1]) or (i>=2 and s[i] == s[i-2]): \n s[i] = chr(ord(s[i]) + 1)\n\n else: \n i += 1 \n \n return '' if i < 0 else ''.join(s)\n\n\n\n\n\n\n\n #made notes \n #https://www.youtube.com/watch?v=c7FX1l6dwjE for expl\n","runtime":"269"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = list(s)\n i = len(s) - 1 \n s[i] = chr(ord(s[i]) + 1)\n while 0 <= i < len(s): \n if ord(s[i]) - ord('a') >= k: \n s[i] = 'a'\n i -= 1 \n s[i] = chr(ord(s[i]) + 1)\n \n elif (i >= 1 and s[i]==s[i-1]) or (i>=2 and s[i] == s[i-2]): \n s[i] = chr(ord(s[i]) + 1)\n\n else: \n i += 1 \n \n return '' if i < 0 else ''.join(s)\n #go thru the code. run it for every input. That's all.\n\n\n\n\n\n\n #made notes \n #https://www.youtube.com/watch?v=c7FX1l6dwjE for expl\n","runtime":"270"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\n # If X3 and X4 form a palindrome, we have X3 == X4.\n # If X2-X4 form a palindrome, we have X2 == X4.\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\n # So far, finding the rightmost incrementable character is O(n).\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \"a\"/\"b\"/\"c\" anyway.\n ans = list(s)\n cur = -1\n for i in range(len(ans) - 1, -1, -1):\n if ord(ans[i]) - 96 >= k:\n # This letter cannot be incremented\n continue\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\n if chr(j) not in seen:\n ans[i] = chr(j)\n break\n else:\n # Not possible to adjust the current letter due to constraint k.\n continue\n # We have replaced ans[i]\n cur = i + 1\n break\n if cur == -1:\n return \"\"\n for i in range(cur, len(ans)):\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for ch in \"abc\":\n if ch not in seen:\n ans[i] = ch\n break\n return \"\".join(ans)","runtime":"272"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\n # If X3 and X4 form a palindrome, we have X3 == X4.\n # If X2-X4 form a palindrome, we have X2 == X4.\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\n # So far, finding the rightmost incrementable character is O(n).\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \"a\"/\"b\"/\"c\" anyway.\n ans = list(s)\n cur = -1\n for i in range(len(ans) - 1, -1, -1):\n if ord(ans[i]) - 96 >= k:\n # This letter cannot be incremented\n continue\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\n if chr(j) not in seen:\n ans[i] = chr(j)\n break\n else:\n # Not possible to adjust the current letter due to constraint k.\n continue\n # We have replaced ans[i]\n cur = i + 1\n break\n if cur == -1:\n return \"\"\n for i in range(cur, len(ans)):\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for ch in \"abc\":\n if ch not in seen:\n ans[i] = ch\n break\n return \"\".join(ans)","runtime":"272"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert the string to a list for easier manipulation\n s = list(s)\n # Start from the last character of the string\n i = len(s) - 1\n # Increment the last character\n s[i] = chr(ord(s[i]) + 1)\n \n # Iterate while the index is within bounds\n while 0 <= i < len(s):\n # If the character exceeds the k-th letter, reset it to 'a' and move left\n if ord(s[i]) - ord('a') >= k:\n s[i] = 'a'\n i -= 1\n # Increment the character at the new position\n s[i] = chr(ord(s[i]) + 1)\n # Check for palindrome conditions\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\n # If a palindrome is detected, increment the character\n s[i] = chr(ord(s[i]) + 1)\n else:\n # Move to the next character\n i += 1\n \n # If the index is negative, it means no valid string was found\n return '' if i < 0 else ''.join(s)","runtime":"274"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert string to list for easier manipulation\n s = list(s)\n n = len(s)\n \n # Function to check if adding char at index i creates a palindrome\n def is_palindrome(s, i):\n return i > 0 and s[i] == s[i-1] or i > 1 and s[i] == s[i-2]\n \n # Start from the end of the string\n i = n - 1\n while i >= 0:\n # Try to increment the current character\n s[i] = chr(ord(s[i]) + 1)\n \n # If the incremented character exceeds the range, handle overflow\n if s[i] > chr(ord('a') + k - 1):\n i -= 1\n continue\n \n # Check if the new character creates a palindrome\n if is_palindrome(s, i):\n continue\n \n # If no palindrome is created, reset the following characters to 'a'\n for j in range(i + 1, n):\n s[j] = 'a'\n while is_palindrome(s, j):\n s[j] = chr(ord(s[j]) + 1)\n if s[j] > chr(ord('a') + k - 1):\n s[j] = 'a'\n \n # If we reach here, we have found a valid string\n return ''.join(s)\n \n # If no valid string is found, return an empty string\n return \"\"\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"277"},{"code":"\nclass Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = list(s)\n\n for i in reversed(range(len(chars))):\n chars[i] = chr(ord(chars[i]) + 1)\n while self._containsPalindrome(chars, i):\n chars[i] = chr(ord(chars[i]) + 1)\n if chars[i] < chr(ord('a') + k):\n # If s[i] is among the first k letters, then change the letters after\n # s[i] to the smallest ones that don't form any palindrome substring.\n return self._changeSuffix(chars, i + 1)\n\n return ''\n\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\n \"\"\"Returns True if chars[0..i] contains palindrome.\"\"\"\n return ((i > 0 and chars[i] == chars[i - 1]) or\n (i > 1 and chars[i] == chars[i - 2]))\n\n def _changeSuffix(self, chars: list[str], i: int) -> str:\n \"\"\"\n Returns a string, where replacing sb[i..n) with the smallest possible\n letters don't form any palindrome substring.\n \"\"\"\n for j in range(i, len(chars)):\n chars[j] = 'a'\n while self._containsPalindrome(chars, j):\n chars[j] = chr(ord(chars[j]) + 1)\n return ''.join(chars)","runtime":"279"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chrs, n = [\"a\", \"b\", \"c\"], len(s)\n i, ci = n-1, \"\"\n while i >= 0:\n c = ord(s[i]) + 1\n nc = set()\n if i-1 >= 0: nc.add(s[i-1])\n if i-2 >= 0: nc.add(s[i-2])\n while c < k + ord(\"a\"):\n if chr(c) not in nc: break\n c += 1\n if c < k + ord(\"a\"): \n ci = chr(c)\n break\n i -= 1\n \n if i == -1: return \"\"\n ans = s[:i]\n ans += ci\n i += 1\n while i < n:\n nc = set()\n if i-1 >= 0: nc.add(ans[i-1])\n if i-2 >= 0: nc.add(ans[i-2])\n for ch in chrs:\n if ch not in nc: \n ans += ch\n break\n i += 1\n return ans","runtime":"281"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = list(s)\n i = len(s) - 1\n s[i] = chr(ord(s[i]) + 1)\n while 0 <= i < len(s):\n if ord(s[i]) - ord('a') >= k:\n s[i] = 'a'\n i -= 1\n s[i] = chr(ord(s[i]) + 1)\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\n s[i] = chr(ord(s[i]) + 1)\n else:\n i += 1\n return '' if i < 0 else ''.join(s)","runtime":"282"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n a = [ord(i)-ord('a')+1 for i in s]\n\n done = False\n\n i = len(a)-1\n while i>=0:\n\n\n while True:\n a[i]+=1\n if a[i]>k:\n break\n if i-1>=0 and a[i]==a[i-1]:\n continue\n if i-2>=0 and a[i]==a[i-2]:\n continue\n break\n if a[i]<=k:\n done = True\n break\n else:\n i-=1\n\n\n\n if i==-1:\n return \"\"\n\n if done:\n for j in range(i+1,len(a)):\n a[j]=1\n while True:\n if a[j]==a[j-1]:\n a[j]+=1\n continue\n if j-2>=0 and a[j]==a[j-2]:\n a[j]+=1\n continue\n break\n a = [chr(i-1+ord('a')) for i in a]\n return ''.join(a)\n","runtime":"283"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = list(s)\n\n for i in reversed(range(len(chars))):\n chars[i] = chr(ord(chars[i]) + 1)\n while self._containsPalindrome(chars, i):\n chars[i] = chr(ord(chars[i]) + 1)\n if chars[i] < chr(ord('a') + k):\n # If s[i] is among the first k letters, then change the letters after\n # s[i] to the smallest ones that don't form any palindrome substring.\n return self._changeSuffix(chars, i + 1)\n\n return ''\n\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\n \"\"\"Returns True if chars[0..i] contains palindrome.\"\"\"\n return ((i > 0 and chars[i] == chars[i - 1]) or\n (i > 1 and chars[i] == chars[i - 2]))\n\n def _changeSuffix(self, chars: list[str], i: int) -> str:\n \"\"\"\n Returns a string, where replacing sb[i..n) with the smallest possible\n letters don't form any palindrome substring.\n \"\"\"\n for j in range(i, len(chars)):\n chars[j] = 'a'\n while self._containsPalindrome(chars, j):\n chars[j] = chr(ord(chars[j]) + 1)\n return ''.join(chars)","runtime":"284"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = list(s)\n i = len(s) - 1\n s[i] = chr(ord(s[i]) + 1)\n while 0 <= i < len(s):\n if ord(s[i]) - ord('a') >= k:\n s[i] = 'a'\n i -= 1\n s[i] = chr(ord(s[i]) + 1)\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\n s[i] = chr(ord(s[i]) + 1)\n else:\n i += 1\n return '' if i < 0 else ''.join(s)","runtime":"288"},{"code":"def nextchar(ch):\n return chr(ord(ch) + 1)\nclass Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n def nex(ch, excluded):\n while ord(ch)-ord('a') < k:\n if ch not in excluded: return ch\n ch = nextchar(ch)\n return ''\n st = list(s)\n while len(st)>0:\n ch = st.pop()\n ch = nex(nextchar(ch), st[-2:])\n if ch:\n st.append(ch)\n break\n if len(st)==0: return ''\n while len(st)<len(s):\n st.append(nex('a', st[-2:]))\n return ''.join(st)\n\n","runtime":"291"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = list(s)\n\n for i in reversed(range(len(chars))):\n chars[i] = chr(ord(chars[i]) + 1)\n while self._containsPalindrome(chars, i):\n chars[i] = chr(ord(chars[i]) + 1)\n if chars[i] < chr(ord('a') + k):\n # If s[i] is among the first k letters, then change the letters after\n # s[i] to the smallest ones that don't form any palindrome substring.\n return self._changeSuffix(chars, i + 1)\n\n return ''\n\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\n \"\"\"Returns True if chars[0..i] contains palindrome.\"\"\"\n return ((i > 0 and chars[i] == chars[i - 1]) or\n (i > 1 and chars[i] == chars[i - 2]))\n\n def _changeSuffix(self, chars: list[str], i: int) -> str:\n \"\"\"\n Returns a string, where replacing sb[i..n) with the smallest possible\n letters don't form any palindrome substring.\n \"\"\"\n for j in range(i, len(chars)):\n chars[j] = 'a'\n while self._containsPalindrome(chars, j):\n chars[j] = chr(ord(chars[j]) + 1)\n return ''.join(chars)","runtime":"292"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = [ord(c) - ord('a') for c in s] # convert characters to integer values for easier manipulation\n n = len(s)\n \n\t\t# increment char's integer value at index idx by 1 and return the left-most modified index of the increment (accounting for carries)\n def add(idx):\n if idx < 0:\n return idx\n \n s[idx] = (s[idx] + 1) % k\n \n if not s[idx]:\n return add(idx - 1)\n \n return idx\n \n i = add(n - 1) # increment the last char's integer value by 1 and save left-most modified idx to variable i\n \n\t\t# loop until i has reached index 0 (or lower) or while the previous 1 or 2 characters are equal to current character\n while 0 < i and (s[i - 1] == s[i] or (i > 1 and s[i - 2] == s[i])):\n i = add(i)\n \n if i < 0:\n return ''\n \n\t\t# construct smallest beautiful string possible for the substring to the right of index i\n i += 1\n\t\t\n while i < n:\n while s[i] == s[i - 1] or (i > 1 and s[i - 2] == s[i]):\n s[i] += 1\n \n i += 1\n \n return ''.join([chr(ord('a') + o) for o in s])","runtime":"295"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = list(s)\n\n for i in reversed(range(len(chars))):\n chars[i] = chr(ord(chars[i]) + 1)\n while self._containsPalindrome(chars, i):\n chars[i] = chr(ord(chars[i]) + 1)\n if chars[i] < chr(ord('a') + k):\n # If s[i] is among the first k letters, then change the letters after\n # s[i] to the smallest ones that don't form any palindrome substring.\n return self._changeSuffix(chars, i + 1)\n\n return ''\n\n def _containsPalindrome(self, chars: List[str], i: int) -> bool:\n \"\"\"Returns True if chars[0..i] contains palindrome.\"\"\"\n return (i > 0 and chars[i] == chars[i - 1]) or \\\n (i > 1 and chars[i] == chars[i - 2])\n\n def _changeSuffix(self, chars: List[str], i: int) -> str:\n \"\"\"\n Returns a string, where replacing sb[i..n) with the smallest possible\n letters don't form any palindrome substring.\n \"\"\"\n for j in range(i, len(chars)):\n chars[j] = 'a'\n while self._containsPalindrome(chars, j):\n chars[j] = chr(ord(chars[j]) + 1)\n return ''.join(chars)","runtime":"299"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n chars = [ord(c) - ord('a') for c in s]\n i = n - 1\n chars[i] += 1\n while i >= 0 and i < n:\n if chars[i] == k:\n i -= 1\n if i >= 0:\n chars[i] += 1\n elif i > 0 and chars[i] == chars[i - 1]:\n chars[i] += 1\n elif i > 1 and chars[i] == chars[i - 2]:\n chars[i] += 1\n else:\n i += 1\n if i < n:\n chars[i] = 0\n if i < 0:\n return \"\"\n return ''.join(chr(c + ord('a')) for c in chars)","runtime":"301"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n def next_char(c, k):\n return chr(((ord(c) - ord('a') + 1) % k) + ord('a'))\n \n def is_valid(s, pos):\n if pos > 0 and s[pos] == s[pos - 1]:\n return False\n if pos > 1 and s[pos] == s[pos - 2]:\n return False\n return True\n \n i = n - 1\n \n while i >= 0:\n initial_char = s[i]\n s[i] = next_char(s[i], k)\n \n while s[i] != 'a' and not is_valid(s, i):\n s[i] = next_char(s[i], k)\n \n if s[i] != 'a':\n break\n \n i -= 1\n \n if i < 0:\n return \"\"\n \n for j in range(i + 1, n):\n for ch in range(ord('a'), ord('a') + k):\n s[j] = chr(ch)\n if is_valid(s, j):\n break\n \n return ''.join(s)","runtime":"331"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n ans = [\"\"] * len(s)\n found = -1\n \n for i in range(len(s) -1, -1, -1):\n for j in range(ord(s[i]) -97 + 1, k):\n if chr(j + 97) != s[max(0, i -1)] and chr(j +97) != s[max(0, i-2)]:\n ans[i] = chr(j + 97)\n found = i\n break\n if found != -1: break\n \n if found == -1: return \"\"\n for i in range(found): ans[i] = s[i]\n for i in range(found + 1, len(ans)):\n for j in range(k +1):\n if chr(j + 97) != ans[max(0, i -1)] and chr(j +97) != ans[max(0, i-2)]:\n ans[i] = chr(j+97)\n break\n return \"\".join(ans) if \"\" not in ans else \"\"","runtime":"334"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)\n ","runtime":"343"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = [ord(c) - ord('a') for c in s]\n length = len(chars)\n idx = length - 1\n chars[idx] += 1\n \n while idx >= 0:\n if chars[idx] == k:\n idx -= 1\n elif chars[idx] not in chars[max(idx - 2, 0):idx]:\n break\n chars[idx] += 1\n \n if idx < 0:\n return ''\n \n for pos in range(idx + 1, length):\n valid_chars = {0, 1, 2} - set(chars[max(0, pos - 2):pos])\n chars[pos] = min(valid_chars)\n \n return ''.join(chr(ord('a') + ch) for ch in chars)","runtime":"351"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"356"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n def is_beautiful(index):\n if index >= 1 and s[index] == s[index - 1]:\n return False\n if index >= 2 and s[index] == s[index - 2]:\n return False\n return True\n \n # Start from the last position\n i = n - 1\n while i >= 0:\n s[i] = chr(ord(s[i]) + 1) # Attempt to increment\n \n # Find next suitable character\n while ord(s[i]) < ord('a') + k and not is_beautiful(i):\n s[i] = chr(ord(s[i]) + 1)\n \n if ord(s[i]) < ord('a') + k:\n # Fill the remaining positions with the smallest lexicographical choices\n for j in range(i + 1, n):\n s[j] = 'a'\n while not is_beautiful(j):\n s[j] = chr(ord(s[j]) + 1)\n return ''.join(s)\n \n # Reset and move to the previous character\n s[i] = 'a'\n i -= 1\n \n return \"\"\n\n# Example usage:\n# solution = Solution()\n# print(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\n# print(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"358"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"359"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"363"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"369"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n i = len(A) - 1\n while i >= 0:\n A[i] += 1\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n for j in range(i + 1, len(A)):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)\n return ''","runtime":"370"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord(\"a\") for c in s]\n i = len(A) - 1\n while i >= 0:\n A[i] += 1\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0) : i]:\n for j in range(i + 1, len(A)):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2) : j]))\n return \"\".join(chr(ord(\"a\") + a) for a in A)\n return \"\"","runtime":"373"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord(\"a\") for c in s]\n i = len(A) - 1\n while i >= 0:\n A[i] += 1\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0) : i]:\n for j in range(i + 1, len(A)):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2) : j]))\n return \"\".join(chr(ord(\"a\") + a) for a in A)\n return \"\"","runtime":"374"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"382"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"404"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","runtime":"452"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # Convert the string to a list of characters\n s = list(s)\n n = len(s)\n\n # Function to check if a substring is a palindrome\n def is_palindrome(substr):\n return substr == substr[::-1]\n\n # Function to find the next valid character\n def next_char(c):\n return chr(ord(c) + 1) if c != chr(ord('a') + k - 1) else None\n\n # Iterate from the end to the beginning\n for i in range(n - 1, -1, -1):\n # Try to increment the current character\n current_char = s[i]\n next_valid_char = next_char(current_char)\n while next_valid_char:\n s[i] = next_valid_char\n if not (i >= 2 and is_palindrome(s[i-2:i+1])) and not (i >= 1 and is_palindrome(s[i-1:i+1])):\n # Reset the subsequent characters to the smallest possible valid sequence\n for j in range(i + 1, n):\n for c in range(ord('a'), ord('a') + k):\n s[j] = chr(c)\n if not (j >= 2 and is_palindrome(s[j-2:j+1])) and not (j >= 1 and is_palindrome(s[j-1:j+1])):\n break\n return ''.join(s)\n next_valid_char = next_char(next_valid_char)\n # If no valid increment is found, backtrack\n if i == 0:\n return \"\"\n return \"\"\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","runtime":"477"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n to_int = lambda x : ord(x) - ord('a')\n s = list(map(to_int, s))\n n = len(s)\n\n for i in range(n - 1, -1, -1):\n poss = set(range(s[i] + 1, k)) - set(s[max(0, i-2):i])\n if len(poss) > 0:\n break\n else:\n return \"\"\n\n s[i] = min(poss)\n for j in range(i + 1, min(i + 4, n)):\n seen = set(s[max(0, j-2):j])\n for k in range(26):\n if k not in seen:\n s[j] = k\n break\n \n for j in range(i + 4, n):\n s[j] = s[j - 3]\n return ''.join(chr(i + ord('a')) for i in s)","runtime":"484"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n # Function to check if a substring is a palindrome\n def is_palindrome(substr):\n return substr == substr[::-1]\n \n # Function to find the next lexicographically larger character\n def next_char(c):\n if c == 'z':\n return None\n return chr(ord(c) + 1)\n \n # Start from the last character\n for i in range(n - 1, -1, -1):\n current_char = s[i]\n next_char_found = False\n \n # Try to find the next valid character\n while not next_char_found:\n next_c = next_char(current_char)\n if next_c and next_c <= chr(96 + k):\n s[i] = next_c\n if i >= 2 and is_palindrome(s[i-2:i+1]):\n current_char = next_c\n continue\n if i >= 1 and is_palindrome(s[i-1:i+1]):\n current_char = next_c\n continue\n next_char_found = True\n else:\n break\n \n if next_char_found:\n # Reset the following characters to the smallest possible\n for j in range(i + 1, n):\n for char in 'abcdefghijklmnopqrstuvwxyz':\n if char <= chr(96 + k):\n s[j] = char\n if j >= 2 and is_palindrome(s[j-2:j+1]):\n continue\n if j >= 1 and is_palindrome(s[j-1:j+1]):\n continue\n break\n return ''.join(s)\n \n return \"\"","runtime":"485"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = [ord(c) - ord('a') for c in s]\n\n ptr = len(s) - 1\n while ptr < len(s):\n if ptr == -1:\n return \"\"\n found = False\n for i in range(k):\n if i <= s[ptr]:\n continue\n elif ptr >= 1 and (i == s[ptr - 1]):\n continue\n elif ptr >= 2 and (i == s[ptr - 2]):\n continue\n else:\n s[ptr] = i\n found = True\n break\n\n if found:\n ptr += 1\n else:\n s[ptr] = -1\n ptr -= 1\n \n return \"\".join(chr(x + ord('a')) for x in s)","runtime":"496"}],"string":"[\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n # Find the first position from the right that can be incremented\\n for i in range(n - 1, -1, -1):\\n ch = ord(s[i]) - ord('a') + 1\\n while ch < k:\\n if (i - 1 < 0 or s[i - 1] != chr(ord('a') + ch)) and (i - 2 < 0 or s[i - 2] != chr(ord('a') + ch)):\\n s[i] = chr(ord('a') + ch)\\n break\\n ch += 1\\n else:\\n if i == 0:\\n return \\\"\\\"\\n continue\\n \\n # Fill the rest of the string with the smallest possible characters\\n for j in range(i + 1, n):\\n for ch in range(k):\\n if (j - 1 < 0 or s[j - 1] != chr(ord('a') + ch)) and (j - 2 < 0 or s[j - 2] != chr(ord('a') + ch)):\\n s[j] = chr(ord('a') + ch)\\n break\\n \\n return \\\"\\\".join(s)\\n \\n return \\\"\\\"\",\n \"runtime\": \"199\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n res = list(s)\\n orda = ord('a')\\n for i in range(len(s)-1, -1, -1):\\n index = ord(s[i]) - orda\\n for j in range(index+1, k):\\n ch = chr(orda+j)\\n if (i>0 and s[i-1]==ch) or (i>1 and s[i-2]==ch):\\n continue\\n \\n # Found a lexicographically larger string\\n res[i] = ch\\n for m in range(i+1, len(s)):\\n for ch in \\\"abc\\\":\\n if ch!=res[m-1] and (m-2<0 or ch!=res[m-2]):\\n res[m] = ch\\n break\\n return ''.join(res)\\n return \\\"\\\"\",\n \"runtime\": \"201\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n cs = list(s)\\n for i in range(n - 1, -1, -1):\\n p = ord(cs[i]) - ord('a') + 1\\n for j in range(p, k):\\n c = chr(ord('a') + j)\\n if (i > 0 and cs[i - 1] == c) or (i > 1 and cs[i - 2] == c):\\n continue\\n cs[i] = c\\n for l in range(i + 1, n):\\n for m in range(k):\\n c = chr(ord('a') + m)\\n if (l > 0 and cs[l - 1] == c) or (l > 1 and cs[l - 2] == c):\\n continue\\n cs[l] = c\\n break\\n return ''.join(cs)\\n return ''\",\n \"runtime\": \"203\"\n },\n {\n \"code\": \"class Solution:\\n def is_palindrome(self, i, s, curr_char):\\n prev_char = ord(s[i-1]) - ord('a')\\n\\n if curr_char == prev_char:\\n return True\\n \\n # if i + 1 < len(s) and curr_char == ord(s[i+1]) - ord('a'):\\n # return True\\n \\n if i - 2 >= 0 and curr_char == ord(s[i-2]) - ord('a'):\\n return True\\n \\n # if i + 2 < len(s) and curr_char == ord(s[i+2]) - ord('a'):\\n # return True\\n \\n return False\\n\\n def smallestBeautifulString(self, s: str, k: int) -> str: \\n i = len(s)-1\\n s = list(s)\\n n = len(s)\\n\\n for i in range(len(s)-1, -1, -1):\\n position = ord(s[i]) - ord('a') + 1\\n\\n for j in range(position, k):\\n rch = chr(j + ord('a'))\\n\\n if (i > 0 and s[i-1] == rch) or (i > 1 and s[i-2] == rch):\\n continue\\n \\n s[i] = rch\\n\\n for l in range(i + 1, n):\\n for m in range(k):\\n next_char = chr(ord('a') + m)\\n if (l > 0 and s[l - 1] == next_char) or (l > 1 and s[l - 2] == next_char):\\n continue\\n s[l] = next_char\\n break\\n \\n return ''.join(s)\\n return ''\",\n \"runtime\": \"204\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n\\n s = list(s)\\n n = len(s)\\n \\n \\n for i in range(n - 1, -1, -1):\\n for c in range(ord(s[i]) + 1, ord('a') + k):\\n \\n s[i] = chr(c)\\n \\n \\n if (i == 0 or s[i] != s[i - 1]) and (i < 2 or s[i] != s[i - 2]):\\n \\n for j in range(i + 1, n):\\n for c in range(ord('a'), ord('a') + k):\\n s[j] = chr(c)\\n if (j == 0 or s[j] != s[j - 1]) and (j < 2 or s[j] != s[j - 2]):\\n break\\n return ''.join(s)\\n \\n return \\\"\\\" \\n \",\n \"runtime\": \"205\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n \\n s = list(s)\\n n = len(s)\\n max_letter = chr(ord('a') + k - 1)\\n \\n for i in reversed(range(n)):\\n cnt = 1\\n while chr(ord(s[i]) + cnt) <= max_letter:\\n tmp = chr(ord(s[i]) + cnt)\\n if (i < 1 or tmp != s[i-1]) and (i < 2 or tmp != s[i - 2]):\\n s[i] = tmp\\n for j in range(i+1, n):\\n c = 0\\n while (j >= 1 and s[j-1] == chr(ord('a') + c)) or (j >= 2 and s[j-2] == chr(ord('a') + c)):\\n c += 1\\n s[j] = chr(ord('a') + c)\\n return \\\"\\\".join(s)\\n \\n cnt += 1\\n \\n return \\\"\\\"\",\n \"runtime\": \"208\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n cs = list(s)\\n for i in range(n - 1, -1, -1):\\n p = ord(cs[i]) - ord('a') + 1\\n for j in range(p, k):\\n c = chr(ord('a') + j)\\n if (i > 0 and cs[i - 1] == c) or (i > 1 and cs[i - 2] == c):\\n continue\\n cs[i] = c\\n for l in range(i + 1, n):\\n for m in range(k):\\n c = chr(ord('a') + m)\\n if (l > 0 and cs[l - 1] == c) or (l > 1 and cs[l - 2] == c):\\n continue\\n cs[l] = c\\n break\\n return ''.join(cs)\\n return ''\",\n \"runtime\": \"216\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n arr = list(s)\\n \\n for i in range(n - 1, -1, -1):\\n curr = ord(arr[i]) - ord('a')\\n for j in range(curr + 1, k):\\n if (i > 0 and chr(j + ord('a')) == arr[i-1]) or (i > 1 and chr(j + ord('a')) == arr[i-2]):\\n continue\\n arr[i] = chr(j + ord('a'))\\n for l in range(i + 1, n):\\n for m in range(k):\\n if (l > 0 and chr(m + ord('a')) == arr[l-1]) or (l > 1 and chr(m + ord('a')) == arr[l-2]):\\n continue\\n arr[l] = chr(m + ord('a'))\\n break\\n return ''.join(arr)\\n \\n return ''\",\n \"runtime\": \"218\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s) # Convert to list for mutability\\n a = ord('a')\\n \\n # Helper function to check if the string is beautiful\\n def is_beautiful(s, i):\\n if i > 0 and s[i] == s[i - 1]:\\n return False\\n if i > 1 and s[i] == s[i - 2]:\\n return False\\n return True\\n \\n # Try to increment from the end\\n for i in range(n - 1, -1, -1):\\n # Increment the current character\\n for j in range(ord(s[i]) - a + 1, k):\\n s[i] = chr(a + j)\\n if is_beautiful(s, i):\\n # Fill the rest of the string with the smallest possible characters\\n for x in range(i + 1, n):\\n for y in range(k):\\n s[x] = chr(a + y)\\n if is_beautiful(s, x):\\n break\\n return ''.join(s)\\n \\n return \\\"\\\" # If no valid string is found\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"223\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n N = len(s)\\n alphabet = string.ascii_lowercase\\n k -= 1\\n arr = [c for c in s]\\n\\n for i in range(N - 1, -1, -1):\\n if arr[i] != alphabet[k]:\\n\\n index = alphabet.index(arr[i])\\n\\n for char in alphabet[index + 1: k + 1]:\\n \\n l = i - 1\\n\\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\\n # we have a valid answer\\n arr[i] = char\\n i += 1\\n\\n while i < N:\\n for o in alphabet:\\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\\n arr[i] = o\\n i += 1\\n break\\n\\n return \\\"\\\".join(arr) \\n \\n return \\\"\\\" \",\n \"runtime\": \"225\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s) # Convert string to list for easier manipulation\\n found = False\\n \\n # Iterate backwards to find a position to increment\\n for i in range(n - 1, -1, -1):\\n for replacement in range(ord(s[i]) + 1, ord('a') + k):\\n s[i] = chr(replacement)\\n \\n # Check from the current position if it can form a beautiful string\\n if (i - 1 >= 0 and s[i] == s[i - 1]) or (i - 2 >= 0 and s[i] == s[i - 2]):\\n continue # Skip, as this does not form a beautiful sequence\\n \\n # Fill in the rest of the string with the smallest valid characters\\n for j in range(i + 1, n):\\n for ch in range(ord('a'), ord('a') + k):\\n s[j] = chr(ch)\\n if (j - 1 >= 0 and s[j] == s[j - 1]) or (j - 2 >= 0 and s[j] == s[j - 2]):\\n continue # Check if next char makes it invalid\\n break\\n \\n found = True\\n break\\n if found:\\n break\\n \\n return ''.join(s) if found else \\\"\\\"\",\n \"runtime\": \"230\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert the string to a list of characters for easier manipulation\\n s = list(s)\\n n = len(s)\\n \\n # Function to check if we can place char `c` at position `i`\\n def is_valid(i, c):\\n if i > 0 and s[i - 1] == c:\\n return False # it would form a palindrome of length 2\\n if i > 1 and s[i - 2] == c:\\n return False # it would form a palindrome of length 3\\n return True\\n\\n # Process the string from the end to the start\\n for i in range(n - 1, -1, -1):\\n # Try to replace the current character with the next lexicographical character\\n for nxt_char in range(ord(s[i]) + 1, ord('a') + k):\\n if is_valid(i, chr(nxt_char)):\\n s[i] = chr(nxt_char)\\n # Fill the rest of the string with the smallest valid letter\\n for j in range(i + 1, n):\\n for c in range(ord('a'), ord('a') + k):\\n if is_valid(j, chr(c)):\\n s[j] = chr(c)\\n break\\n return \\\"\\\".join(s)\\n \\n # If no valid string was found\\n return \\\"\\\"\\n\\n# Example usage:\\nsol = Solution()\\nprint(sol.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(sol.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"234\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s) # Convert to list for easier manipulation\\n \\n # Function to check if the string is beautiful up to a certain index\\n def is_beautiful(s, index):\\n if index >= 1 and s[index] == s[index - 1]:\\n return False\\n if index >= 2 and s[index] == s[index - 2]:\\n return False\\n return True\\n \\n # Start from the end of the string and try to increment\\n for i in range(n - 1, -1, -1):\\n # Try to increment the character at position i\\n for j in range(ord(s[i]) - ord('a') + 1, k):\\n s[i] = chr(ord('a') + j)\\n # Check if this position is beautiful\\n if is_beautiful(s, i):\\n # Fill the rest with the smallest valid characters\\n for x in range(i + 1, n):\\n for y in range(k):\\n s[x] = chr(ord('a') + y)\\n if is_beautiful(s, x):\\n break\\n return ''.join(s)\\n \\n # If not found, return an empty string\\n return \\\"\\\"\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"235\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert the string to a list of characters\\n chars = list(s)\\n n = len(chars)\\n\\n # Function to check if adding a character at index i creates a palindrome\\n def is_palindrome(i):\\n return i > 0 and chars[i] == chars[i-1] or i > 1 and chars[i] == chars[i-2]\\n\\n # Iterate from the end to the beginning\\n for i in range(n-1, -1, -1):\\n # Try to increment the current character\\n for c in range(ord(chars[i]) - ord('a') + 1, k):\\n chars[i] = chr(ord('a') + c)\\n if not is_palindrome(i):\\n break\\n else:\\n continue\\n # Update the rest of the string to the smallest possible valid string\\n for j in range(i+1, n):\\n for c in range(k):\\n chars[j] = chr(ord('a') + c)\\n if not is_palindrome(j):\\n break\\n # If we successfully updated the string, return the result\\n return ''.join(chars)\\n \\n # If no valid increment is found, return an empty string\\n return \\\"\\\"\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"239\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n '''\\n our current string is valid\\n we just have to find next valid one\\n\\n find first char we can increase (and maintain nonpalindome property)\\n\\n then make all chars after it \\\"abcabc...\\\" with some edge cases\\n\\n find first char we can change from right to left\\n\\n then, change all chars right of it to some invariant of \\\"abc\\\" and return ans\\n\\n '''\\n N = len(s)\\n alphabet = string.ascii_lowercase\\n k -= 1\\n arr = [c for c in s]\\n\\n for i in range(N - 1, -1, -1):\\n if arr[i] != alphabet[k]:\\n\\n index = alphabet.index(arr[i])\\n\\n for char in alphabet[index + 1: k + 1]:\\n \\n l = i - 1\\n\\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\\n # we have a valid answer\\n arr[i] = char\\n i += 1\\n\\n while i < N:\\n for o in alphabet:\\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\\n arr[i] = o\\n i += 1\\n break\\n\\n return \\\"\\\".join(arr)\\n\\n \\n \\n return \\\"\\\"\\n\\n \\n\\n \",\n \"runtime\": \"247\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s) # Convert string to list for easier manipulation\\n \\n # Function to check if the string is beautiful at a given position\\n def is_beautiful(pos):\\n if pos > 0 and s[pos] == s[pos - 1]:\\n return False\\n if pos > 1 and s[pos] == s[pos - 2]:\\n return False\\n return True\\n \\n # Try to increment the string from the end\\n for i in range(n - 1, -1, -1):\\n for ch in range(ord(s[i]) - ord('a') + 1, k):\\n s[i] = chr(ord('a') + ch)\\n if is_beautiful(i):\\n # Fill the rest of the string with the smallest possible characters\\n for j in range(i + 1, n):\\n for ch in range(k):\\n s[j] = chr(ord('a') + ch)\\n if is_beautiful(j):\\n break\\n return ''.join(s)\\n \\n # If no valid string was found, return an empty string\\n return \\\"\\\"\",\n \"runtime\": \"248\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert the string to a list for easier manipulation\\n s = list(s)\\n n = len(s)\\n \\n # Function to check if a substring is a palindrome\\n def is_palindrome(substring):\\n return substring == substring[::-1]\\n \\n # Function to find the next valid character\\n def next_char(char):\\n return chr(ord(char) + 1) if char != chr(ord('a') + k - 1) else None\\n \\n # Start from the last character\\n for i in range(n - 1, -1, -1):\\n current_char = s[i]\\n next_valid_char = next_char(current_char)\\n \\n while next_valid_char:\\n s[i] = next_valid_char\\n \\n # Check if the new string is beautiful\\n if not (i - 1 >= 0 and s[i - 1] == next_valid_char or \\n i - 2 >= 0 and s[i - 2] == next_valid_char):\\n break\\n \\n next_valid_char = next_char(next_valid_char)\\n \\n if next_valid_char:\\n # If we found a valid character, reset the following characters to 'a'\\n for j in range(i + 1, n):\\n for char in map(chr, range(ord('a'), ord('a') + k)):\\n if (j - 1 < 0 or s[j - 1] != char) and (j - 2 < 0 or s[j - 2] != char):\\n s[j] = char\\n break\\n return ''.join(s)\\n \\n return \\\"\\\" # If no valid string is found\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"250\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n i, n = len(s) - 1, len(s)\\n s = list(s)\\n s[-1] = chr(ord(s[i]) + 1) # Increment the last character of the string\\n while i >= 0 and i < n:\\n if ord(s[i]) >= ord('a') + k: # If the character exceeds the limit, reset it to 'a' and move to the previous character\\n s[i] = \\\"a\\\"\\n i -= 1\\n if i >= 0:\\n s[i] = chr(ord(s[i]) + 1) # Increment the previous character\\n else:\\n break # If there are no more characters, break out of the loop\\n elif (i - 1 >= 0 and s[i] == s[i - 1]) or (i - 2 >= 0 and s[i] == s[i - 2]):\\n s[i] = chr(ord(s[i]) + 1) # If the character violates the \\\"beautiful\\\" property, increment it\\n else:\\n i += 1 # Move to the next character\\n if i == -1:\\n s = \\\"\\\" # If the string cannot be made \\\"beautiful\\\", return an empty string\\n return ''.join(s)\",\n \"runtime\": \"254\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\\n # If X3 and X4 form a palindrome, we have X3 == X4.\\n # If X2-X4 form a palindrome, we have X2 == X4.\\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\\n # So far, finding the rightmost incrementable character is O(n).\\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \\\"a\\\"/\\\"b\\\"/\\\"c\\\" anyway.\\n ans = list(s)\\n cur = -1\\n for i in range(len(ans) - 1, -1, -1):\\n if ord(ans[i]) - 96 >= k:\\n # This letter cannot be incremented\\n continue\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\\n if chr(j) not in seen:\\n ans[i] = chr(j)\\n break\\n else:\\n # Not possible to adjust the current letter due to constraint k.\\n continue\\n # We have replaced ans[i]\\n cur = i + 1\\n break\\n if cur == -1:\\n return \\\"\\\"\\n for i in range(cur, len(ans)):\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for ch in \\\"abc\\\":\\n if ch not in seen:\\n ans[i] = ch\\n break\\n return \\\"\\\".join(ans)\",\n \"runtime\": \"258\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n def is_palindrome(s, i):\\n if i > 0 and s[i] == s[i - 1]:\\n return True\\n if i > 1 and s[i] == s[i - 2]:\\n return True\\n return False\\n \\n for i in range(n - 1, -1, -1):\\n for j in range(ord(s[i]) - ord('a') + 1, k):\\n s[i] = chr(j + ord('a'))\\n if not is_palindrome(s, i):\\n for l in range(i + 1, n):\\n for m in range(k):\\n s[l] = chr(m + ord('a'))\\n if not is_palindrome(s, l):\\n break\\n return ''.join(s)\\n \\n return \\\"\\\"\",\n \"runtime\": \"266\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = list(s)\\n i = len(s) - 1\\n s[i] = chr(ord(s[i]) + 1)\\n while 0 <= i < len(s):\\n if ord(s[i]) - ord('a') >= k:\\n s[i] = 'a'\\n i -= 1\\n s[i] = chr(ord(s[i]) + 1)\\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]): s[i] = chr(ord(s[i]) + 1)\\n else: i += 1\\n return '' if i < 0 else ''.join(s)\",\n \"runtime\": \"267\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = list(s)\\n i = len(s) - 1 \\n s[i] = chr(ord(s[i]) + 1)\\n while 0 <= i < len(s): \\n if ord(s[i]) - ord('a') >= k: \\n s[i] = 'a'\\n i -= 1 \\n s[i] = chr(ord(s[i]) + 1)\\n \\n elif (i >= 1 and s[i]==s[i-1]) or (i>=2 and s[i] == s[i-2]): \\n s[i] = chr(ord(s[i]) + 1)\\n\\n else: \\n i += 1 \\n \\n return '' if i < 0 else ''.join(s)\\n\\n\\n\\n\\n\\n\\n\\n #made notes \\n #https://www.youtube.com/watch?v=c7FX1l6dwjE for expl\\n\",\n \"runtime\": \"269\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = list(s)\\n i = len(s) - 1 \\n s[i] = chr(ord(s[i]) + 1)\\n while 0 <= i < len(s): \\n if ord(s[i]) - ord('a') >= k: \\n s[i] = 'a'\\n i -= 1 \\n s[i] = chr(ord(s[i]) + 1)\\n \\n elif (i >= 1 and s[i]==s[i-1]) or (i>=2 and s[i] == s[i-2]): \\n s[i] = chr(ord(s[i]) + 1)\\n\\n else: \\n i += 1 \\n \\n return '' if i < 0 else ''.join(s)\\n #go thru the code. run it for every input. That's all.\\n\\n\\n\\n\\n\\n\\n #made notes \\n #https://www.youtube.com/watch?v=c7FX1l6dwjE for expl\\n\",\n \"runtime\": \"270\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\\n # If X3 and X4 form a palindrome, we have X3 == X4.\\n # If X2-X4 form a palindrome, we have X2 == X4.\\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\\n # So far, finding the rightmost incrementable character is O(n).\\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \\\"a\\\"/\\\"b\\\"/\\\"c\\\" anyway.\\n ans = list(s)\\n cur = -1\\n for i in range(len(ans) - 1, -1, -1):\\n if ord(ans[i]) - 96 >= k:\\n # This letter cannot be incremented\\n continue\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\\n if chr(j) not in seen:\\n ans[i] = chr(j)\\n break\\n else:\\n # Not possible to adjust the current letter due to constraint k.\\n continue\\n # We have replaced ans[i]\\n cur = i + 1\\n break\\n if cur == -1:\\n return \\\"\\\"\\n for i in range(cur, len(ans)):\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for ch in \\\"abc\\\":\\n if ch not in seen:\\n ans[i] = ch\\n break\\n return \\\"\\\".join(ans)\",\n \"runtime\": \"272\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\\n # If X3 and X4 form a palindrome, we have X3 == X4.\\n # If X2-X4 form a palindrome, we have X2 == X4.\\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\\n # So far, finding the rightmost incrementable character is O(n).\\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \\\"a\\\"/\\\"b\\\"/\\\"c\\\" anyway.\\n ans = list(s)\\n cur = -1\\n for i in range(len(ans) - 1, -1, -1):\\n if ord(ans[i]) - 96 >= k:\\n # This letter cannot be incremented\\n continue\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\\n if chr(j) not in seen:\\n ans[i] = chr(j)\\n break\\n else:\\n # Not possible to adjust the current letter due to constraint k.\\n continue\\n # We have replaced ans[i]\\n cur = i + 1\\n break\\n if cur == -1:\\n return \\\"\\\"\\n for i in range(cur, len(ans)):\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for ch in \\\"abc\\\":\\n if ch not in seen:\\n ans[i] = ch\\n break\\n return \\\"\\\".join(ans)\",\n \"runtime\": \"272\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert the string to a list for easier manipulation\\n s = list(s)\\n # Start from the last character of the string\\n i = len(s) - 1\\n # Increment the last character\\n s[i] = chr(ord(s[i]) + 1)\\n \\n # Iterate while the index is within bounds\\n while 0 <= i < len(s):\\n # If the character exceeds the k-th letter, reset it to 'a' and move left\\n if ord(s[i]) - ord('a') >= k:\\n s[i] = 'a'\\n i -= 1\\n # Increment the character at the new position\\n s[i] = chr(ord(s[i]) + 1)\\n # Check for palindrome conditions\\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\\n # If a palindrome is detected, increment the character\\n s[i] = chr(ord(s[i]) + 1)\\n else:\\n # Move to the next character\\n i += 1\\n \\n # If the index is negative, it means no valid string was found\\n return '' if i < 0 else ''.join(s)\",\n \"runtime\": \"274\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert string to list for easier manipulation\\n s = list(s)\\n n = len(s)\\n \\n # Function to check if adding char at index i creates a palindrome\\n def is_palindrome(s, i):\\n return i > 0 and s[i] == s[i-1] or i > 1 and s[i] == s[i-2]\\n \\n # Start from the end of the string\\n i = n - 1\\n while i >= 0:\\n # Try to increment the current character\\n s[i] = chr(ord(s[i]) + 1)\\n \\n # If the incremented character exceeds the range, handle overflow\\n if s[i] > chr(ord('a') + k - 1):\\n i -= 1\\n continue\\n \\n # Check if the new character creates a palindrome\\n if is_palindrome(s, i):\\n continue\\n \\n # If no palindrome is created, reset the following characters to 'a'\\n for j in range(i + 1, n):\\n s[j] = 'a'\\n while is_palindrome(s, j):\\n s[j] = chr(ord(s[j]) + 1)\\n if s[j] > chr(ord('a') + k - 1):\\n s[j] = 'a'\\n \\n # If we reach here, we have found a valid string\\n return ''.join(s)\\n \\n # If no valid string is found, return an empty string\\n return \\\"\\\"\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"277\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = list(s)\\n\\n for i in reversed(range(len(chars))):\\n chars[i] = chr(ord(chars[i]) + 1)\\n while self._containsPalindrome(chars, i):\\n chars[i] = chr(ord(chars[i]) + 1)\\n if chars[i] < chr(ord('a') + k):\\n # If s[i] is among the first k letters, then change the letters after\\n # s[i] to the smallest ones that don't form any palindrome substring.\\n return self._changeSuffix(chars, i + 1)\\n\\n return ''\\n\\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\\n \\\"\\\"\\\"Returns True if chars[0..i] contains palindrome.\\\"\\\"\\\"\\n return ((i > 0 and chars[i] == chars[i - 1]) or\\n (i > 1 and chars[i] == chars[i - 2]))\\n\\n def _changeSuffix(self, chars: list[str], i: int) -> str:\\n \\\"\\\"\\\"\\n Returns a string, where replacing sb[i..n) with the smallest possible\\n letters don't form any palindrome substring.\\n \\\"\\\"\\\"\\n for j in range(i, len(chars)):\\n chars[j] = 'a'\\n while self._containsPalindrome(chars, j):\\n chars[j] = chr(ord(chars[j]) + 1)\\n return ''.join(chars)\",\n \"runtime\": \"279\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chrs, n = [\\\"a\\\", \\\"b\\\", \\\"c\\\"], len(s)\\n i, ci = n-1, \\\"\\\"\\n while i >= 0:\\n c = ord(s[i]) + 1\\n nc = set()\\n if i-1 >= 0: nc.add(s[i-1])\\n if i-2 >= 0: nc.add(s[i-2])\\n while c < k + ord(\\\"a\\\"):\\n if chr(c) not in nc: break\\n c += 1\\n if c < k + ord(\\\"a\\\"): \\n ci = chr(c)\\n break\\n i -= 1\\n \\n if i == -1: return \\\"\\\"\\n ans = s[:i]\\n ans += ci\\n i += 1\\n while i < n:\\n nc = set()\\n if i-1 >= 0: nc.add(ans[i-1])\\n if i-2 >= 0: nc.add(ans[i-2])\\n for ch in chrs:\\n if ch not in nc: \\n ans += ch\\n break\\n i += 1\\n return ans\",\n \"runtime\": \"281\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = list(s)\\n i = len(s) - 1\\n s[i] = chr(ord(s[i]) + 1)\\n while 0 <= i < len(s):\\n if ord(s[i]) - ord('a') >= k:\\n s[i] = 'a'\\n i -= 1\\n s[i] = chr(ord(s[i]) + 1)\\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\\n s[i] = chr(ord(s[i]) + 1)\\n else:\\n i += 1\\n return '' if i < 0 else ''.join(s)\",\n \"runtime\": \"282\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n a = [ord(i)-ord('a')+1 for i in s]\\n\\n done = False\\n\\n i = len(a)-1\\n while i>=0:\\n\\n\\n while True:\\n a[i]+=1\\n if a[i]>k:\\n break\\n if i-1>=0 and a[i]==a[i-1]:\\n continue\\n if i-2>=0 and a[i]==a[i-2]:\\n continue\\n break\\n if a[i]<=k:\\n done = True\\n break\\n else:\\n i-=1\\n\\n\\n\\n if i==-1:\\n return \\\"\\\"\\n\\n if done:\\n for j in range(i+1,len(a)):\\n a[j]=1\\n while True:\\n if a[j]==a[j-1]:\\n a[j]+=1\\n continue\\n if j-2>=0 and a[j]==a[j-2]:\\n a[j]+=1\\n continue\\n break\\n a = [chr(i-1+ord('a')) for i in a]\\n return ''.join(a)\\n\",\n \"runtime\": \"283\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = list(s)\\n\\n for i in reversed(range(len(chars))):\\n chars[i] = chr(ord(chars[i]) + 1)\\n while self._containsPalindrome(chars, i):\\n chars[i] = chr(ord(chars[i]) + 1)\\n if chars[i] < chr(ord('a') + k):\\n # If s[i] is among the first k letters, then change the letters after\\n # s[i] to the smallest ones that don't form any palindrome substring.\\n return self._changeSuffix(chars, i + 1)\\n\\n return ''\\n\\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\\n \\\"\\\"\\\"Returns True if chars[0..i] contains palindrome.\\\"\\\"\\\"\\n return ((i > 0 and chars[i] == chars[i - 1]) or\\n (i > 1 and chars[i] == chars[i - 2]))\\n\\n def _changeSuffix(self, chars: list[str], i: int) -> str:\\n \\\"\\\"\\\"\\n Returns a string, where replacing sb[i..n) with the smallest possible\\n letters don't form any palindrome substring.\\n \\\"\\\"\\\"\\n for j in range(i, len(chars)):\\n chars[j] = 'a'\\n while self._containsPalindrome(chars, j):\\n chars[j] = chr(ord(chars[j]) + 1)\\n return ''.join(chars)\",\n \"runtime\": \"284\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = list(s)\\n i = len(s) - 1\\n s[i] = chr(ord(s[i]) + 1)\\n while 0 <= i < len(s):\\n if ord(s[i]) - ord('a') >= k:\\n s[i] = 'a'\\n i -= 1\\n s[i] = chr(ord(s[i]) + 1)\\n elif (i >= 1 and s[i] == s[i - 1]) or (i >= 2 and s[i] == s[i - 2]):\\n s[i] = chr(ord(s[i]) + 1)\\n else:\\n i += 1\\n return '' if i < 0 else ''.join(s)\",\n \"runtime\": \"288\"\n },\n {\n \"code\": \"def nextchar(ch):\\n return chr(ord(ch) + 1)\\nclass Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n def nex(ch, excluded):\\n while ord(ch)-ord('a') < k:\\n if ch not in excluded: return ch\\n ch = nextchar(ch)\\n return ''\\n st = list(s)\\n while len(st)>0:\\n ch = st.pop()\\n ch = nex(nextchar(ch), st[-2:])\\n if ch:\\n st.append(ch)\\n break\\n if len(st)==0: return ''\\n while len(st)<len(s):\\n st.append(nex('a', st[-2:]))\\n return ''.join(st)\\n\\n\",\n \"runtime\": \"291\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = list(s)\\n\\n for i in reversed(range(len(chars))):\\n chars[i] = chr(ord(chars[i]) + 1)\\n while self._containsPalindrome(chars, i):\\n chars[i] = chr(ord(chars[i]) + 1)\\n if chars[i] < chr(ord('a') + k):\\n # If s[i] is among the first k letters, then change the letters after\\n # s[i] to the smallest ones that don't form any palindrome substring.\\n return self._changeSuffix(chars, i + 1)\\n\\n return ''\\n\\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\\n \\\"\\\"\\\"Returns True if chars[0..i] contains palindrome.\\\"\\\"\\\"\\n return ((i > 0 and chars[i] == chars[i - 1]) or\\n (i > 1 and chars[i] == chars[i - 2]))\\n\\n def _changeSuffix(self, chars: list[str], i: int) -> str:\\n \\\"\\\"\\\"\\n Returns a string, where replacing sb[i..n) with the smallest possible\\n letters don't form any palindrome substring.\\n \\\"\\\"\\\"\\n for j in range(i, len(chars)):\\n chars[j] = 'a'\\n while self._containsPalindrome(chars, j):\\n chars[j] = chr(ord(chars[j]) + 1)\\n return ''.join(chars)\",\n \"runtime\": \"292\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = [ord(c) - ord('a') for c in s] # convert characters to integer values for easier manipulation\\n n = len(s)\\n \\n\\t\\t# increment char's integer value at index idx by 1 and return the left-most modified index of the increment (accounting for carries)\\n def add(idx):\\n if idx < 0:\\n return idx\\n \\n s[idx] = (s[idx] + 1) % k\\n \\n if not s[idx]:\\n return add(idx - 1)\\n \\n return idx\\n \\n i = add(n - 1) # increment the last char's integer value by 1 and save left-most modified idx to variable i\\n \\n\\t\\t# loop until i has reached index 0 (or lower) or while the previous 1 or 2 characters are equal to current character\\n while 0 < i and (s[i - 1] == s[i] or (i > 1 and s[i - 2] == s[i])):\\n i = add(i)\\n \\n if i < 0:\\n return ''\\n \\n\\t\\t# construct smallest beautiful string possible for the substring to the right of index i\\n i += 1\\n\\t\\t\\n while i < n:\\n while s[i] == s[i - 1] or (i > 1 and s[i - 2] == s[i]):\\n s[i] += 1\\n \\n i += 1\\n \\n return ''.join([chr(ord('a') + o) for o in s])\",\n \"runtime\": \"295\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = list(s)\\n\\n for i in reversed(range(len(chars))):\\n chars[i] = chr(ord(chars[i]) + 1)\\n while self._containsPalindrome(chars, i):\\n chars[i] = chr(ord(chars[i]) + 1)\\n if chars[i] < chr(ord('a') + k):\\n # If s[i] is among the first k letters, then change the letters after\\n # s[i] to the smallest ones that don't form any palindrome substring.\\n return self._changeSuffix(chars, i + 1)\\n\\n return ''\\n\\n def _containsPalindrome(self, chars: List[str], i: int) -> bool:\\n \\\"\\\"\\\"Returns True if chars[0..i] contains palindrome.\\\"\\\"\\\"\\n return (i > 0 and chars[i] == chars[i - 1]) or \\\\\\n (i > 1 and chars[i] == chars[i - 2])\\n\\n def _changeSuffix(self, chars: List[str], i: int) -> str:\\n \\\"\\\"\\\"\\n Returns a string, where replacing sb[i..n) with the smallest possible\\n letters don't form any palindrome substring.\\n \\\"\\\"\\\"\\n for j in range(i, len(chars)):\\n chars[j] = 'a'\\n while self._containsPalindrome(chars, j):\\n chars[j] = chr(ord(chars[j]) + 1)\\n return ''.join(chars)\",\n \"runtime\": \"299\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n chars = [ord(c) - ord('a') for c in s]\\n i = n - 1\\n chars[i] += 1\\n while i >= 0 and i < n:\\n if chars[i] == k:\\n i -= 1\\n if i >= 0:\\n chars[i] += 1\\n elif i > 0 and chars[i] == chars[i - 1]:\\n chars[i] += 1\\n elif i > 1 and chars[i] == chars[i - 2]:\\n chars[i] += 1\\n else:\\n i += 1\\n if i < n:\\n chars[i] = 0\\n if i < 0:\\n return \\\"\\\"\\n return ''.join(chr(c + ord('a')) for c in chars)\",\n \"runtime\": \"301\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n def next_char(c, k):\\n return chr(((ord(c) - ord('a') + 1) % k) + ord('a'))\\n \\n def is_valid(s, pos):\\n if pos > 0 and s[pos] == s[pos - 1]:\\n return False\\n if pos > 1 and s[pos] == s[pos - 2]:\\n return False\\n return True\\n \\n i = n - 1\\n \\n while i >= 0:\\n initial_char = s[i]\\n s[i] = next_char(s[i], k)\\n \\n while s[i] != 'a' and not is_valid(s, i):\\n s[i] = next_char(s[i], k)\\n \\n if s[i] != 'a':\\n break\\n \\n i -= 1\\n \\n if i < 0:\\n return \\\"\\\"\\n \\n for j in range(i + 1, n):\\n for ch in range(ord('a'), ord('a') + k):\\n s[j] = chr(ch)\\n if is_valid(s, j):\\n break\\n \\n return ''.join(s)\",\n \"runtime\": \"331\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n ans = [\\\"\\\"] * len(s)\\n found = -1\\n \\n for i in range(len(s) -1, -1, -1):\\n for j in range(ord(s[i]) -97 + 1, k):\\n if chr(j + 97) != s[max(0, i -1)] and chr(j +97) != s[max(0, i-2)]:\\n ans[i] = chr(j + 97)\\n found = i\\n break\\n if found != -1: break\\n \\n if found == -1: return \\\"\\\"\\n for i in range(found): ans[i] = s[i]\\n for i in range(found + 1, len(ans)):\\n for j in range(k +1):\\n if chr(j + 97) != ans[max(0, i -1)] and chr(j +97) != ans[max(0, i-2)]:\\n ans[i] = chr(j+97)\\n break\\n return \\\"\\\".join(ans) if \\\"\\\" not in ans else \\\"\\\"\",\n \"runtime\": \"334\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\\n \",\n \"runtime\": \"343\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = [ord(c) - ord('a') for c in s]\\n length = len(chars)\\n idx = length - 1\\n chars[idx] += 1\\n \\n while idx >= 0:\\n if chars[idx] == k:\\n idx -= 1\\n elif chars[idx] not in chars[max(idx - 2, 0):idx]:\\n break\\n chars[idx] += 1\\n \\n if idx < 0:\\n return ''\\n \\n for pos in range(idx + 1, length):\\n valid_chars = {0, 1, 2} - set(chars[max(0, pos - 2):pos])\\n chars[pos] = min(valid_chars)\\n \\n return ''.join(chr(ord('a') + ch) for ch in chars)\",\n \"runtime\": \"351\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"356\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n def is_beautiful(index):\\n if index >= 1 and s[index] == s[index - 1]:\\n return False\\n if index >= 2 and s[index] == s[index - 2]:\\n return False\\n return True\\n \\n # Start from the last position\\n i = n - 1\\n while i >= 0:\\n s[i] = chr(ord(s[i]) + 1) # Attempt to increment\\n \\n # Find next suitable character\\n while ord(s[i]) < ord('a') + k and not is_beautiful(i):\\n s[i] = chr(ord(s[i]) + 1)\\n \\n if ord(s[i]) < ord('a') + k:\\n # Fill the remaining positions with the smallest lexicographical choices\\n for j in range(i + 1, n):\\n s[j] = 'a'\\n while not is_beautiful(j):\\n s[j] = chr(ord(s[j]) + 1)\\n return ''.join(s)\\n \\n # Reset and move to the previous character\\n s[i] = 'a'\\n i -= 1\\n \\n return \\\"\\\"\\n\\n# Example usage:\\n# solution = Solution()\\n# print(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\n# print(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"358\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"359\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"363\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"369\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n i = len(A) - 1\\n while i >= 0:\\n A[i] += 1\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n for j in range(i + 1, len(A)):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\\n return ''\",\n \"runtime\": \"370\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord(\\\"a\\\") for c in s]\\n i = len(A) - 1\\n while i >= 0:\\n A[i] += 1\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0) : i]:\\n for j in range(i + 1, len(A)):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2) : j]))\\n return \\\"\\\".join(chr(ord(\\\"a\\\") + a) for a in A)\\n return \\\"\\\"\",\n \"runtime\": \"373\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord(\\\"a\\\") for c in s]\\n i = len(A) - 1\\n while i >= 0:\\n A[i] += 1\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0) : i]:\\n for j in range(i + 1, len(A)):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2) : j]))\\n return \\\"\\\".join(chr(ord(\\\"a\\\") + a) for a in A)\\n return \\\"\\\"\",\n \"runtime\": \"374\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"382\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"404\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"runtime\": \"452\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # Convert the string to a list of characters\\n s = list(s)\\n n = len(s)\\n\\n # Function to check if a substring is a palindrome\\n def is_palindrome(substr):\\n return substr == substr[::-1]\\n\\n # Function to find the next valid character\\n def next_char(c):\\n return chr(ord(c) + 1) if c != chr(ord('a') + k - 1) else None\\n\\n # Iterate from the end to the beginning\\n for i in range(n - 1, -1, -1):\\n # Try to increment the current character\\n current_char = s[i]\\n next_valid_char = next_char(current_char)\\n while next_valid_char:\\n s[i] = next_valid_char\\n if not (i >= 2 and is_palindrome(s[i-2:i+1])) and not (i >= 1 and is_palindrome(s[i-1:i+1])):\\n # Reset the subsequent characters to the smallest possible valid sequence\\n for j in range(i + 1, n):\\n for c in range(ord('a'), ord('a') + k):\\n s[j] = chr(c)\\n if not (j >= 2 and is_palindrome(s[j-2:j+1])) and not (j >= 1 and is_palindrome(s[j-1:j+1])):\\n break\\n return ''.join(s)\\n next_valid_char = next_char(next_valid_char)\\n # If no valid increment is found, backtrack\\n if i == 0:\\n return \\\"\\\"\\n return \\\"\\\"\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"runtime\": \"477\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n to_int = lambda x : ord(x) - ord('a')\\n s = list(map(to_int, s))\\n n = len(s)\\n\\n for i in range(n - 1, -1, -1):\\n poss = set(range(s[i] + 1, k)) - set(s[max(0, i-2):i])\\n if len(poss) > 0:\\n break\\n else:\\n return \\\"\\\"\\n\\n s[i] = min(poss)\\n for j in range(i + 1, min(i + 4, n)):\\n seen = set(s[max(0, j-2):j])\\n for k in range(26):\\n if k not in seen:\\n s[j] = k\\n break\\n \\n for j in range(i + 4, n):\\n s[j] = s[j - 3]\\n return ''.join(chr(i + ord('a')) for i in s)\",\n \"runtime\": \"484\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n # Function to check if a substring is a palindrome\\n def is_palindrome(substr):\\n return substr == substr[::-1]\\n \\n # Function to find the next lexicographically larger character\\n def next_char(c):\\n if c == 'z':\\n return None\\n return chr(ord(c) + 1)\\n \\n # Start from the last character\\n for i in range(n - 1, -1, -1):\\n current_char = s[i]\\n next_char_found = False\\n \\n # Try to find the next valid character\\n while not next_char_found:\\n next_c = next_char(current_char)\\n if next_c and next_c <= chr(96 + k):\\n s[i] = next_c\\n if i >= 2 and is_palindrome(s[i-2:i+1]):\\n current_char = next_c\\n continue\\n if i >= 1 and is_palindrome(s[i-1:i+1]):\\n current_char = next_c\\n continue\\n next_char_found = True\\n else:\\n break\\n \\n if next_char_found:\\n # Reset the following characters to the smallest possible\\n for j in range(i + 1, n):\\n for char in 'abcdefghijklmnopqrstuvwxyz':\\n if char <= chr(96 + k):\\n s[j] = char\\n if j >= 2 and is_palindrome(s[j-2:j+1]):\\n continue\\n if j >= 1 and is_palindrome(s[j-1:j+1]):\\n continue\\n break\\n return ''.join(s)\\n \\n return \\\"\\\"\",\n \"runtime\": \"485\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = [ord(c) - ord('a') for c in s]\\n\\n ptr = len(s) - 1\\n while ptr < len(s):\\n if ptr == -1:\\n return \\\"\\\"\\n found = False\\n for i in range(k):\\n if i <= s[ptr]:\\n continue\\n elif ptr >= 1 and (i == s[ptr - 1]):\\n continue\\n elif ptr >= 2 and (i == s[ptr - 2]):\\n continue\\n else:\\n s[ptr] = i\\n found = True\\n break\\n\\n if found:\\n ptr += 1\\n else:\\n s[ptr] = -1\\n ptr -= 1\\n \\n return \\\"\\\".join(chr(x + ord('a')) for x in s)\",\n \"runtime\": \"496\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":57,"string":"57"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chrs, n = [\"a\", \"b\", \"c\"], len(s)\n i, ci = n-1, \"\"\n while i >= 0:\n c = ord(s[i]) + 1\n nc = set()\n if i-1 >= 0: nc.add(s[i-1])\n if i-2 >= 0: nc.add(s[i-2])\n while c < k + ord(\"a\"):\n if chr(c) not in nc: break\n c += 1\n if c < k + ord(\"a\"): \n ci = chr(c)\n break\n i -= 1\n \n if i == -1: return \"\"\n ans = s[:i]\n ans += ci\n i += 1\n while i < n:\n nc = set()\n if i-1 >= 0: nc.add(ans[i-1])\n if i-2 >= 0: nc.add(ans[i-2])\n for ch in chrs:\n if ch not in nc: \n ans += ch\n break\n i += 1\n return ans","memory":"17800"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\n # If X3 and X4 form a palindrome, we have X3 == X4.\n # If X2-X4 form a palindrome, we have X2 == X4.\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\n # So far, finding the rightmost incrementable character is O(n).\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \"a\"/\"b\"/\"c\" anyway.\n ans = list(s)\n cur = -1\n for i in range(len(ans) - 1, -1, -1):\n if ord(ans[i]) - 96 >= k:\n # This letter cannot be incremented\n continue\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\n if chr(j) not in seen:\n ans[i] = chr(j)\n break\n else:\n # Not possible to adjust the current letter due to constraint k.\n continue\n # We have replaced ans[i]\n cur = i + 1\n break\n if cur == -1:\n return \"\"\n for i in range(cur, len(ans)):\n seen = []\n if i - 1 >= 0:\n seen.append(ans[i - 1])\n if i - 2 >= 0:\n seen.append(ans[i - 2])\n for ch in \"abc\":\n if ch not in seen:\n ans[i] = ch\n break\n return \"\".join(ans)","memory":"18200"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s) # Convert to list for mutability\n a = ord('a')\n \n # Helper function to check if the string is beautiful\n def is_beautiful(s, i):\n if i > 0 and s[i] == s[i - 1]:\n return False\n if i > 1 and s[i] == s[i - 2]:\n return False\n return True\n \n # Try to increment from the end\n for i in range(n - 1, -1, -1):\n # Increment the current character\n for j in range(ord(s[i]) - a + 1, k):\n s[i] = chr(a + j)\n if is_beautiful(s, i):\n # Fill the rest of the string with the smallest possible characters\n for x in range(i + 1, n):\n for y in range(k):\n s[x] = chr(a + y)\n if is_beautiful(s, x):\n break\n return ''.join(s)\n \n return \"\" # If no valid string is found\n\n# Example usage:\nsolution = Solution()\nprint(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\nprint(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","memory":"18300"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n n = len(s)\n s = list(s)\n \n def is_beautiful(index):\n if index >= 1 and s[index] == s[index - 1]:\n return False\n if index >= 2 and s[index] == s[index - 2]:\n return False\n return True\n \n # Start from the last position\n i = n - 1\n while i >= 0:\n s[i] = chr(ord(s[i]) + 1) # Attempt to increment\n \n # Find next suitable character\n while ord(s[i]) < ord('a') + k and not is_beautiful(i):\n s[i] = chr(ord(s[i]) + 1)\n \n if ord(s[i]) < ord('a') + k:\n # Fill the remaining positions with the smallest lexicographical choices\n for j in range(i + 1, n):\n s[j] = 'a'\n while not is_beautiful(j):\n s[j] = chr(ord(s[j]) + 1)\n return ''.join(s)\n \n # Reset and move to the previous character\n s[i] = 'a'\n i -= 1\n \n return \"\"\n\n# Example usage:\n# solution = Solution()\n# print(solution.smallestBeautifulString(\"abcz\", 26)) # Output: \"abda\"\n# print(solution.smallestBeautifulString(\"dc\", 4)) # Output: \"\"","memory":"18300"},{"code":"class Solution:\n def is_palindrome(self, i, s, curr_char):\n prev_char = ord(s[i-1]) - ord('a')\n\n if curr_char == prev_char:\n return True\n \n # if i + 1 < len(s) and curr_char == ord(s[i+1]) - ord('a'):\n # return True\n \n if i - 2 >= 0 and curr_char == ord(s[i-2]) - ord('a'):\n return True\n \n # if i + 2 < len(s) and curr_char == ord(s[i+2]) - ord('a'):\n # return True\n \n return False\n\n def smallestBeautifulString(self, s: str, k: int) -> str: \n i = len(s)-1\n s = list(s)\n n = len(s)\n\n for i in range(len(s)-1, -1, -1):\n position = ord(s[i]) - ord('a') + 1\n\n for j in range(position, k):\n rch = chr(j + ord('a'))\n\n if (i > 0 and s[i-1] == rch) or (i > 1 and s[i-2] == rch):\n continue\n \n s[i] = rch\n\n for l in range(i + 1, n):\n for m in range(k):\n next_char = chr(ord('a') + m)\n if (l > 0 and s[l - 1] == next_char) or (l > 1 and s[l - 2] == next_char):\n continue\n s[l] = next_char\n break\n \n return ''.join(s)\n return ''","memory":"18400"},{"code":"\nclass Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n chars = list(s)\n\n for i in reversed(range(len(chars))):\n chars[i] = chr(ord(chars[i]) + 1)\n while self._containsPalindrome(chars, i):\n chars[i] = chr(ord(chars[i]) + 1)\n if chars[i] < chr(ord('a') + k):\n # If s[i] is among the first k letters, then change the letters after\n # s[i] to the smallest ones that don't form any palindrome substring.\n return self._changeSuffix(chars, i + 1)\n\n return ''\n\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\n \"\"\"Returns True if chars[0..i] contains palindrome.\"\"\"\n return ((i > 0 and chars[i] == chars[i - 1]) or\n (i > 1 and chars[i] == chars[i - 2]))\n\n def _changeSuffix(self, chars: list[str], i: int) -> str:\n \"\"\"\n Returns a string, where replacing sb[i..n) with the smallest possible\n letters don't form any palindrome substring.\n \"\"\"\n for j in range(i, len(chars)):\n chars[j] = 'a'\n while self._containsPalindrome(chars, j):\n chars[j] = chr(ord(chars[j]) + 1)\n return ''.join(chars)","memory":"18500"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n N = len(s)\n alphabet = string.ascii_lowercase\n k -= 1\n arr = [c for c in s]\n\n for i in range(N - 1, -1, -1):\n if arr[i] != alphabet[k]:\n\n index = alphabet.index(arr[i])\n\n for char in alphabet[index + 1: k + 1]:\n \n l = i - 1\n\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\n # we have a valid answer\n arr[i] = char\n i += 1\n\n while i < N:\n for o in alphabet:\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\n arr[i] = o\n i += 1\n break\n\n return \"\".join(arr) \n \n return \"\" ","memory":"18600"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n '''\n our current string is valid\n we just have to find next valid one\n\n find first char we can increase (and maintain nonpalindome property)\n\n then make all chars after it \"abcabc...\" with some edge cases\n\n find first char we can change from right to left\n\n then, change all chars right of it to some invariant of \"abc\" and return ans\n\n '''\n N = len(s)\n alphabet = string.ascii_lowercase\n k -= 1\n arr = [c for c in s]\n\n for i in range(N - 1, -1, -1):\n if arr[i] != alphabet[k]:\n\n index = alphabet.index(arr[i])\n\n for char in alphabet[index + 1: k + 1]:\n \n l = i - 1\n\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\n # we have a valid answer\n arr[i] = char\n i += 1\n\n while i < N:\n for o in alphabet:\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\n arr[i] = o\n i += 1\n break\n\n return \"\".join(arr)\n\n \n \n return \"\"\n\n \n\n ","memory":"18700"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n l=[]\n n=len(s)\n for i in range(n):\n l+=[s[i]]\n i=n-1\n while i>=0 and l[i]==chr(97+k-1):\n l[i]=\"a\"\n i-=1\n else:\n if i==-1:\n return \"\"\n l[i]=chr(ord(l[i])+1)\n i=0\n p=-1\n for i in range(n):\n if i+1<n:\n if l[i]==l[i+1]:\n p=i+1\n break\n if i+2<n:\n if l[i]==l[i+2]:\n p=i+2\n break\n if p==-1:\n s1=\"\"\n for i in l:\n s1+=i\n return s1\n a=self.solve(l,p,k)\n if a==-1:\n return \"\"\n l1=[\"a\",\"b\",\"c\"]\n s1=\"\"\n for i in range(n):\n if i<a:\n s1+=l[i]\n else:\n for j in range(3):\n if i-2>=0:\n if l1[j]!=l[i-1] and l1[j]!=l[i-2]:\n l[i]=l1[j]\n s1+=l[i]\n break\n elif i-1>=0:\n if l1[j]!=l[i-1]:\n l[i]=l1[j]\n s1+=l[i]\n break\n else:\n l[i]=l1[j]\n s1+=l[i]\n break\n return s1\n def solve(self,l,p,k):\n f=1\n while p>0:\n if p-1>=0:\n if l[p]==l[p-1]==chr(97+k-1):\n if (p-2)<0:\n return -1\n l[p-2]=chr(ord(l[p-2])+1)\n l[p-1]=\"a\"\n l[p]=\"b\"\n f=p\n continue\n elif l[p-1]==l[p]:\n l[p]=chr(ord(l[p])+1)\n f=p\n continue\n if p-2>=0:\n if l[p-2]==l[p]==chr(97+k-1):\n l[p-1]=chr(ord(l[p-1])+1)\n l[p]=\"a\"\n f=p\n continue\n elif l[p-2]==l[p]:\n l[p]=chr(ord(l[p])+1)\n f=p\n continue\n p-=1\n return f+1","memory":"18900"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n s = [ord(c) - ord('a') for c in s]\n\n ptr = len(s) - 1\n while ptr < len(s):\n if ptr == -1:\n return \"\"\n found = False\n for i in range(k):\n if i <= s[ptr]:\n continue\n elif ptr >= 1 and (i == s[ptr - 1]):\n continue\n elif ptr >= 2 and (i == s[ptr - 2]):\n continue\n else:\n s[ptr] = i\n found = True\n break\n\n if found:\n ptr += 1\n else:\n s[ptr] = -1\n ptr -= 1\n \n return \"\".join(chr(x + ord('a')) for x in s)","memory":"19200"},{"code":"class Solution:\n def smallestBeautifulString(self, s: str, k: int) -> str:\n A = [ord(c) - ord('a') for c in s]\n n = len(A)\n i = n - 1\n A[i] += 1\n while i >= 0:\n if A[i] == k:\n i -= 1\n elif A[i] not in A[max(i - 2, 0):i]:\n break\n A[i] += 1\n if i < 0:\n return ''\n for j in range(i + 1, n):\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\n return ''.join(chr(ord('a') + a) for a in A)","memory":"19300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chrs, n = [\\\"a\\\", \\\"b\\\", \\\"c\\\"], len(s)\\n i, ci = n-1, \\\"\\\"\\n while i >= 0:\\n c = ord(s[i]) + 1\\n nc = set()\\n if i-1 >= 0: nc.add(s[i-1])\\n if i-2 >= 0: nc.add(s[i-2])\\n while c < k + ord(\\\"a\\\"):\\n if chr(c) not in nc: break\\n c += 1\\n if c < k + ord(\\\"a\\\"): \\n ci = chr(c)\\n break\\n i -= 1\\n \\n if i == -1: return \\\"\\\"\\n ans = s[:i]\\n ans += ci\\n i += 1\\n while i < n:\\n nc = set()\\n if i-1 >= 0: nc.add(ans[i-1])\\n if i-2 >= 0: nc.add(ans[i-2])\\n for ch in chrs:\\n if ch not in nc: \\n ans += ch\\n break\\n i += 1\\n return ans\",\n \"memory\": \"17800\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n # First, the input s is already beautiful, so it does not have any palindrome substring already.\\n # Second, we want to check from the right to left for whether a character can be incremented to keep it as beautiful. If the rightmost character can be incremented, then the answer is there already. Otherwise, assume that we increment [i], we need to reset the following characters to a's. Due to this nature, we do not need to check if the incremented character violates palindrome property for the suffix, which will be reset anyway. We want to check if the modified character can compose palindrome for the prefix.\\n # Consider: [X1] [X2] [X3] [X4*] wher X4 is modified.\\n # If X3 and X4 form a palindrome, we have X3 == X4.\\n # If X2-X4 form a palindrome, we have X2 == X4.\\n # Can X1 - X4 form a palindrome? No, because X2 != X3 given that the input string is already beautiful.\\n # Hence we only need to check the equality for X2 and X3. O(1) complexity.\\n # So far, finding the rightmost incrementable character is O(n).\\n # If the incremented character is not the rightmost, the suffix needs to be adjusted.\\n # For the suffix a's, we scan the suffix from the left to right. We try to find the least character to be incremented and set it to the corresponding index. The complexity is also O(n).\\n # Is it possible that there is no solutions in adjusting the suffix? No. Because the character is always adjusted with respect to the previous two, it can be \\\"a\\\"/\\\"b\\\"/\\\"c\\\" anyway.\\n ans = list(s)\\n cur = -1\\n for i in range(len(ans) - 1, -1, -1):\\n if ord(ans[i]) - 96 >= k:\\n # This letter cannot be incremented\\n continue\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for j in range(ord(ans[i]) + 1, min(ord(ans[i]) + 4, 97 + k)):\\n if chr(j) not in seen:\\n ans[i] = chr(j)\\n break\\n else:\\n # Not possible to adjust the current letter due to constraint k.\\n continue\\n # We have replaced ans[i]\\n cur = i + 1\\n break\\n if cur == -1:\\n return \\\"\\\"\\n for i in range(cur, len(ans)):\\n seen = []\\n if i - 1 >= 0:\\n seen.append(ans[i - 1])\\n if i - 2 >= 0:\\n seen.append(ans[i - 2])\\n for ch in \\\"abc\\\":\\n if ch not in seen:\\n ans[i] = ch\\n break\\n return \\\"\\\".join(ans)\",\n \"memory\": \"18200\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s) # Convert to list for mutability\\n a = ord('a')\\n \\n # Helper function to check if the string is beautiful\\n def is_beautiful(s, i):\\n if i > 0 and s[i] == s[i - 1]:\\n return False\\n if i > 1 and s[i] == s[i - 2]:\\n return False\\n return True\\n \\n # Try to increment from the end\\n for i in range(n - 1, -1, -1):\\n # Increment the current character\\n for j in range(ord(s[i]) - a + 1, k):\\n s[i] = chr(a + j)\\n if is_beautiful(s, i):\\n # Fill the rest of the string with the smallest possible characters\\n for x in range(i + 1, n):\\n for y in range(k):\\n s[x] = chr(a + y)\\n if is_beautiful(s, x):\\n break\\n return ''.join(s)\\n \\n return \\\"\\\" # If no valid string is found\\n\\n# Example usage:\\nsolution = Solution()\\nprint(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\nprint(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n n = len(s)\\n s = list(s)\\n \\n def is_beautiful(index):\\n if index >= 1 and s[index] == s[index - 1]:\\n return False\\n if index >= 2 and s[index] == s[index - 2]:\\n return False\\n return True\\n \\n # Start from the last position\\n i = n - 1\\n while i >= 0:\\n s[i] = chr(ord(s[i]) + 1) # Attempt to increment\\n \\n # Find next suitable character\\n while ord(s[i]) < ord('a') + k and not is_beautiful(i):\\n s[i] = chr(ord(s[i]) + 1)\\n \\n if ord(s[i]) < ord('a') + k:\\n # Fill the remaining positions with the smallest lexicographical choices\\n for j in range(i + 1, n):\\n s[j] = 'a'\\n while not is_beautiful(j):\\n s[j] = chr(ord(s[j]) + 1)\\n return ''.join(s)\\n \\n # Reset and move to the previous character\\n s[i] = 'a'\\n i -= 1\\n \\n return \\\"\\\"\\n\\n# Example usage:\\n# solution = Solution()\\n# print(solution.smallestBeautifulString(\\\"abcz\\\", 26)) # Output: \\\"abda\\\"\\n# print(solution.smallestBeautifulString(\\\"dc\\\", 4)) # Output: \\\"\\\"\",\n \"memory\": \"18300\"\n },\n {\n \"code\": \"class Solution:\\n def is_palindrome(self, i, s, curr_char):\\n prev_char = ord(s[i-1]) - ord('a')\\n\\n if curr_char == prev_char:\\n return True\\n \\n # if i + 1 < len(s) and curr_char == ord(s[i+1]) - ord('a'):\\n # return True\\n \\n if i - 2 >= 0 and curr_char == ord(s[i-2]) - ord('a'):\\n return True\\n \\n # if i + 2 < len(s) and curr_char == ord(s[i+2]) - ord('a'):\\n # return True\\n \\n return False\\n\\n def smallestBeautifulString(self, s: str, k: int) -> str: \\n i = len(s)-1\\n s = list(s)\\n n = len(s)\\n\\n for i in range(len(s)-1, -1, -1):\\n position = ord(s[i]) - ord('a') + 1\\n\\n for j in range(position, k):\\n rch = chr(j + ord('a'))\\n\\n if (i > 0 and s[i-1] == rch) or (i > 1 and s[i-2] == rch):\\n continue\\n \\n s[i] = rch\\n\\n for l in range(i + 1, n):\\n for m in range(k):\\n next_char = chr(ord('a') + m)\\n if (l > 0 and s[l - 1] == next_char) or (l > 1 and s[l - 2] == next_char):\\n continue\\n s[l] = next_char\\n break\\n \\n return ''.join(s)\\n return ''\",\n \"memory\": \"18400\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n chars = list(s)\\n\\n for i in reversed(range(len(chars))):\\n chars[i] = chr(ord(chars[i]) + 1)\\n while self._containsPalindrome(chars, i):\\n chars[i] = chr(ord(chars[i]) + 1)\\n if chars[i] < chr(ord('a') + k):\\n # If s[i] is among the first k letters, then change the letters after\\n # s[i] to the smallest ones that don't form any palindrome substring.\\n return self._changeSuffix(chars, i + 1)\\n\\n return ''\\n\\n def _containsPalindrome(self, chars: list[str], i: int) -> bool:\\n \\\"\\\"\\\"Returns True if chars[0..i] contains palindrome.\\\"\\\"\\\"\\n return ((i > 0 and chars[i] == chars[i - 1]) or\\n (i > 1 and chars[i] == chars[i - 2]))\\n\\n def _changeSuffix(self, chars: list[str], i: int) -> str:\\n \\\"\\\"\\\"\\n Returns a string, where replacing sb[i..n) with the smallest possible\\n letters don't form any palindrome substring.\\n \\\"\\\"\\\"\\n for j in range(i, len(chars)):\\n chars[j] = 'a'\\n while self._containsPalindrome(chars, j):\\n chars[j] = chr(ord(chars[j]) + 1)\\n return ''.join(chars)\",\n \"memory\": \"18500\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n N = len(s)\\n alphabet = string.ascii_lowercase\\n k -= 1\\n arr = [c for c in s]\\n\\n for i in range(N - 1, -1, -1):\\n if arr[i] != alphabet[k]:\\n\\n index = alphabet.index(arr[i])\\n\\n for char in alphabet[index + 1: k + 1]:\\n \\n l = i - 1\\n\\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\\n # we have a valid answer\\n arr[i] = char\\n i += 1\\n\\n while i < N:\\n for o in alphabet:\\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\\n arr[i] = o\\n i += 1\\n break\\n\\n return \\\"\\\".join(arr) \\n \\n return \\\"\\\" \",\n \"memory\": \"18600\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n '''\\n our current string is valid\\n we just have to find next valid one\\n\\n find first char we can increase (and maintain nonpalindome property)\\n\\n then make all chars after it \\\"abcabc...\\\" with some edge cases\\n\\n find first char we can change from right to left\\n\\n then, change all chars right of it to some invariant of \\\"abc\\\" and return ans\\n\\n '''\\n N = len(s)\\n alphabet = string.ascii_lowercase\\n k -= 1\\n arr = [c for c in s]\\n\\n for i in range(N - 1, -1, -1):\\n if arr[i] != alphabet[k]:\\n\\n index = alphabet.index(arr[i])\\n\\n for char in alphabet[index + 1: k + 1]:\\n \\n l = i - 1\\n\\n if (l < 0 or arr[l] != char) and (l - 1 < 0 or arr[l - 1] != char):\\n # we have a valid answer\\n arr[i] = char\\n i += 1\\n\\n while i < N:\\n for o in alphabet:\\n if (i - 1 < 0 or arr[i - 1] != o) and (i - 2 < 0 or arr[i - 2] != o):\\n arr[i] = o\\n i += 1\\n break\\n\\n return \\\"\\\".join(arr)\\n\\n \\n \\n return \\\"\\\"\\n\\n \\n\\n \",\n \"memory\": \"18700\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n l=[]\\n n=len(s)\\n for i in range(n):\\n l+=[s[i]]\\n i=n-1\\n while i>=0 and l[i]==chr(97+k-1):\\n l[i]=\\\"a\\\"\\n i-=1\\n else:\\n if i==-1:\\n return \\\"\\\"\\n l[i]=chr(ord(l[i])+1)\\n i=0\\n p=-1\\n for i in range(n):\\n if i+1<n:\\n if l[i]==l[i+1]:\\n p=i+1\\n break\\n if i+2<n:\\n if l[i]==l[i+2]:\\n p=i+2\\n break\\n if p==-1:\\n s1=\\\"\\\"\\n for i in l:\\n s1+=i\\n return s1\\n a=self.solve(l,p,k)\\n if a==-1:\\n return \\\"\\\"\\n l1=[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\\n s1=\\\"\\\"\\n for i in range(n):\\n if i<a:\\n s1+=l[i]\\n else:\\n for j in range(3):\\n if i-2>=0:\\n if l1[j]!=l[i-1] and l1[j]!=l[i-2]:\\n l[i]=l1[j]\\n s1+=l[i]\\n break\\n elif i-1>=0:\\n if l1[j]!=l[i-1]:\\n l[i]=l1[j]\\n s1+=l[i]\\n break\\n else:\\n l[i]=l1[j]\\n s1+=l[i]\\n break\\n return s1\\n def solve(self,l,p,k):\\n f=1\\n while p>0:\\n if p-1>=0:\\n if l[p]==l[p-1]==chr(97+k-1):\\n if (p-2)<0:\\n return -1\\n l[p-2]=chr(ord(l[p-2])+1)\\n l[p-1]=\\\"a\\\"\\n l[p]=\\\"b\\\"\\n f=p\\n continue\\n elif l[p-1]==l[p]:\\n l[p]=chr(ord(l[p])+1)\\n f=p\\n continue\\n if p-2>=0:\\n if l[p-2]==l[p]==chr(97+k-1):\\n l[p-1]=chr(ord(l[p-1])+1)\\n l[p]=\\\"a\\\"\\n f=p\\n continue\\n elif l[p-2]==l[p]:\\n l[p]=chr(ord(l[p])+1)\\n f=p\\n continue\\n p-=1\\n return f+1\",\n \"memory\": \"18900\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n s = [ord(c) - ord('a') for c in s]\\n\\n ptr = len(s) - 1\\n while ptr < len(s):\\n if ptr == -1:\\n return \\\"\\\"\\n found = False\\n for i in range(k):\\n if i <= s[ptr]:\\n continue\\n elif ptr >= 1 and (i == s[ptr - 1]):\\n continue\\n elif ptr >= 2 and (i == s[ptr - 2]):\\n continue\\n else:\\n s[ptr] = i\\n found = True\\n break\\n\\n if found:\\n ptr += 1\\n else:\\n s[ptr] = -1\\n ptr -= 1\\n \\n return \\\"\\\".join(chr(x + ord('a')) for x in s)\",\n \"memory\": \"19200\"\n },\n {\n \"code\": \"class Solution:\\n def smallestBeautifulString(self, s: str, k: int) -> str:\\n A = [ord(c) - ord('a') for c in s]\\n n = len(A)\\n i = n - 1\\n A[i] += 1\\n while i >= 0:\\n if A[i] == k:\\n i -= 1\\n elif A[i] not in A[max(i - 2, 0):i]:\\n break\\n A[i] += 1\\n if i < 0:\\n return ''\\n for j in range(i + 1, n):\\n A[j] = min({0, 1, 2} - set(A[max(0, j - 2): j]))\\n return ''.join(chr(ord('a') + a) for a in A)\",\n \"memory\": \"19300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":11,"string":"11"}}},{"rowIdx":2471,"cells":{"question_id":{"kind":"number","value":1730,"string":"1,730"},"name":{"kind":"string","value":"special-array-with-x-elements-greater-than-or-equal-x"},"content":{"kind":"string","value":"<p>You are given an array <code>nums</code> of non-negative integers. <code>nums</code> is considered <strong>special</strong> if there exists a number <code>x</code> such that there are <strong>exactly</strong> <code>x</code> numbers in <code>nums</code> that are <strong>greater than or equal to</strong> <code>x</code>.</p>\n\n<p>Notice that <code>x</code> <strong>does not</strong> have to be an element in <code>nums</code>.</p>\n\n<p>Return <code>x</code> <em>if the array is <strong>special</strong>, otherwise, return </em><code>-1</code>. It can be proven that if <code>nums</code> is special, the value for <code>x</code> is <strong>unique</strong>.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [3,5]\n<strong>Output:</strong> 2\n<strong>Explanation:</strong> There are 2 values (3 and 5) that are greater than or equal to 2.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [0,0]\n<strong>Output:</strong> -1\n<strong>Explanation:</strong> No numbers fit the criteria for x.\nIf x = 0, there should be 0 numbers >= x, but there are 2.\nIf x = 1, there should be 1 number >= x, but there are 0.\nIf x = 2, there should be 2 numbers >= x, but there are 0.\nx cannot be greater since there are only 2 numbers in nums.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<pre>\n<strong>Input:</strong> nums = [0,4,3,0,4]\n<strong>Output:</strong> 3\n<strong>Explanation:</strong> There are 3 values that are greater than or equal to 3.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= nums.length <= 100</code></li>\n\t<li><code>0 <= nums[i] <= 1000</code></li>\n</ul>\n"},"acRate":{"kind":"number","value":66.87363690436851,"string":"66.873637"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","binary-search","sorting"],"string":"[\n \"array\",\n \"binary-search\",\n \"sorting\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"20\", 0.0655], [\"21\", 0.0655], [\"22\", 0.1966], [\"23\", 0.1966], [\"24\", 0.1311], [\"25\", 0.2621], [\"26\", 0.5898], [\"27\", 0.3277], [\"28\", 0.7208], [\"29\", 0.7864], [\"30\", 1.7038], [\"31\", 1.7038], [\"32\", 2.6212], [\"33\", 3.2765], [\"34\", 3.9974], [\"35\", 4.2595], [\"36\", 5.308], [\"37\", 4.8493], [\"38\", 5.7012], [\"39\", 5.2425], [\"40\", 8.2569], [\"41\", 6.4875], [\"42\", 6.2254], [\"43\", 5.7667], [\"44\", 5.3735], [\"45\", 5.6356], [\"46\", 3.8008], [\"47\", 3.2765], [\"48\", 2.8834], [\"49\", 2.3591], [\"50\", 1.5727]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16200\", 0.2621], [\"16300\", 4.5872], [\"16400\", 21.7562], [\"16500\", 43.3159]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n \"\"\"\n 0 4 3 0 4 - nums\n 0 1 2 3 4 5 - index of new_arr\n 2 0 0 1 2 0 - count \n 3 2 0 - prefix_sum\n \"\"\"\n count = [0] * (len(nums) + 1)\n for n in nums:\n index = n if n < len(nums) else len(nums)\n count[index] += 1\n \n total_right = 0\n for i in range(len(count) - 1, -1, -1):\n total_right += count[i]\n if i == total_right:\n return i\n \n return -1\n ","runtime":"20"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n l, r = 0, len(nums)\n\n def check(num):\n\n res = 0\n for n in nums:\n if n >= num:\n res += 1\n return res\n while l <= r:\n m = (l + r) // 2\n\n count = check(m)\n if count == m:\n return m\n if count > m:\n l = m + 1\n elif count < m:\n r = m - 1\n return -1\n\n \n \n","runtime":"21"},{"code":"from typing import List\n\n\nclass Solution:\n def specialArray(self, nums: List[int]) -> int:\n n = len(nums)\n count = [0] * (n + 1)\n\n for num in nums:\n count[min(num, n)] += 1\n\n for i in range(n, 0, -1):\n count[i - 1] += count[i]\n if count[i] == i:\n return i\n\n return -1\n","runtime":"22"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n count=Counter(nums)\n res=[0]*(max(nums)+1)\n \n for i in nums:\n res[i]+=1\n \n n=len(res)\n x=n-1\n ele=res[n-1]\n \n for i in range(len(res)-1,0,-1):\n if ele==x:\n return x\n \n x-=1\n ele+=res[x]\n \n return -1","runtime":"23"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n i = 0\n prev = -1\n total_right = len(nums)\n while i < len(nums):\n if (prev < total_right <= nums[i]):\n return total_right\n if nums[i] > len(nums):\n break\n while i+1 < len(nums) and nums[i] == nums[i+1]:\n i+=1\n prev = nums[i]\n i+=1\n total_right = len(nums)-i\n return -1\n","runtime":"23"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n n = len(nums)\n l, h = 1, n\n while(l<=h):\n mid = (l+h)//2\n count = sum(1 for i in nums if(i>=mid))\n\n if(count==mid):\n return mid\n elif(count>mid):\n l = mid+1\n else:\n h = mid - 1\n return -1","runtime":"24"},{"code":"import bisect\nclass Solution:\n def specialArray(self, nums: List[int]) -> int:\n sortedN = sorted(nums)\n finalidx = 0\n for i in range(1,len(sortedN)+1):\n idx = bisect.bisect_left(sortedN, i)\n if len(sortedN)-idx == i:\n return i\n \n \n return finalidx if finalidx > 0 else -1\n ","runtime":"25"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n N = len(nums)\n freq = [0] * (N+1)\n \n for num in nums:\n freq[min(N, num)] += 1\n \n x = 0\n for i in range(N, 0, -1):\n x += freq[i]\n if i == x:\n return x\n return -1","runtime":"26"},{"code":"\nclass Solution:\n def ele(self,nums,n):\n st=0\n en=len(nums)-1\n while(st<=en):\n m=st+(en-st)//2\n if (nums[m]>=n):\n en=m-1;\n else:\n st=m+1\n return st\n \n def specialArray(self, nums: List[int]) -> int:\n s=sorted(nums)\n l=len(nums)\n for i in range(l+1):\n n=self.ele(s,i)\n c=l-n\n if (c==i):\n return c \n return -1\n \n \n ","runtime":"27"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n counts = Counter(nums)\n total = len(nums)\n\n # Keep track of nums smaller and larger than x.\n remain = total\n x = 0\n for num in sorted(counts.keys()):\n\n # Try each x up to num.x\n while x <= num:\n if x == remain:\n return remain\n x += 1\n\n # Disregard values smaller than x.\n remain -= counts[num]\n return -1\n","runtime":"28"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n n = len(nums)\n nums.sort(reverse = True)\n\n if nums[-1] >= n:\n return n\n \n if nums[0] == 0 or (nums[0] == 1 and n > 1):\n return -1\n\n for i in range(1, n):\n if nums[i] < i and nums[i-1] >= i:\n return i\n\n return -1","runtime":"29"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n for i in range(len(nums)):\n c=0\n for j in nums:\n if i+1<=j:\n c+=1\n if c==i+1:\n return i+1\n return -1","runtime":"30"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n # Time: O(n2)\n # Memory: O(1)\n # val = 1\n # i = 0\n # while i < len(nums):\n # count = 0\n # for j in range(len(nums)):\n # if nums[j] >= val:\n # count+= 1\n \n # if count == val:\n # return val\n # else:\n # val+= 1\n # i+= 1\n # return -1\n \n\n # [0,0,3,3,4,4,5] len = 5\n # Time: O(nlogn)\n # Memory: O(1)\n nums.sort()\n print(nums)\n i = 0\n total_right = len(nums)\n prev = -1\n while i < len(nums):\n if nums[i] == total_right or (prev < total_right < nums[i]):\n return total_right\n\n while i+1 < len(nums) and nums[i] == nums[i+1]:\n i+= 1\n \n prev = nums[i]\n i+= 1\n total_right = len(nums) - i\n \n return -1","runtime":"31"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"32"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"32"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n # Step 1: Sort the array in ascending order\n nums.sort()\n \n # Get the length of the array\n n = len(nums)\n \n # Step 2: Iterate over all possible values of x (from 0 to n)\n for x in range(n + 1):\n # Step 3: Check how many elements are greater than or equal to x\n # We can do this by comparing x with the elements in the sorted array\n # We know that if the length of nums is n, then the number of elements >= x \n # is the portion of the array starting from the first element that is >= x.\n greater_or_equal_count = 0\n \n # Step 4: Count the number of elements >= x\n # for num in nums:\n # if num >= x:\n # greater_or_equal_count += 1\n \n for pos, num in enumerate(nums):\n if num >= x:\n greater_or_equal_count += len(nums[pos:])\n break\n # print(x, greater_or_equal_count)\n\n # Step 5: If exactly x elements are greater than or equal to x, return x\n if greater_or_equal_count == x:\n return x\n \n # Step 6: If no such x is found, return -1\n return -1","runtime":"33"},{"code":"class Solution:\n def get_first_greater_or_equal(self, nums, val):\n start = 0\n end = len(nums) - 1\n\n index = len(nums)\n while start <= end:\n mid = (start + end) // 2\n\n if nums[mid] >= val:\n index = mid\n end = mid - 1\n else:\n start = mid + 1\n\n return index\n \n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n \n N = len(nums)\n for i in range(1, N + 1):\n k = self.get_first_greater_or_equal(nums, i)\n \n if N - k == i:\n return i\n \n return -1","runtime":"34"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n n = len(nums)\n x = n\n while x > 0:\n count = 0\n for num in nums:\n if num >= x:\n count += 1\n if count == x:\n return x\n x -= 1\n return -1 ","runtime":"35"},{"code":"class Solution:\n def howmany(self, nums, test):\n a = 0\n for num in nums:\n if num >= test: a += 1\n return a\n def specialArray(self, nums: List[int]) -> int:\n lenght = len(nums)\n while lenght > 0:\n if self.howmany(nums, lenght) == lenght: return lenght\n lenght -= 1\n return -1\n","runtime":"36"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = -1\n for i, n in enumerate(nums):\n if n == prev:\n continue\n if prev < len(nums) - i <= n:\n return len(nums) - i\n prev = n\n return -1\n \n","runtime":"36"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = -1\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"37"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n # l = 0\n # r = max(nums)\n # while l<=r:\n # m = (l+r)//2\n # cnt = 0\n # for num in nums:\n # if m<=num:\n # cnt+=1 \n # if cnt==m:\n # return cnt\n # elif cnt>m:\n # l = m+1\n # else:\n # r= m-1\n # return -1\n\n\n \n for i in range(1,max(nums)+1):\n cnt = 0\n for num in nums:\n if i<=num:\n cnt+=1\n if i == cnt:\n return i\n return -1\n\n # l = 0\n # r = len(nums)\n # while l<=r:\n # mid = (l+r)//2\n # cnt = 0\n # for num in nums:\n # if num>=mid:\n # cnt+=1\n # if mid == cnt:\n # return mid\n # elif cnt>mid:\n # l = mid+1\n # else:\n # l = mid-1\n # return -1\n\n\n # k = -1\n # while k <= len(nums):\n # count = 0\n # for i in nums:\n # if i >= k:\n # count += 1\n # if k == count:\n # return k\n # k += 1\n # return -1","runtime":"37"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n n = len(nums)\n\n def binary_insert(left, right, x):\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] < x:\n left = mid + 1\n else:\n right = mid - 1\n return left\n\n\n\n for x in range(0, n + 1):\n if n - binary_insert(0, n - 1, x) == x:\n return x\n \n return -1\n\n ","runtime":"38"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n # 0 <= n\n n = len(nums)\n nums.sort()\n for i in range(1, n+1):\n j = -i\n if nums[j] >= i and (nums[j-1] < i if j-1 >= -n else True):\n return i\n return -1\n","runtime":"39"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n n = len(nums)\n for i in range(n + 1):\n total = 0\n for num in nums:\n if num >= i:\n total += 1\n if total == i:\n return total\n return -1","runtime":"39"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n if nums[0] >= len(nums):\n return len(nums)\n for i in range(1, len(nums)):\n if nums[i-1] < len(nums)-i <= nums[i]:\n return len(nums)-i\n # 0 3 6 7 7\n return -1","runtime":"40"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"40"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n\n n = len(nums)\n\n for idx, num in enumerate(nums):\n counts = n - idx\n\n prev = 0 if idx == 0 else nums[idx - 1]\n \n if prev < counts <= num:\n return counts\n\n return -1\n","runtime":"41"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"41"},{"code":"import bisect\n\nclass Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums=sorted(nums)\n n=len(nums)\n for i in range(n,0,-1):\n k=bisect.bisect_left(nums,i)\n if(n-k==i):\n return i\n return -1","runtime":"42"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n counts = [0] * (max(nums) + 1)\n for val in nums:\n counts[val] += 1\n counts = list(accumulate(counts))\n for val in range(1, max(nums) + 1):\n if counts[-1] - counts[val - 1] == val:\n return val\n return -1","runtime":"42"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n\n for i in range(len(nums)):\n x = len(nums) - i\n if nums[i] >= x:\n if i == 0:\n return x\n else:\n if nums[i-1] < x:\n return x\n\n return -1","runtime":"43"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n len_arr = len(nums)\n ans=-1\n \n count_sort=[0]*(max(nums)+1)\n prefix_sum=[0]*(max(nums)+1)\n\n for val in nums:\n count_sort[val]+=1\n\n for i, num in reversed(list(enumerate(count_sort))):\n if i == (len(count_sort)-1):\n prefix_sum[i] = num\n else:\n prefix_sum[i] = prefix_sum[i+1] + num\n \n if prefix_sum[i] == i:\n ans = i\n\n return ans if ans > -1 else -1","runtime":"43"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","runtime":"44"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort(reverse=True)\n ans=-1\n for i in range(1,len(nums)+1):\n if(nums[i-1]>=i and (i == len(nums) or nums[i] < i)):\n ans=i\n return ans\n '''\n ans=-1\n for i in range(1,len(nums)+1):\n count=sum(1 for j in nums if j >= i) \n if(count>=i):\n ans=i\n return ans\n '''\n ","runtime":"45"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n n = len(nums)\n \n for x in range(n + 1):\n count = sum(1 for num in nums if num >= x)\n if count == x:\n return x\n \n return -1\n","runtime":"45"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n for i in range(len(nums) + 1):\n count = 0\n for j in nums:\n if j >= i:\n count+=1\n if count == i:\n return i\n return -1\n\n ","runtime":"46"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n # Step 1: Sort the array in descending order\n nums.sort(reverse=True)\n n = len(nums)\n \n # Step 2: Iterate over possible values of x\n for x in range(1, n + 1):\n print(nums,n,nums[x-1],x)\n # Check if the x-th largest element is >= x\n if nums[x - 1] >= x:\n # Step 3: If x is the last element or the next element is less than x\n # print(nums[x])\n if x == n or nums[x] < x:\n return x\n # Step 4: If no special number is found, return -1\n return -1\n\n # # Step 1: Sort the array in ascending order\n # nums.sort()\n \n # # Get the length of the array\n # n = len(nums)\n \n # # Step 2: Iterate over all possible values of x (from 0 to n)\n # for x in range(n + 1):\n # # Step 3: Check how many elements are greater than or equal to x\n # # We can do this by comparing x with the elements in the sorted array\n # # We know that if the length of nums is n, then the number of elements >= x \n # # is the portion of the array starting from the first element that is >= x.\n # greater_or_equal_count = 0\n \n # # Step 4: Count the number of elements >= x\n # # for num in nums:\n # # if num >= x:\n # # greater_or_equal_count += 1\n \n # for pos, num in enumerate(nums):\n # if num >= x:\n # greater_or_equal_count += len(nums[pos:])\n # break\n # # print(x, greater_or_equal_count)\n\n # # Step 5: If exactly x elements are greater than or equal to x, return x\n # if greater_or_equal_count == x:\n # return x\n \n # # Step 6: If no such x is found, return -1\n # return -1","runtime":"47"},{"code":"from typing import List\n\nclass Solution:\n def specialArray(self, nums: List[int]) -> int:\n for x in range(len(nums) + 1):\n if sum(num >= x for num in nums) == x:\n return x\n return -1\n","runtime":"48"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n count = defaultdict(int)\n\n for i in range(len(nums) + 1):\n for num in nums:\n if num >= i:\n count[i] += 1\n if count[i] == i:\n return i\n\n # for k, v in count.items():\n # if k == v:\n # return k\n\n return -1","runtime":"48"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n n = len(nums)\n \n for x in range(n + 1):\n count = sum(1 for num in nums if num >= x)\n if count == x:\n return x\n \n return -1\n","runtime":"49"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n \n nums.sort()\n n = len(nums)\n k = 0\n\n for i in range(n+1):\n cnt = 0\n for j in range(n):\n if nums[j] >= i:\n cnt += 1\n if i == cnt:\n return i\n return -1","runtime":"50"}],"string":"[\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n 0 4 3 0 4 - nums\\n 0 1 2 3 4 5 - index of new_arr\\n 2 0 0 1 2 0 - count \\n 3 2 0 - prefix_sum\\n \\\"\\\"\\\"\\n count = [0] * (len(nums) + 1)\\n for n in nums:\\n index = n if n < len(nums) else len(nums)\\n count[index] += 1\\n \\n total_right = 0\\n for i in range(len(count) - 1, -1, -1):\\n total_right += count[i]\\n if i == total_right:\\n return i\\n \\n return -1\\n \",\n \"runtime\": \"20\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n l, r = 0, len(nums)\\n\\n def check(num):\\n\\n res = 0\\n for n in nums:\\n if n >= num:\\n res += 1\\n return res\\n while l <= r:\\n m = (l + r) // 2\\n\\n count = check(m)\\n if count == m:\\n return m\\n if count > m:\\n l = m + 1\\n elif count < m:\\n r = m - 1\\n return -1\\n\\n \\n \\n\",\n \"runtime\": \"21\"\n },\n {\n \"code\": \"from typing import List\\n\\n\\nclass Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n count = [0] * (n + 1)\\n\\n for num in nums:\\n count[min(num, n)] += 1\\n\\n for i in range(n, 0, -1):\\n count[i - 1] += count[i]\\n if count[i] == i:\\n return i\\n\\n return -1\\n\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n count=Counter(nums)\\n res=[0]*(max(nums)+1)\\n \\n for i in nums:\\n res[i]+=1\\n \\n n=len(res)\\n x=n-1\\n ele=res[n-1]\\n \\n for i in range(len(res)-1,0,-1):\\n if ele==x:\\n return x\\n \\n x-=1\\n ele+=res[x]\\n \\n return -1\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n i = 0\\n prev = -1\\n total_right = len(nums)\\n while i < len(nums):\\n if (prev < total_right <= nums[i]):\\n return total_right\\n if nums[i] > len(nums):\\n break\\n while i+1 < len(nums) and nums[i] == nums[i+1]:\\n i+=1\\n prev = nums[i]\\n i+=1\\n total_right = len(nums)-i\\n return -1\\n\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n n = len(nums)\\n l, h = 1, n\\n while(l<=h):\\n mid = (l+h)//2\\n count = sum(1 for i in nums if(i>=mid))\\n\\n if(count==mid):\\n return mid\\n elif(count>mid):\\n l = mid+1\\n else:\\n h = mid - 1\\n return -1\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"import bisect\\nclass Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n sortedN = sorted(nums)\\n finalidx = 0\\n for i in range(1,len(sortedN)+1):\\n idx = bisect.bisect_left(sortedN, i)\\n if len(sortedN)-idx == i:\\n return i\\n \\n \\n return finalidx if finalidx > 0 else -1\\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n N = len(nums)\\n freq = [0] * (N+1)\\n \\n for num in nums:\\n freq[min(N, num)] += 1\\n \\n x = 0\\n for i in range(N, 0, -1):\\n x += freq[i]\\n if i == x:\\n return x\\n return -1\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def ele(self,nums,n):\\n st=0\\n en=len(nums)-1\\n while(st<=en):\\n m=st+(en-st)//2\\n if (nums[m]>=n):\\n en=m-1;\\n else:\\n st=m+1\\n return st\\n \\n def specialArray(self, nums: List[int]) -> int:\\n s=sorted(nums)\\n l=len(nums)\\n for i in range(l+1):\\n n=self.ele(s,i)\\n c=l-n\\n if (c==i):\\n return c \\n return -1\\n \\n \\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n counts = Counter(nums)\\n total = len(nums)\\n\\n # Keep track of nums smaller and larger than x.\\n remain = total\\n x = 0\\n for num in sorted(counts.keys()):\\n\\n # Try each x up to num.x\\n while x <= num:\\n if x == remain:\\n return remain\\n x += 1\\n\\n # Disregard values smaller than x.\\n remain -= counts[num]\\n return -1\\n\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n nums.sort(reverse = True)\\n\\n if nums[-1] >= n:\\n return n\\n \\n if nums[0] == 0 or (nums[0] == 1 and n > 1):\\n return -1\\n\\n for i in range(1, n):\\n if nums[i] < i and nums[i-1] >= i:\\n return i\\n\\n return -1\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n for i in range(len(nums)):\\n c=0\\n for j in nums:\\n if i+1<=j:\\n c+=1\\n if c==i+1:\\n return i+1\\n return -1\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n # Time: O(n2)\\n # Memory: O(1)\\n # val = 1\\n # i = 0\\n # while i < len(nums):\\n # count = 0\\n # for j in range(len(nums)):\\n # if nums[j] >= val:\\n # count+= 1\\n \\n # if count == val:\\n # return val\\n # else:\\n # val+= 1\\n # i+= 1\\n # return -1\\n \\n\\n # [0,0,3,3,4,4,5] len = 5\\n # Time: O(nlogn)\\n # Memory: O(1)\\n nums.sort()\\n print(nums)\\n i = 0\\n total_right = len(nums)\\n prev = -1\\n while i < len(nums):\\n if nums[i] == total_right or (prev < total_right < nums[i]):\\n return total_right\\n\\n while i+1 < len(nums) and nums[i] == nums[i+1]:\\n i+= 1\\n \\n prev = nums[i]\\n i+= 1\\n total_right = len(nums) - i\\n \\n return -1\",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n # Step 1: Sort the array in ascending order\\n nums.sort()\\n \\n # Get the length of the array\\n n = len(nums)\\n \\n # Step 2: Iterate over all possible values of x (from 0 to n)\\n for x in range(n + 1):\\n # Step 3: Check how many elements are greater than or equal to x\\n # We can do this by comparing x with the elements in the sorted array\\n # We know that if the length of nums is n, then the number of elements >= x \\n # is the portion of the array starting from the first element that is >= x.\\n greater_or_equal_count = 0\\n \\n # Step 4: Count the number of elements >= x\\n # for num in nums:\\n # if num >= x:\\n # greater_or_equal_count += 1\\n \\n for pos, num in enumerate(nums):\\n if num >= x:\\n greater_or_equal_count += len(nums[pos:])\\n break\\n # print(x, greater_or_equal_count)\\n\\n # Step 5: If exactly x elements are greater than or equal to x, return x\\n if greater_or_equal_count == x:\\n return x\\n \\n # Step 6: If no such x is found, return -1\\n return -1\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def get_first_greater_or_equal(self, nums, val):\\n start = 0\\n end = len(nums) - 1\\n\\n index = len(nums)\\n while start <= end:\\n mid = (start + end) // 2\\n\\n if nums[mid] >= val:\\n index = mid\\n end = mid - 1\\n else:\\n start = mid + 1\\n\\n return index\\n \\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n \\n N = len(nums)\\n for i in range(1, N + 1):\\n k = self.get_first_greater_or_equal(nums, i)\\n \\n if N - k == i:\\n return i\\n \\n return -1\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n x = n\\n while x > 0:\\n count = 0\\n for num in nums:\\n if num >= x:\\n count += 1\\n if count == x:\\n return x\\n x -= 1\\n return -1 \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def howmany(self, nums, test):\\n a = 0\\n for num in nums:\\n if num >= test: a += 1\\n return a\\n def specialArray(self, nums: List[int]) -> int:\\n lenght = len(nums)\\n while lenght > 0:\\n if self.howmany(nums, lenght) == lenght: return lenght\\n lenght -= 1\\n return -1\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = -1\\n for i, n in enumerate(nums):\\n if n == prev:\\n continue\\n if prev < len(nums) - i <= n:\\n return len(nums) - i\\n prev = n\\n return -1\\n \\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = -1\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n # l = 0\\n # r = max(nums)\\n # while l<=r:\\n # m = (l+r)//2\\n # cnt = 0\\n # for num in nums:\\n # if m<=num:\\n # cnt+=1 \\n # if cnt==m:\\n # return cnt\\n # elif cnt>m:\\n # l = m+1\\n # else:\\n # r= m-1\\n # return -1\\n\\n\\n \\n for i in range(1,max(nums)+1):\\n cnt = 0\\n for num in nums:\\n if i<=num:\\n cnt+=1\\n if i == cnt:\\n return i\\n return -1\\n\\n # l = 0\\n # r = len(nums)\\n # while l<=r:\\n # mid = (l+r)//2\\n # cnt = 0\\n # for num in nums:\\n # if num>=mid:\\n # cnt+=1\\n # if mid == cnt:\\n # return mid\\n # elif cnt>mid:\\n # l = mid+1\\n # else:\\n # l = mid-1\\n # return -1\\n\\n\\n # k = -1\\n # while k <= len(nums):\\n # count = 0\\n # for i in nums:\\n # if i >= k:\\n # count += 1\\n # if k == count:\\n # return k\\n # k += 1\\n # return -1\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n n = len(nums)\\n\\n def binary_insert(left, right, x):\\n while left <= right:\\n mid = (left + right) // 2\\n if nums[mid] < x:\\n left = mid + 1\\n else:\\n right = mid - 1\\n return left\\n\\n\\n\\n for x in range(0, n + 1):\\n if n - binary_insert(0, n - 1, x) == x:\\n return x\\n \\n return -1\\n\\n \",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n # 0 <= n\\n n = len(nums)\\n nums.sort()\\n for i in range(1, n+1):\\n j = -i\\n if nums[j] >= i and (nums[j-1] < i if j-1 >= -n else True):\\n return i\\n return -1\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n for i in range(n + 1):\\n total = 0\\n for num in nums:\\n if num >= i:\\n total += 1\\n if total == i:\\n return total\\n return -1\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n if nums[0] >= len(nums):\\n return len(nums)\\n for i in range(1, len(nums)):\\n if nums[i-1] < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n\\n n = len(nums)\\n\\n for idx, num in enumerate(nums):\\n counts = n - idx\\n\\n prev = 0 if idx == 0 else nums[idx - 1]\\n \\n if prev < counts <= num:\\n return counts\\n\\n return -1\\n\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"import bisect\\n\\nclass Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums=sorted(nums)\\n n=len(nums)\\n for i in range(n,0,-1):\\n k=bisect.bisect_left(nums,i)\\n if(n-k==i):\\n return i\\n return -1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n counts = [0] * (max(nums) + 1)\\n for val in nums:\\n counts[val] += 1\\n counts = list(accumulate(counts))\\n for val in range(1, max(nums) + 1):\\n if counts[-1] - counts[val - 1] == val:\\n return val\\n return -1\",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n\\n for i in range(len(nums)):\\n x = len(nums) - i\\n if nums[i] >= x:\\n if i == 0:\\n return x\\n else:\\n if nums[i-1] < x:\\n return x\\n\\n return -1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n len_arr = len(nums)\\n ans=-1\\n \\n count_sort=[0]*(max(nums)+1)\\n prefix_sum=[0]*(max(nums)+1)\\n\\n for val in nums:\\n count_sort[val]+=1\\n\\n for i, num in reversed(list(enumerate(count_sort))):\\n if i == (len(count_sort)-1):\\n prefix_sum[i] = num\\n else:\\n prefix_sum[i] = prefix_sum[i+1] + num\\n \\n if prefix_sum[i] == i:\\n ans = i\\n\\n return ans if ans > -1 else -1\",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort(reverse=True)\\n ans=-1\\n for i in range(1,len(nums)+1):\\n if(nums[i-1]>=i and (i == len(nums) or nums[i] < i)):\\n ans=i\\n return ans\\n '''\\n ans=-1\\n for i in range(1,len(nums)+1):\\n count=sum(1 for j in nums if j >= i) \\n if(count>=i):\\n ans=i\\n return ans\\n '''\\n \",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n n = len(nums)\\n \\n for x in range(n + 1):\\n count = sum(1 for num in nums if num >= x)\\n if count == x:\\n return x\\n \\n return -1\\n\",\n \"runtime\": \"45\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n for i in range(len(nums) + 1):\\n count = 0\\n for j in nums:\\n if j >= i:\\n count+=1\\n if count == i:\\n return i\\n return -1\\n\\n \",\n \"runtime\": \"46\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n # Step 1: Sort the array in descending order\\n nums.sort(reverse=True)\\n n = len(nums)\\n \\n # Step 2: Iterate over possible values of x\\n for x in range(1, n + 1):\\n print(nums,n,nums[x-1],x)\\n # Check if the x-th largest element is >= x\\n if nums[x - 1] >= x:\\n # Step 3: If x is the last element or the next element is less than x\\n # print(nums[x])\\n if x == n or nums[x] < x:\\n return x\\n # Step 4: If no special number is found, return -1\\n return -1\\n\\n # # Step 1: Sort the array in ascending order\\n # nums.sort()\\n \\n # # Get the length of the array\\n # n = len(nums)\\n \\n # # Step 2: Iterate over all possible values of x (from 0 to n)\\n # for x in range(n + 1):\\n # # Step 3: Check how many elements are greater than or equal to x\\n # # We can do this by comparing x with the elements in the sorted array\\n # # We know that if the length of nums is n, then the number of elements >= x \\n # # is the portion of the array starting from the first element that is >= x.\\n # greater_or_equal_count = 0\\n \\n # # Step 4: Count the number of elements >= x\\n # # for num in nums:\\n # # if num >= x:\\n # # greater_or_equal_count += 1\\n \\n # for pos, num in enumerate(nums):\\n # if num >= x:\\n # greater_or_equal_count += len(nums[pos:])\\n # break\\n # # print(x, greater_or_equal_count)\\n\\n # # Step 5: If exactly x elements are greater than or equal to x, return x\\n # if greater_or_equal_count == x:\\n # return x\\n \\n # # Step 6: If no such x is found, return -1\\n # return -1\",\n \"runtime\": \"47\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n for x in range(len(nums) + 1):\\n if sum(num >= x for num in nums) == x:\\n return x\\n return -1\\n\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n count = defaultdict(int)\\n\\n for i in range(len(nums) + 1):\\n for num in nums:\\n if num >= i:\\n count[i] += 1\\n if count[i] == i:\\n return i\\n\\n # for k, v in count.items():\\n # if k == v:\\n # return k\\n\\n return -1\",\n \"runtime\": \"48\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n n = len(nums)\\n \\n for x in range(n + 1):\\n count = sum(1 for num in nums if num >= x)\\n if count == x:\\n return x\\n \\n return -1\\n\",\n \"runtime\": \"49\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n \\n nums.sort()\\n n = len(nums)\\n k = 0\\n\\n for i in range(n+1):\\n cnt = 0\\n for j in range(n):\\n if nums[j] >= i:\\n cnt += 1\\n if i == cnt:\\n return i\\n return -1\",\n \"runtime\": \"50\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":42,"string":"42"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort(reverse=True)\n n = len(nums)\n \n for x in range(n + 1):\n count = 0\n for num in nums:\n if num >= x:\n count += 1\n else:\n break\n if count == x:\n return x\n \n return -1","memory":"16200"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n \n for i in range(1, len(nums) + 1):\n num_greater = len([x for x in nums if x >= i])\n if num_greater == i:\n return i\n \n return -1","memory":"16300"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n prev = float(\"-inf\")\n for i in range(len(nums)):\n if prev < len(nums)-i <= nums[i]:\n return len(nums)-i\n prev = nums[i]\n # 0 3 6 7 7\n return -1","memory":"16400"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n n = len(nums)\n for i in range(n + 1):\n total = 0\n for num in nums:\n if num >= i:\n total += 1\n if total == i:\n return total\n return -1","memory":"16400"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n\n n = len(nums)\n\n for idx, num in enumerate(nums):\n counts = n - idx\n\n prev = 0 if idx == 0 else nums[idx - 1]\n \n if prev < counts <= num:\n return counts\n\n return -1\n","memory":"16500"},{"code":"class Solution:\n def specialArray(self, nums: List[int]) -> int:\n nums.sort()\n if nums[0] >= len(nums):\n return len(nums)\n for i in range(1, len(nums)):\n if nums[i-1] < len(nums)-i <= nums[i]:\n return len(nums)-i\n # 0 3 6 7 7\n return -1","memory":"16500"}],"string":"[\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort(reverse=True)\\n n = len(nums)\\n \\n for x in range(n + 1):\\n count = 0\\n for num in nums:\\n if num >= x:\\n count += 1\\n else:\\n break\\n if count == x:\\n return x\\n \\n return -1\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n \\n for i in range(1, len(nums) + 1):\\n num_greater = len([x for x in nums if x >= i])\\n if num_greater == i:\\n return i\\n \\n return -1\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n prev = float(\\\"-inf\\\")\\n for i in range(len(nums)):\\n if prev < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n prev = nums[i]\\n # 0 3 6 7 7\\n return -1\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n n = len(nums)\\n for i in range(n + 1):\\n total = 0\\n for num in nums:\\n if num >= i:\\n total += 1\\n if total == i:\\n return total\\n return -1\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n\\n n = len(nums)\\n\\n for idx, num in enumerate(nums):\\n counts = n - idx\\n\\n prev = 0 if idx == 0 else nums[idx - 1]\\n \\n if prev < counts <= num:\\n return counts\\n\\n return -1\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def specialArray(self, nums: List[int]) -> int:\\n nums.sort()\\n if nums[0] >= len(nums):\\n return len(nums)\\n for i in range(1, len(nums)):\\n if nums[i-1] < len(nums)-i <= nums[i]:\\n return len(nums)-i\\n # 0 3 6 7 7\\n return -1\",\n \"memory\": \"16500\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":6,"string":"6"}}},{"rowIdx":2472,"cells":{"question_id":{"kind":"number","value":1400,"string":"1,400"},"name":{"kind":"string","value":"find-winner-on-a-tic-tac-toe-game"},"content":{"kind":"string","value":"<p><strong>Tic-tac-toe</strong> is played by two players <code>A</code> and <code>B</code> on a <code>3 x 3</code> grid. The rules of Tic-Tac-Toe are:</p>\n\n<ul>\n\t<li>Players take turns placing characters into empty squares <code>' '</code>.</li>\n\t<li>The first player <code>A</code> always places <code>'X'</code> characters, while the second player <code>B</code> always places <code>'O'</code> characters.</li>\n\t<li><code>'X'</code> and <code>'O'</code> characters are always placed into empty squares, never on filled ones.</li>\n\t<li>The game ends when there are <strong>three</strong> of the same (non-empty) character filling any row, column, or diagonal.</li>\n\t<li>The game also ends if all squares are non-empty.</li>\n\t<li>No more moves can be played if the game is over.</li>\n</ul>\n\n<p>Given a 2D integer array <code>moves</code> where <code>moves[i] = [row<sub>i</sub>, col<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> move will be played on <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code>. return <em>the winner of the game if it exists</em> (<code>A</code> or <code>B</code>). In case the game ends in a draw return <code>"Draw"</code>. If there are still movements to play return <code>"Pending"</code>.</p>\n\n<p>You can assume that <code>moves</code> is valid (i.e., it follows the rules of <strong>Tic-Tac-Toe</strong>), the grid is initially empty, and <code>A</code> will play first.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/09/22/xo1-grid.jpg\" style=\"width: 244px; height: 245px;\" />\n<pre>\n<strong>Input:</strong> moves = [[0,0],[2,0],[1,1],[2,1],[2,2]]\n<strong>Output:</strong> "A"\n<strong>Explanation:</strong> A wins, they always play first.\n</pre>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/09/22/xo2-grid.jpg\" style=\"width: 244px; height: 245px;\" />\n<pre>\n<strong>Input:</strong> moves = [[0,0],[1,1],[0,1],[0,2],[1,0],[2,0]]\n<strong>Output:</strong> "B"\n<strong>Explanation:</strong> B wins.\n</pre>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2021/09/22/xo3-grid.jpg\" style=\"width: 244px; height: 245px;\" />\n<pre>\n<strong>Input:</strong> moves = [[0,0],[1,1],[2,0],[1,0],[1,2],[2,1],[0,1],[0,2],[2,2]]\n<strong>Output:</strong> "Draw"\n<strong>Explanation:</strong> The game ends in a draw since there are no moves to make.\n</pre>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= moves.length <= 9</code></li>\n\t<li><code>moves[i].length == 2</code></li>\n\t<li><code>0 <= row<sub>i</sub>, col<sub>i</sub> <= 2</code></li>\n\t<li>There are no repeated elements on <code>moves</code>.</li>\n\t<li><code>moves</code> follow the rules of tic tac toe.</li>\n</ul>\n"},"acRate":{"kind":"number","value":53.961911239585106,"string":"53.961911"},"difficulty":{"kind":"string","value":"Easy"},"topics":{"kind":"list like","value":["array","hash-table","matrix","simulation"],"string":"[\n \"array\",\n \"hash-table\",\n \"matrix\",\n \"simulation\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"19\", 0.0695], [\"21\", 0.0695], [\"22\", 0.2085], [\"23\", 0.417], [\"24\", 0.278], [\"25\", 0.4864], [\"26\", 0.6949], [\"27\", 1.8763], [\"28\", 1.8068], [\"29\", 1.3899], [\"30\", 1.3204], [\"31\", 4.795], [\"32\", 4.1001], [\"33\", 4.517], [\"34\", 4.656], [\"35\", 6.6713], [\"36\", 7.8527], [\"37\", 6.8798], [\"38\", 6.1154], [\"39\", 8.4781], [\"40\", 8.4086], [\"41\", 6.4628], [\"42\", 4.7255], [\"43\", 5.0035], [\"44\", 4.378], [\"45\", 2.4322]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16000\", 0.0695], [\"16100\", 0.0695], [\"16200\", 0.0695], [\"16300\", 0.9034], [\"16400\", 10.7714], [\"16500\", 25.8513], [\"16600\", 39.2634]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # Approach 2024.09.19\n cache = defaultdict(int)\n for i, pt in enumerate(moves):\n r_key = f\"{i%2}_p_{pt[0]}\"\n c_key = f\"{i%2}_c_{pt[1]}\"\n pd_key = f\"{i%2}_pd_{pt[0] + pt[1]}\"\n nd_key = f\"{i%2}_nd_{pt[0] - pt[1]}\"\n cache[r_key] += 1\n cache[c_key] += 1\n cache[pd_key] += 1\n cache[nd_key] += 1\n\n if cache[r_key] == 3 or cache[c_key] == 3 or \\\n cache[pd_key] == 3 or cache[nd_key] == 3:\n if i%2 == 0:\n return \"A\"\n else:\n return \"B\"\n \n if len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"","runtime":"22"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n A=[0]*8\n B=[0]*8\n for i in range(len(moves)):\n r,c=moves[i]\n player = A if i%2==0 else B\n player[r] += 1\n player[c+3] += 1\n if r==c:\n player[6] += 1\n if r==2-c:\n player[7] += 1\n for i in range(8):\n if A[i]==3:\n return \"A\"\n if B[i]==3:\n return \"B\"\n \n return \"Draw\" if len(moves) == 9 else \"Pending\"","runtime":"23"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n rows = [0] * 3\n cols = [0] * 3\n diagonal45, diagonal135 = 0, 0\n\n player = 1 # A\n for move in moves:\n x, y = move[0], move[1]\n rows[x] += player\n cols[y] += player\n\n if x == y:\n diagonal135 += player\n if x + y == 2:\n diagonal45 += player\n \n if abs(rows[x]) == 3 or abs(cols[y]) == 3 or abs(diagonal45) == 3 or abs(diagonal135) == 3:\n return \"A\" if player == 1 else \"B\"\n \n player *= -1\n \n return \"Pending\" if len(moves) < 9 else \"Draw\"\n\n","runtime":"24"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n rows = [0] * 3\n cols = [0] * 3\n diag = 0\n antidiag = 0\n player = -1\n for r, c in moves:\n player = -1 * player\n if r == c:\n diag += player\n if r + c == 2:\n antidiag += player\n rows[r] += player\n cols[c] += player\n if (abs(diag) == 3 or abs(antidiag) == 3 or abs(rows[r]) == 3 or abs(cols[c]) == 3):\n if player == 1:\n return \"A\"\n else:\n return \"B\"\n if len(moves) == 9:\n return \"Draw\"\n return \"Pending\"\n\n\n # Brute Force\n # matrix = [[0]*3 for i in range(3)]\n # def checkSequence():\n # if (\n # (matrix[0][0] == matrix[0][1] == matrix[0][2] != 0) or\n # (matrix[1][0] == matrix[1][1] == matrix[1][2] != 0) or\n # (matrix[2][0] == matrix[2][1] == matrix[2][2] != 0) or\n\n # (matrix[0][0] == matrix[1][0] == matrix[2][0] != 0) or\n # (matrix[0][1] == matrix[1][1] == matrix[2][1] != 0) or\n # (matrix[0][2] == matrix[1][2] == matrix[2][2] != 0) or\n\n # (matrix[0][0] == matrix[1][1] == matrix[2][2] != 0) or\n # (matrix[2][0] == matrix[1][1] == matrix[0][2] != 0)\n # ):\n # return True\n # else:\n # return False\n \n # player = -1\n # for move in moves:\n # player = -1 * player\n # x, y = move\n # matrix[x][y] = player\n # if checkSequence():\n # if player == 1:\n # return \"A\"\n # else:\n # return \"B\"\n # if len(moves) == 9:\n # return \"Draw\"\n # return \"Pending\" \n\n \n \n ","runtime":"25"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n board = [[\"-1\"] * 3 for _ in range(3)]\n\n count = 0\n for move in moves:\n if count % 2 == 0:\n board[move[0]][move[1]] = \"A\"\n else:\n board[move[0]][move[1]] = \"B\"\n count += 1\n\n for i in range(3):\n if board[i][0] == board[i][1] == board[i][2] and board[i][0] != \"-1\": # check col\n return board[i][0]\n if board[0][i] == board[1][i] == board[2][i] and board[0][i] != \"-1\": # check row\n return board[0][i] \n \n if board[0][0] == board[1][1] == board[2][2] and board[0][0] != \"-1\" and board[1][1] != \"-1\" and board[2][2] != \"-1\":\n return board[0][0]\n \n if board[0][2] == board[1][1] == board[2][0] and board[0][2] != \"-1\" and board[1][1] != \"-1\" and board[2][0] != \"-1\":\n return board[0][2]\n\n return \"Draw\" if count == 9 else \"Pending\"\n","runtime":"26"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n = len(moves)\n matrix = [[0] * 3 for _ in range(3)]\n \n def isvalid(directions):\n hash_map = Counter(directions)\n del hash_map[0]\n for key, count in hash_map.items():\n if count == 3:\n return key\n \n for i in range(n):\n if i % 2 == 0:\n row, col = moves[i]\n matrix[row][col] = 'A'\n else:\n row, col = moves[i]\n matrix[row][col] = 'B'\n\n ############ Row #####################\n\n for row in matrix:\n row_map = Counter(row)\n del row_map[0]\n for key, count in row_map.items():\n if count == 3:\n return key\n\n ########### Column #######################\n\n for j in range(len(matrix)):\n columns = [row[j] for row in matrix]\n col_map = Counter(columns)\n del col_map[0]\n for key, count in col_map.items():\n if count == 3:\n return key\n\n ########### diagonal #######################\n \n diagonal,anti_diagonal = [], []\n for i in range(len(matrix)):\n for j in range(len(matrix)):\n if i - j == 0:\n diagonal.append(matrix[i][j])\n if i + j == 2:\n anti_diagonal.append(matrix[i][j])\n\n diagonal_map = Counter(diagonal)\n del diagonal_map[0]\n for key, count in diagonal_map.items():\n if count == 3:\n return key\n\n anti_diagonal_map = Counter(anti_diagonal)\n del anti_diagonal_map[0]\n for key, count in anti_diagonal_map.items():\n if count == 3:\n return key\n\n \n return \"Draw\" if len(moves) == 9 else'Pending'\n'''class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n ar = self.sameRowCol(a, 0)\n if ar[0] == 100:\n return \"A\"\n elif len(ar) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n \n ac = self.sameRowCol(a, 1)\n if ac[0] == 100:\n return \"A\"\n elif len(ac) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n br = self.sameRowCol(b, 0)\n if br[0] == 100:\n return \"B\"\n elif len(br) == 2:\n if self.occupied(a, br) == False and len(b) <= len(a):\n return \"B\"\n bc = self.sameRowCol(b, 1)\n if bc[0] == 100:\n return \"B\"\n elif len(bc) == 2:\n if self.occupied(a, bc) == False and len(b) <= len(a):\n return \"B\"\n \n if len(a)+len(b) <=6:\n return \"Pending\"\n return \"Draw\"\n \n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\n found = False\n for r in route:\n if r[0] == target[0] and r[1] == target[1]:\n found = True\n break\n return found\n \n def diagnol(self, route: List[List[int]])->List[int]:\n dic = {}\n for r in route:\n if r[0] in dic:\n dic[r[0]].append(r[1])\n else:\n dic[r[0]] = []\n dic[r[0]].append(r[1])\n \n cnt1, cnt2 = 0, 0\n for i in range(0, 3):\n for j in dic[i]:\n if dic[i] == j:\n cnt1 = cnt1+1\n if dic[i]+j == 2:\n cnt2 = cnt2+1\n r = []\n if cnt1 == 3 or cnt2 == 3:\n r.append(100)\n return r\n \n l = []\n if cnt1 == 2:\n if 1 not in dic:\n r.append(1)\n r.append(1)\n return r\n else:\n found = False\n for j in dic[1]:\n if j == 1:\n found = True\n break\n if found:\n if 0 not in dic:\n r.append(0)\n r.append(0)\n return r\n else:\n if 2 not in dic:\n r.append(2)\n r.append(2)\n return r\n else:\n \n \n \n \n \n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\n dic = {}\n idx2 = 0\n if idx == 0:\n idx2=1\n for mv in route:\n if mv[idx] in dic:\n dic[mv[idx]].append(mv[idx2])\n else:\n dic[mv[idx]] = []\n dic[mv[idx]].append(mv[idx2])\n \n for k in dic:\n if len(dic[k]) >= 3:\n r = []\n r.append(100)\n return r\n elif len(dic[k]) == 2:\n s = set(dic[k])\n for i in range(0, 3):\n if i not in s:\n r=[]\n r.append(k)\n r.append(i)\n return r\n r=[]\n r.append(-1)\n return r'''\n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n a_row_total, a_col_total = 0, 0 \n for mv in a:\n a_row_total = a_row_total+mv[0]\n a_col_total = a_col_total+mv[1]\n if a_row_total == 3 or a_col_total ==3:\n return \"A\"\n \n b_row_total, b_col_total = 0, 0 \n for mv in b:\n b_row_total = b_row_total+mv[0]\n b_col_total = b_col_total+mv[1]\n if b_row_total == 3 or b_col_total ==3:\n return \"B\"\n \n if len(a) < 3 or len(b) < 3:\n return \"Pending\"\n return \"Draw\"'''\n \n \n \n \n \n \n \n \n \n \n \n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = {}, {}\n \n for i in range(0, len(moves)):\n if i % 2 ==0:\n if moves[i][0] in a:\n a[moves[i][0]].append(moves[i][1])\n else:\n a[moves[i][0]] = []\n a[moves[i][0]].append(moves[i][1])\n else:\n if moves[i][0] in b:\n b[moves[i][0]].append(moves[i][1])\n else:\n b[moves[i][0]] = []\n b[moves[i][0]].append(moves[i][1])\n print(a, b)\n if len(a) >= 3:\n Awin = True\n for i in range(0, 3):\n if a[i][0] != i:\n Awin = False\n #print(Awin)\n if Awin:\n return \"A\"\n \n if len(b) >= 3:\n Awin = True\n for i in range(0, 3):\n if b[i][0] != i:\n Awin = False\n if Awin:\n return \"B\"\n \n for k in range(0, 3):\n if k in a:\n if len(a[k]) >= 3:\n return \"A\"\n if k in b:\n if len(b[k]) >= 3:\n return \"B\"\n \n return \"Draw\"'''\n \n \n \n ","runtime":"27"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # if a player has 3 or more plays:\n # 1. diagonal = columns are monotonic, rows are monotonic\n # [0,0] [1,1] [2,2]\n # [0,2] [1,1] [2,0]\n\n # 2. horizontal = columns are monotonic, rows are all equal\n # [0,0][0,1][0,2]\n # [0,2][0,1][0,0]\n\n # 3. vertical = rows are monotonic, columns are all equal\n # [0,0][1,0][2,0]\n # [2,2][1,2][0,2]\n\n \n board = [[None for _ in range(3)] for _ in range(3)]\n for i, move in enumerate(moves):\n row, col = move[0], move[1]\n board[row][col] = \"A\" if i % 2 == 0 else \"B\"\n\n row = col = 0\n\n # Check each value of board\n for row in range(len(board)):\n for col in range(len(board[0])):\n if board[row][col]:\n symbol = board[row][col]\n\n if row == 0 and board[row + 1][col] == symbol and board[row + 2][col] == symbol: # Vertical win\n return f\"{symbol}\"\n\n if col == 0 and board[row][col + 1] == symbol and board[row][col + 2] == symbol: # Horizontal win\n return f\"{symbol}\"\n\n if row == 0 and col == 0 and board[row + 1][col + 1] == symbol and board[row + 2][col + 2] == symbol: # Diagonal win\n return f\"{symbol}\"\n\n if row == 0 and col == 2 and board[row + 1][col - 1] == symbol and board[row + 2][col - 2] == symbol: # Anti-diagonal win\n return f\"{symbol}\"\n\n for row in board:\n print(row)\n\n if len(moves) == 9:\n return \"Draw\"\n\n return \"Pending\"\n\n\n\n \n","runtime":"28"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n\n \n winning_combination1 = [[0,0], [1,1], [2,2]]\n winning_combination2 = [[1,1], [0,2], [2,0]]\n\n a_board = []\n b_board = []\n a = True\n b = False\n\n for move in moves:\n if a:\n a_board.append(move)\n a = False\n b = True\n else:\n b_board.append(move)\n b = False\n a = True\n \n if all(x in a_board for x in winning_combination1):\n return 'A'\n if all(x in a_board for x in winning_combination2):\n return 'A'\n\n if all(x in b_board for x in winning_combination1):\n return 'B'\n if all(x in b_board for x in winning_combination2):\n return 'B'\n\n for move in a_board:\n row = move[0]\n col = move[1]\n if [row, col -1] in a_board and [row, col + 1] in a_board:\n return 'A'\n if [row -1, col] in a_board and [row + 1, col] in a_board:\n return 'A'\n\n for move in b_board:\n row = move[0]\n col = move[1]\n if [row, col -1] in b_board and [row, col + 1] in b_board:\n return 'B'\n if [row -1, col] in b_board and [row + 1, col] in b_board:\n return 'B'\n\n if len(moves) < 9:\n return 'Pending'\n return 'Draw'","runtime":"29"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # We could a count for each of the 8 lines\n # We can increment or decrement the count each time they play on it\n # If one of the counts hits 3 or -3 return the respective player's name\n rows = [0,0,0]\n cols = [0,0,0]\n diag = 0\n diag2 = 0\n\n for i, move in enumerate(moves):\n inc = 1 if i%2==0 else -1\n rows[move[0]] += inc\n cols[move[1]] += inc\n \n if move == [0,0] or move==[2,2]:\n diag += inc\n elif move == [2,0] or move == [0,2]:\n diag2 += inc\n if move == [1,1]:\n diag += inc\n diag2 += inc\n if 3 in rows or 3 in cols or diag==3 or diag2==3: return 'A'\n if -3 in rows or -3 in cols or diag==-3 or diag2==-3: return 'B'\n \n return \"Draw\" if len(moves)==9 else \"Pending\"","runtime":"29"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n A = [0]*8\n B = [0]*8\n # No one can win with less then 5 total moves\n num_moves = len(moves)\n for i in range(num_moves):\n row, col = moves[i]\n current_player = A if i % 2 == 0 else B\n # Increment the count for this row\n current_player[row] += 1\n # Increment the count for this column\n current_player[col + 3] += 1\n if row == col:\n current_player[6] += 1\n if row == 2 - col:\n current_player[7] += 1\n\n for i in range(8):\n if A[i] == 3:\n return \"A\"\n if B[i] == 3:\n return \"B\"\n return \"Draw\" if num_moves == 9 else \"Pending\"","runtime":"30"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n=3\n rows=[0]* n\n cols=[0]*n\n sign=0\n diag=revdiag=0\n for i,move in enumerate(moves):\n r,c=move\n sign=1 if i%2==0 else -1\n rows[r]+=sign\n cols[c]+=sign\n if r==c:\n diag+=sign\n if r+c == n-1:\n revdiag+=sign\n if abs(diag) == n or abs(revdiag)==n or abs(rows[r]) ==n or abs(cols[c]) == n:\n return \"A\" if sign ==1 else \"B\"\n return \"Draw\" if len(moves) == (n*n) else \"Pending\" \n\n\n\n\n\n\n\n\n\n ","runtime":"31"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # Step 1: Initialize a 3x3 grid\n grid = [[\"\"] * 3 for _ in range(3)]\n\n # Step 2: Alternate between Player A ('X') and Player B ('O')\n for i, move in enumerate(moves):\n row, col = move\n if i % 2 == 0:\n grid[row][col] = 'X' # Player A's move\n else:\n grid[row][col] = 'O' # Player B's move\n\n # Step 3: Check for a winner after every move\n if self.checkWinner(grid, row, col):\n return 'A' if grid[row][col] == 'X' else 'B'\n \n # Step 4: If all moves are made and no winner, check if it's a draw or pending\n return \"Draw\" if len(moves) == 9 else \"Pending\"\n \n # Step 5: Function to check if there's a winner\n def checkWinner(self, grid, row, col):\n n = 3\n player = grid[row][col]\n\n # Check the row\n if all(grid[row][c] == player for c in range(n)):\n return True\n \n # Check the column\n if all(grid[r][col] == player for r in range(n)):\n return True\n \n # Check the main diagonal\n if row == col and all(grid[r][r] == player for r in range(n)):\n return True\n \n # Check the anti-diagonal\n if row + col == n - 1 and all(grid[r][n-1-r] == player for r in range(n)):\n return True\n \n return False\n","runtime":"32"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n A=[0]*8\n B=[0]*8\n\n for i in range(len(moves)):\n r,c = moves[i]\n player = A if i %2 == 0 else B\n player[r] += 1\n player[c+3] += 1\n\n if r==c:\n player[6] +=1\n # should be an if because we need to update both side of the diagonals for (1,1)\n if r==2-c:\n player[7] +=1\n for i in range(len(A)):\n if A[i] == 3:\n return \"A\"\n elif B[i] == 3:\n return \"B\"\n print(A,B)\n return \"Draw\" if len(moves) == 9 else \"Pending\"\n\n\n\n","runtime":"32"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n = len(moves)\n matrix = [[0] * 3 for _ in range(3)]\n \n def isvalid(directions):\n hash_map = Counter(directions)\n del hash_map[0]\n for key, count in hash_map.items():\n if count == 3:\n return key\n \n for i in range(n):\n if i % 2 == 0:\n row, col = moves[i]\n matrix[row][col] = 'A'\n else:\n row, col = moves[i]\n matrix[row][col] = 'B'\n\n for row in matrix:\n row_map = Counter(row)\n del row_map[0]\n for key, count in row_map.items():\n if count == 3:\n return key\n\n for j in range(len(matrix)):\n columns = [row[j] for row in matrix]\n col_map = Counter(columns)\n del col_map[0]\n for key, count in col_map.items():\n if count == 3:\n return key\n\n ########### diagonal #######################\n \n diagonal,anti_diagonal = [], []\n for i in range(len(matrix)):\n for j in range(len(matrix)):\n if i - j == 0:\n diagonal.append(matrix[i][j])\n if i + j == 2:\n anti_diagonal.append(matrix[i][j])\n\n diagonal_map = Counter(diagonal)\n del diagonal_map[0]\n for key, count in diagonal_map.items():\n if count == 3:\n return key\n\n anti_diagonal_map = Counter(anti_diagonal)\n del anti_diagonal_map[0]\n for key, count in anti_diagonal_map.items():\n if count == 3:\n return key\n\n \n return \"Draw\" if len(moves) == 9 else 'Pending'","runtime":"33"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # Initialize the board\n board = [[0 for j in range(3)] for i in range(3)]\n\n player = 1 # 1 for Player A, -1 for Player B\n count = 0 # To keep track of the number of moves\n\n # Place each move on the board\n for row, col in moves:\n board[row][col] = player # Place player's mark\n count += 1\n player *= -1 # Alternate the player\n\n # Check rows and columns for a win\n for i in range(3):\n # Check the ith row\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\n return \"A\" if board[i][0] == 1 else \"B\"\n # Check the ith column\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\n return \"A\" if board[0][i] == 1 else \"B\"\n\n # Check the main diagonal\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\n return \"A\" if board[0][0] == 1 else \"B\"\n\n # Check the anti-diagonal\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\n return \"A\" if board[0][2] == 1 else \"B\"\n\n # If all moves are made and no winner, return \"Draw\"\n return \"Draw\" if count == 9 else \"Pending\"\n","runtime":"33"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n = 3\n rows, cols = [0]*n, [0]*n\n diag = anti = 0\n player = 1\n for row, col in moves:\n rows[row] += player\n cols[col] += player\n if row == col:\n diag += player\n if row + col == n-1:\n anti += player\n \n if any(abs(line) == n for line in (rows[row], cols[col], diag, anti)):\n return \"A\" if player == 1 else \"B\"\n\n player *= -1\n return \"Draw\" if len(moves) == n*n else \"Pending\"","runtime":"34"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n if len(moves) < 5:\n return \"Pending\"\n\n grid = [[0 for _ in range(3)] for _ in range(3)]\n for i, move in enumerate(moves): \n x, y = move \n if i%2 == 0:\n grid[x][y] = 1\n else:\n grid[x][y] = -1\n\n for i in range(3):\n if abs(sum(grid[i])) == 3:\n return \"A\" if sum(grid[i]) > 0 else \"B\"\n for j in range(3):\n summ = 0\n for row in range(3):\n summ += grid[row][j]\n if abs(summ) == 3:\n return \"A\" if summ > 0 else \"B\"\n summ = 0\n for row in range(3):\n summ += grid[row][row]\n if abs(summ) == 3:\n return \"A\" if summ > 0 else \"B\"\n summ = 0\n for row in range(3):\n summ += grid[row][3-1-row]\n if abs(summ) == 3:\n return \"A\" if summ > 0 else \"B\"\n return \"Draw\" if len(moves)==9 else \"Pending\" ","runtime":"34"},{"code":"class Solution:\n def checkAntidiagonal(self, gameboard, turn) -> bool:\n for i in range(3):\n if gameboard[i][2 - i] != turn:\n return False\n return True\n\n def checkDiagonal(self, gameboard, turn) -> bool:\n for i in range(3):\n if gameboard[i][i] != turn:\n return False\n return True\n\n def checkRow(self, gameboard, x_coord, turn) -> bool:\n for i in range(3):\n if gameboard[x_coord][i] != turn:\n return False\n return True\n \n def checkCol(self, gameboard, y_coord, turn) -> bool:\n for i in range(3):\n if gameboard[i][y_coord] != turn:\n return False\n return True\n \n def tictactoe(self, moves: List[List[int]]) -> str:\n\n gameboard = [[0 for _ in range(3)] for _ in range(3)]\n turn = 1\n\n for move in moves:\n x_coord = move[0]\n y_coord = move[1]\n\n gameboard[x_coord][y_coord] = turn\n if(self.checkRow(gameboard, x_coord, turn) or self.checkCol(gameboard, y_coord, turn) or (x_coord == y_coord and self.checkDiagonal(gameboard, turn)) or (x_coord + y_coord == 2 and self.checkAntidiagonal(gameboard, turn))):\n if(turn == 1):\n return \"A\"\n else:\n return \"B\"\n \n turn *= -1\n \n return \"Draw\" if len(moves) == 9 else \"Pending\"","runtime":"35"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n As = moves[::2]\n print(As)\n Bs = moves[1::2]\n print(Bs)\n def horizontal(moves) -> bool:\n map = {}\n for move in moves:\n row = move[0]\n if row in map:\n map[row] += 1\n else:\n map[row] = 1\n vals = map.values()\n return 3 in vals\n \n def vertical(moves) -> bool:\n map = {}\n for move in moves:\n col = move[1]\n if col in map:\n map[col] += 1\n else:\n map[col] = 1\n vals = map.values()\n return 3 in vals\n\n \n def diagonal(moves) -> bool:\n b1 = [0,0] in moves and [1,1] in moves and [2,2] in moves\n b2 = [0,2] in moves and [1,1] in moves and [2,0] in moves\n return b1 or b2\n\n if horizontal(As) or vertical(As) or diagonal(As):\n return \"A\"\n elif horizontal(Bs) or vertical(Bs) or diagonal(Bs):\n return \"B\"\n elif len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"\n\n ","runtime":"35"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n\n board = [[0 for j in range(3)] for i in range(3)]\n\n player = 1 \n count = 0 \n\n for row, col in moves:\n board[row][col] = player # Place player's mark\n count += 1\n player *= -1 # Alternate the player\n\n for i in range(3):\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\n return \"A\" if board[i][0] == 1 else \"B\"\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\n return \"A\" if board[0][i] == 1 else \"B\"\n\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\n return \"A\" if board[0][0] == 1 else \"B\"\n\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\n return \"A\" if board[0][2] == 1 else \"B\"\n\n return \"Draw\" if count == 9 else \"Pending\"\n","runtime":"36"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n matrix = []\n for _ in range(0, 3):\n row = [0]*3\n matrix.append(row)\n \n for i in range(0, len(moves)):\n row, col = moves[i]\n #print(row, col)\n if i % 2 == 0:\n matrix[row][col] = 'A'\n else:\n matrix[row][col] = 'B'\n #print(matrix)\n \n\n ############ Row #####################\n \n for i in range(0, 3):\n cnt_a = 0\n cnt_b = 0\n for j in range(0, 3):\n if matrix[i][j] == 'A':\n cnt_a = cnt_a+1\n elif matrix[i][j] == 'B':\n cnt_b = cnt_b+1\n if cnt_a == 3:\n return \"A\"\n elif cnt_b == 3:\n return \"B\"\n \n ########### Column #######################\n for i in range(0, 3):\n cnt_a = 0\n cnt_b = 0\n for j in range(0, 3):\n if matrix[j][i] == 'A':\n cnt_a = cnt_a+1\n elif matrix[j][i] == 'B':\n cnt_b = cnt_b+1\n if cnt_a == 3:\n return \"A\"\n elif cnt_b == 3:\n return \"B\"\n \n ########### diagonal #######################\n cnt_a = 0\n cnt_b = 0\n for i in range(0, 3):\n if matrix[i][i] == 'A':\n cnt_a = cnt_a+1\n elif matrix[i][i] == 'B':\n cnt_b = cnt_b+1\n if cnt_a == 3:\n return \"A\"\n elif cnt_b == 3:\n return \"B\"\n \n cnt_a = 0\n cnt_b = 0\n for i in range(0, 3):\n if matrix[i][2-i] == 'A':\n cnt_a = cnt_a+1\n elif matrix[i][2-i] == 'B':\n cnt_b = cnt_b+1\n if cnt_a == 3:\n return \"A\"\n elif cnt_b == 3:\n return \"B\"\n \n #return \"\"\n return \"Draw\" if len(moves) == 9 else'Pending'\n'''class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n ar = self.sameRowCol(a, 0)\n if ar[0] == 100:\n return \"A\"\n elif len(ar) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n \n ac = self.sameRowCol(a, 1)\n if ac[0] == 100:\n return \"A\"\n elif len(ac) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n br = self.sameRowCol(b, 0)\n if br[0] == 100:\n return \"B\"\n elif len(br) == 2:\n if self.occupied(a, br) == False and len(b) <= len(a):\n return \"B\"\n bc = self.sameRowCol(b, 1)\n if bc[0] == 100:\n return \"B\"\n elif len(bc) == 2:\n if self.occupied(a, bc) == False and len(b) <= len(a):\n return \"B\"\n \n if len(a)+len(b) <=6:\n return \"Pending\"\n return \"Draw\"\n \n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\n found = False\n for r in route:\n if r[0] == target[0] and r[1] == target[1]:\n found = True\n break\n return found\n \n def diagnol(self, route: List[List[int]])->List[int]:\n dic = {}\n for r in route:\n if r[0] in dic:\n dic[r[0]].append(r[1])\n else:\n dic[r[0]] = []\n dic[r[0]].append(r[1])\n \n cnt1, cnt2 = 0, 0\n for i in range(0, 3):\n for j in dic[i]:\n if dic[i] == j:\n cnt1 = cnt1+1\n if dic[i]+j == 2:\n cnt2 = cnt2+1\n r = []\n if cnt1 == 3 or cnt2 == 3:\n r.append(100)\n return r\n \n l = []\n if cnt1 == 2:\n if 1 not in dic:\n r.append(1)\n r.append(1)\n return r\n else:\n found = False\n for j in dic[1]:\n if j == 1:\n found = True\n break\n if found:\n if 0 not in dic:\n r.append(0)\n r.append(0)\n return r\n else:\n if 2 not in dic:\n r.append(2)\n r.append(2)\n return r\n else:\n \n \n \n \n \n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\n dic = {}\n idx2 = 0\n if idx == 0:\n idx2=1\n for mv in route:\n if mv[idx] in dic:\n dic[mv[idx]].append(mv[idx2])\n else:\n dic[mv[idx]] = []\n dic[mv[idx]].append(mv[idx2])\n \n for k in dic:\n if len(dic[k]) >= 3:\n r = []\n r.append(100)\n return r\n elif len(dic[k]) == 2:\n s = set(dic[k])\n for i in range(0, 3):\n if i not in s:\n r=[]\n r.append(k)\n r.append(i)\n return r\n r=[]\n r.append(-1)\n return r'''\n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n a_row_total, a_col_total = 0, 0 \n for mv in a:\n a_row_total = a_row_total+mv[0]\n a_col_total = a_col_total+mv[1]\n if a_row_total == 3 or a_col_total ==3:\n return \"A\"\n \n b_row_total, b_col_total = 0, 0 \n for mv in b:\n b_row_total = b_row_total+mv[0]\n b_col_total = b_col_total+mv[1]\n if b_row_total == 3 or b_col_total ==3:\n return \"B\"\n \n if len(a) < 3 or len(b) < 3:\n return \"Pending\"\n return \"Draw\"'''\n \n \n \n \n \n \n \n \n \n \n \n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = {}, {}\n \n for i in range(0, len(moves)):\n if i % 2 ==0:\n if moves[i][0] in a:\n a[moves[i][0]].append(moves[i][1])\n else:\n a[moves[i][0]] = []\n a[moves[i][0]].append(moves[i][1])\n else:\n if moves[i][0] in b:\n b[moves[i][0]].append(moves[i][1])\n else:\n b[moves[i][0]] = []\n b[moves[i][0]].append(moves[i][1])\n print(a, b)\n if len(a) >= 3:\n Awin = True\n for i in range(0, 3):\n if a[i][0] != i:\n Awin = False\n #print(Awin)\n if Awin:\n return \"A\"\n \n if len(b) >= 3:\n Awin = True\n for i in range(0, 3):\n if b[i][0] != i:\n Awin = False\n if Awin:\n return \"B\"\n \n for k in range(0, 3):\n if k in a:\n if len(a[k]) >= 3:\n return \"A\"\n if k in b:\n if len(b[k]) >= 3:\n return \"B\"\n \n return \"Draw\"'''\n \n \n \n ","runtime":"37"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n matrix = [[\"_\" for i in range(3)] for i in range(3)]\n a = True \n for move in moves: \n currRow = move[0]\n currCol = move[1]\n matrix[currRow][currCol] = \"X\" if a else \"0\"\n for col in range(3):\n found = True\n for row in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n for row in range(3):\n found = True\n for col in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\n if matrix[1][1] != \"_\":\n return \"A\" if matrix[1][1] == \"X\" else \"B\"\n a = not a \n return \"Draw\" if len(moves) == 9 else \"Pending\"\n","runtime":"37"},{"code":"from typing import List\nfrom collections import deque\n\nclass Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n \n matrix = [['' for _ in range(3)] for _ in range(3)]\n a_turn = True \n\n \n def inbound(i, j):\n return 0 <= i < 3 and 0 <= j < 3\n\n \n for i in range(len(moves)):\n r, c = moves[i][0], moves[i][1]\n if a_turn:\n matrix[r][c] = \"X\" \n a_turn = False\n else:\n matrix[r][c] = \"O\" \n a_turn = True\n \n \n directions = [(0,1), (1,0), (1,1), (1,-1)]\n \n \n def bfs(i, j, player):\n for dx, dy in directions:\n q = deque([(i, j, 1)]) \n while q:\n r, c, steps = q.popleft()\n if steps == 3: \n return True\n nr, nc = r + dx, c + dy\n if inbound(nr, nc) and matrix[nr][nc] == player:\n q.append((nr, nc, steps + 1))\n return False\n\n \n for i in range(3):\n for j in range(3):\n if matrix[i][j] == \"X\" and bfs(i, j, \"X\"):\n return \"A\"\n if matrix[i][j] == \"O\" and bfs(i, j, \"O\"):\n return \"B\"\n \n \n if len(moves) == 9:\n return \"Draw\"\n return \"Pending\"\n","runtime":"38"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n matrix = [[\"_\" for i in range(3)] for i in range(3)]\n a = True \n for move in moves: \n currRow = move[0]\n currCol = move[1]\n matrix[currRow][currCol] = \"X\" if a else \"0\"\n for col in range(3):\n found = True\n for row in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n for row in range(3):\n found = True\n for col in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\n if matrix[1][1] != \"_\":\n return \"A\" if matrix[1][1] == \"X\" else \"B\"\n a = not a \n return \"Draw\" if len(moves) == 9 else \"Pending\"\n","runtime":"39"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n grid = [[0] * 3 for _ in range(3)]\n visited = 0\n i = 0\n while i < len(moves):\n r, c = moves[i]\n visited += 1\n if i % 2 == 0:\n grid[r][c] = 1\n else:\n grid[r][c] = -1\n i += 1\n\n for r in range(len(grid)):\n if sum(grid[r]) == 3:\n return 'A'\n elif sum(grid[r]) == -3:\n return 'B'\n \n for c in range(len(grid[0])):\n if grid[0][c] + grid[1][c] + grid[2][c] == 3:\n return 'A'\n elif grid[0][c] + grid[1][c] + grid[2][c] == -3:\n return 'B'\n \n if grid[0][0] + grid[1][1] + grid[2][2] == 3:\n return 'A'\n elif grid[0][0] + grid[1][1] + grid[2][2] == -3:\n return 'B'\n \n if grid[0][2] + grid[1][1] + grid[2][0] == 3:\n return 'A'\n elif grid[0][2] + grid[1][1] + grid[2][0] == -3:\n return 'B' \n \n if visited == 9:\n return 'Draw'\n else:\n return 'Pending'","runtime":"39"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n winning_conditions = [\n {(0, 0), (1, 1), (2, 2)},\n {(0, 2), (1, 1), (2, 0)},\n {(0, 0), (0, 1), (0, 2)},\n {(1, 0), (1, 1), (1, 2)},\n {(2, 0), (2, 1), (2, 2)},\n {(0, 0), (1, 0), (2, 0)},\n {(0, 1), (1, 1), (2, 1)},\n {(0, 2), (1, 2), (2, 2)},\n ]\n amoves = {tuple(move) for move in moves[::2]}\n bmoves = {tuple(move) for move in moves[1::2]}\n for wcond in winning_conditions:\n if wcond.issubset(amoves):\n return \"A\"\n elif wcond.issubset(bmoves):\n return \"B\"\n if len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"","runtime":"40"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n board = [[0] * 3 for _ in range(3)]\n\n player = 1 # A\n for move in moves:\n board[move[0]][move[1]] = player\n player *= -1\n\n # check by row\n for i in range(3):\n sum = 0\n for j in range(3):\n sum += board[i][j]\n if sum == 3:\n return \"A\"\n if sum == -3:\n return \"B\"\n \n # check by col\n for j in range(3):\n sum = 0\n for i in range(3):\n sum += board[i][j]\n if sum == 3:\n return \"A\"\n if sum == -3:\n return \"B\"\n \n # check by diagonal\n sum = 0\n for i in range(3):\n sum += board[i][i]\n \n if sum == 3:\n return \"A\"\n if sum == -3:\n return \"B\"\n\n \"\"\"\n 0,2\n 1,1\n 2,0\n \"\"\"\n sum = 0\n for i in range(3):\n sum += board[0 + i][2 - i]\n \n if sum == 3:\n return \"A\"\n if sum == -3:\n return \"B\"\n \n if len(moves) < 9:\n return \"Pending\"\n return \"Draw\"\n\n","runtime":"40"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n table = [[0]*3 for _ in range(3)]\n count = 1\n for move in moves:\n table[move[0]][move[1]] = count\n count = -count\n \n print(table)\n for i in range(3):\n if table[0][i]==table[1][i]==table[2][i]:\n if table[0][i]==1:\n return \"A\"\n elif table[0][i]==-1:\n return \"B\"\n \n if table[i][0]==table[i][1]==table[i][2]:\n if table[i][0]==1:\n return \"A\"\n elif table[i][0]==-1:\n return \"B\"\n \n if table[0][0]==table[1][1]==table[2][2]:\n if table[0][0]==1:\n return \"A\"\n elif table[0][0]==-1:\n return \"B\"\n\n if table[2][0]==table[1][1]==table[0][2]:\n if table[2][0]==1:\n return \"A\"\n elif table[2][0]==-1:\n return \"B\"\n \n return 'Draw' if len(moves)==9 else 'Pending'\n\n ","runtime":"41"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n As = moves[::2]\n Bs = moves[1::2]\n \n def horizontal(moves) -> bool:\n map = {}\n for move in moves:\n row = move[0]\n if row in map:\n map[row] += 1\n else:\n map[row] = 1\n vals = map.values()\n return 3 in vals\n \n def vertical(moves) -> bool:\n map = {}\n for move in moves:\n col = move[1]\n if col in map:\n map[col] += 1\n else:\n map[col] = 1\n vals = map.values()\n return 3 in vals\n\n \n def diagonal(moves) -> bool:\n b1 = [0,0] in moves and [1,1] in moves and [2,2] in moves\n b2 = [0,2] in moves and [1,1] in moves and [2,0] in moves\n return b1 or b2\n\n if horizontal(As) or vertical(As) or diagonal(As):\n return \"A\"\n elif horizontal(Bs) or vertical(Bs) or diagonal(Bs):\n return \"B\"\n elif len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"\n\n ","runtime":"42"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n\n # fill the grid\n grid = [[' ' for _ in range(3)] for _ in range(3)]\n\n for idx, (x,y) in enumerate(moves):\n if (idx % 2 == 0):\n grid[x][y] = 'X'\n else:\n grid[x][y] = 'O'\n\n\n # check for all rows\n for i in range(3):\n char_1 = grid[i][0]\n char_2 = grid[i][1]\n char_3 = grid[i][2]\n\n if char_1 == char_2 == char_3 == 'X':\n return \"A\"\n elif char_1 == char_2 == char_3 == 'O':\n return \"B\"\n \n\n # check for all cols\n for i in range(3):\n char_1 = grid[0][i]\n char_2 = grid[1][i]\n char_3 = grid[2][i]\n\n if char_1 == char_2 == char_3 == 'X':\n return \"A\"\n elif char_1 == char_2 == char_3 == 'O':\n return \"B\"\n\n # check for both diagonals\n if grid[0][0] == grid[1][1] == grid[2][2] == 'X':\n return \"A\"\n elif grid[0][0] == grid[1][1] == grid[2][2] == 'O':\n return \"B\"\n\n #n Second Diagonal\n if grid[0][2] == grid[1][1] == grid[2][0] == 'X':\n return \"A\"\n elif grid[0][2] == grid[1][1] == grid[2][0] == 'O':\n return \"B\"\n\n\n # if count < 9 then return pending else return draw\n if len(moves) < 9:\n return \"Pending\"\n else:\n return \"Draw\"\n\n \n ","runtime":"43"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n grid = [None for _ in range(9)]\n winLines = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]\n playerOne = True\n for move in moves:\n x, y = move\n grid[y*3+x] = playerOne\n playerOne = not playerOne\n for a,b,c in winLines:\n if grid[a] == grid[b] == grid[c]:\n if grid[a] is not None:\n return (\"B\",\"A\")[grid[a]]\n if any([s is None for s in grid]):\n return \"Pending\"\n return \"Draw\"","runtime":"44"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # Approach 2024.09.19\n cache = defaultdict(int)\n for i, pt in enumerate(moves):\n r_key = f\"{i%2}_p_{pt[0]}\"\n c_key = f\"{i%2}_c_{pt[1]}\"\n pd_key = f\"{i%2}_pd_{pt[0] + pt[1]}\"\n nd_key = f\"{i%2}_nd_{pt[0] - pt[1]}\"\n cache[r_key] += 1\n cache[c_key] += 1\n cache[pd_key] += 1\n cache[nd_key] += 1\n\n if cache[r_key] == 3 or cache[c_key] == 3 or \\\n cache[pd_key] == 3 or cache[nd_key] == 3:\n if i%2 == 0:\n return \"A\"\n else:\n return \"B\"\n \n if len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"","runtime":"44"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n #a = x, b = o\n player_a_moves, player_b_moves = moves[::2], moves[1::2]\n \n def dfs(player, idx):\n seen.add(idx)\n dirs = [(1, 0), (-1, 0), (0, 1), (0, -1), (-1, 1), (1, -1), (1, 1)]\n q = collections.deque()\n q.append((player_moves[player][idx], 1, dirs))\n while q:\n coord, connections, coord_moves = q.pop()\n if connections == 3:\n return player\n for move in coord_moves:\n x, y = move\n px, py = coord\n nx, ny = px + x, py + y\n if nx in range(4) and ny in range(4) and [nx, ny] in player_moves[player]:\n q.append(((nx, ny), connections + 1, [(x, y)]))\n\n player_moves = {\"A\":player_a_moves, \"B\":player_b_moves}\n for player in player_moves:\n seen = set()\n for i in range(len(player_moves[player])):\n if i not in seen:\n outcome = dfs(player, i)\n if outcome:\n return outcome\n #ends in draw\n if len(moves) == 9:\n return \"Draw\"\n return \"Pending\"","runtime":"45"}],"string":"[\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # Approach 2024.09.19\\n cache = defaultdict(int)\\n for i, pt in enumerate(moves):\\n r_key = f\\\"{i%2}_p_{pt[0]}\\\"\\n c_key = f\\\"{i%2}_c_{pt[1]}\\\"\\n pd_key = f\\\"{i%2}_pd_{pt[0] + pt[1]}\\\"\\n nd_key = f\\\"{i%2}_nd_{pt[0] - pt[1]}\\\"\\n cache[r_key] += 1\\n cache[c_key] += 1\\n cache[pd_key] += 1\\n cache[nd_key] += 1\\n\\n if cache[r_key] == 3 or cache[c_key] == 3 or \\\\\\n cache[pd_key] == 3 or cache[nd_key] == 3:\\n if i%2 == 0:\\n return \\\"A\\\"\\n else:\\n return \\\"B\\\"\\n \\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\",\n \"runtime\": \"22\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n A=[0]*8\\n B=[0]*8\\n for i in range(len(moves)):\\n r,c=moves[i]\\n player = A if i%2==0 else B\\n player[r] += 1\\n player[c+3] += 1\\n if r==c:\\n player[6] += 1\\n if r==2-c:\\n player[7] += 1\\n for i in range(8):\\n if A[i]==3:\\n return \\\"A\\\"\\n if B[i]==3:\\n return \\\"B\\\"\\n \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\",\n \"runtime\": \"23\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n rows = [0] * 3\\n cols = [0] * 3\\n diagonal45, diagonal135 = 0, 0\\n\\n player = 1 # A\\n for move in moves:\\n x, y = move[0], move[1]\\n rows[x] += player\\n cols[y] += player\\n\\n if x == y:\\n diagonal135 += player\\n if x + y == 2:\\n diagonal45 += player\\n \\n if abs(rows[x]) == 3 or abs(cols[y]) == 3 or abs(diagonal45) == 3 or abs(diagonal135) == 3:\\n return \\\"A\\\" if player == 1 else \\\"B\\\"\\n \\n player *= -1\\n \\n return \\\"Pending\\\" if len(moves) < 9 else \\\"Draw\\\"\\n\\n\",\n \"runtime\": \"24\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n rows = [0] * 3\\n cols = [0] * 3\\n diag = 0\\n antidiag = 0\\n player = -1\\n for r, c in moves:\\n player = -1 * player\\n if r == c:\\n diag += player\\n if r + c == 2:\\n antidiag += player\\n rows[r] += player\\n cols[c] += player\\n if (abs(diag) == 3 or abs(antidiag) == 3 or abs(rows[r]) == 3 or abs(cols[c]) == 3):\\n if player == 1:\\n return \\\"A\\\"\\n else:\\n return \\\"B\\\"\\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n return \\\"Pending\\\"\\n\\n\\n # Brute Force\\n # matrix = [[0]*3 for i in range(3)]\\n # def checkSequence():\\n # if (\\n # (matrix[0][0] == matrix[0][1] == matrix[0][2] != 0) or\\n # (matrix[1][0] == matrix[1][1] == matrix[1][2] != 0) or\\n # (matrix[2][0] == matrix[2][1] == matrix[2][2] != 0) or\\n\\n # (matrix[0][0] == matrix[1][0] == matrix[2][0] != 0) or\\n # (matrix[0][1] == matrix[1][1] == matrix[2][1] != 0) or\\n # (matrix[0][2] == matrix[1][2] == matrix[2][2] != 0) or\\n\\n # (matrix[0][0] == matrix[1][1] == matrix[2][2] != 0) or\\n # (matrix[2][0] == matrix[1][1] == matrix[0][2] != 0)\\n # ):\\n # return True\\n # else:\\n # return False\\n \\n # player = -1\\n # for move in moves:\\n # player = -1 * player\\n # x, y = move\\n # matrix[x][y] = player\\n # if checkSequence():\\n # if player == 1:\\n # return \\\"A\\\"\\n # else:\\n # return \\\"B\\\"\\n # if len(moves) == 9:\\n # return \\\"Draw\\\"\\n # return \\\"Pending\\\" \\n\\n \\n \\n \",\n \"runtime\": \"25\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n board = [[\\\"-1\\\"] * 3 for _ in range(3)]\\n\\n count = 0\\n for move in moves:\\n if count % 2 == 0:\\n board[move[0]][move[1]] = \\\"A\\\"\\n else:\\n board[move[0]][move[1]] = \\\"B\\\"\\n count += 1\\n\\n for i in range(3):\\n if board[i][0] == board[i][1] == board[i][2] and board[i][0] != \\\"-1\\\": # check col\\n return board[i][0]\\n if board[0][i] == board[1][i] == board[2][i] and board[0][i] != \\\"-1\\\": # check row\\n return board[0][i] \\n \\n if board[0][0] == board[1][1] == board[2][2] and board[0][0] != \\\"-1\\\" and board[1][1] != \\\"-1\\\" and board[2][2] != \\\"-1\\\":\\n return board[0][0]\\n \\n if board[0][2] == board[1][1] == board[2][0] and board[0][2] != \\\"-1\\\" and board[1][1] != \\\"-1\\\" and board[2][0] != \\\"-1\\\":\\n return board[0][2]\\n\\n return \\\"Draw\\\" if count == 9 else \\\"Pending\\\"\\n\",\n \"runtime\": \"26\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n = len(moves)\\n matrix = [[0] * 3 for _ in range(3)]\\n \\n def isvalid(directions):\\n hash_map = Counter(directions)\\n del hash_map[0]\\n for key, count in hash_map.items():\\n if count == 3:\\n return key\\n \\n for i in range(n):\\n if i % 2 == 0:\\n row, col = moves[i]\\n matrix[row][col] = 'A'\\n else:\\n row, col = moves[i]\\n matrix[row][col] = 'B'\\n\\n ############ Row #####################\\n\\n for row in matrix:\\n row_map = Counter(row)\\n del row_map[0]\\n for key, count in row_map.items():\\n if count == 3:\\n return key\\n\\n ########### Column #######################\\n\\n for j in range(len(matrix)):\\n columns = [row[j] for row in matrix]\\n col_map = Counter(columns)\\n del col_map[0]\\n for key, count in col_map.items():\\n if count == 3:\\n return key\\n\\n ########### diagonal #######################\\n \\n diagonal,anti_diagonal = [], []\\n for i in range(len(matrix)):\\n for j in range(len(matrix)):\\n if i - j == 0:\\n diagonal.append(matrix[i][j])\\n if i + j == 2:\\n anti_diagonal.append(matrix[i][j])\\n\\n diagonal_map = Counter(diagonal)\\n del diagonal_map[0]\\n for key, count in diagonal_map.items():\\n if count == 3:\\n return key\\n\\n anti_diagonal_map = Counter(anti_diagonal)\\n del anti_diagonal_map[0]\\n for key, count in anti_diagonal_map.items():\\n if count == 3:\\n return key\\n\\n \\n return \\\"Draw\\\" if len(moves) == 9 else'Pending'\\n'''class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n ar = self.sameRowCol(a, 0)\\n if ar[0] == 100:\\n return \\\"A\\\"\\n elif len(ar) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n \\n ac = self.sameRowCol(a, 1)\\n if ac[0] == 100:\\n return \\\"A\\\"\\n elif len(ac) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n br = self.sameRowCol(b, 0)\\n if br[0] == 100:\\n return \\\"B\\\"\\n elif len(br) == 2:\\n if self.occupied(a, br) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n bc = self.sameRowCol(b, 1)\\n if bc[0] == 100:\\n return \\\"B\\\"\\n elif len(bc) == 2:\\n if self.occupied(a, bc) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n \\n if len(a)+len(b) <=6:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"\\n \\n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\\n found = False\\n for r in route:\\n if r[0] == target[0] and r[1] == target[1]:\\n found = True\\n break\\n return found\\n \\n def diagnol(self, route: List[List[int]])->List[int]:\\n dic = {}\\n for r in route:\\n if r[0] in dic:\\n dic[r[0]].append(r[1])\\n else:\\n dic[r[0]] = []\\n dic[r[0]].append(r[1])\\n \\n cnt1, cnt2 = 0, 0\\n for i in range(0, 3):\\n for j in dic[i]:\\n if dic[i] == j:\\n cnt1 = cnt1+1\\n if dic[i]+j == 2:\\n cnt2 = cnt2+1\\n r = []\\n if cnt1 == 3 or cnt2 == 3:\\n r.append(100)\\n return r\\n \\n l = []\\n if cnt1 == 2:\\n if 1 not in dic:\\n r.append(1)\\n r.append(1)\\n return r\\n else:\\n found = False\\n for j in dic[1]:\\n if j == 1:\\n found = True\\n break\\n if found:\\n if 0 not in dic:\\n r.append(0)\\n r.append(0)\\n return r\\n else:\\n if 2 not in dic:\\n r.append(2)\\n r.append(2)\\n return r\\n else:\\n \\n \\n \\n \\n \\n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\\n dic = {}\\n idx2 = 0\\n if idx == 0:\\n idx2=1\\n for mv in route:\\n if mv[idx] in dic:\\n dic[mv[idx]].append(mv[idx2])\\n else:\\n dic[mv[idx]] = []\\n dic[mv[idx]].append(mv[idx2])\\n \\n for k in dic:\\n if len(dic[k]) >= 3:\\n r = []\\n r.append(100)\\n return r\\n elif len(dic[k]) == 2:\\n s = set(dic[k])\\n for i in range(0, 3):\\n if i not in s:\\n r=[]\\n r.append(k)\\n r.append(i)\\n return r\\n r=[]\\n r.append(-1)\\n return r'''\\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n a_row_total, a_col_total = 0, 0 \\n for mv in a:\\n a_row_total = a_row_total+mv[0]\\n a_col_total = a_col_total+mv[1]\\n if a_row_total == 3 or a_col_total ==3:\\n return \\\"A\\\"\\n \\n b_row_total, b_col_total = 0, 0 \\n for mv in b:\\n b_row_total = b_row_total+mv[0]\\n b_col_total = b_col_total+mv[1]\\n if b_row_total == 3 or b_col_total ==3:\\n return \\\"B\\\"\\n \\n if len(a) < 3 or len(b) < 3:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"'''\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = {}, {}\\n \\n for i in range(0, len(moves)):\\n if i % 2 ==0:\\n if moves[i][0] in a:\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n a[moves[i][0]] = []\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n if moves[i][0] in b:\\n b[moves[i][0]].append(moves[i][1])\\n else:\\n b[moves[i][0]] = []\\n b[moves[i][0]].append(moves[i][1])\\n print(a, b)\\n if len(a) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if a[i][0] != i:\\n Awin = False\\n #print(Awin)\\n if Awin:\\n return \\\"A\\\"\\n \\n if len(b) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if b[i][0] != i:\\n Awin = False\\n if Awin:\\n return \\\"B\\\"\\n \\n for k in range(0, 3):\\n if k in a:\\n if len(a[k]) >= 3:\\n return \\\"A\\\"\\n if k in b:\\n if len(b[k]) >= 3:\\n return \\\"B\\\"\\n \\n return \\\"Draw\\\"'''\\n \\n \\n \\n \",\n \"runtime\": \"27\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # if a player has 3 or more plays:\\n # 1. diagonal = columns are monotonic, rows are monotonic\\n # [0,0] [1,1] [2,2]\\n # [0,2] [1,1] [2,0]\\n\\n # 2. horizontal = columns are monotonic, rows are all equal\\n # [0,0][0,1][0,2]\\n # [0,2][0,1][0,0]\\n\\n # 3. vertical = rows are monotonic, columns are all equal\\n # [0,0][1,0][2,0]\\n # [2,2][1,2][0,2]\\n\\n \\n board = [[None for _ in range(3)] for _ in range(3)]\\n for i, move in enumerate(moves):\\n row, col = move[0], move[1]\\n board[row][col] = \\\"A\\\" if i % 2 == 0 else \\\"B\\\"\\n\\n row = col = 0\\n\\n # Check each value of board\\n for row in range(len(board)):\\n for col in range(len(board[0])):\\n if board[row][col]:\\n symbol = board[row][col]\\n\\n if row == 0 and board[row + 1][col] == symbol and board[row + 2][col] == symbol: # Vertical win\\n return f\\\"{symbol}\\\"\\n\\n if col == 0 and board[row][col + 1] == symbol and board[row][col + 2] == symbol: # Horizontal win\\n return f\\\"{symbol}\\\"\\n\\n if row == 0 and col == 0 and board[row + 1][col + 1] == symbol and board[row + 2][col + 2] == symbol: # Diagonal win\\n return f\\\"{symbol}\\\"\\n\\n if row == 0 and col == 2 and board[row + 1][col - 1] == symbol and board[row + 2][col - 2] == symbol: # Anti-diagonal win\\n return f\\\"{symbol}\\\"\\n\\n for row in board:\\n print(row)\\n\\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n\\n return \\\"Pending\\\"\\n\\n\\n\\n \\n\",\n \"runtime\": \"28\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n\\n \\n winning_combination1 = [[0,0], [1,1], [2,2]]\\n winning_combination2 = [[1,1], [0,2], [2,0]]\\n\\n a_board = []\\n b_board = []\\n a = True\\n b = False\\n\\n for move in moves:\\n if a:\\n a_board.append(move)\\n a = False\\n b = True\\n else:\\n b_board.append(move)\\n b = False\\n a = True\\n \\n if all(x in a_board for x in winning_combination1):\\n return 'A'\\n if all(x in a_board for x in winning_combination2):\\n return 'A'\\n\\n if all(x in b_board for x in winning_combination1):\\n return 'B'\\n if all(x in b_board for x in winning_combination2):\\n return 'B'\\n\\n for move in a_board:\\n row = move[0]\\n col = move[1]\\n if [row, col -1] in a_board and [row, col + 1] in a_board:\\n return 'A'\\n if [row -1, col] in a_board and [row + 1, col] in a_board:\\n return 'A'\\n\\n for move in b_board:\\n row = move[0]\\n col = move[1]\\n if [row, col -1] in b_board and [row, col + 1] in b_board:\\n return 'B'\\n if [row -1, col] in b_board and [row + 1, col] in b_board:\\n return 'B'\\n\\n if len(moves) < 9:\\n return 'Pending'\\n return 'Draw'\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # We could a count for each of the 8 lines\\n # We can increment or decrement the count each time they play on it\\n # If one of the counts hits 3 or -3 return the respective player's name\\n rows = [0,0,0]\\n cols = [0,0,0]\\n diag = 0\\n diag2 = 0\\n\\n for i, move in enumerate(moves):\\n inc = 1 if i%2==0 else -1\\n rows[move[0]] += inc\\n cols[move[1]] += inc\\n \\n if move == [0,0] or move==[2,2]:\\n diag += inc\\n elif move == [2,0] or move == [0,2]:\\n diag2 += inc\\n if move == [1,1]:\\n diag += inc\\n diag2 += inc\\n if 3 in rows or 3 in cols or diag==3 or diag2==3: return 'A'\\n if -3 in rows or -3 in cols or diag==-3 or diag2==-3: return 'B'\\n \\n return \\\"Draw\\\" if len(moves)==9 else \\\"Pending\\\"\",\n \"runtime\": \"29\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n A = [0]*8\\n B = [0]*8\\n # No one can win with less then 5 total moves\\n num_moves = len(moves)\\n for i in range(num_moves):\\n row, col = moves[i]\\n current_player = A if i % 2 == 0 else B\\n # Increment the count for this row\\n current_player[row] += 1\\n # Increment the count for this column\\n current_player[col + 3] += 1\\n if row == col:\\n current_player[6] += 1\\n if row == 2 - col:\\n current_player[7] += 1\\n\\n for i in range(8):\\n if A[i] == 3:\\n return \\\"A\\\"\\n if B[i] == 3:\\n return \\\"B\\\"\\n return \\\"Draw\\\" if num_moves == 9 else \\\"Pending\\\"\",\n \"runtime\": \"30\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n=3\\n rows=[0]* n\\n cols=[0]*n\\n sign=0\\n diag=revdiag=0\\n for i,move in enumerate(moves):\\n r,c=move\\n sign=1 if i%2==0 else -1\\n rows[r]+=sign\\n cols[c]+=sign\\n if r==c:\\n diag+=sign\\n if r+c == n-1:\\n revdiag+=sign\\n if abs(diag) == n or abs(revdiag)==n or abs(rows[r]) ==n or abs(cols[c]) == n:\\n return \\\"A\\\" if sign ==1 else \\\"B\\\"\\n return \\\"Draw\\\" if len(moves) == (n*n) else \\\"Pending\\\" \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \",\n \"runtime\": \"31\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # Step 1: Initialize a 3x3 grid\\n grid = [[\\\"\\\"] * 3 for _ in range(3)]\\n\\n # Step 2: Alternate between Player A ('X') and Player B ('O')\\n for i, move in enumerate(moves):\\n row, col = move\\n if i % 2 == 0:\\n grid[row][col] = 'X' # Player A's move\\n else:\\n grid[row][col] = 'O' # Player B's move\\n\\n # Step 3: Check for a winner after every move\\n if self.checkWinner(grid, row, col):\\n return 'A' if grid[row][col] == 'X' else 'B'\\n \\n # Step 4: If all moves are made and no winner, check if it's a draw or pending\\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n \\n # Step 5: Function to check if there's a winner\\n def checkWinner(self, grid, row, col):\\n n = 3\\n player = grid[row][col]\\n\\n # Check the row\\n if all(grid[row][c] == player for c in range(n)):\\n return True\\n \\n # Check the column\\n if all(grid[r][col] == player for r in range(n)):\\n return True\\n \\n # Check the main diagonal\\n if row == col and all(grid[r][r] == player for r in range(n)):\\n return True\\n \\n # Check the anti-diagonal\\n if row + col == n - 1 and all(grid[r][n-1-r] == player for r in range(n)):\\n return True\\n \\n return False\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n A=[0]*8\\n B=[0]*8\\n\\n for i in range(len(moves)):\\n r,c = moves[i]\\n player = A if i %2 == 0 else B\\n player[r] += 1\\n player[c+3] += 1\\n\\n if r==c:\\n player[6] +=1\\n # should be an if because we need to update both side of the diagonals for (1,1)\\n if r==2-c:\\n player[7] +=1\\n for i in range(len(A)):\\n if A[i] == 3:\\n return \\\"A\\\"\\n elif B[i] == 3:\\n return \\\"B\\\"\\n print(A,B)\\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n\\n\\n\\n\",\n \"runtime\": \"32\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n = len(moves)\\n matrix = [[0] * 3 for _ in range(3)]\\n \\n def isvalid(directions):\\n hash_map = Counter(directions)\\n del hash_map[0]\\n for key, count in hash_map.items():\\n if count == 3:\\n return key\\n \\n for i in range(n):\\n if i % 2 == 0:\\n row, col = moves[i]\\n matrix[row][col] = 'A'\\n else:\\n row, col = moves[i]\\n matrix[row][col] = 'B'\\n\\n for row in matrix:\\n row_map = Counter(row)\\n del row_map[0]\\n for key, count in row_map.items():\\n if count == 3:\\n return key\\n\\n for j in range(len(matrix)):\\n columns = [row[j] for row in matrix]\\n col_map = Counter(columns)\\n del col_map[0]\\n for key, count in col_map.items():\\n if count == 3:\\n return key\\n\\n ########### diagonal #######################\\n \\n diagonal,anti_diagonal = [], []\\n for i in range(len(matrix)):\\n for j in range(len(matrix)):\\n if i - j == 0:\\n diagonal.append(matrix[i][j])\\n if i + j == 2:\\n anti_diagonal.append(matrix[i][j])\\n\\n diagonal_map = Counter(diagonal)\\n del diagonal_map[0]\\n for key, count in diagonal_map.items():\\n if count == 3:\\n return key\\n\\n anti_diagonal_map = Counter(anti_diagonal)\\n del anti_diagonal_map[0]\\n for key, count in anti_diagonal_map.items():\\n if count == 3:\\n return key\\n\\n \\n return \\\"Draw\\\" if len(moves) == 9 else 'Pending'\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # Initialize the board\\n board = [[0 for j in range(3)] for i in range(3)]\\n\\n player = 1 # 1 for Player A, -1 for Player B\\n count = 0 # To keep track of the number of moves\\n\\n # Place each move on the board\\n for row, col in moves:\\n board[row][col] = player # Place player's mark\\n count += 1\\n player *= -1 # Alternate the player\\n\\n # Check rows and columns for a win\\n for i in range(3):\\n # Check the ith row\\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\\n return \\\"A\\\" if board[i][0] == 1 else \\\"B\\\"\\n # Check the ith column\\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\\n return \\\"A\\\" if board[0][i] == 1 else \\\"B\\\"\\n\\n # Check the main diagonal\\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\\n return \\\"A\\\" if board[0][0] == 1 else \\\"B\\\"\\n\\n # Check the anti-diagonal\\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\\n return \\\"A\\\" if board[0][2] == 1 else \\\"B\\\"\\n\\n # If all moves are made and no winner, return \\\"Draw\\\"\\n return \\\"Draw\\\" if count == 9 else \\\"Pending\\\"\\n\",\n \"runtime\": \"33\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n = 3\\n rows, cols = [0]*n, [0]*n\\n diag = anti = 0\\n player = 1\\n for row, col in moves:\\n rows[row] += player\\n cols[col] += player\\n if row == col:\\n diag += player\\n if row + col == n-1:\\n anti += player\\n \\n if any(abs(line) == n for line in (rows[row], cols[col], diag, anti)):\\n return \\\"A\\\" if player == 1 else \\\"B\\\"\\n\\n player *= -1\\n return \\\"Draw\\\" if len(moves) == n*n else \\\"Pending\\\"\",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n if len(moves) < 5:\\n return \\\"Pending\\\"\\n\\n grid = [[0 for _ in range(3)] for _ in range(3)]\\n for i, move in enumerate(moves): \\n x, y = move \\n if i%2 == 0:\\n grid[x][y] = 1\\n else:\\n grid[x][y] = -1\\n\\n for i in range(3):\\n if abs(sum(grid[i])) == 3:\\n return \\\"A\\\" if sum(grid[i]) > 0 else \\\"B\\\"\\n for j in range(3):\\n summ = 0\\n for row in range(3):\\n summ += grid[row][j]\\n if abs(summ) == 3:\\n return \\\"A\\\" if summ > 0 else \\\"B\\\"\\n summ = 0\\n for row in range(3):\\n summ += grid[row][row]\\n if abs(summ) == 3:\\n return \\\"A\\\" if summ > 0 else \\\"B\\\"\\n summ = 0\\n for row in range(3):\\n summ += grid[row][3-1-row]\\n if abs(summ) == 3:\\n return \\\"A\\\" if summ > 0 else \\\"B\\\"\\n return \\\"Draw\\\" if len(moves)==9 else \\\"Pending\\\" \",\n \"runtime\": \"34\"\n },\n {\n \"code\": \"class Solution:\\n def checkAntidiagonal(self, gameboard, turn) -> bool:\\n for i in range(3):\\n if gameboard[i][2 - i] != turn:\\n return False\\n return True\\n\\n def checkDiagonal(self, gameboard, turn) -> bool:\\n for i in range(3):\\n if gameboard[i][i] != turn:\\n return False\\n return True\\n\\n def checkRow(self, gameboard, x_coord, turn) -> bool:\\n for i in range(3):\\n if gameboard[x_coord][i] != turn:\\n return False\\n return True\\n \\n def checkCol(self, gameboard, y_coord, turn) -> bool:\\n for i in range(3):\\n if gameboard[i][y_coord] != turn:\\n return False\\n return True\\n \\n def tictactoe(self, moves: List[List[int]]) -> str:\\n\\n gameboard = [[0 for _ in range(3)] for _ in range(3)]\\n turn = 1\\n\\n for move in moves:\\n x_coord = move[0]\\n y_coord = move[1]\\n\\n gameboard[x_coord][y_coord] = turn\\n if(self.checkRow(gameboard, x_coord, turn) or self.checkCol(gameboard, y_coord, turn) or (x_coord == y_coord and self.checkDiagonal(gameboard, turn)) or (x_coord + y_coord == 2 and self.checkAntidiagonal(gameboard, turn))):\\n if(turn == 1):\\n return \\\"A\\\"\\n else:\\n return \\\"B\\\"\\n \\n turn *= -1\\n \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n As = moves[::2]\\n print(As)\\n Bs = moves[1::2]\\n print(Bs)\\n def horizontal(moves) -> bool:\\n map = {}\\n for move in moves:\\n row = move[0]\\n if row in map:\\n map[row] += 1\\n else:\\n map[row] = 1\\n vals = map.values()\\n return 3 in vals\\n \\n def vertical(moves) -> bool:\\n map = {}\\n for move in moves:\\n col = move[1]\\n if col in map:\\n map[col] += 1\\n else:\\n map[col] = 1\\n vals = map.values()\\n return 3 in vals\\n\\n \\n def diagonal(moves) -> bool:\\n b1 = [0,0] in moves and [1,1] in moves and [2,2] in moves\\n b2 = [0,2] in moves and [1,1] in moves and [2,0] in moves\\n return b1 or b2\\n\\n if horizontal(As) or vertical(As) or diagonal(As):\\n return \\\"A\\\"\\n elif horizontal(Bs) or vertical(Bs) or diagonal(Bs):\\n return \\\"B\\\"\\n elif len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\\n\\n \",\n \"runtime\": \"35\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n\\n board = [[0 for j in range(3)] for i in range(3)]\\n\\n player = 1 \\n count = 0 \\n\\n for row, col in moves:\\n board[row][col] = player # Place player's mark\\n count += 1\\n player *= -1 # Alternate the player\\n\\n for i in range(3):\\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\\n return \\\"A\\\" if board[i][0] == 1 else \\\"B\\\"\\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\\n return \\\"A\\\" if board[0][i] == 1 else \\\"B\\\"\\n\\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\\n return \\\"A\\\" if board[0][0] == 1 else \\\"B\\\"\\n\\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\\n return \\\"A\\\" if board[0][2] == 1 else \\\"B\\\"\\n\\n return \\\"Draw\\\" if count == 9 else \\\"Pending\\\"\\n\",\n \"runtime\": \"36\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n matrix = []\\n for _ in range(0, 3):\\n row = [0]*3\\n matrix.append(row)\\n \\n for i in range(0, len(moves)):\\n row, col = moves[i]\\n #print(row, col)\\n if i % 2 == 0:\\n matrix[row][col] = 'A'\\n else:\\n matrix[row][col] = 'B'\\n #print(matrix)\\n \\n\\n ############ Row #####################\\n \\n for i in range(0, 3):\\n cnt_a = 0\\n cnt_b = 0\\n for j in range(0, 3):\\n if matrix[i][j] == 'A':\\n cnt_a = cnt_a+1\\n elif matrix[i][j] == 'B':\\n cnt_b = cnt_b+1\\n if cnt_a == 3:\\n return \\\"A\\\"\\n elif cnt_b == 3:\\n return \\\"B\\\"\\n \\n ########### Column #######################\\n for i in range(0, 3):\\n cnt_a = 0\\n cnt_b = 0\\n for j in range(0, 3):\\n if matrix[j][i] == 'A':\\n cnt_a = cnt_a+1\\n elif matrix[j][i] == 'B':\\n cnt_b = cnt_b+1\\n if cnt_a == 3:\\n return \\\"A\\\"\\n elif cnt_b == 3:\\n return \\\"B\\\"\\n \\n ########### diagonal #######################\\n cnt_a = 0\\n cnt_b = 0\\n for i in range(0, 3):\\n if matrix[i][i] == 'A':\\n cnt_a = cnt_a+1\\n elif matrix[i][i] == 'B':\\n cnt_b = cnt_b+1\\n if cnt_a == 3:\\n return \\\"A\\\"\\n elif cnt_b == 3:\\n return \\\"B\\\"\\n \\n cnt_a = 0\\n cnt_b = 0\\n for i in range(0, 3):\\n if matrix[i][2-i] == 'A':\\n cnt_a = cnt_a+1\\n elif matrix[i][2-i] == 'B':\\n cnt_b = cnt_b+1\\n if cnt_a == 3:\\n return \\\"A\\\"\\n elif cnt_b == 3:\\n return \\\"B\\\"\\n \\n #return \\\"\\\"\\n return \\\"Draw\\\" if len(moves) == 9 else'Pending'\\n'''class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n ar = self.sameRowCol(a, 0)\\n if ar[0] == 100:\\n return \\\"A\\\"\\n elif len(ar) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n \\n ac = self.sameRowCol(a, 1)\\n if ac[0] == 100:\\n return \\\"A\\\"\\n elif len(ac) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n br = self.sameRowCol(b, 0)\\n if br[0] == 100:\\n return \\\"B\\\"\\n elif len(br) == 2:\\n if self.occupied(a, br) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n bc = self.sameRowCol(b, 1)\\n if bc[0] == 100:\\n return \\\"B\\\"\\n elif len(bc) == 2:\\n if self.occupied(a, bc) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n \\n if len(a)+len(b) <=6:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"\\n \\n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\\n found = False\\n for r in route:\\n if r[0] == target[0] and r[1] == target[1]:\\n found = True\\n break\\n return found\\n \\n def diagnol(self, route: List[List[int]])->List[int]:\\n dic = {}\\n for r in route:\\n if r[0] in dic:\\n dic[r[0]].append(r[1])\\n else:\\n dic[r[0]] = []\\n dic[r[0]].append(r[1])\\n \\n cnt1, cnt2 = 0, 0\\n for i in range(0, 3):\\n for j in dic[i]:\\n if dic[i] == j:\\n cnt1 = cnt1+1\\n if dic[i]+j == 2:\\n cnt2 = cnt2+1\\n r = []\\n if cnt1 == 3 or cnt2 == 3:\\n r.append(100)\\n return r\\n \\n l = []\\n if cnt1 == 2:\\n if 1 not in dic:\\n r.append(1)\\n r.append(1)\\n return r\\n else:\\n found = False\\n for j in dic[1]:\\n if j == 1:\\n found = True\\n break\\n if found:\\n if 0 not in dic:\\n r.append(0)\\n r.append(0)\\n return r\\n else:\\n if 2 not in dic:\\n r.append(2)\\n r.append(2)\\n return r\\n else:\\n \\n \\n \\n \\n \\n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\\n dic = {}\\n idx2 = 0\\n if idx == 0:\\n idx2=1\\n for mv in route:\\n if mv[idx] in dic:\\n dic[mv[idx]].append(mv[idx2])\\n else:\\n dic[mv[idx]] = []\\n dic[mv[idx]].append(mv[idx2])\\n \\n for k in dic:\\n if len(dic[k]) >= 3:\\n r = []\\n r.append(100)\\n return r\\n elif len(dic[k]) == 2:\\n s = set(dic[k])\\n for i in range(0, 3):\\n if i not in s:\\n r=[]\\n r.append(k)\\n r.append(i)\\n return r\\n r=[]\\n r.append(-1)\\n return r'''\\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n a_row_total, a_col_total = 0, 0 \\n for mv in a:\\n a_row_total = a_row_total+mv[0]\\n a_col_total = a_col_total+mv[1]\\n if a_row_total == 3 or a_col_total ==3:\\n return \\\"A\\\"\\n \\n b_row_total, b_col_total = 0, 0 \\n for mv in b:\\n b_row_total = b_row_total+mv[0]\\n b_col_total = b_col_total+mv[1]\\n if b_row_total == 3 or b_col_total ==3:\\n return \\\"B\\\"\\n \\n if len(a) < 3 or len(b) < 3:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"'''\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = {}, {}\\n \\n for i in range(0, len(moves)):\\n if i % 2 ==0:\\n if moves[i][0] in a:\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n a[moves[i][0]] = []\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n if moves[i][0] in b:\\n b[moves[i][0]].append(moves[i][1])\\n else:\\n b[moves[i][0]] = []\\n b[moves[i][0]].append(moves[i][1])\\n print(a, b)\\n if len(a) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if a[i][0] != i:\\n Awin = False\\n #print(Awin)\\n if Awin:\\n return \\\"A\\\"\\n \\n if len(b) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if b[i][0] != i:\\n Awin = False\\n if Awin:\\n return \\\"B\\\"\\n \\n for k in range(0, 3):\\n if k in a:\\n if len(a[k]) >= 3:\\n return \\\"A\\\"\\n if k in b:\\n if len(b[k]) >= 3:\\n return \\\"B\\\"\\n \\n return \\\"Draw\\\"'''\\n \\n \\n \\n \",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n matrix = [[\\\"_\\\" for i in range(3)] for i in range(3)]\\n a = True \\n for move in moves: \\n currRow = move[0]\\n currCol = move[1]\\n matrix[currRow][currCol] = \\\"X\\\" if a else \\\"0\\\"\\n for col in range(3):\\n found = True\\n for row in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n for row in range(3):\\n found = True\\n for col in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\\n if matrix[1][1] != \\\"_\\\":\\n return \\\"A\\\" if matrix[1][1] == \\\"X\\\" else \\\"B\\\"\\n a = not a \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n\",\n \"runtime\": \"37\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import deque\\n\\nclass Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n \\n matrix = [['' for _ in range(3)] for _ in range(3)]\\n a_turn = True \\n\\n \\n def inbound(i, j):\\n return 0 <= i < 3 and 0 <= j < 3\\n\\n \\n for i in range(len(moves)):\\n r, c = moves[i][0], moves[i][1]\\n if a_turn:\\n matrix[r][c] = \\\"X\\\" \\n a_turn = False\\n else:\\n matrix[r][c] = \\\"O\\\" \\n a_turn = True\\n \\n \\n directions = [(0,1), (1,0), (1,1), (1,-1)]\\n \\n \\n def bfs(i, j, player):\\n for dx, dy in directions:\\n q = deque([(i, j, 1)]) \\n while q:\\n r, c, steps = q.popleft()\\n if steps == 3: \\n return True\\n nr, nc = r + dx, c + dy\\n if inbound(nr, nc) and matrix[nr][nc] == player:\\n q.append((nr, nc, steps + 1))\\n return False\\n\\n \\n for i in range(3):\\n for j in range(3):\\n if matrix[i][j] == \\\"X\\\" and bfs(i, j, \\\"X\\\"):\\n return \\\"A\\\"\\n if matrix[i][j] == \\\"O\\\" and bfs(i, j, \\\"O\\\"):\\n return \\\"B\\\"\\n \\n \\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n return \\\"Pending\\\"\\n\",\n \"runtime\": \"38\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n matrix = [[\\\"_\\\" for i in range(3)] for i in range(3)]\\n a = True \\n for move in moves: \\n currRow = move[0]\\n currCol = move[1]\\n matrix[currRow][currCol] = \\\"X\\\" if a else \\\"0\\\"\\n for col in range(3):\\n found = True\\n for row in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n for row in range(3):\\n found = True\\n for col in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\\n if matrix[1][1] != \\\"_\\\":\\n return \\\"A\\\" if matrix[1][1] == \\\"X\\\" else \\\"B\\\"\\n a = not a \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n grid = [[0] * 3 for _ in range(3)]\\n visited = 0\\n i = 0\\n while i < len(moves):\\n r, c = moves[i]\\n visited += 1\\n if i % 2 == 0:\\n grid[r][c] = 1\\n else:\\n grid[r][c] = -1\\n i += 1\\n\\n for r in range(len(grid)):\\n if sum(grid[r]) == 3:\\n return 'A'\\n elif sum(grid[r]) == -3:\\n return 'B'\\n \\n for c in range(len(grid[0])):\\n if grid[0][c] + grid[1][c] + grid[2][c] == 3:\\n return 'A'\\n elif grid[0][c] + grid[1][c] + grid[2][c] == -3:\\n return 'B'\\n \\n if grid[0][0] + grid[1][1] + grid[2][2] == 3:\\n return 'A'\\n elif grid[0][0] + grid[1][1] + grid[2][2] == -3:\\n return 'B'\\n \\n if grid[0][2] + grid[1][1] + grid[2][0] == 3:\\n return 'A'\\n elif grid[0][2] + grid[1][1] + grid[2][0] == -3:\\n return 'B' \\n \\n if visited == 9:\\n return 'Draw'\\n else:\\n return 'Pending'\",\n \"runtime\": \"39\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n winning_conditions = [\\n {(0, 0), (1, 1), (2, 2)},\\n {(0, 2), (1, 1), (2, 0)},\\n {(0, 0), (0, 1), (0, 2)},\\n {(1, 0), (1, 1), (1, 2)},\\n {(2, 0), (2, 1), (2, 2)},\\n {(0, 0), (1, 0), (2, 0)},\\n {(0, 1), (1, 1), (2, 1)},\\n {(0, 2), (1, 2), (2, 2)},\\n ]\\n amoves = {tuple(move) for move in moves[::2]}\\n bmoves = {tuple(move) for move in moves[1::2]}\\n for wcond in winning_conditions:\\n if wcond.issubset(amoves):\\n return \\\"A\\\"\\n elif wcond.issubset(bmoves):\\n return \\\"B\\\"\\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n board = [[0] * 3 for _ in range(3)]\\n\\n player = 1 # A\\n for move in moves:\\n board[move[0]][move[1]] = player\\n player *= -1\\n\\n # check by row\\n for i in range(3):\\n sum = 0\\n for j in range(3):\\n sum += board[i][j]\\n if sum == 3:\\n return \\\"A\\\"\\n if sum == -3:\\n return \\\"B\\\"\\n \\n # check by col\\n for j in range(3):\\n sum = 0\\n for i in range(3):\\n sum += board[i][j]\\n if sum == 3:\\n return \\\"A\\\"\\n if sum == -3:\\n return \\\"B\\\"\\n \\n # check by diagonal\\n sum = 0\\n for i in range(3):\\n sum += board[i][i]\\n \\n if sum == 3:\\n return \\\"A\\\"\\n if sum == -3:\\n return \\\"B\\\"\\n\\n \\\"\\\"\\\"\\n 0,2\\n 1,1\\n 2,0\\n \\\"\\\"\\\"\\n sum = 0\\n for i in range(3):\\n sum += board[0 + i][2 - i]\\n \\n if sum == 3:\\n return \\\"A\\\"\\n if sum == -3:\\n return \\\"B\\\"\\n \\n if len(moves) < 9:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"\\n\\n\",\n \"runtime\": \"40\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n table = [[0]*3 for _ in range(3)]\\n count = 1\\n for move in moves:\\n table[move[0]][move[1]] = count\\n count = -count\\n \\n print(table)\\n for i in range(3):\\n if table[0][i]==table[1][i]==table[2][i]:\\n if table[0][i]==1:\\n return \\\"A\\\"\\n elif table[0][i]==-1:\\n return \\\"B\\\"\\n \\n if table[i][0]==table[i][1]==table[i][2]:\\n if table[i][0]==1:\\n return \\\"A\\\"\\n elif table[i][0]==-1:\\n return \\\"B\\\"\\n \\n if table[0][0]==table[1][1]==table[2][2]:\\n if table[0][0]==1:\\n return \\\"A\\\"\\n elif table[0][0]==-1:\\n return \\\"B\\\"\\n\\n if table[2][0]==table[1][1]==table[0][2]:\\n if table[2][0]==1:\\n return \\\"A\\\"\\n elif table[2][0]==-1:\\n return \\\"B\\\"\\n \\n return 'Draw' if len(moves)==9 else 'Pending'\\n\\n \",\n \"runtime\": \"41\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n As = moves[::2]\\n Bs = moves[1::2]\\n \\n def horizontal(moves) -> bool:\\n map = {}\\n for move in moves:\\n row = move[0]\\n if row in map:\\n map[row] += 1\\n else:\\n map[row] = 1\\n vals = map.values()\\n return 3 in vals\\n \\n def vertical(moves) -> bool:\\n map = {}\\n for move in moves:\\n col = move[1]\\n if col in map:\\n map[col] += 1\\n else:\\n map[col] = 1\\n vals = map.values()\\n return 3 in vals\\n\\n \\n def diagonal(moves) -> bool:\\n b1 = [0,0] in moves and [1,1] in moves and [2,2] in moves\\n b2 = [0,2] in moves and [1,1] in moves and [2,0] in moves\\n return b1 or b2\\n\\n if horizontal(As) or vertical(As) or diagonal(As):\\n return \\\"A\\\"\\n elif horizontal(Bs) or vertical(Bs) or diagonal(Bs):\\n return \\\"B\\\"\\n elif len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\\n\\n \",\n \"runtime\": \"42\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n\\n # fill the grid\\n grid = [[' ' for _ in range(3)] for _ in range(3)]\\n\\n for idx, (x,y) in enumerate(moves):\\n if (idx % 2 == 0):\\n grid[x][y] = 'X'\\n else:\\n grid[x][y] = 'O'\\n\\n\\n # check for all rows\\n for i in range(3):\\n char_1 = grid[i][0]\\n char_2 = grid[i][1]\\n char_3 = grid[i][2]\\n\\n if char_1 == char_2 == char_3 == 'X':\\n return \\\"A\\\"\\n elif char_1 == char_2 == char_3 == 'O':\\n return \\\"B\\\"\\n \\n\\n # check for all cols\\n for i in range(3):\\n char_1 = grid[0][i]\\n char_2 = grid[1][i]\\n char_3 = grid[2][i]\\n\\n if char_1 == char_2 == char_3 == 'X':\\n return \\\"A\\\"\\n elif char_1 == char_2 == char_3 == 'O':\\n return \\\"B\\\"\\n\\n # check for both diagonals\\n if grid[0][0] == grid[1][1] == grid[2][2] == 'X':\\n return \\\"A\\\"\\n elif grid[0][0] == grid[1][1] == grid[2][2] == 'O':\\n return \\\"B\\\"\\n\\n #n Second Diagonal\\n if grid[0][2] == grid[1][1] == grid[2][0] == 'X':\\n return \\\"A\\\"\\n elif grid[0][2] == grid[1][1] == grid[2][0] == 'O':\\n return \\\"B\\\"\\n\\n\\n # if count < 9 then return pending else return draw\\n if len(moves) < 9:\\n return \\\"Pending\\\"\\n else:\\n return \\\"Draw\\\"\\n\\n \\n \",\n \"runtime\": \"43\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n grid = [None for _ in range(9)]\\n winLines = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]\\n playerOne = True\\n for move in moves:\\n x, y = move\\n grid[y*3+x] = playerOne\\n playerOne = not playerOne\\n for a,b,c in winLines:\\n if grid[a] == grid[b] == grid[c]:\\n if grid[a] is not None:\\n return (\\\"B\\\",\\\"A\\\")[grid[a]]\\n if any([s is None for s in grid]):\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # Approach 2024.09.19\\n cache = defaultdict(int)\\n for i, pt in enumerate(moves):\\n r_key = f\\\"{i%2}_p_{pt[0]}\\\"\\n c_key = f\\\"{i%2}_c_{pt[1]}\\\"\\n pd_key = f\\\"{i%2}_pd_{pt[0] + pt[1]}\\\"\\n nd_key = f\\\"{i%2}_nd_{pt[0] - pt[1]}\\\"\\n cache[r_key] += 1\\n cache[c_key] += 1\\n cache[pd_key] += 1\\n cache[nd_key] += 1\\n\\n if cache[r_key] == 3 or cache[c_key] == 3 or \\\\\\n cache[pd_key] == 3 or cache[nd_key] == 3:\\n if i%2 == 0:\\n return \\\"A\\\"\\n else:\\n return \\\"B\\\"\\n \\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\",\n \"runtime\": \"44\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n #a = x, b = o\\n player_a_moves, player_b_moves = moves[::2], moves[1::2]\\n \\n def dfs(player, idx):\\n seen.add(idx)\\n dirs = [(1, 0), (-1, 0), (0, 1), (0, -1), (-1, 1), (1, -1), (1, 1)]\\n q = collections.deque()\\n q.append((player_moves[player][idx], 1, dirs))\\n while q:\\n coord, connections, coord_moves = q.pop()\\n if connections == 3:\\n return player\\n for move in coord_moves:\\n x, y = move\\n px, py = coord\\n nx, ny = px + x, py + y\\n if nx in range(4) and ny in range(4) and [nx, ny] in player_moves[player]:\\n q.append(((nx, ny), connections + 1, [(x, y)]))\\n\\n player_moves = {\\\"A\\\":player_a_moves, \\\"B\\\":player_b_moves}\\n for player in player_moves:\\n seen = set()\\n for i in range(len(player_moves[player])):\\n if i not in seen:\\n outcome = dfs(player, i)\\n if outcome:\\n return outcome\\n #ends in draw\\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n return \\\"Pending\\\"\",\n \"runtime\": \"45\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":33,"string":"33"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n M = [ [0]*3 for _ in range(3) ]\n L = len(moves) \n s = ''\n def check(M):\n for r in range(3):\n n = sum(M[r])\n if n==3: return 'A'\n elif n==-3: return 'B'\n for c in range(3):\n n = M[0][c] + M[1][c] + M[2][c]\n if n==3: return 'A'\n elif n==-3: return 'B'\n n = M[0][0] + M[1][1] + M[2][2]\n if n==3: return 'A'\n elif n==-3: return 'B'\n n = M[0][2] + M[1][1] + M[2][0]\n if n==3: return 'A'\n elif n==-3: return 'B'\n return 'Pending'\n for i in range(L):\n v = 1 if i%2==0 else -1\n x,y = moves[i]\n M[x][y] = v\n s = check(M) \n if s=='A' or s=='B': return s \n return s if L<9 else 'Draw' ","memory":"16000"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n row = [0, 0, 0]\n col = [0, 0, 0]\n diag = 0\n anti_diag = 0\n\n player = 1\n for m in moves:\n row[m[0]] += player\n col[m[1]] += player\n if m[0] == m[1]:\n diag += player\n if m[0] + m[1] == 2:\n anti_diag += player\n \n if row[m[0]] == 3 or col[m[1]] == 3 or diag == 3 or anti_diag == 3:\n return \"A\"\n \n if row[m[0]] == -3 or col[m[1]] == -3 or diag == -3 or anti_diag == -3:\n return \"B\"\n \n player = -player\n \n return \"Draw\" if len(moves) == 9 else \"Pending\"\n\n \n\n\n","memory":"16100"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n turn = 0\n a_hist = [0] * 8\n b_hist = [0] * 8\n hist = [a_hist, b_hist]\n for row,col in moves:\n hist[turn][row] += 1\n hist[turn][col+3] += 1\n if row == col:\n hist[turn][6] += 1\n if row+col == 2:\n hist[turn][7] += 1\n turn = not(turn)\n for i in range(8):\n if a_hist[i] == 3:\n return 'A'\n elif b_hist[i] == 3:\n return 'B'\n if len(moves) < 9:\n return 'Pending'\n else:\n return 'Draw'","memory":"16200"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n rows = defaultdict(int)\n cols = defaultdict(int)\n left_diagonal = 0\n right_diagonal = 0\n \n n = 3\n curr = 1\n \n for i, (row, col) in enumerate(moves):\n rows[row] += curr\n cols[col] += curr\n if row == col:\n left_diagonal += curr\n if row + col == n - 1:\n right_diagonal += curr\n \n if (abs(rows[row]) == n or \n abs(cols[col]) == n or \n abs(left_diagonal) == n or \n abs(right_diagonal) == n):\n return 'A' if curr == 1 else 'B'\n \n curr = -curr\n \n if len(moves) == n * n:\n return 'Draw'\n else:\n return 'Pending'\n","memory":"16300"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n = 3\n rows, cols = [0]*n, [0]*n\n diag = anti = 0\n player = 1\n for row, col in moves:\n rows[row] += player\n cols[col] += player\n if row == col:\n diag += player\n if row + col == n-1:\n anti += player\n \n if any(abs(line) == n for line in (rows[row], cols[col], diag, anti)):\n return \"A\" if player == 1 else \"B\"\n\n player *= -1\n return \"Draw\" if len(moves) == n*n else \"Pending\"","memory":"16400"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n # Initialize the board\n board = [[0 for j in range(3)] for i in range(3)]\n\n player = 1 # 1 for Player A, -1 for Player B\n count = 0 # To keep track of the number of moves\n\n # Place each move on the board\n for row, col in moves:\n board[row][col] = player # Place player's mark\n count += 1\n player *= -1 # Alternate the player\n\n # Check rows and columns for a win\n for i in range(3):\n # Check the ith row\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\n return \"A\" if board[i][0] == 1 else \"B\"\n # Check the ith column\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\n return \"A\" if board[0][i] == 1 else \"B\"\n\n # Check the main diagonal\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\n return \"A\" if board[0][0] == 1 else \"B\"\n\n # Check the anti-diagonal\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\n return \"A\" if board[0][2] == 1 else \"B\"\n\n # If all moves are made and no winner, return \"Draw\"\n return \"Draw\" if count == 9 else \"Pending\"\n","memory":"16400"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n matrix = [[\"_\" for i in range(3)] for i in range(3)]\n a = True \n for move in moves: \n currRow = move[0]\n currCol = move[1]\n matrix[currRow][currCol] = \"X\" if a else \"0\"\n for col in range(3):\n found = True\n for row in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n for row in range(3):\n found = True\n for col in range(3):\n if matrix[row][col] != (\"X\" if a else \"0\"): \n found = False \n break\n if found: \n return \"A\" if a else \"B\" \n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\n if matrix[1][1] != \"_\":\n return \"A\" if matrix[1][1] == \"X\" else \"B\"\n a = not a \n return \"Draw\" if len(moves) == 9 else \"Pending\"\n","memory":"16500"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n matrix = [[\"\" for _ in range(3)] for _ in range(3)]\n input = []\n for idx in range(len(moves)):\n if idx % 2 == 0:\n input.append(\"A\")\n else:\n input.append(\"B\")\n for i in range(len(moves)):\n row, col = moves[i]\n matrix[row][col] = input[i]\n\n # return matrix\n x=0\n while x < 3:\n if matrix[x][0] == matrix[x][1] == matrix[x][2] and matrix[x][0] != \"\":\n return matrix[x][0]\n elif matrix[0][x] == matrix[1][x] == matrix[2][x] and matrix[0][x] != \"\":\n return matrix[0][x]\n elif matrix[0][0] == matrix[1][1] == matrix[2][2] and matrix[0][0] != \"\":\n return matrix[0][0]\n elif matrix[0][2] == matrix[1][1] == matrix[2][0] and matrix[0][2] != \"\":\n return matrix[0][2]\n x+=1\n if len(moves) == 9:\n return \"Draw\"\n else:\n return \"Pending\"\n","memory":"16500"},{"code":"from typing import List\nfrom collections import deque\n\nclass Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n \n matrix = [['' for _ in range(3)] for _ in range(3)]\n a_turn = True \n\n \n def inbound(i, j):\n return 0 <= i < 3 and 0 <= j < 3\n\n \n for i in range(len(moves)):\n r, c = moves[i][0], moves[i][1]\n if a_turn:\n matrix[r][c] = \"X\" \n a_turn = False\n else:\n matrix[r][c] = \"O\" \n a_turn = True\n \n \n directions = [(0,1), (1,0), (1,1), (1,-1)]\n \n \n def bfs(i, j, player):\n for dx, dy in directions:\n q = deque([(i, j, 1)]) \n while q:\n r, c, steps = q.popleft()\n if steps == 3: \n return True\n nr, nc = r + dx, c + dy\n if inbound(nr, nc) and matrix[nr][nc] == player:\n q.append((nr, nc, steps + 1))\n return False\n\n \n for i in range(3):\n for j in range(3):\n if matrix[i][j] == \"X\" and bfs(i, j, \"X\"):\n return \"A\"\n if matrix[i][j] == \"O\" and bfs(i, j, \"O\"):\n return \"B\"\n \n \n if len(moves) == 9:\n return \"Draw\"\n return \"Pending\"\n","memory":"16600"},{"code":"class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n n = len(moves)\n matrix = [[0] * 3 for _ in range(3)]\n \n def isvalid(directions):\n hash_map = Counter(directions)\n del hash_map[0]\n for key, count in hash_map.items():\n if count == 3:\n return key\n \n for i in range(n):\n if i % 2 == 0:\n row, col = moves[i]\n matrix[row][col] = 'A'\n else:\n row, col = moves[i]\n matrix[row][col] = 'B'\n\n ############ Row #####################\n\n for row in matrix:\n row_map = Counter(row)\n del row_map[0]\n for key, count in row_map.items():\n if count == 3:\n return key\n\n ########### Column #######################\n\n for j in range(len(matrix)):\n columns = [row[j] for row in matrix]\n col_map = Counter(columns)\n del col_map[0]\n for key, count in col_map.items():\n if count == 3:\n return key\n\n ########### diagonal #######################\n \n diagonal,anti_diagonal = [], []\n for i in range(len(matrix)):\n for j in range(len(matrix)):\n if i - j == 0:\n diagonal.append(matrix[i][j])\n if i + j == 2:\n anti_diagonal.append(matrix[i][j])\n\n diagonal_map = Counter(diagonal)\n del diagonal_map[0]\n for key, count in diagonal_map.items():\n if count == 3:\n return key\n\n anti_diagonal_map = Counter(anti_diagonal)\n del anti_diagonal_map[0]\n for key, count in anti_diagonal_map.items():\n if count == 3:\n return key\n\n \n return \"Draw\" if len(moves) == 9 else'Pending'\n'''class Solution:\n def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n ar = self.sameRowCol(a, 0)\n if ar[0] == 100:\n return \"A\"\n elif len(ar) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n \n ac = self.sameRowCol(a, 1)\n if ac[0] == 100:\n return \"A\"\n elif len(ac) == 2:\n if self.occupied(b, ar) == False and len(a) <= len(b):\n return \"A\"\n br = self.sameRowCol(b, 0)\n if br[0] == 100:\n return \"B\"\n elif len(br) == 2:\n if self.occupied(a, br) == False and len(b) <= len(a):\n return \"B\"\n bc = self.sameRowCol(b, 1)\n if bc[0] == 100:\n return \"B\"\n elif len(bc) == 2:\n if self.occupied(a, bc) == False and len(b) <= len(a):\n return \"B\"\n \n if len(a)+len(b) <=6:\n return \"Pending\"\n return \"Draw\"\n \n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\n found = False\n for r in route:\n if r[0] == target[0] and r[1] == target[1]:\n found = True\n break\n return found\n \n def diagnol(self, route: List[List[int]])->List[int]:\n dic = {}\n for r in route:\n if r[0] in dic:\n dic[r[0]].append(r[1])\n else:\n dic[r[0]] = []\n dic[r[0]].append(r[1])\n \n cnt1, cnt2 = 0, 0\n for i in range(0, 3):\n for j in dic[i]:\n if dic[i] == j:\n cnt1 = cnt1+1\n if dic[i]+j == 2:\n cnt2 = cnt2+1\n r = []\n if cnt1 == 3 or cnt2 == 3:\n r.append(100)\n return r\n \n l = []\n if cnt1 == 2:\n if 1 not in dic:\n r.append(1)\n r.append(1)\n return r\n else:\n found = False\n for j in dic[1]:\n if j == 1:\n found = True\n break\n if found:\n if 0 not in dic:\n r.append(0)\n r.append(0)\n return r\n else:\n if 2 not in dic:\n r.append(2)\n r.append(2)\n return r\n else:\n \n \n \n \n \n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\n dic = {}\n idx2 = 0\n if idx == 0:\n idx2=1\n for mv in route:\n if mv[idx] in dic:\n dic[mv[idx]].append(mv[idx2])\n else:\n dic[mv[idx]] = []\n dic[mv[idx]].append(mv[idx2])\n \n for k in dic:\n if len(dic[k]) >= 3:\n r = []\n r.append(100)\n return r\n elif len(dic[k]) == 2:\n s = set(dic[k])\n for i in range(0, 3):\n if i not in s:\n r=[]\n r.append(k)\n r.append(i)\n return r\n r=[]\n r.append(-1)\n return r'''\n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = [], []\n for i in range(0, len(moves)):\n if i % 2 == 0:\n a.append(moves[i])\n else:\n b.append(moves[i])\n \n a_row_total, a_col_total = 0, 0 \n for mv in a:\n a_row_total = a_row_total+mv[0]\n a_col_total = a_col_total+mv[1]\n if a_row_total == 3 or a_col_total ==3:\n return \"A\"\n \n b_row_total, b_col_total = 0, 0 \n for mv in b:\n b_row_total = b_row_total+mv[0]\n b_col_total = b_col_total+mv[1]\n if b_row_total == 3 or b_col_total ==3:\n return \"B\"\n \n if len(a) < 3 or len(b) < 3:\n return \"Pending\"\n return \"Draw\"'''\n \n \n \n \n \n \n \n \n \n \n \n'''def tictactoe(self, moves: List[List[int]]) -> str:\n a, b = {}, {}\n \n for i in range(0, len(moves)):\n if i % 2 ==0:\n if moves[i][0] in a:\n a[moves[i][0]].append(moves[i][1])\n else:\n a[moves[i][0]] = []\n a[moves[i][0]].append(moves[i][1])\n else:\n if moves[i][0] in b:\n b[moves[i][0]].append(moves[i][1])\n else:\n b[moves[i][0]] = []\n b[moves[i][0]].append(moves[i][1])\n print(a, b)\n if len(a) >= 3:\n Awin = True\n for i in range(0, 3):\n if a[i][0] != i:\n Awin = False\n #print(Awin)\n if Awin:\n return \"A\"\n \n if len(b) >= 3:\n Awin = True\n for i in range(0, 3):\n if b[i][0] != i:\n Awin = False\n if Awin:\n return \"B\"\n \n for k in range(0, 3):\n if k in a:\n if len(a[k]) >= 3:\n return \"A\"\n if k in b:\n if len(b[k]) >= 3:\n return \"B\"\n \n return \"Draw\"'''\n \n \n \n ","memory":"16600"}],"string":"[\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n M = [ [0]*3 for _ in range(3) ]\\n L = len(moves) \\n s = ''\\n def check(M):\\n for r in range(3):\\n n = sum(M[r])\\n if n==3: return 'A'\\n elif n==-3: return 'B'\\n for c in range(3):\\n n = M[0][c] + M[1][c] + M[2][c]\\n if n==3: return 'A'\\n elif n==-3: return 'B'\\n n = M[0][0] + M[1][1] + M[2][2]\\n if n==3: return 'A'\\n elif n==-3: return 'B'\\n n = M[0][2] + M[1][1] + M[2][0]\\n if n==3: return 'A'\\n elif n==-3: return 'B'\\n return 'Pending'\\n for i in range(L):\\n v = 1 if i%2==0 else -1\\n x,y = moves[i]\\n M[x][y] = v\\n s = check(M) \\n if s=='A' or s=='B': return s \\n return s if L<9 else 'Draw' \",\n \"memory\": \"16000\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n row = [0, 0, 0]\\n col = [0, 0, 0]\\n diag = 0\\n anti_diag = 0\\n\\n player = 1\\n for m in moves:\\n row[m[0]] += player\\n col[m[1]] += player\\n if m[0] == m[1]:\\n diag += player\\n if m[0] + m[1] == 2:\\n anti_diag += player\\n \\n if row[m[0]] == 3 or col[m[1]] == 3 or diag == 3 or anti_diag == 3:\\n return \\\"A\\\"\\n \\n if row[m[0]] == -3 or col[m[1]] == -3 or diag == -3 or anti_diag == -3:\\n return \\\"B\\\"\\n \\n player = -player\\n \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n\\n \\n\\n\\n\",\n \"memory\": \"16100\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n turn = 0\\n a_hist = [0] * 8\\n b_hist = [0] * 8\\n hist = [a_hist, b_hist]\\n for row,col in moves:\\n hist[turn][row] += 1\\n hist[turn][col+3] += 1\\n if row == col:\\n hist[turn][6] += 1\\n if row+col == 2:\\n hist[turn][7] += 1\\n turn = not(turn)\\n for i in range(8):\\n if a_hist[i] == 3:\\n return 'A'\\n elif b_hist[i] == 3:\\n return 'B'\\n if len(moves) < 9:\\n return 'Pending'\\n else:\\n return 'Draw'\",\n \"memory\": \"16200\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n rows = defaultdict(int)\\n cols = defaultdict(int)\\n left_diagonal = 0\\n right_diagonal = 0\\n \\n n = 3\\n curr = 1\\n \\n for i, (row, col) in enumerate(moves):\\n rows[row] += curr\\n cols[col] += curr\\n if row == col:\\n left_diagonal += curr\\n if row + col == n - 1:\\n right_diagonal += curr\\n \\n if (abs(rows[row]) == n or \\n abs(cols[col]) == n or \\n abs(left_diagonal) == n or \\n abs(right_diagonal) == n):\\n return 'A' if curr == 1 else 'B'\\n \\n curr = -curr\\n \\n if len(moves) == n * n:\\n return 'Draw'\\n else:\\n return 'Pending'\\n\",\n \"memory\": \"16300\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n = 3\\n rows, cols = [0]*n, [0]*n\\n diag = anti = 0\\n player = 1\\n for row, col in moves:\\n rows[row] += player\\n cols[col] += player\\n if row == col:\\n diag += player\\n if row + col == n-1:\\n anti += player\\n \\n if any(abs(line) == n for line in (rows[row], cols[col], diag, anti)):\\n return \\\"A\\\" if player == 1 else \\\"B\\\"\\n\\n player *= -1\\n return \\\"Draw\\\" if len(moves) == n*n else \\\"Pending\\\"\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n # Initialize the board\\n board = [[0 for j in range(3)] for i in range(3)]\\n\\n player = 1 # 1 for Player A, -1 for Player B\\n count = 0 # To keep track of the number of moves\\n\\n # Place each move on the board\\n for row, col in moves:\\n board[row][col] = player # Place player's mark\\n count += 1\\n player *= -1 # Alternate the player\\n\\n # Check rows and columns for a win\\n for i in range(3):\\n # Check the ith row\\n if abs(board[i][0] + board[i][1] + board[i][2]) == 3:\\n return \\\"A\\\" if board[i][0] == 1 else \\\"B\\\"\\n # Check the ith column\\n if abs(board[0][i] + board[1][i] + board[2][i]) == 3:\\n return \\\"A\\\" if board[0][i] == 1 else \\\"B\\\"\\n\\n # Check the main diagonal\\n if abs(board[0][0] + board[1][1] + board[2][2]) == 3:\\n return \\\"A\\\" if board[0][0] == 1 else \\\"B\\\"\\n\\n # Check the anti-diagonal\\n if abs(board[0][2] + board[1][1] + board[2][0]) == 3:\\n return \\\"A\\\" if board[0][2] == 1 else \\\"B\\\"\\n\\n # If all moves are made and no winner, return \\\"Draw\\\"\\n return \\\"Draw\\\" if count == 9 else \\\"Pending\\\"\\n\",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n matrix = [[\\\"_\\\" for i in range(3)] for i in range(3)]\\n a = True \\n for move in moves: \\n currRow = move[0]\\n currCol = move[1]\\n matrix[currRow][currCol] = \\\"X\\\" if a else \\\"0\\\"\\n for col in range(3):\\n found = True\\n for row in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n for row in range(3):\\n found = True\\n for col in range(3):\\n if matrix[row][col] != (\\\"X\\\" if a else \\\"0\\\"): \\n found = False \\n break\\n if found: \\n return \\\"A\\\" if a else \\\"B\\\" \\n if (matrix[0][0] == matrix[1][1] and matrix[1][1] == matrix[2][2]) or (matrix[0][2] == matrix[1][1] and matrix[1][1] == matrix[2][0]):\\n if matrix[1][1] != \\\"_\\\":\\n return \\\"A\\\" if matrix[1][1] == \\\"X\\\" else \\\"B\\\"\\n a = not a \\n return \\\"Draw\\\" if len(moves) == 9 else \\\"Pending\\\"\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n matrix = [[\\\"\\\" for _ in range(3)] for _ in range(3)]\\n input = []\\n for idx in range(len(moves)):\\n if idx % 2 == 0:\\n input.append(\\\"A\\\")\\n else:\\n input.append(\\\"B\\\")\\n for i in range(len(moves)):\\n row, col = moves[i]\\n matrix[row][col] = input[i]\\n\\n # return matrix\\n x=0\\n while x < 3:\\n if matrix[x][0] == matrix[x][1] == matrix[x][2] and matrix[x][0] != \\\"\\\":\\n return matrix[x][0]\\n elif matrix[0][x] == matrix[1][x] == matrix[2][x] and matrix[0][x] != \\\"\\\":\\n return matrix[0][x]\\n elif matrix[0][0] == matrix[1][1] == matrix[2][2] and matrix[0][0] != \\\"\\\":\\n return matrix[0][0]\\n elif matrix[0][2] == matrix[1][1] == matrix[2][0] and matrix[0][2] != \\\"\\\":\\n return matrix[0][2]\\n x+=1\\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n else:\\n return \\\"Pending\\\"\\n\",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"from typing import List\\nfrom collections import deque\\n\\nclass Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n \\n matrix = [['' for _ in range(3)] for _ in range(3)]\\n a_turn = True \\n\\n \\n def inbound(i, j):\\n return 0 <= i < 3 and 0 <= j < 3\\n\\n \\n for i in range(len(moves)):\\n r, c = moves[i][0], moves[i][1]\\n if a_turn:\\n matrix[r][c] = \\\"X\\\" \\n a_turn = False\\n else:\\n matrix[r][c] = \\\"O\\\" \\n a_turn = True\\n \\n \\n directions = [(0,1), (1,0), (1,1), (1,-1)]\\n \\n \\n def bfs(i, j, player):\\n for dx, dy in directions:\\n q = deque([(i, j, 1)]) \\n while q:\\n r, c, steps = q.popleft()\\n if steps == 3: \\n return True\\n nr, nc = r + dx, c + dy\\n if inbound(nr, nc) and matrix[nr][nc] == player:\\n q.append((nr, nc, steps + 1))\\n return False\\n\\n \\n for i in range(3):\\n for j in range(3):\\n if matrix[i][j] == \\\"X\\\" and bfs(i, j, \\\"X\\\"):\\n return \\\"A\\\"\\n if matrix[i][j] == \\\"O\\\" and bfs(i, j, \\\"O\\\"):\\n return \\\"B\\\"\\n \\n \\n if len(moves) == 9:\\n return \\\"Draw\\\"\\n return \\\"Pending\\\"\\n\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n n = len(moves)\\n matrix = [[0] * 3 for _ in range(3)]\\n \\n def isvalid(directions):\\n hash_map = Counter(directions)\\n del hash_map[0]\\n for key, count in hash_map.items():\\n if count == 3:\\n return key\\n \\n for i in range(n):\\n if i % 2 == 0:\\n row, col = moves[i]\\n matrix[row][col] = 'A'\\n else:\\n row, col = moves[i]\\n matrix[row][col] = 'B'\\n\\n ############ Row #####################\\n\\n for row in matrix:\\n row_map = Counter(row)\\n del row_map[0]\\n for key, count in row_map.items():\\n if count == 3:\\n return key\\n\\n ########### Column #######################\\n\\n for j in range(len(matrix)):\\n columns = [row[j] for row in matrix]\\n col_map = Counter(columns)\\n del col_map[0]\\n for key, count in col_map.items():\\n if count == 3:\\n return key\\n\\n ########### diagonal #######################\\n \\n diagonal,anti_diagonal = [], []\\n for i in range(len(matrix)):\\n for j in range(len(matrix)):\\n if i - j == 0:\\n diagonal.append(matrix[i][j])\\n if i + j == 2:\\n anti_diagonal.append(matrix[i][j])\\n\\n diagonal_map = Counter(diagonal)\\n del diagonal_map[0]\\n for key, count in diagonal_map.items():\\n if count == 3:\\n return key\\n\\n anti_diagonal_map = Counter(anti_diagonal)\\n del anti_diagonal_map[0]\\n for key, count in anti_diagonal_map.items():\\n if count == 3:\\n return key\\n\\n \\n return \\\"Draw\\\" if len(moves) == 9 else'Pending'\\n'''class Solution:\\n def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n ar = self.sameRowCol(a, 0)\\n if ar[0] == 100:\\n return \\\"A\\\"\\n elif len(ar) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n \\n ac = self.sameRowCol(a, 1)\\n if ac[0] == 100:\\n return \\\"A\\\"\\n elif len(ac) == 2:\\n if self.occupied(b, ar) == False and len(a) <= len(b):\\n return \\\"A\\\"\\n br = self.sameRowCol(b, 0)\\n if br[0] == 100:\\n return \\\"B\\\"\\n elif len(br) == 2:\\n if self.occupied(a, br) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n bc = self.sameRowCol(b, 1)\\n if bc[0] == 100:\\n return \\\"B\\\"\\n elif len(bc) == 2:\\n if self.occupied(a, bc) == False and len(b) <= len(a):\\n return \\\"B\\\"\\n \\n if len(a)+len(b) <=6:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"\\n \\n def occupied(self, route: List[List[int]], target: List[int]) -> bool:\\n found = False\\n for r in route:\\n if r[0] == target[0] and r[1] == target[1]:\\n found = True\\n break\\n return found\\n \\n def diagnol(self, route: List[List[int]])->List[int]:\\n dic = {}\\n for r in route:\\n if r[0] in dic:\\n dic[r[0]].append(r[1])\\n else:\\n dic[r[0]] = []\\n dic[r[0]].append(r[1])\\n \\n cnt1, cnt2 = 0, 0\\n for i in range(0, 3):\\n for j in dic[i]:\\n if dic[i] == j:\\n cnt1 = cnt1+1\\n if dic[i]+j == 2:\\n cnt2 = cnt2+1\\n r = []\\n if cnt1 == 3 or cnt2 == 3:\\n r.append(100)\\n return r\\n \\n l = []\\n if cnt1 == 2:\\n if 1 not in dic:\\n r.append(1)\\n r.append(1)\\n return r\\n else:\\n found = False\\n for j in dic[1]:\\n if j == 1:\\n found = True\\n break\\n if found:\\n if 0 not in dic:\\n r.append(0)\\n r.append(0)\\n return r\\n else:\\n if 2 not in dic:\\n r.append(2)\\n r.append(2)\\n return r\\n else:\\n \\n \\n \\n \\n \\n def sameRowCol(self, route: List[List[int]], idx: int) -> List[int]:\\n dic = {}\\n idx2 = 0\\n if idx == 0:\\n idx2=1\\n for mv in route:\\n if mv[idx] in dic:\\n dic[mv[idx]].append(mv[idx2])\\n else:\\n dic[mv[idx]] = []\\n dic[mv[idx]].append(mv[idx2])\\n \\n for k in dic:\\n if len(dic[k]) >= 3:\\n r = []\\n r.append(100)\\n return r\\n elif len(dic[k]) == 2:\\n s = set(dic[k])\\n for i in range(0, 3):\\n if i not in s:\\n r=[]\\n r.append(k)\\n r.append(i)\\n return r\\n r=[]\\n r.append(-1)\\n return r'''\\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = [], []\\n for i in range(0, len(moves)):\\n if i % 2 == 0:\\n a.append(moves[i])\\n else:\\n b.append(moves[i])\\n \\n a_row_total, a_col_total = 0, 0 \\n for mv in a:\\n a_row_total = a_row_total+mv[0]\\n a_col_total = a_col_total+mv[1]\\n if a_row_total == 3 or a_col_total ==3:\\n return \\\"A\\\"\\n \\n b_row_total, b_col_total = 0, 0 \\n for mv in b:\\n b_row_total = b_row_total+mv[0]\\n b_col_total = b_col_total+mv[1]\\n if b_row_total == 3 or b_col_total ==3:\\n return \\\"B\\\"\\n \\n if len(a) < 3 or len(b) < 3:\\n return \\\"Pending\\\"\\n return \\\"Draw\\\"'''\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n'''def tictactoe(self, moves: List[List[int]]) -> str:\\n a, b = {}, {}\\n \\n for i in range(0, len(moves)):\\n if i % 2 ==0:\\n if moves[i][0] in a:\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n a[moves[i][0]] = []\\n a[moves[i][0]].append(moves[i][1])\\n else:\\n if moves[i][0] in b:\\n b[moves[i][0]].append(moves[i][1])\\n else:\\n b[moves[i][0]] = []\\n b[moves[i][0]].append(moves[i][1])\\n print(a, b)\\n if len(a) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if a[i][0] != i:\\n Awin = False\\n #print(Awin)\\n if Awin:\\n return \\\"A\\\"\\n \\n if len(b) >= 3:\\n Awin = True\\n for i in range(0, 3):\\n if b[i][0] != i:\\n Awin = False\\n if Awin:\\n return \\\"B\\\"\\n \\n for k in range(0, 3):\\n if k in a:\\n if len(a[k]) >= 3:\\n return \\\"A\\\"\\n if k in b:\\n if len(b[k]) >= 3:\\n return \\\"B\\\"\\n \\n return \\\"Draw\\\"'''\\n \\n \\n \\n \",\n \"memory\": \"16600\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":10,"string":"10"}}},{"rowIdx":2473,"cells":{"question_id":{"kind":"number","value":3490,"string":"3,490"},"name":{"kind":"string","value":"find-the-maximum-length-of-valid-subsequence-i"},"content":{"kind":"string","value":"You are given an integer array <code>nums</code>.\n<p>A <span data-keyword=\"subsequence-array\">subsequence</span> <code>sub</code> of <code>nums</code> with length <code>x</code> is called <strong>valid</strong> if it satisfies:</p>\n\n<ul>\n\t<li><code>(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.</code></li>\n</ul>\n\n<p>Return the length of the <strong>longest</strong> <strong>valid</strong> subsequence of <code>nums</code>.</p>\n\n<p>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,4]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The longest valid subsequence is <code>[1, 2, 3, 4]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,1,1,2,1,2]</span></p>\n\n<p><strong>Output:</strong> 6</p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The longest valid subsequence is <code>[1, 2, 1, 2, 1, 2]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 3:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,3]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">2</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The longest valid subsequence is <code>[1, 3]</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= nums.length <= 2 * 10<sup>5</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>7</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":37.92171153167979,"string":"37.921712"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"560\", 0.7968], [\"565\", 0.9959999999999999], [\"570\", 2.7888], [\"575\", 3.984], [\"580\", 2.9879999999999995], [\"585\", 6.1752], [\"590\", 3.5856], [\"595\", 4.7808], [\"600\", 3.7848], [\"605\", 4.7808], [\"610\", 5.1792], [\"615\", 3.984], [\"620\", 4.7808], [\"625\", 3.3864], [\"630\", 3.1872000000000003], [\"635\", 3.5856], [\"640\", 3.7847999999999997], [\"645\", 4.780799999999999], [\"650\", 2.988], [\"655\", 2.9880000000000004], [\"659\", 2.3904], [\"664\", 2.1912000000000003], [\"669\", 1.7928], [\"674\", 0.5975999999999999], [\"679\", 1.1951999999999998], [\"684\", 0.1992], [\"689\", 0.3984], [\"694\", 0.5975999999999999], [\"699\", 0.3984], [\"704\", 0.5975999999999999], [\"709\", 0.1992], [\"714\", 0.1992], [\"719\", 0.3984], [\"724\", 0.3984], [\"729\", 0.1992], [\"734\", 0.5976], [\"739\", 0.1992], [\"744\", 0.1992], [\"749\", 0.1992], [\"754\", 0.1992], [\"759\", 0.1992], [\"764\", 0.5975999999999999], [\"769\", 0.3984], [\"774\", 0.1992], [\"779\", 0.1992], [\"784\", 0.1992], [\"789\", 0.1992], [\"794\", 0.1992], [\"799\", 0.1992], [\"804\", 0.7968], [\"809\", 0.1992], [\"814\", 0.3984], [\"819\", 0.3984], [\"824\", 0.1992], [\"829\", 0.5975999999999999], [\"834\", 0.1992], [\"839\", 0.1992], [\"844\", 0.1992], [\"849\", 0.1992], [\"854\", 0.1992], [\"858\", 0.3984], [\"863\", 0.1992], [\"868\", 0.1992], [\"873\", 0.1992], [\"878\", 0.1992], [\"883\", 0.1992], [\"888\", 0.1992], [\"893\", 0.1992], [\"898\", 0.1992], [\"903\", 0.1992], [\"908\", 0.1992]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"35200\", 0.3984], [\"35300\", 0.1992], [\"35900\", 0.5976], [\"36000\", 0.5976], [\"36100\", 0.5976], [\"36800\", 0.1992], [\"36900\", 0.1992], [\"37600\", 0.1992], [\"37900\", 0.1992], [\"38000\", 0.1992], [\"38100\", 0.1992], [\"38200\", 0.5976], [\"38300\", 3.9841], [\"38400\", 3.3865], [\"38500\", 0.1992], [\"38600\", 0.1992], [\"38900\", 1.5936], [\"39000\", 6.1753], [\"39100\", 26.6932], [\"39200\", 25.6972], [\"39300\", 1.5936], [\"39500\", 0.3984], [\"39600\", 0.3984], [\"39700\", 1.5936], [\"39800\", 7.5697], [\"39900\", 5.5777], [\"40000\", 0.5976], [\"40600\", 0.1992], [\"41200\", 0.1992], [\"41300\", 0.5976], [\"41400\", 0.3984], [\"41500\", 0.3984], [\"42100\", 0.1992], [\"42200\", 0.1992], [\"42900\", 0.3984], [\"43000\", 0.3984], [\"43700\", 0.1992], [\"47900\", 0.1992], [\"49900\", 0.1992], [\"50200\", 0.1992], [\"51500\", 0.1992], [\"52300\", 0.1992], [\"56400\", 0.5976], [\"57100\", 0.1992]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n a,b,c,d = 0,0,0,0\n for v in nums:\n if v%2==0: a,b = a+1, c+1\n else: c,d = b+1,d+1\n return max(a,b,c,d)\n\n ","runtime":"560"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n odd, even, alternating = 0, 0, 0\n expected_sign = nums[0] % 2\n for num in nums:\n if num % 2 == 0:\n even += 1\n else:\n odd += 1\n if num % 2 == expected_sign:\n alternating += 1\n expected_sign = 1 - expected_sign\n return max(odd, even, alternating)","runtime":"560"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n odds = evens = swaps = 0\n swap_even = not (nums[0] % 2 == 0)\n \n for i in nums:\n if i % 2 == 0:\n evens += 1\n if not swap_even:\n swap_even = True\n swaps += 1\n else:\n odds += 1\n if swap_even:\n swap_even = False\n swaps += 1\n \n return max([swaps, evens, odds])","runtime":"565"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n remainders = [i % 2 for i in nums]\n parity_sum = sum(remainders)\n prev = remainders[0]\n n = 1\n for i in remainders[1:]:\n if prev != i:\n n += 1\n prev = i\n res = max(len(remainders) - parity_sum, parity_sum)\n res = max(res, n)\n return res","runtime":"565"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n\n n = len(nums)\n \n oddodd = 0\n oddeven = 0\n eveneven = 0\n evenodd = 0\n\n for i in range(n):\n if nums[i] % 2 == 0:\n eveneven += 1\n evenodd = oddeven + 1\n else:\n oddodd += 1\n oddeven = evenodd + 1\n\n return max(oddodd, oddeven, eveneven, evenodd)","runtime":"570"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n,k,prev = len(nums),1,nums[0]%2\n ones=prev\n for x in nums[1:]:\n x%=2\n ones+=x\n if prev!=x:\n k+=1\n prev=x\n return max(ones,n-ones,k)","runtime":"570"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even = 0\n odd = 0\n evenodd = 0\n oddeven = 0\n\n for num in nums:\n if num % 2 == 0:\n even += 1\n evenodd = oddeven + 1\n else:\n odd += 1\n oddeven = evenodd + 1\n\n return max(even, odd, evenodd, oddeven)","runtime":"575"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n if len(nums) == 0:\n return 0\n nums = [x % 2 for x in nums]\n all_odd = sum(nums)\n all_even = len(nums) - all_odd\n alternating = 1\n last = nums[0]\n for i in range(1, len(nums)):\n if nums[i] != last:\n last = nums[i]\n alternating += 1\n return max(all_odd, all_even, alternating)\n\n","runtime":"575"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n c = nums[0] % 2\n odd = even = both = 0\n for num in nums:\n if num % 2 == 0:\n even += 1\n else:\n odd += 1\n if num % 2 == c:\n both += 1\n c = 1 - c # Toggle the parity\n return max(both, even, odd)","runtime":"580"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # Declaration to count odd, even and both pair.\n # In both pair 1st odd, 2nd even, 3rd odd ....\n # To count if pair (sub[i] + sub[i + 1]) % 2 for if all element odd, even or both\n c = nums[0] % 2\n odd = 0\n even = 0\n both = 0\n for num in nums:\n if num % 2 == 0:\n even += 1\n else:\n odd += 1\n # Check if the current number's parity matches the expected parity `c`.\n if num % 2 == c:\n #// If yes, it means we are continuing a valid alternating pattern.\n both += 1\n #// Flip the expected parity for the next number (0 becomes 1, 1 becomes 0).\n c = 1 - c\n \n return max(even, odd, both)\n ","runtime":"580"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even, odd, alt = 0, 0, 0\n curr = None\n for n in nums:\n if n % 2:\n odd += 1\n else:\n even += 1\n \n if curr is None:\n curr = n % 2\n alt += 1\n elif curr != n % 2:\n curr = n % 2\n alt += 1\n return max(even, odd, alt)","runtime":"585"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even, odd, alt = 0, 0, 0\n curr = nums[0] % 2\n for n in nums:\n if n % 2:\n odd += 1\n else:\n even += 1\n if curr == n % 2:\n curr = 1 - curr\n alt += 1\n return max(even, odd, alt)","runtime":"585"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n previous = nums[0] % 2\n alternating = 1\n length = 1\n odds_count = previous\n for num in nums[1:]:\n length += 1\n remainder_2 = num % 2\n odds_count += remainder_2\n if previous != remainder_2:\n alternating += 1\n previous = remainder_2\n return max(alternating, odds_count, length - odds_count)\n","runtime":"590"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n c = nums[0] % 2\n odd = even = both = 0\n for num in nums:\n if num % 2 == 0:\n even += 1\n else:\n odd += 1\n if num % 2 == c:\n both += 1\n c = 1 - c # Toggle the parity\n return max(both, even, odd)","runtime":"590"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums_rem = [x%2 for x in nums]\n total = 1\n pre = nums_rem[0]\n for i in range(1, len(nums_rem)):\n if (nums_rem[i] != pre):\n total += 1\n pre = nums_rem[i]\n\n res0 = total\n res1, res2 = 0, 0\n for x in nums_rem:\n if x == 0:\n res1 += 1\n else:\n res2 += 1\n res = max(res0, res1, res2)\n return res \n ","runtime":"595"},{"code":"# 找出有效子序列的最大长度 I\n\n# 整数数组 nums\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\n\n# 满足以下条件，则称其为 有效子序列：\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\n\n# 返回 nums 的 最长的有效子序列 的长度。\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0]*2 for _ in range(2)]\n for x in nums: \n x %= 2 \n dp[x][0] = 1 + dp[0][x]; \n dp[x][1] = 1 + dp[1][x]; \n return max(map(max, dp)) \n\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n return max(map(max, dp)) ","runtime":"595"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even, odd, both = 0, 0, 0\n check = nums[0] % 2\n for num in nums:\n if num % 2 == 0:\n even += 1\n else:\n odd += 1\n \n if num % 2 == check:\n both += 1\n check = 1 - check\n \n return max(even, odd, both)","runtime":"600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n ecnt = 0\n for x in nums:\n if x % 2 == 0:\n ecnt += 1\n res = max(ecnt, len(nums) - ecnt)\n v0 = nums[0]\n pol = v0 % 2\n sofar = 1\n for i in range(1, len(nums)):\n cpol = nums[i] % 2\n if cpol != pol:\n pol = cpol\n sofar += 1\n return max(res, sofar, 2)","runtime":"600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n oddRes = 0\n evenRes = 0\n oddEvenRes = 0\n evenOddRes = 0\n currOddEven = True\n currEvenOdd = True\n \n for i in range(len(nums)):\n if nums[i] % 2 == 1:\n oddRes += 1\n if currOddEven:\n oddEvenRes += 1\n currOddEven = False\n if not currEvenOdd:\n evenOddRes += 1\n currEvenOdd = True\n if nums[i] % 2 == 0:\n evenRes += 1\n if not currOddEven:\n oddEvenRes += 1\n currOddEven = True\n if currEvenOdd:\n evenOddRes += 1\n currEvenOdd = False\n\n return max(oddRes, evenRes, oddEvenRes, evenOddRes)\n \n ","runtime":"605"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n\n odd = 0\n even = 0\n both = 1\n prev = -1\n\n for i in range(len(nums)):\n curr = nums[i]%2\n if curr == 0:\n even+=1\n else:\n odd+=1\n if prev==-1:\n prev = curr\n continue\n \n if curr != prev:\n both+=1\n \n prev = nums[i]%2\n return max(odd,even,both)\n \n \n\n\n","runtime":"605"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n evens = 0\n odds = 0\n one = 1\n if nums[0] % 2:\n odds += 1\n else:\n evens += 1\n parity = (nums[0] % 2) ^ 1\n for i in range(1, len(nums)):\n if nums[i] % 2 == parity:\n one += 1\n parity ^= 1\n if nums[i] % 2 == 0:\n evens += 1\n else:\n odds += 1\n\n return max(one, evens, odds)","runtime":"610"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n previous = nums[0] % 2\n alternating = 1\n length = 1\n odds_count = previous\n for num in nums[1:]:\n length += 1\n remainder_2 = num % 2\n odds_count += remainder_2\n if previous != remainder_2:\n alternating += 1\n previous = remainder_2\n return max(alternating, odds_count, length - odds_count)\n","runtime":"610"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n\n z, o = 0, 0\n aez = aeo = 0\n for i in nums:\n if i%2:\n aeo = max(aeo, aez+1)\n o += 1\n else:\n aez = max(aez, aeo+1)\n z += 1\n \n return max(z, o, aez, aeo)\n","runtime":"615"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n previous = nums[0] % 2\n alternating = 1\n for num in nums[1:]:\n remainder_2 = num % 2\n if previous != remainder_2:\n alternating += 1\n previous = remainder_2\n evens_count = sum([num % 2 for num in nums])\n return max(alternating, evens_count, len(nums) - evens_count)\n","runtime":"615"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n odds = evens = alt = 0\n curr_mod = (nums[0] % 2 + 1) % 2\n for i in range(len(nums)):\n if nums[i] % 2 == 0:\n evens += 1\n else:\n odds += 1\n if curr_mod % 2 != nums[i] % 2:\n alt += 1\n curr_mod = (curr_mod + 1) % 2\n return max(odds, evens, alt)","runtime":"620"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n N = len(nums)\n for i in range(N):\n nums[i] %= 2\n ret = max(nums.count(0),nums.count(1))\n dp = [0]*2\n for i in range(N):\n dp[nums[i]] = dp[1-nums[i]]+1\n return max(ret,dp[0],dp[1])","runtime":"620"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n if len(nums)<3:return len(nums)\n\n counteven,countodd=0,0\n for i in range(len(nums)):\n if nums[i]%2==0:counteven+=1\n else: countodd+=1\n ans=[nums[0]]\n if ans[-1]%2!=0: #if the 1st num of odd \n for i in range(1,len(nums)):\n if ans[-1]%2!=0 and nums[i]%2==0: \n ans.append(nums[i])\n elif ans[-1]%2==0 and nums[i]%2!=0:\n ans.append(nums[i])\n else:\n ans=[]\n for i in nums:\n if i%2==0: \n ans.append(i)\n break\n for i in range(1,len(nums)):\n if ans[-1]%2!=0 and nums[i]%2==0: \n ans.append(nums[i])\n elif ans[-1]%2==0 and nums[i]%2!=0:\n ans.append(nums[i])\n return max(len(ans),counteven,countodd) ","runtime":"625"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n total = 1\n pre = nums[0]%2\n for i in range(1, len(nums)):\n if (nums[i]%2 != pre):\n total += 1\n pre = nums[i]%2\n\n res0 = total\n res1, res2 = 0, 0\n for x in nums:\n if x%2 == 0:\n res1 += 1\n else:\n res2 += 1\n res = max(res0, res1, res2)\n return res \n ","runtime":"625"},{"code":"class Solution:\n def maximumLength(self, n: List[int]) -> int:\n a=0\n b=0\n c=[n[0]]\n for i in n:\n if i%2==0:\n a+=1\n for i in n:\n if i%2==1:\n b+=1\n for i in range(1,len(n)):\n if c[-1]%2==0 and n[i]%2==1:\n c.append(n[i])\n elif c[-1]%2==1 and n[i]%2==0:\n c.append(n[i])\n return max(a,b,len(c))\n","runtime":"630"},{"code":"class Solution:\n def maximumLength(self, a: List[int]) -> int:\n even, odd = [-1, -1], [-1, -1]\n res = 0\n for i in range(len(a)):\n if a[i] % 2 == 0:\n if even[0] == -1:\n even[0] = 1\n else:\n even[0] += 1\n if even[1] == -1:\n even[1] = 1\n if odd[1] != -1:\n even[1] = odd[1] + 1\n else:\n if odd[0] == -1:\n odd[0] = 1\n else:\n odd[0] += 1\n if odd[1] == -1:\n odd[1] = 1\n if even[1] != -1:\n odd[1] = even[1] + 1\n return max(max(even), max(odd))\n \n\n ","runtime":"635"},{"code":"class Solution:\n def maximumLength(self, A: List[int]) -> int:\n A = [a % 2 for a in A]\n return max(A.count(0), A.count(1), len(list(groupby(A))))","runtime":"635"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n alter = []\n odd = []\n even = []\n for i in nums:\n if i%2 == 0:\n even.append(i)\n else:\n odd.append(i)\n if len(alter)==0 or alter[-1]%2 != i%2:\n alter.append(i)\n return max(len(alter), len(odd), len(even))","runtime":"640"},{"code":"class Solution(object):\n def help(self, nums, flag):\n even_odd = flag\n cnt1, cnt2 = 0, 0\n for num in nums:\n if num%2 == flag:\n cnt1 += 1\n flag = not flag\n if num%2 == even_odd:\n cnt2 += 1\n return max(cnt1, cnt2)\n\n def maximumLength(self, nums):\n ans1 = self.help(nums, True)\n ans2 = self.help(nums, False)\n return max(ans1, ans2)","runtime":"640"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n nums = list(map(lambda x: x%2, nums))\n\n z, o = 0, 0\n aez = aeo = 0\n for i in nums:\n if i:\n aeo = max(aeo, aez+1)\n o += 1\n else:\n aez = max(aez, aeo+1)\n z += 1\n \n return max(z, o, aez, aeo)\n","runtime":"645"},{"code":"# 找出有效子序列的最大长度 I\n\n# 整数数组 nums\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\n\n# 满足以下条件，则称其为 有效子序列：\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\n\n# 返回 nums 的 最长的有效子序列 的长度。\n\n# 解題思路：\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\n\n# 動態規劃狀態設置：\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\n\n# 遞推公式：\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\n\n# 最終結果：\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\n\n# 對每個餘數做DP\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0] * 2 for _ in range(2)]\n\n for num in nums:\n num %= 2\n for y in range(2):\n dp[num][y] = dp[y][num] + 1\n\n return max(map(max, dp))","runtime":"645"},{"code":"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\n# L(i) = 1 [if i == 0]\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\n# L(i) = L(i-1) ow\n\n# oo = e\n# ee = e\n# eo/oe = o\n\n# \n# eeeeo\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n EE = 0\n EO = 1\n OO = 1\n OE = 0\n \n if nums[0] % 2 == 0:\n OE = 1\n EE = 1\n OO = 0\n EO = 0\n\n mx = 0\n # EE = 0,1,1,2\n # EO = 1,1,2,2\n # OE = 0,2,2,4\n # OO = 1,1,3,3\n\n # EE = 0, 1, 1, 1,2,2,3\n # EO = 1, 1, 2, 3,3,4,4\n # OE = 0, 2, 2,|2,4,4,6 \n # OO = 1, 1, 3, 3,3,5,5\n \n for i in range(1, len(nums)):\n \n if nums[i] % 2 == 0:\n EE = EE + 1\n OE = OO + 1\n else:\n EO = EO + 1\n OO = OE + 1\n\n mx = max(mx, EE, EO, OO, OE)\n\n return mx","runtime":"650"},{"code":"class Solution(object):\n def help(self, nums, flag):\n even_odd = flag\n cnt1, cnt2 = 0, 0\n for num in nums:\n if num%2 == flag:\n cnt1 += 1\n flag = not flag\n if num%2 == even_odd:\n cnt2 += 1\n return max(cnt1, cnt2)\n\n def maximumLength(self, nums):\n ans1 = self.help(nums, True)\n ans2 = self.help(nums, False)\n return max(ans1, ans2)","runtime":"650"},{"code":"# 找出有效子序列的最大长度 I\n\n# 整数数组 nums\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\n\n# 满足以下条件，则称其为 有效子序列：\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\n\n# 返回 nums 的 最长的有效子序列 的长度。\n\n# 解題思路：\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\n\n# 動態規劃狀態設置：\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\n\n# 遞推公式：\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\n\n# 最終結果：\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\n\n# 2301 2302\n# 3201. Find the Maximum Length of Valid Subsequence I\n# 3202. Find the Maximum Length of Valid Subsequence II\n\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\n# return max(map(max, dp)) \n\n# 對每個餘數做DP\n\n# DP 2D,\n# O(n * k), S: O(k * 2)\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0] * 2 for _ in range(2)]\n\n for num in nums:\n num %= 2\n for y in range(2):\n dp[num][y] = dp[y][num] + 1\n\n return max(map(max, dp))","runtime":"655"},{"code":"# 找出有效子序列的最大长度 I\n\n# 整数数组 nums\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\n\n# 满足以下条件，则称其为 有效子序列：\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\n\n# 返回 nums 的 最长的有效子序列 的长度。\n\n# 解題思路：\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\n\n# 動態規劃狀態設置：\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\n\n# 遞推公式：\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\n\n# 最終結果：\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\n\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\n# return max(map(max, dp)) \n\n# 對每個餘數做DP\n\n# DP 2D,\n# O(n * k), S: O(k * 2)\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0] * 2 for _ in range(2)]\n\n for num in nums:\n num %= 2\n for y in range(2):\n dp[num][y] = dp[y][num] + 1\n\n return max(map(max, dp))","runtime":"655"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [a % 2 for a in nums]\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))","runtime":"659"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n alternatingOdd = 0\n alternatingEven = 0\n\n current = 1\n for num in nums:\n if num % 2 == current % 2:\n current += 1\n alternatingOdd += 1\n \n current = 0\n for num in nums:\n if num % 2 == current % 2:\n current += 1\n alternatingEven += 1\n \n l1, l2 = len([x for x in nums if x % 2 == 0]), len([x for x in nums if x % 2 == 1])\n\n return max([alternatingOdd, alternatingEven, l1, l2])","runtime":"659"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n A = [a % 2 for a in nums]\n return max(A.count(0), A.count(1), len(list(groupby(A))))","runtime":"664"},{"code":"class Solution:\n def maximumLength(self, A: List[int]) -> int:\n A = [a % 2 for a in A]\n return max(A.count(0), A.count(1), len(list(groupby(A))))","runtime":"664"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [a % 2 for a in nums] # O(n) in time and space\n # subsequence can choose all 0's by eliminating any 1's.\n # or choose all 1's. So we just count 0s and 1s.\n # or choose all 10's \n # or choose all 01's\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))\n # itertools.groupby return list of (key, group)","runtime":"669"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n \"\"\"\n sequence has consequitive sums that are all even or all odd\n\n brute force:\n - generate every possible sequence and evaluate condition\n o((2 ** n) * n)) - runtime\n\n brute force + backtracking:\n - generate every sequence but once we encounter a bad sequence in the construction backtrack\n better than brute force\n\n start and end index, then evaluate if its valid in a linear pass:\n - o(n ** 3)\n\n lis pattern? - for every index, find the max length of valid subsequence including the element at that index\n then if we solve prefix wise (left to right) and we conside a new element x + 1, whats the best way to expand \n the sequence using the answers of elements to the left\n - o(n ** 2)\n\n divide and conquer???\n - split in half. solve for each half then best subsequence. merge best on left and right\n - don't think this is easy with non-contiguous questions like subsequence\n\n o(n ** 2)\n 1, 2, 3, 4\n =============\n 1st solve\n 1\n \n 2nd solve\n 1 2 \n\n 3rd solve\n 1 2 3 \n if i include 3, what is the max lenght i can make if i extend on 2, so 3 + 2 % 2 == 1, so I have to ask about the max length of the sequence that has all adjacent sums % == 1\n \n 4th solve\n 1 2 3 4 -> \n\n why does this solve the problem?\n - we solved the problem of what is the longest valid subsequence we can make if terminate \n at element X. we solved this for every element X. proof by case, the optimal solution will \n terminate at some Y and we solve for every X, w/o knowing which Y it's clearly the X that's \n largest.\n\n a + b % 2 == 1 iff a + b is odd iff (a or b are odd but not both)\n\n 1 2 3 4\n 1 1 1\n\n 1 2 1 1 2 1 2\n odd - even - odd - even - ...\n\n 2 2 2 2 2 1 1 2 2\n even - even - even ...\n\n\n \"\"\"\n n = len(nums)\n nums = [num % 2 == True for num in nums]\n max_valid_subsequence = max(sum(nums), n - sum(nums))\n\n for truth_value in [True, False]:\n is_even = truth_value\n length_subsequence = 0\n for i in range(n):\n if nums[i] % 2 == 1 and is_even:\n is_even = not is_even\n length_subsequence += 1\n elif nums[i] % 2 == 0 and not is_even:\n is_even = not is_even\n length_subsequence += 1\n\n max_valid_subsequence = max(max_valid_subsequence, length_subsequence)\n return max_valid_subsequence\n","runtime":"669"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n if len(nums) == 1:\n return 1\n maxlen = 2\n even = list(filter(lambda x: x%2==0,nums))\n maxlen = max(maxlen, len(even))\n odd = list(filter(lambda x: x%2==1,nums))\n maxlen = max(maxlen, len(odd))\n evenodd=[]\n even = 1\n for i in nums:\n if even == 1 and i%2==0:\n evenodd.append(i)\n even = 0\n if even == 0 and i%2==1:\n evenodd.append(i)\n even = 1\n maxlen = max(maxlen, len(evenodd))\n oddeven=[]\n odd = 1\n for i in nums:\n if odd == 1 and i%2==1:\n oddeven.append(i)\n odd = 0\n if odd == 0 and i%2==0:\n oddeven.append(i)\n odd = 1\n maxlen = max(maxlen, len(oddeven))\n return maxlen\n","runtime":"674"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # all odd, all even, odd->even, even->odd\n dp = [0, 0, 0, 0]\n \n for num in nums:\n if num & 1:\n dp[0] += 1\n dp[2] += (dp[2] & 1 == 0)\n dp[3] += dp[3] & 1\n else:\n dp[1] += 1\n dp[2] += dp[2] & 1\n dp[3] += (dp[3] & 1 == 0)\n \n return max(dp)\n ","runtime":"674"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # ans = 2\n \n # curCount = 2\n # cur = (nums[0] + nums[1]) % 2\n \n # for i in range(1, len(nums) - 1):\n # print('cur=', cur)\n # print(nums[i] + nums[i+1])\n # if (nums[i] + nums[i+1]) % 2 == cur:\n # curCount += 1\n # ans = max(ans, curCount)\n # else:\n # cur = 1 - cur\n # curCount = 2\n # return ans\n oddCount = 0\n for num in nums:\n oddCount += num % 2\n \n curOdd = 1\n startWithOddCount = 0\n \n curEven = 0\n startWithEvenCount = 0\n \n for num in nums:\n if num % 2 == curOdd:\n curOdd = 1 - curOdd\n startWithOddCount += 1\n if num % 2 == curEven:\n curEven = 1 - curEven\n startWithEvenCount += 1\n \n # print(oddCount)\n # print(len(nums) - oddCount)\n # print(startWithOddCount)\n # print(startWithEvenCount)\n return max(oddCount, len(nums) - oddCount, startWithOddCount, startWithEvenCount)","runtime":"679"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n return max(\n sum(int(num % 2 == 0) for num in nums),\n sum(int(num % 2 == 1) for num in nums),\n sum(nums[j-1] % 2 != nums[j] % 2 for j in range(1, len(nums))) + 1,\n )","runtime":"679"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # count even length subsequence \n even_len, odd_len, alt_len = 0, 0, 0\n i = 0 \n while i < len(nums): \n if nums[i] %2 == 0: \n even_len += 1\n i += 1\n\n # count odd mod subsequence \n i = 0 \n while i < len(nums): \n if nums[i] %2 == 1: \n odd_len += 1\n i += 1\n\n # count alternating subsequence\n i = 0 \n next_odd = not (nums[i] % 2 == 0)\n while i < len(nums): \n if nums[i] % 2 == next_odd: \n alt_len += 1\n next_odd = not next_odd\n i += 1\n return max(max(even_len, odd_len), alt_len)","runtime":"684"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [1] * len(nums)\n longestEven, longestOdd = 0, 0\n evenCount, oddCount = 0, 0\n\n if nums[0] % 2 == 0:\n evenCount += 1\n else:\n oddCount += 1\n \n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if nums[i-1] % 2 == 1:\n dp[i] = max(dp[i-1], longestOdd) + 1\n longestEven = max(longestEven, dp[i])\n evenCount += 1\n else:\n if nums[i-1] % 2 == 0:\n dp[i] = max(dp[i-1], longestEven) + 1\n longestOdd = max(longestOdd, dp[i])\n oddCount += 1\n\n return max(max(dp), evenCount, oddCount)\n\n ","runtime":"689"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n def helper1(nums):\n count = 0\n for i in range(len(nums)):\n if nums[i]%2 == 0:\n count += 1\n return count\n def helper2(nums):\n count = 0\n for i in range(len(nums)):\n if nums[i]%2 == 1:\n count += 1\n return count\n #starting with odd num\n def helper3(nums):\n par = 1\n count = 0\n for i in range(len(nums)):\n if par == 1 and nums[i]%2 == 1:\n par = 0\n count += 1\n elif par == 0 and nums[i]%2 == 0:\n par = 1\n count += 1\n return count\n def helper4(nums):\n par = 0\n count = 0\n for i in range(len(nums)):\n if par == 0 and nums[i]%2 == 0:\n par = 1\n count += 1\n elif par == 1 and nums[i]%2 == 1:\n par = 0\n count += 1\n return count\n val = max(helper1(nums),helper2(nums),helper3(nums),helper4(nums))\n return val","runtime":"689"},{"code":"class Solution:\n def maximumLength(self, A: List[int]) -> int:\n A = [a % 2 for a in A]\n return max(A.count(0), A.count(1), len(list(groupby(A))))","runtime":"694"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n m = collections.Counter()\n\n for n in nums:\n c = n%2\n m[c] +=1\n\n res = max(m.values())\n\n m = collections.Counter()\n for n in nums:\n c = n%2\n m[c] = m[1-c]+1\n\n return max(res,max(m.values()))","runtime":"694"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n max_len = 0\n for target in range(k):\n compliments = {}\n for num in nums:\n curr_remainder = num % k\n compliment = (target - curr_remainder)%k\n if compliment in compliments:\n compliments[curr_remainder] = compliments[compliment] + 1\n else:\n compliments[curr_remainder] = 1\n \n if compliments[curr_remainder] > max_len:\n max_len = compliments[curr_remainder]\n \n return max_len\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count_odd = 0\n # count_even = 0\n # alt_odd = 0\n # alt_even = 0\n\n # for num in nums:\n # if num % 2:\n # count_odd += 1\n # alt_odd = alt_even + 1\n # else:\n # count_even += 1\n # alt_even = alt_odd + 1\n \n # return max(count_odd, count_even, alt_odd, alt_even)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # k = 2\n # max_length = 0\n # for target_remainder in range(k):\n # seen_remainders = {}\n # for num in nums:\n # curr_remainder = num % k\n # compliment_remainder = target_remainder - curr_remainder\n # if compliment_remainder < 0:\n # compliment_remainder = k - abs(compliment_remainder)\n \n # if compliment_remainder in seen_remainders:\n # if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\n # seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\n # else:\n # seen_remainders[curr_remainder] = 1\n \n # if seen_remainders[curr_remainder] > max_length:\n # max_length = seen_remainders[curr_remainder]\n\n # return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # count_zeros = 0\n # count_ones = 0\n # count_alt_zeros = 0\n # count_alt_ones = 0\n # for num in nums:\n # if num % 2:\n # count_ones += 1\n # count_alt_zeros += 1\n # else:\n # count_zeros += 1\n # count_alt_ones += 1\n \n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count = [0,0]\n # ends = [0,0]\n # for num in nums:\n # count[num % 2] += 1\n # ends[num % 2] = ends[1 - num % 2] + 1\n \n # return max( max(count), max(ends) )\n\n\n # remainders = [ num % 2 for num in nums ]\n # for \n\n\n\n # max_zero = self.get_lis(nums, 0)\n # max_one = self.get_lis(nums, 1)\n # return max_zero if max_zero >= max_one else max_one\n \n # def get_lis(self, nums, remainder):\n # lis = [1] * len(nums)\n # max_lis = 1 if nums else 0\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % 2 == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if lis[index] > max_lis:\n # max_lis = lis[index]\n \n # return max_lis\n\n ","runtime":"699"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n, k = len(nums), 2\n dp = [[0] * k for _ in range(k)]\n for i in range(n):\n for j in range(k):\n dp[nums[i] % k][j] = 1 + dp[j][nums[i] % k]\n return max(max(dp[i]) for i in range(k))","runtime":"704"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n m = 1\n c = 0\n for i in nums:\n if i & 1:\n c += 1\n m = max(m, c)\n c = 0\n for i in nums:\n if not i & 1:\n c += 1\n m = max(m, c)\n c = b = 0\n for i in nums:\n if (i & 1) == b:\n c += 1\n m = max(m, c)\n b = not b\n c = 0\n b = 1\n for i in nums:\n if (i & 1) == b:\n c += 1\n m = max(m, c)\n b = not b\n return m","runtime":"704"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n def compute_max(parity):\n total, prev = 1, 0\n \n for x in range(1, len(nums)):\n if (nums[prev] + nums[x]) % 2 == parity:\n total += 1\n prev = x\n \n return total\n \n odds, evens = 0, 0\n for v in nums:\n if v % 2 == 0: evens += 1\n else: odds += 1\n \n return max(odds, evens,\n compute_max(0), \n compute_max(1), \n compute_max(0), \n compute_max(1))","runtime":"709"},{"code":"class Solution:\n\tdef maximumLength(self, nums: List[int]) -> int:\n\n\t\tresult1, result3 , result2 , result4 = 1 , 1 , 1 , 1\n\n\t\tfor i in range(len(nums)):\n\t\t\tnums[i] = nums[i] % 2\n\n\t\tif 0 in nums:\n\n\t\t\ti = nums.index(0)\n\t\t\tlast = 0\n\n\t\t\tfor index in range(i + 1,len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult1 = result1 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult1 = result1 + 1\n\n\t\t\tfor index in range(i + 1, len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult2 = result2 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult2 = result2 + 1\n\n\t\tif 1 in nums:\n\n\t\t\ti = nums.index(1)\n\t\t\tlast = 1\n\n\t\t\tfor index in range(i + 1 ,len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult3 = result3 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult3 = result3 + 1\n\n\t\t\tfor index in range(i + 1, len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult4 = result4 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult4 = result4 + 1\n\n\t\treturn max([result1 , result2, result3, result4])","runtime":"714"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [1] * len(nums)\n longestEven, longestOdd = 0, 0\n evenCount, oddCount = 0, 0\n\n if nums[0] % 2 == 0:\n evenCount += 1\n else:\n oddCount += 1\n \n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if nums[i-1] % 2 == 1:\n dp[i] = max(dp[i-1], longestOdd) + 1\n longestEven = max(longestEven, dp[i])\n evenCount += 1\n else:\n if nums[i-1] % 2 == 0:\n dp[i] = max(dp[i-1], longestEven) + 1\n longestOdd = max(longestOdd, dp[i])\n oddCount += 1\n\n return max(max(dp), evenCount, oddCount)\n\n ","runtime":"719"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # odd even odd even\n def func(odd, switch):\n length = 0\n for i in range(len(nums)):\n if nums[i] % 2 == 1 and odd:\n length += 1\n if switch:\n odd = not odd\n elif nums[i] % 2 == 0 and not odd:\n length += 1\n if switch:\n odd = not odd\n return length\n\n return max(func(True, True), func(True, False),\n func(False, True), func(False, False))\n","runtime":"719"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n max_length = 0\n for p0 in [0, 1]:\n for c in [0, 1]:\n length = 0\n for num in nums:\n parity = num % 2\n expected_parity = p0 if length % 2 == 0 else p0 ^ c\n if parity == expected_parity:\n length += 1\n max_length = max(max_length, length)\n return max_length","runtime":"724"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [a%2 for a in nums]\n count_0 = 0\n for a in nums:\n if a==0:\n count_0 += 1\n count_1 = len(nums) - count_0\n \n c = 0\n for idx,_ in enumerate(nums[1::]):\n if nums[idx+1] != nums[idx]:\n c+=1\n print(nums[idx+1])\n c+=1\n print(nums)\n return max(c, count_1, count_0)\n","runtime":"724"},{"code":"# Data Structures and Algorithm Used:\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\n\n# Short Intuition:\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\n\n# Detailed Intuition:\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\n# - The final result is the maximum value found in this dictionary.\n\n# Pseudocode:\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\n# 2. For each number `n` in `nums`:\n# a. Iterate over all possible `i` from `0` to `k-1`.\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\n# 3. The answer is the maximum value in the `count` dictionary.\n\nfrom collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums):\n # Step 1: Initialize the dictionary to keep track of subsequence counts\n count = defaultdict(int)\n \n # Step 2: Iterate over each number in the array\n for n in nums:\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\n for i in range(2):\n # Step 2b: Update the count for the pair (i, n%k)\n count[(i, n % 2)] = count[(n % 2, i)] + 1\n \n # Step 3: Return the maximum value found in the count dictionary\n return max(count.values())\n\n# Time Complexity:\n# - O(n * k) where n is the length of the array and k is the given integer. \n# This is because for each element in the array, we perform `k` updates in the dictionary.\n\n# Space Complexity:\n# - O(k^2) for storing the count of subsequences in the dictionary.\n","runtime":"729"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n def compute_max(parity):\n total, prev = 1, -1\n \n for x in range(len(nums)):\n if prev == -1:\n prev = x\n continue\n \n #print(nums[prev], nums[x], (nums[prev] + nums[x]) % 2, parity)\n if (nums[prev] + nums[x]) % 2 == parity:\n total += 1\n prev = x\n \n return total\n\n odd, even = 0, 0\n while odd < len(nums) and nums[odd] % 2 != 1: odd += 1\n while even < len(nums) and nums[even] % 2 != 0: even += 1\n \n odds, evens = 0, 0\n for v in nums:\n if v % 2 == 0: evens += 1\n else: odds += 1\n \n return max(odds, evens,\n compute_max(0), \n compute_max(1), \n compute_max(0), \n compute_max(1))","runtime":"734"},{"code":"class Solution:\n def maximumk(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n \n for mod in range(k):\n for num in nums:\n currNum = num % k\n prevNum = (mod - currNum) % k\n dp[currNum][mod] = max(dp[currNum][mod], 1 + dp[prevNum][mod])\n \n max_value = max(max(row) for row in dp)\n return max_value \n\n def maximumLength(self, nums: List[int]) -> int:\n return self.maximumk(nums, 2)","runtime":"739"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n max_length = 0\n for target_remainder in range(k):\n seen_remainders = {}\n for num in nums:\n curr_remainder = num % k\n compliment_remainder = target_remainder - curr_remainder\n if compliment_remainder < 0:\n compliment_remainder = k - abs(compliment_remainder)\n \n if compliment_remainder in seen_remainders:\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\n else:\n seen_remainders[curr_remainder] = 1\n \n if seen_remainders[curr_remainder] > max_length:\n max_length = seen_remainders[curr_remainder]\n\n return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # count_zeros = 0\n # count_ones = 0\n # count_alt_zeros = 0\n # count_alt_ones = 0\n # for num in nums:\n # if num % 2:\n # count_ones += 1\n # count_alt_zeros += 1\n # else:\n # count_zeros += 1\n # count_alt_ones += 1\n \n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count = [0,0]\n # ends = [0,0]\n # for num in nums:\n # count[num % 2] += 1\n # ends[num % 2] = ends[1 - num % 2] + 1\n \n # return max( max(count), max(ends) )\n\n\n # remainders = [ num % 2 for num in nums ]\n # for \n\n\n\n # max_zero = self.get_lis(nums, 0)\n # max_one = self.get_lis(nums, 1)\n # return max_zero if max_zero >= max_one else max_one\n \n # def get_lis(self, nums, remainder):\n # lis = [1] * len(nums)\n # max_lis = 1 if nums else 0\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % 2 == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if lis[index] > max_lis:\n # max_lis = lis[index]\n \n # return max_lis\n\n ","runtime":"744"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # odd even odd even\n def func1(odd):\n length = 0\n for i in range(len(nums)):\n if nums[i] % 2 == 1 and odd:\n length += 1\n odd = not odd\n elif nums[i] % 2 == 0 and not odd:\n length += 1\n odd = not odd\n return length\n\n len1 = max(func1(True), func1(False))\n\n # all odd or even\n def func2(odd):\n length = 0\n for i in range(len(nums)):\n if nums[i] % 2 == 1 and odd:\n length += 1\n elif nums[i] % 2 == 0 and not odd:\n length += 1\n return length\n\n len2 = max(func2(True), func2(False))\n\n return max(len1, len2)\n","runtime":"749"},{"code":"# Data Structures and Algorithm Used:\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\n\n# Short Intuition:\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\n\n# Detailed Intuition:\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\n# - The final result is the maximum value found in this dictionary.\n\n# Pseudocode:\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\n# 2. For each number `n` in `nums`:\n# a. Iterate over all possible `i` from `0` to `k-1`.\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\n# 3. The answer is the maximum value in the `count` dictionary.\n\nfrom collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums):\n # Step 1: Initialize the dictionary to keep track of subsequence counts\n count = defaultdict(int)\n \n # Step 2: Iterate over each number in the array\n for n in nums:\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\n for i in range(2):\n # Step 2b: Update the count for the pair (i, n%k)\n count[(i, n % 2)] = count[(n % 2, i)] + 1\n \n # Step 3: Return the maximum value found in the count dictionary\n return max(count.values())\n\n# Time Complexity:\n# - O(n * k) where n is the length of the array and k is the given integer. \n# This is because for each element in the array, we perform `k` updates in the dictionary.\n\n# Space Complexity:\n# - O(k^2) for storing the count of subsequences in the dictionary.\n","runtime":"754"},{"code":"class Solution:\n def maximumLength(self, a: List[int]) -> int:\n even, odd = [-1, -1], [-1, -1]\n res = 0\n for i in range(len(a)):\n if a[i] % 2 == 0:\n if even[0] == -1:\n even[0] = 1\n else:\n even[0] += 1\n if even[1] == -1:\n even[1] = 1\n if odd[1] != -1:\n even[1] = odd[1] + 1\n else:\n if odd[0] == -1:\n odd[0] = 1\n else:\n odd[0] += 1\n if odd[1] == -1:\n odd[1] = 1\n if even[1] != -1:\n odd[1] = even[1] + 1\n res = max(res, max(even), max(odd))\n return res\n \n\n ","runtime":"759"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n max_length = 0\n for target_remainder in range(k):\n seen_remainders = {}\n for num in nums:\n curr_remainder = num % k\n compliment_remainder = target_remainder - curr_remainder\n if compliment_remainder < 0:\n compliment_remainder = k - abs(compliment_remainder)\n \n if compliment_remainder in seen_remainders:\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\n else:\n seen_remainders[curr_remainder] = 1\n \n if seen_remainders[curr_remainder] > max_length:\n max_length = seen_remainders[curr_remainder]\n\n return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # count_zeros = 0\n # count_ones = 0\n # count_alt_zeros = 0\n # count_alt_ones = 0\n # for num in nums:\n # if num % 2:\n # count_ones += 1\n # count_alt_zeros += 1\n # else:\n # count_zeros += 1\n # count_alt_ones += 1\n \n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count = [0,0]\n # ends = [0,0]\n # for num in nums:\n # count[num % 2] += 1\n # ends[num % 2] = ends[1 - num % 2] + 1\n \n # return max( max(count), max(ends) )\n\n\n # remainders = [ num % 2 for num in nums ]\n # for \n\n\n\n # max_zero = self.get_lis(nums, 0)\n # max_one = self.get_lis(nums, 1)\n # return max_zero if max_zero >= max_one else max_one\n \n # def get_lis(self, nums, remainder):\n # lis = [1] * len(nums)\n # max_lis = 1 if nums else 0\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % 2 == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if lis[index] > max_lis:\n # max_lis = lis[index]\n \n # return max_lis\n\n ","runtime":"764"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n i,j = 1,0\n colI, colJ = [], [] \n while i != len(nums):\n colI.extend([(nums[1]+nums[0])%2, nums[0]]) if not colI else colI.extend([])\n if (colI[-1]+nums[i])%2==colI[0]:\n colI.append(nums[i])\n else:\n j = i if j < 1 else j\n i+=1\n while j != len(nums):\n colJ.extend([(colI[0]+1)%2, nums[j-1]]) if not colJ and j > 1 else colJ.extend([])\n if colJ and (colJ[-1]+nums[j])%2==colJ[0]:\n colJ.append(nums[j])\n j+=1\n ctO,ctE = 0,0\n for n in nums:\n if n%2==0:\n ctE+=1\n else:\n ctO+=1\n return max(len(colI)-1, len(colJ)-1, ctO, ctE)","runtime":"764"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \"\"\"\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\n where dp[a][b] means the length of subsequence ending with ...,a,b\n dp[b][a % k] 表示以模数为 a % k 的数字 b 结尾的最长有效子序列的长度。\n \"\"\"\n dp = defaultdict(Counter)\n k = 2\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n \n return max(max(dp[a].values()) for a in range(k))\n","runtime":"769"},{"code":"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\n# similar to question 1027.\n# simliar to question 3202.\n# class Solution:\n # def maximumLength(self, nums: List[int]) -> int:\n\n\nclass Solution:\n # def maximumLength(self, A: List[int]) -> int:\n # A = [a % 2 for a in A]\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\n\n def maximumLength(self, A: List[int], k = 2) -> int:\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))","runtime":"774"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n # dp是一个k * k的2D array\n res = 0\n dp = [[0] * k for _ in range(k)]\n for a in nums:\n for b in range(k):\n dp[b][a%k] = dp[a%k][b] + 1\n res = max(res, dp[b][a%k])\n\n return res\n\n\n\n# 当我们使用 defaultdict(Counter) 时，defaultdict 的默认工厂函数是 Counter。这意味着当访问字典中不存在的键时，会自动为这个键创建一个 Counter 作为其默认值。\n\n# 这个用法的典型场景：通常用于嵌套字典结构，特别是当需要记录某种二维关系时，【一个分类和每个分类下不同对象的计数】\n\n# from collections import defaultdict, Counter\n\n# d = defaultdict(Counter)\n# d['a']['x'] += 1\n# d['a']['y'] += 2\n# d['b']['x'] += 3\n\n# print(d)\n# defaultdict(<class 'collections.Counter'>, {'a': Counter({'y': 2, 'x': 1}), 'b': Counter({'x': 3})})\n","runtime":"779"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n import numpy as np\n if len(nums)==2:\n return 2\n nums = np.array(nums)\n n2=nums%2\n z_count = np.sum(n2)\n o_count = len(nums)-z_count\n n3 = np.sum(n2[1:]!=n2[:-1])\n # n4 = np.count(n2[1:]+n2[:-1])\n return max(1+np.max(np.unique(n2[1:]+n2[:-1],return_counts=True)[1]),z_count,o_count)","runtime":"784"},{"code":"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\n# similar to question 1027.\n# simliar to question 3202.\n# class Solution:\n # def maximumLength(self, nums: List[int]) -> int:\n\n\nclass Solution:\n # def maximumLength(self, A: List[int]) -> int:\n # A = [a % 2 for a in A]\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\n\n def maximumLength(self, A: List[int], k = 2) -> int:\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n","runtime":"789"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n # thinking as a DP problem\n result = 0\n\n # if (sub[0] + sub[1]) % 2 == 0\n # dp[0] is the max len of valid subseq ending with a value whose mod of 2 is 0\n dp = [0, 0]\n for v in nums:\n x = v % 2\n y = x\n dp[x] = max(dp[x], dp[y] + 1)\n result = max(result, dp[x])\n \n # if (sub[0] + sub[1]) % 2 == 1\n # dp[0] is the max len of valid subseq ending with a value whose mod of 2 is 0\n dp = [0, 0]\n for v in nums:\n x = v % 2\n y = 1 - x\n dp[x] = max(dp[x], dp[y] + 1)\n result = max(result, dp[x])\n \n return result\n \n # case 1, all even numbers\n # case 2, all odd numbers\n even, odd = 0, 0\n \n stack = []\n \n for v in nums:\n if v % 2 == 0:\n even += 1\n else:\n odd += 1\n \n if len(stack) > 0 and v % 2 == stack[-1] % 2:\n continue\n stack.append(v)\n \n l = len(stack)\n \n result = max(even, odd, l)\n return result\n \n \n \n ","runtime":"794"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 0 -> e,o,e\n # 1 -> e,e,e \n # 0 -> o,e,o\n # 1 -> o,o,o\n gmax = 0\n dp = [[0,0] for i in range(len(nums))]\n prev_e, prev_o = -1, -1\n if nums[0] % 2 == 0:\n prev_e = 0\n else:\n prev_o = 0\n\n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if prev_e >= 0:\n dp[i][1] = dp[prev_e][1] + 1\n if prev_o >= 0:\n dp[i][0] = dp[prev_o][0] + 1\n prev_e = i\n else:\n if prev_e >= 0:\n dp[i][0] = dp[prev_e][0] + 1\n if prev_o >= 0:\n dp[i][1] = dp[prev_o][1] + 1\n prev_o = i\n gmax = max(gmax, max(dp[i]))\n \n # add 1 for the unaccounted for last element\n return gmax + 1 \n \n\n\n \n\n\n\n\n \n\n\n ","runtime":"799"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \"\"\"\n check https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii\n \"\"\"\n dp = defaultdict(Counter)\n k = 2\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n","runtime":"804"},{"code":"####################### 2D DP ###################### \n\n# Time O(nk)\n# Space O(k * k)\n# More general,\n# dp[b][a] = max(dp[b][a], dp[a][b] + 1)\n# where dp[a][b] means the max length of subsequence ending with ...,a (sth mod k = a),b(sth mod k = b),\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n # dp是一个k * k的2D array\n res = 0\n dp = [[0] * k for _ in range(k)]\n # dp = defaultdict((Counter)) 我不建议用，过于fancy了\n for a in nums:\n for b in range(k):\n dp[b][a%k] = dp[a%k][b] + 1\n res = max(res, dp[b][a%k])\n\n return res\n\n####################### 1D DP ###################### \n# time: O(NK)\n# space: O(K)\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n res = 0\n k = 2\n for target_remainder in range(2):\n dp = [0] * k\n for num in nums: \n current_remainder = num % k\n previous_remainder = (target_remainder - current_remainder) % k\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n res = max(res, dp[current_remainder])\n\n return res\n\n\n\n# 当我们使用 defaultdict(Counter) 时，defaultdict 的默认工厂函数是 Counter。这意味着当访问字典中不存在的键时，会自动为这个键创建一个 Counter 作为其默认值。\n\n# 这个用法的典型场景：通常用于嵌套字典结构，特别是当需要记录某种二维关系时，【一个分类和每个分类下不同对象的计数】\n\n# from collections import defaultdict, Counter\n\n# d = defaultdict(Counter)\n# d['a']['x'] += 1\n# d['a']['y'] += 2\n# d['b']['x'] += 3\n\n# print(d)\n# defaultdict(<class 'collections.Counter'>, {'a': Counter({'y': 2, 'x': 1}), 'b': Counter({'x': 3})})\n","runtime":"804"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 0 -> e,o,e\n # 1 -> e,e,e \n # 0 -> o,e,o\n # 1 -> o,o,o\n gmax = 0\n dp = [[0,0] for i in range(len(nums))]\n prev_e, prev_o = -1, -1\n if nums[0] % 2 == 0:\n prev_e = 0\n else:\n prev_o = 0\n\n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if prev_e >= 0:\n dp[i][1] = dp[prev_e][1] + 1\n if prev_o >= 0:\n dp[i][0] = dp[prev_o][0] + 1\n prev_e = i\n else:\n if prev_e >= 0:\n dp[i][0] = dp[prev_e][0] + 1\n if prev_o >= 0:\n dp[i][1] = dp[prev_o][1] + 1\n prev_o = i\n gmax = max(gmax, max(dp[i]))\n \n # add 1 for the unaccounted for last element\n return gmax + 1 \n \n\n\n \n\n\n\n\n \n\n\n ","runtime":"809"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n evenCount, oddCount = 0, 0\n for num in nums:\n if num % 2 == 1:\n oddCount += 1\n else:\n evenCount += 1\n\n ans = max(evenCount, oddCount)\n\n l = len(nums)\n dp = [0] * l\n for i in range(l):\n dp[i] = 1\n for j in range(i-1, -1, -1):\n if nums[j] % 2 != nums[i] % 2:\n dp[i] = max(dp[i], 1+dp[j])\n break\n \n print(dp)\n return max(ans, dp[l-1])","runtime":"814"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n DP = [[0] * k for _ in range(k)]\n for i in range(k):\n DP[0][i] = 0\n \n for num in nums:\n mod_num = num % k\n temp = DP[mod_num].copy()\n \n for i in range(k):\n x_mod = (mod_num + i) % k\n temp[x_mod] = max(temp[x_mod], DP[i][x_mod] + 1)\n DP[mod_num] = temp\n \n # print(DP)\n \n return max(max(row) for row in DP)","runtime":"814"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n f = [[0] * k for _ in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j - x + k) % k\n f[x][y] = f[y][x] + 1\n ans = max(ans, f[x][y])\n return ans","runtime":"819"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # basically alternate nums must all be odd / all even\n # odd/odd, even/odd, even/even\n # we only need to do DP for even/odd\n # LVS[i][p] is the Longest alt seq ending in parity p up to i\n # 0: even, 1: odd\n n = len(nums)\n LVS = [[0,0] for _ in range(n)]\n # base cases\n LVS[0][nums[0] % 2] = 1\n even = 1 if nums[0] % 2 == 0 else 0\n # bottom up\n for i in range(1, n):\n if nums[i] % 2 == 0: \n even += 1\n for p in range(2):\n LVS[i][p] = LVS[i-1][p]\n LVS[i][nums[i] % 2] = LVS[i-1][1 - (nums[i] % 2)] + 1\n # # find evens\n # even = 0\n # for num in nums:\n # if num % 2 == 0:\n # even += 1\n return max(max(LVS[n-1]), even, n-even)","runtime":"819"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0] * 2 for _ in range(n)]\n last_even = -1\n last_odd = -1\n res = 0\n\n for i, val in enumerate(nums): \n if val % 2 == 0: \n last_even = i\n if last_odd == -1: \n dp[i] = [1, 0]\n continue\n dp[i][0] = dp[last_odd][0] + 1\n dp[i][1] = dp[last_odd][1]\n res = dp[i][0] + dp[i][1]\n else: \n last_odd = i\n if last_even == -1: \n dp[i] = [0, 1]\n continue\n dp[i][0] = dp[last_even][0]\n dp[i][1] = dp[last_even][1] + 1\n res = max(res, dp[i][0] + dp[i][1])\n \n countOdd = sum([1 for num in nums if num % 2 == 1])\n countEven = sum([1 for num in nums if num % 2 == 0 ])\n return max(res, countOdd, countEven) \n \n ","runtime":"824"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n N = len(nums)\n dp = [[0] * 4 for _ in range(N)]\n # i,0 -> all odd\n # i,1 -> all even\n # i,2 -> odd/even alt w/ last one odd\n # i,3 -> odd/even alt w/ last one even\n\n dp[0][0] = dp[0][2] = 1 if nums[0]%2 != 0 else 0\n dp[0][1] = dp[0][3] = 1 if nums[0]%2 == 0 else 0\n\n for i in range(1, N):\n if nums[i]%2 == 0:\n dp[i][0] = dp[i-1][0]\n dp[i][1] = dp[i-1][1] + 1\n dp[i][2] = dp[i-1][2]\n dp[i][3] = max(dp[i-1][2] + 1, dp[i-1][2])\n else:\n dp[i][0] = dp[i-1][0] + 1\n dp[i][1] = dp[i-1][1]\n dp[i][2] = max(dp[i-1][3] + 1, dp[i-1][2])\n dp[i][3] = dp[i-1][3]\n \n return max(dp[N-1])\n","runtime":"829"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # https://github.com/doocs/leetcode/tree/main/solution/3200-3299/3201.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20I\n k = 2\n f = [[0] * k for _ in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j - x + k) % k\n f[x][y] = f[y][x] + 1\n ans = max(ans, f[x][y])\n return ans\n","runtime":"829"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n K=2\n\n dp = defaultdict(lambda: defaultdict(int))\n result = 0\n for val in nums:\n for prev_mod in range(K):\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\n result = max(result, dp[prev_mod][val%K])\n return result\n# Time O(N*k)\n\n\n\n# %k == constant -> alternating mod values\n # Note, also true if all mod values 0, but this also falls under alternating mod values\n\n# if end with element a%k, having b as prev mod\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\n# dp[b][a%k] = dp[a%k][b] +1","runtime":"844"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0]*2 for i in range(2)]\n maxl = 1\n for num in nums:\n currnum = num%2\n for i in range(2):\n dp[currnum][i] = max(dp[currnum][i], dp[i][currnum]+1)\n maxl = max(dp[currnum][i],maxl)\n return maxl","runtime":"849"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # based on the current number, and the target\n # rest, you can find the prev number in sequence\n dp = [[0 for _ in range(2)] for _ in range(2)]\n\n for num in nums:\n current = num % 2\n\n for k in range(2):\n prev = (2 + k - current) % 2\n dp[current][k] = max(dp[current][k], dp[prev][k] + 1)\n\n return max([max(x) for x in dp])","runtime":"854"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 2d dp\n # dp(i, j): max length if current remainder was i and previous remainder was j\n # only possible sequences are alternating (0101.., 1010...) or same (00000..., 11111..)\n\n dp = [[0] * 2 for _ in range(2)]\n res = 0\n\n for i in range(len(nums)):\n curr_remainder = nums[i] % 2\n\n for prev_remainder in range(2):\n dp[curr_remainder][prev_remainder] = max(dp[curr_remainder][prev_remainder], dp[prev_remainder][curr_remainder] + 1)\n res = max(res, dp[curr_remainder][prev_remainder])\n\n return res","runtime":"858"},{"code":"from collections import defaultdict, deque\nfrom copy import deepcopy\nfrom typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n for i in range(len(nums)):\n nums[i] %= 2 \n \n zero_count = nums.count(0)\n one_count = nums.count(1)\n\n index_map_01 = defaultdict(deque)\n for i in range(len(nums)):\n index_map_01[nums[i]].append(i)\n\n index_map_10 = deepcopy(index_map_01) \n\n max_alternating_01 = 0\n if zero_count > 0:\n max_alternating_01 = 1\n\n previous_index = index_map_01[0].popleft()\n next_element = 1\n\n while index_map_01[next_element]:\n if len(index_map_01[next_element]) > 0:\n current_index = index_map_01[next_element].popleft()\n if current_index > previous_index:\n max_alternating_01 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n max_alternating_10 = 0\n if one_count > 0:\n max_alternating_10 = 1\n previous_index = index_map_10[1].popleft()\n next_element = 0\n while index_map_10[next_element]:\n if len(index_map_10[next_element]) > 0:\n current_index = index_map_10[next_element].popleft()\n if current_index > previous_index:\n max_alternating_10 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)","runtime":"863"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even = sum(n % 2 == 0 for n in nums)\n odd = sum(n % 2 == 1 for n in nums)\n @cache\n def dfs(i, parity):\n if i == len(nums):\n return 0\n if nums[i] % 2 == parity:\n return 1 + dfs(i + 1, 1 - parity)\n return dfs(i + 1, parity)\n return max(\n even,\n odd,\n dfs(0, 1),\n dfs(0, 0)\n )\n\n \n \n ","runtime":"868"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n max_lens_odd = [1] * n\n max_lens_even = [1] * n\n for i in range(n):\n update_odd = update_even = False\n for j in range(i - 1, -1, -1):\n if update_odd and update_even:\n break\n curr_sum = nums[i] + nums[j]\n if curr_sum % 2 and update_odd:\n continue\n if curr_sum % 2 == 0 and update_even:\n continue\n if curr_sum % 2:\n update_odd = True\n if max_lens_odd[j] + 1 > max_lens_odd[i]:\n max_lens_odd[i] = max_lens_odd[j] + 1\n else:\n update_even = True\n if max_lens_even[j] + 1 > max_lens_even[i]:\n max_lens_even[i] = max_lens_even[j] + 1\n ans = max(max(max_lens_odd), max(max_lens_even))\n return ans\n","runtime":"873"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = [[0]*2 for i in range(2)]\n maxl = 1\n for num in nums:\n currnum = num%2\n for i in range(2):\n dp[currnum][i] = max(dp[currnum][i], dp[i][currnum]+1)\n maxl = max(dp[currnum][i],maxl)\n return maxl","runtime":"878"},{"code":"class Solution:\n\n def findParity(self, nums: List[int], i: int, parity : int) -> int:\n if i == 0:\n return -1\n j = i - 1\n while j >= 0 and (nums[i] + nums[j]) % 2 !=parity:\n j -= 1\n return j\n\n def findSameParity(self, nums: List[int], i: int) -> int:\n return self.findParity(nums, i, 0)\n\n def findOppositeParity(self, nums: List[int], i: int) -> int:\n return self.findParity(nums, i, 1)\n\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n if n <= 2:\n return n\n dpEven = [None] * n\n dpOdd = [None] * n\n dpEven[0] = dpOdd[0] = 1\n for i in range(1, n):\n j = self.findSameParity(nums, i)\n if j < 0:\n dpEven[i] = 1\n else:\n dpEven[i] = 1 + dpEven[j]\n k = self.findOppositeParity(nums, i)\n if k < 0:\n dpOdd[i] = 1\n else:\n if j < 0:\n dpOdd[i] = 1 + dpOdd[k]\n else:\n dpOdd[i] = max(1 + dpOdd[k], dpOdd[j])\n return max(max(dpEven),max(dpOdd))\n\n\n ","runtime":"883"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n #create a dp 3 * len(nums) array where dp[i][j] = longest subsequence at index i with state even-even, odd-odd, even-odd\n \n dp = {}\n dp[(-1, 'o')] = 0\n dp[(-1, 'eo')] = 0\n dp[(-1, 'e')] = 0\n \n last_even = -1\n last_odd = -1\n for i in range(len(nums)):\n if nums[i] % 2 == 0:\n dp[(i,'e')] = 1 + dp[(last_even, 'e')]\n dp[(i, 'eo')] = 1 + dp[(last_odd, 'eo')]\n dp[(i, 'o')] = 0\n last_even = i\n else:\n dp[(i,'e')] = 0\n dp[(i, 'eo')] = 1 + dp[(last_even, 'eo')]\n dp[(i, 'o')] = 1 + dp[(last_odd, 'o')]\n last_odd = i\n #print(dp)\n n = len(nums) - 1\n return max(dp.values())","runtime":"888"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n count1 = count0 = 0\n for i in range(len(nums)):\n nums[i] = nums[i] % 2\n if nums[i] == 0:\n count0 += 1\n else:\n count1 += 1\n \n @cache\n def dp(index,odd):\n if index >= len(nums):\n return 0\n if nums[index] % 2 == odd:\n return 1 + dp(index+1,1-odd)\n else:\n return dp(index+1,odd)\n \n return max(count0,count1,dp(0,0),dp(0,1))\n \n \n \n\n ","runtime":"893"},{"code":"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\n# similar to the question 1027.\nclass Solution:\n def maximumLength(self, A: List[int]) -> int:\n\n\n # A = [a % 2 for a in A]\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\n\n k=2\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = max(dp[b][a % k], dp[a % k][b] + 1)\n return max(max(dp[a].values()) for a in range(k))\n\n\n ","runtime":"898"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n odd = 0\n even = 0\n alternating = 0\n exp = nums[0] % 2\n \n for num in nums:\n rem = num % 2\n \n # if odd\n if rem: \n odd += 1\n else:\n even += 1\n \n if rem != exp:\n alternating += 1\n exp = rem\n print(odd, even, alternating)\n return max(odd, even, alternating + 1)","runtime":"903"},{"code":"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\n# similar to the question 1027.\nclass Solution:\n def maximumLength(self, A: List[int]) -> int:\n\n\n # A = [a % 2 for a in A]\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\n\n k=2\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = max(dp[b][a % k], dp[a % k][b] + 1)\n return max(max(dp[a].values()) for a in range(k))\n\n\n ","runtime":"908"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n a,b,c,d = 0,0,0,0\\n for v in nums:\\n if v%2==0: a,b = a+1, c+1\\n else: c,d = b+1,d+1\\n return max(a,b,c,d)\\n\\n \",\n \"runtime\": \"560\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n odd, even, alternating = 0, 0, 0\\n expected_sign = nums[0] % 2\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n if num % 2 == expected_sign:\\n alternating += 1\\n expected_sign = 1 - expected_sign\\n return max(odd, even, alternating)\",\n \"runtime\": \"560\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n odds = evens = swaps = 0\\n swap_even = not (nums[0] % 2 == 0)\\n \\n for i in nums:\\n if i % 2 == 0:\\n evens += 1\\n if not swap_even:\\n swap_even = True\\n swaps += 1\\n else:\\n odds += 1\\n if swap_even:\\n swap_even = False\\n swaps += 1\\n \\n return max([swaps, evens, odds])\",\n \"runtime\": \"565\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n remainders = [i % 2 for i in nums]\\n parity_sum = sum(remainders)\\n prev = remainders[0]\\n n = 1\\n for i in remainders[1:]:\\n if prev != i:\\n n += 1\\n prev = i\\n res = max(len(remainders) - parity_sum, parity_sum)\\n res = max(res, n)\\n return res\",\n \"runtime\": \"565\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n\\n n = len(nums)\\n \\n oddodd = 0\\n oddeven = 0\\n eveneven = 0\\n evenodd = 0\\n\\n for i in range(n):\\n if nums[i] % 2 == 0:\\n eveneven += 1\\n evenodd = oddeven + 1\\n else:\\n oddodd += 1\\n oddeven = evenodd + 1\\n\\n return max(oddodd, oddeven, eveneven, evenodd)\",\n \"runtime\": \"570\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n,k,prev = len(nums),1,nums[0]%2\\n ones=prev\\n for x in nums[1:]:\\n x%=2\\n ones+=x\\n if prev!=x:\\n k+=1\\n prev=x\\n return max(ones,n-ones,k)\",\n \"runtime\": \"570\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even = 0\\n odd = 0\\n evenodd = 0\\n oddeven = 0\\n\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n evenodd = oddeven + 1\\n else:\\n odd += 1\\n oddeven = evenodd + 1\\n\\n return max(even, odd, evenodd, oddeven)\",\n \"runtime\": \"575\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0\\n nums = [x % 2 for x in nums]\\n all_odd = sum(nums)\\n all_even = len(nums) - all_odd\\n alternating = 1\\n last = nums[0]\\n for i in range(1, len(nums)):\\n if nums[i] != last:\\n last = nums[i]\\n alternating += 1\\n return max(all_odd, all_even, alternating)\\n\\n\",\n \"runtime\": \"575\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n c = nums[0] % 2\\n odd = even = both = 0\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n if num % 2 == c:\\n both += 1\\n c = 1 - c # Toggle the parity\\n return max(both, even, odd)\",\n \"runtime\": \"580\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # Declaration to count odd, even and both pair.\\n # In both pair 1st odd, 2nd even, 3rd odd ....\\n # To count if pair (sub[i] + sub[i + 1]) % 2 for if all element odd, even or both\\n c = nums[0] % 2\\n odd = 0\\n even = 0\\n both = 0\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n # Check if the current number's parity matches the expected parity `c`.\\n if num % 2 == c:\\n #// If yes, it means we are continuing a valid alternating pattern.\\n both += 1\\n #// Flip the expected parity for the next number (0 becomes 1, 1 becomes 0).\\n c = 1 - c\\n \\n return max(even, odd, both)\\n \",\n \"runtime\": \"580\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even, odd, alt = 0, 0, 0\\n curr = None\\n for n in nums:\\n if n % 2:\\n odd += 1\\n else:\\n even += 1\\n \\n if curr is None:\\n curr = n % 2\\n alt += 1\\n elif curr != n % 2:\\n curr = n % 2\\n alt += 1\\n return max(even, odd, alt)\",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even, odd, alt = 0, 0, 0\\n curr = nums[0] % 2\\n for n in nums:\\n if n % 2:\\n odd += 1\\n else:\\n even += 1\\n if curr == n % 2:\\n curr = 1 - curr\\n alt += 1\\n return max(even, odd, alt)\",\n \"runtime\": \"585\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n previous = nums[0] % 2\\n alternating = 1\\n length = 1\\n odds_count = previous\\n for num in nums[1:]:\\n length += 1\\n remainder_2 = num % 2\\n odds_count += remainder_2\\n if previous != remainder_2:\\n alternating += 1\\n previous = remainder_2\\n return max(alternating, odds_count, length - odds_count)\\n\",\n \"runtime\": \"590\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n c = nums[0] % 2\\n odd = even = both = 0\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n if num % 2 == c:\\n both += 1\\n c = 1 - c # Toggle the parity\\n return max(both, even, odd)\",\n \"runtime\": \"590\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums_rem = [x%2 for x in nums]\\n total = 1\\n pre = nums_rem[0]\\n for i in range(1, len(nums_rem)):\\n if (nums_rem[i] != pre):\\n total += 1\\n pre = nums_rem[i]\\n\\n res0 = total\\n res1, res2 = 0, 0\\n for x in nums_rem:\\n if x == 0:\\n res1 += 1\\n else:\\n res2 += 1\\n res = max(res0, res1, res2)\\n return res \\n \",\n \"runtime\": \"595\"\n },\n {\n \"code\": \"# 找出有效子序列的最大长度 I\\n\\n# 整数数组 nums\\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\\n\\n# 满足以下条件，则称其为 有效子序列：\\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\\n\\n# 返回 nums 的 最长的有效子序列 的长度。\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0]*2 for _ in range(2)]\\n for x in nums: \\n x %= 2 \\n dp[x][0] = 1 + dp[0][x]; \\n dp[x][1] = 1 + dp[1][x]; \\n return max(map(max, dp)) \\n\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n return max(map(max, dp)) \",\n \"runtime\": \"595\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even, odd, both = 0, 0, 0\\n check = nums[0] % 2\\n for num in nums:\\n if num % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n \\n if num % 2 == check:\\n both += 1\\n check = 1 - check\\n \\n return max(even, odd, both)\",\n \"runtime\": \"600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n ecnt = 0\\n for x in nums:\\n if x % 2 == 0:\\n ecnt += 1\\n res = max(ecnt, len(nums) - ecnt)\\n v0 = nums[0]\\n pol = v0 % 2\\n sofar = 1\\n for i in range(1, len(nums)):\\n cpol = nums[i] % 2\\n if cpol != pol:\\n pol = cpol\\n sofar += 1\\n return max(res, sofar, 2)\",\n \"runtime\": \"600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n oddRes = 0\\n evenRes = 0\\n oddEvenRes = 0\\n evenOddRes = 0\\n currOddEven = True\\n currEvenOdd = True\\n \\n for i in range(len(nums)):\\n if nums[i] % 2 == 1:\\n oddRes += 1\\n if currOddEven:\\n oddEvenRes += 1\\n currOddEven = False\\n if not currEvenOdd:\\n evenOddRes += 1\\n currEvenOdd = True\\n if nums[i] % 2 == 0:\\n evenRes += 1\\n if not currOddEven:\\n oddEvenRes += 1\\n currOddEven = True\\n if currEvenOdd:\\n evenOddRes += 1\\n currEvenOdd = False\\n\\n return max(oddRes, evenRes, oddEvenRes, evenOddRes)\\n \\n \",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n\\n odd = 0\\n even = 0\\n both = 1\\n prev = -1\\n\\n for i in range(len(nums)):\\n curr = nums[i]%2\\n if curr == 0:\\n even+=1\\n else:\\n odd+=1\\n if prev==-1:\\n prev = curr\\n continue\\n \\n if curr != prev:\\n both+=1\\n \\n prev = nums[i]%2\\n return max(odd,even,both)\\n \\n \\n\\n\\n\",\n \"runtime\": \"605\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n evens = 0\\n odds = 0\\n one = 1\\n if nums[0] % 2:\\n odds += 1\\n else:\\n evens += 1\\n parity = (nums[0] % 2) ^ 1\\n for i in range(1, len(nums)):\\n if nums[i] % 2 == parity:\\n one += 1\\n parity ^= 1\\n if nums[i] % 2 == 0:\\n evens += 1\\n else:\\n odds += 1\\n\\n return max(one, evens, odds)\",\n \"runtime\": \"610\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n previous = nums[0] % 2\\n alternating = 1\\n length = 1\\n odds_count = previous\\n for num in nums[1:]:\\n length += 1\\n remainder_2 = num % 2\\n odds_count += remainder_2\\n if previous != remainder_2:\\n alternating += 1\\n previous = remainder_2\\n return max(alternating, odds_count, length - odds_count)\\n\",\n \"runtime\": \"610\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n\\n z, o = 0, 0\\n aez = aeo = 0\\n for i in nums:\\n if i%2:\\n aeo = max(aeo, aez+1)\\n o += 1\\n else:\\n aez = max(aez, aeo+1)\\n z += 1\\n \\n return max(z, o, aez, aeo)\\n\",\n \"runtime\": \"615\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n previous = nums[0] % 2\\n alternating = 1\\n for num in nums[1:]:\\n remainder_2 = num % 2\\n if previous != remainder_2:\\n alternating += 1\\n previous = remainder_2\\n evens_count = sum([num % 2 for num in nums])\\n return max(alternating, evens_count, len(nums) - evens_count)\\n\",\n \"runtime\": \"615\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n odds = evens = alt = 0\\n curr_mod = (nums[0] % 2 + 1) % 2\\n for i in range(len(nums)):\\n if nums[i] % 2 == 0:\\n evens += 1\\n else:\\n odds += 1\\n if curr_mod % 2 != nums[i] % 2:\\n alt += 1\\n curr_mod = (curr_mod + 1) % 2\\n return max(odds, evens, alt)\",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n N = len(nums)\\n for i in range(N):\\n nums[i] %= 2\\n ret = max(nums.count(0),nums.count(1))\\n dp = [0]*2\\n for i in range(N):\\n dp[nums[i]] = dp[1-nums[i]]+1\\n return max(ret,dp[0],dp[1])\",\n \"runtime\": \"620\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n if len(nums)<3:return len(nums)\\n\\n counteven,countodd=0,0\\n for i in range(len(nums)):\\n if nums[i]%2==0:counteven+=1\\n else: countodd+=1\\n ans=[nums[0]]\\n if ans[-1]%2!=0: #if the 1st num of odd \\n for i in range(1,len(nums)):\\n if ans[-1]%2!=0 and nums[i]%2==0: \\n ans.append(nums[i])\\n elif ans[-1]%2==0 and nums[i]%2!=0:\\n ans.append(nums[i])\\n else:\\n ans=[]\\n for i in nums:\\n if i%2==0: \\n ans.append(i)\\n break\\n for i in range(1,len(nums)):\\n if ans[-1]%2!=0 and nums[i]%2==0: \\n ans.append(nums[i])\\n elif ans[-1]%2==0 and nums[i]%2!=0:\\n ans.append(nums[i])\\n return max(len(ans),counteven,countodd) \",\n \"runtime\": \"625\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n total = 1\\n pre = nums[0]%2\\n for i in range(1, len(nums)):\\n if (nums[i]%2 != pre):\\n total += 1\\n pre = nums[i]%2\\n\\n res0 = total\\n res1, res2 = 0, 0\\n for x in nums:\\n if x%2 == 0:\\n res1 += 1\\n else:\\n res2 += 1\\n res = max(res0, res1, res2)\\n return res \\n \",\n \"runtime\": \"625\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, n: List[int]) -> int:\\n a=0\\n b=0\\n c=[n[0]]\\n for i in n:\\n if i%2==0:\\n a+=1\\n for i in n:\\n if i%2==1:\\n b+=1\\n for i in range(1,len(n)):\\n if c[-1]%2==0 and n[i]%2==1:\\n c.append(n[i])\\n elif c[-1]%2==1 and n[i]%2==0:\\n c.append(n[i])\\n return max(a,b,len(c))\\n\",\n \"runtime\": \"630\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, a: List[int]) -> int:\\n even, odd = [-1, -1], [-1, -1]\\n res = 0\\n for i in range(len(a)):\\n if a[i] % 2 == 0:\\n if even[0] == -1:\\n even[0] = 1\\n else:\\n even[0] += 1\\n if even[1] == -1:\\n even[1] = 1\\n if odd[1] != -1:\\n even[1] = odd[1] + 1\\n else:\\n if odd[0] == -1:\\n odd[0] = 1\\n else:\\n odd[0] += 1\\n if odd[1] == -1:\\n odd[1] = 1\\n if even[1] != -1:\\n odd[1] = even[1] + 1\\n return max(max(even), max(odd))\\n \\n\\n \",\n \"runtime\": \"635\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int]) -> int:\\n A = [a % 2 for a in A]\\n return max(A.count(0), A.count(1), len(list(groupby(A))))\",\n \"runtime\": \"635\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n alter = []\\n odd = []\\n even = []\\n for i in nums:\\n if i%2 == 0:\\n even.append(i)\\n else:\\n odd.append(i)\\n if len(alter)==0 or alter[-1]%2 != i%2:\\n alter.append(i)\\n return max(len(alter), len(odd), len(even))\",\n \"runtime\": \"640\"\n },\n {\n \"code\": \"class Solution(object):\\n def help(self, nums, flag):\\n even_odd = flag\\n cnt1, cnt2 = 0, 0\\n for num in nums:\\n if num%2 == flag:\\n cnt1 += 1\\n flag = not flag\\n if num%2 == even_odd:\\n cnt2 += 1\\n return max(cnt1, cnt2)\\n\\n def maximumLength(self, nums):\\n ans1 = self.help(nums, True)\\n ans2 = self.help(nums, False)\\n return max(ans1, ans2)\",\n \"runtime\": \"640\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n nums = list(map(lambda x: x%2, nums))\\n\\n z, o = 0, 0\\n aez = aeo = 0\\n for i in nums:\\n if i:\\n aeo = max(aeo, aez+1)\\n o += 1\\n else:\\n aez = max(aez, aeo+1)\\n z += 1\\n \\n return max(z, o, aez, aeo)\\n\",\n \"runtime\": \"645\"\n },\n {\n \"code\": \"# 找出有效子序列的最大长度 I\\n\\n# 整数数组 nums\\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\\n\\n# 满足以下条件，则称其为 有效子序列：\\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\\n\\n# 返回 nums 的 最长的有效子序列 的长度。\\n\\n# 解題思路：\\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\\n\\n# 動態規劃狀態設置：\\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\\n\\n# 遞推公式：\\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\\n\\n# 最終結果：\\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\\n\\n# 對每個餘數做DP\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0] * 2 for _ in range(2)]\\n\\n for num in nums:\\n num %= 2\\n for y in range(2):\\n dp[num][y] = dp[y][num] + 1\\n\\n return max(map(max, dp))\",\n \"runtime\": \"645\"\n },\n {\n \"code\": \"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\\n# L(i) = 1 [if i == 0]\\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\\n# L(i) = L(i-1) ow\\n\\n# oo = e\\n# ee = e\\n# eo/oe = o\\n\\n# \\n# eeeeo\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n EE = 0\\n EO = 1\\n OO = 1\\n OE = 0\\n \\n if nums[0] % 2 == 0:\\n OE = 1\\n EE = 1\\n OO = 0\\n EO = 0\\n\\n mx = 0\\n # EE = 0,1,1,2\\n # EO = 1,1,2,2\\n # OE = 0,2,2,4\\n # OO = 1,1,3,3\\n\\n # EE = 0, 1, 1, 1,2,2,3\\n # EO = 1, 1, 2, 3,3,4,4\\n # OE = 0, 2, 2,|2,4,4,6 \\n # OO = 1, 1, 3, 3,3,5,5\\n \\n for i in range(1, len(nums)):\\n \\n if nums[i] % 2 == 0:\\n EE = EE + 1\\n OE = OO + 1\\n else:\\n EO = EO + 1\\n OO = OE + 1\\n\\n mx = max(mx, EE, EO, OO, OE)\\n\\n return mx\",\n \"runtime\": \"650\"\n },\n {\n \"code\": \"class Solution(object):\\n def help(self, nums, flag):\\n even_odd = flag\\n cnt1, cnt2 = 0, 0\\n for num in nums:\\n if num%2 == flag:\\n cnt1 += 1\\n flag = not flag\\n if num%2 == even_odd:\\n cnt2 += 1\\n return max(cnt1, cnt2)\\n\\n def maximumLength(self, nums):\\n ans1 = self.help(nums, True)\\n ans2 = self.help(nums, False)\\n return max(ans1, ans2)\",\n \"runtime\": \"650\"\n },\n {\n \"code\": \"# 找出有效子序列的最大长度 I\\n\\n# 整数数组 nums\\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\\n\\n# 满足以下条件，则称其为 有效子序列：\\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\\n\\n# 返回 nums 的 最长的有效子序列 的长度。\\n\\n# 解題思路：\\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\\n\\n# 動態規劃狀態設置：\\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\\n\\n# 遞推公式：\\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\\n\\n# 最終結果：\\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\\n\\n# 2301 2302\\n# 3201. Find the Maximum Length of Valid Subsequence I\\n# 3202. Find the Maximum Length of Valid Subsequence II\\n\\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\\n# return max(map(max, dp)) \\n\\n# 對每個餘數做DP\\n\\n# DP 2D,\\n# O(n * k), S: O(k * 2)\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0] * 2 for _ in range(2)]\\n\\n for num in nums:\\n num %= 2\\n for y in range(2):\\n dp[num][y] = dp[y][num] + 1\\n\\n return max(map(max, dp))\",\n \"runtime\": \"655\"\n },\n {\n \"code\": \"# 找出有效子序列的最大长度 I\\n\\n# 整数数组 nums\\n# nums 的子序列 sub 的长度为 x ，如果其满足以下条件，则称其为 有效子序列：\\n\\n# 满足以下条件，则称其为 有效子序列：\\n# (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.\\n\\n# 返回 nums 的 最长的有效子序列 的长度。\\n\\n# 解題思路：\\n# 這道題目要求找出一個數組中最長的有效子序列，條件是每對相鄰元素的和對 2 取餘數相等。可以利用動態規劃來解決這個問題。\\n\\n# 動態規劃狀態設置：\\n# dp[x][0]: 表示以偶數和結束的子序列的長度，當前元素 x 是偶數。\\n# dp[x][1]: 表示以奇數和結束的子序列的長度，當前元素 x 是奇數。\\n\\n# 遞推公式：\\n# 如果當前元素 x 是偶數，那麼它可以延長之前以奇數和為結束的子序列（因為偶數 + 奇數 = 奇數），所以更新 dp[偶數][0]。\\n# 如果當前元素 x 是奇數，那麼它可以延長之前以偶數和為結束的子序列（因為奇數 + 偶數 = 偶數），所以更新 dp[奇數][1]。\\n\\n# 最終結果：\\n# 遍歷完整個數組後，dp 中存儲了所有可能的最長子序列的長度，通過 max(map(max, dp)) 可以獲取最大的子序列長度。\\n\\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\\n# return max(map(max, dp)) \\n\\n# 對每個餘數做DP\\n\\n# DP 2D,\\n# O(n * k), S: O(k * 2)\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0] * 2 for _ in range(2)]\\n\\n for num in nums:\\n num %= 2\\n for y in range(2):\\n dp[num][y] = dp[y][num] + 1\\n\\n return max(map(max, dp))\",\n \"runtime\": \"655\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [a % 2 for a in nums]\\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))\",\n \"runtime\": \"659\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n alternatingOdd = 0\\n alternatingEven = 0\\n\\n current = 1\\n for num in nums:\\n if num % 2 == current % 2:\\n current += 1\\n alternatingOdd += 1\\n \\n current = 0\\n for num in nums:\\n if num % 2 == current % 2:\\n current += 1\\n alternatingEven += 1\\n \\n l1, l2 = len([x for x in nums if x % 2 == 0]), len([x for x in nums if x % 2 == 1])\\n\\n return max([alternatingOdd, alternatingEven, l1, l2])\",\n \"runtime\": \"659\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n A = [a % 2 for a in nums]\\n return max(A.count(0), A.count(1), len(list(groupby(A))))\",\n \"runtime\": \"664\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int]) -> int:\\n A = [a % 2 for a in A]\\n return max(A.count(0), A.count(1), len(list(groupby(A))))\",\n \"runtime\": \"664\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [a % 2 for a in nums] # O(n) in time and space\\n # subsequence can choose all 0's by eliminating any 1's.\\n # or choose all 1's. So we just count 0s and 1s.\\n # or choose all 10's \\n # or choose all 01's\\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))\\n # itertools.groupby return list of (key, group)\",\n \"runtime\": \"669\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n \\\"\\\"\\\"\\n sequence has consequitive sums that are all even or all odd\\n\\n brute force:\\n - generate every possible sequence and evaluate condition\\n o((2 ** n) * n)) - runtime\\n\\n brute force + backtracking:\\n - generate every sequence but once we encounter a bad sequence in the construction backtrack\\n better than brute force\\n\\n start and end index, then evaluate if its valid in a linear pass:\\n - o(n ** 3)\\n\\n lis pattern? - for every index, find the max length of valid subsequence including the element at that index\\n then if we solve prefix wise (left to right) and we conside a new element x + 1, whats the best way to expand \\n the sequence using the answers of elements to the left\\n - o(n ** 2)\\n\\n divide and conquer???\\n - split in half. solve for each half then best subsequence. merge best on left and right\\n - don't think this is easy with non-contiguous questions like subsequence\\n\\n o(n ** 2)\\n 1, 2, 3, 4\\n =============\\n 1st solve\\n 1\\n \\n 2nd solve\\n 1 2 \\n\\n 3rd solve\\n 1 2 3 \\n if i include 3, what is the max lenght i can make if i extend on 2, so 3 + 2 % 2 == 1, so I have to ask about the max length of the sequence that has all adjacent sums % == 1\\n \\n 4th solve\\n 1 2 3 4 -> \\n\\n why does this solve the problem?\\n - we solved the problem of what is the longest valid subsequence we can make if terminate \\n at element X. we solved this for every element X. proof by case, the optimal solution will \\n terminate at some Y and we solve for every X, w/o knowing which Y it's clearly the X that's \\n largest.\\n\\n a + b % 2 == 1 iff a + b is odd iff (a or b are odd but not both)\\n\\n 1 2 3 4\\n 1 1 1\\n\\n 1 2 1 1 2 1 2\\n odd - even - odd - even - ...\\n\\n 2 2 2 2 2 1 1 2 2\\n even - even - even ...\\n\\n\\n \\\"\\\"\\\"\\n n = len(nums)\\n nums = [num % 2 == True for num in nums]\\n max_valid_subsequence = max(sum(nums), n - sum(nums))\\n\\n for truth_value in [True, False]:\\n is_even = truth_value\\n length_subsequence = 0\\n for i in range(n):\\n if nums[i] % 2 == 1 and is_even:\\n is_even = not is_even\\n length_subsequence += 1\\n elif nums[i] % 2 == 0 and not is_even:\\n is_even = not is_even\\n length_subsequence += 1\\n\\n max_valid_subsequence = max(max_valid_subsequence, length_subsequence)\\n return max_valid_subsequence\\n\",\n \"runtime\": \"669\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n if len(nums) == 1:\\n return 1\\n maxlen = 2\\n even = list(filter(lambda x: x%2==0,nums))\\n maxlen = max(maxlen, len(even))\\n odd = list(filter(lambda x: x%2==1,nums))\\n maxlen = max(maxlen, len(odd))\\n evenodd=[]\\n even = 1\\n for i in nums:\\n if even == 1 and i%2==0:\\n evenodd.append(i)\\n even = 0\\n if even == 0 and i%2==1:\\n evenodd.append(i)\\n even = 1\\n maxlen = max(maxlen, len(evenodd))\\n oddeven=[]\\n odd = 1\\n for i in nums:\\n if odd == 1 and i%2==1:\\n oddeven.append(i)\\n odd = 0\\n if odd == 0 and i%2==0:\\n oddeven.append(i)\\n odd = 1\\n maxlen = max(maxlen, len(oddeven))\\n return maxlen\\n\",\n \"runtime\": \"674\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # all odd, all even, odd->even, even->odd\\n dp = [0, 0, 0, 0]\\n \\n for num in nums:\\n if num & 1:\\n dp[0] += 1\\n dp[2] += (dp[2] & 1 == 0)\\n dp[3] += dp[3] & 1\\n else:\\n dp[1] += 1\\n dp[2] += dp[2] & 1\\n dp[3] += (dp[3] & 1 == 0)\\n \\n return max(dp)\\n \",\n \"runtime\": \"674\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # ans = 2\\n \\n # curCount = 2\\n # cur = (nums[0] + nums[1]) % 2\\n \\n # for i in range(1, len(nums) - 1):\\n # print('cur=', cur)\\n # print(nums[i] + nums[i+1])\\n # if (nums[i] + nums[i+1]) % 2 == cur:\\n # curCount += 1\\n # ans = max(ans, curCount)\\n # else:\\n # cur = 1 - cur\\n # curCount = 2\\n # return ans\\n oddCount = 0\\n for num in nums:\\n oddCount += num % 2\\n \\n curOdd = 1\\n startWithOddCount = 0\\n \\n curEven = 0\\n startWithEvenCount = 0\\n \\n for num in nums:\\n if num % 2 == curOdd:\\n curOdd = 1 - curOdd\\n startWithOddCount += 1\\n if num % 2 == curEven:\\n curEven = 1 - curEven\\n startWithEvenCount += 1\\n \\n # print(oddCount)\\n # print(len(nums) - oddCount)\\n # print(startWithOddCount)\\n # print(startWithEvenCount)\\n return max(oddCount, len(nums) - oddCount, startWithOddCount, startWithEvenCount)\",\n \"runtime\": \"679\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n return max(\\n sum(int(num % 2 == 0) for num in nums),\\n sum(int(num % 2 == 1) for num in nums),\\n sum(nums[j-1] % 2 != nums[j] % 2 for j in range(1, len(nums))) + 1,\\n )\",\n \"runtime\": \"679\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # count even length subsequence \\n even_len, odd_len, alt_len = 0, 0, 0\\n i = 0 \\n while i < len(nums): \\n if nums[i] %2 == 0: \\n even_len += 1\\n i += 1\\n\\n # count odd mod subsequence \\n i = 0 \\n while i < len(nums): \\n if nums[i] %2 == 1: \\n odd_len += 1\\n i += 1\\n\\n # count alternating subsequence\\n i = 0 \\n next_odd = not (nums[i] % 2 == 0)\\n while i < len(nums): \\n if nums[i] % 2 == next_odd: \\n alt_len += 1\\n next_odd = not next_odd\\n i += 1\\n return max(max(even_len, odd_len), alt_len)\",\n \"runtime\": \"684\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [1] * len(nums)\\n longestEven, longestOdd = 0, 0\\n evenCount, oddCount = 0, 0\\n\\n if nums[0] % 2 == 0:\\n evenCount += 1\\n else:\\n oddCount += 1\\n \\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if nums[i-1] % 2 == 1:\\n dp[i] = max(dp[i-1], longestOdd) + 1\\n longestEven = max(longestEven, dp[i])\\n evenCount += 1\\n else:\\n if nums[i-1] % 2 == 0:\\n dp[i] = max(dp[i-1], longestEven) + 1\\n longestOdd = max(longestOdd, dp[i])\\n oddCount += 1\\n\\n return max(max(dp), evenCount, oddCount)\\n\\n \",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n def helper1(nums):\\n count = 0\\n for i in range(len(nums)):\\n if nums[i]%2 == 0:\\n count += 1\\n return count\\n def helper2(nums):\\n count = 0\\n for i in range(len(nums)):\\n if nums[i]%2 == 1:\\n count += 1\\n return count\\n #starting with odd num\\n def helper3(nums):\\n par = 1\\n count = 0\\n for i in range(len(nums)):\\n if par == 1 and nums[i]%2 == 1:\\n par = 0\\n count += 1\\n elif par == 0 and nums[i]%2 == 0:\\n par = 1\\n count += 1\\n return count\\n def helper4(nums):\\n par = 0\\n count = 0\\n for i in range(len(nums)):\\n if par == 0 and nums[i]%2 == 0:\\n par = 1\\n count += 1\\n elif par == 1 and nums[i]%2 == 1:\\n par = 0\\n count += 1\\n return count\\n val = max(helper1(nums),helper2(nums),helper3(nums),helper4(nums))\\n return val\",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int]) -> int:\\n A = [a % 2 for a in A]\\n return max(A.count(0), A.count(1), len(list(groupby(A))))\",\n \"runtime\": \"694\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n m = collections.Counter()\\n\\n for n in nums:\\n c = n%2\\n m[c] +=1\\n\\n res = max(m.values())\\n\\n m = collections.Counter()\\n for n in nums:\\n c = n%2\\n m[c] = m[1-c]+1\\n\\n return max(res,max(m.values()))\",\n \"runtime\": \"694\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n max_len = 0\\n for target in range(k):\\n compliments = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment = (target - curr_remainder)%k\\n if compliment in compliments:\\n compliments[curr_remainder] = compliments[compliment] + 1\\n else:\\n compliments[curr_remainder] = 1\\n \\n if compliments[curr_remainder] > max_len:\\n max_len = compliments[curr_remainder]\\n \\n return max_len\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count_odd = 0\\n # count_even = 0\\n # alt_odd = 0\\n # alt_even = 0\\n\\n # for num in nums:\\n # if num % 2:\\n # count_odd += 1\\n # alt_odd = alt_even + 1\\n # else:\\n # count_even += 1\\n # alt_even = alt_odd + 1\\n \\n # return max(count_odd, count_even, alt_odd, alt_even)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # k = 2\\n # max_length = 0\\n # for target_remainder in range(k):\\n # seen_remainders = {}\\n # for num in nums:\\n # curr_remainder = num % k\\n # compliment_remainder = target_remainder - curr_remainder\\n # if compliment_remainder < 0:\\n # compliment_remainder = k - abs(compliment_remainder)\\n \\n # if compliment_remainder in seen_remainders:\\n # if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\\n # seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\\n # else:\\n # seen_remainders[curr_remainder] = 1\\n \\n # if seen_remainders[curr_remainder] > max_length:\\n # max_length = seen_remainders[curr_remainder]\\n\\n # return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # count_zeros = 0\\n # count_ones = 0\\n # count_alt_zeros = 0\\n # count_alt_ones = 0\\n # for num in nums:\\n # if num % 2:\\n # count_ones += 1\\n # count_alt_zeros += 1\\n # else:\\n # count_zeros += 1\\n # count_alt_ones += 1\\n \\n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count = [0,0]\\n # ends = [0,0]\\n # for num in nums:\\n # count[num % 2] += 1\\n # ends[num % 2] = ends[1 - num % 2] + 1\\n \\n # return max( max(count), max(ends) )\\n\\n\\n # remainders = [ num % 2 for num in nums ]\\n # for \\n\\n\\n\\n # max_zero = self.get_lis(nums, 0)\\n # max_one = self.get_lis(nums, 1)\\n # return max_zero if max_zero >= max_one else max_one\\n \\n # def get_lis(self, nums, remainder):\\n # lis = [1] * len(nums)\\n # max_lis = 1 if nums else 0\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % 2 == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if lis[index] > max_lis:\\n # max_lis = lis[index]\\n \\n # return max_lis\\n\\n \",\n \"runtime\": \"699\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n, k = len(nums), 2\\n dp = [[0] * k for _ in range(k)]\\n for i in range(n):\\n for j in range(k):\\n dp[nums[i] % k][j] = 1 + dp[j][nums[i] % k]\\n return max(max(dp[i]) for i in range(k))\",\n \"runtime\": \"704\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n m = 1\\n c = 0\\n for i in nums:\\n if i & 1:\\n c += 1\\n m = max(m, c)\\n c = 0\\n for i in nums:\\n if not i & 1:\\n c += 1\\n m = max(m, c)\\n c = b = 0\\n for i in nums:\\n if (i & 1) == b:\\n c += 1\\n m = max(m, c)\\n b = not b\\n c = 0\\n b = 1\\n for i in nums:\\n if (i & 1) == b:\\n c += 1\\n m = max(m, c)\\n b = not b\\n return m\",\n \"runtime\": \"704\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n def compute_max(parity):\\n total, prev = 1, 0\\n \\n for x in range(1, len(nums)):\\n if (nums[prev] + nums[x]) % 2 == parity:\\n total += 1\\n prev = x\\n \\n return total\\n \\n odds, evens = 0, 0\\n for v in nums:\\n if v % 2 == 0: evens += 1\\n else: odds += 1\\n \\n return max(odds, evens,\\n compute_max(0), \\n compute_max(1), \\n compute_max(0), \\n compute_max(1))\",\n \"runtime\": \"709\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef maximumLength(self, nums: List[int]) -> int:\\n\\n\\t\\tresult1, result3 , result2 , result4 = 1 , 1 , 1 , 1\\n\\n\\t\\tfor i in range(len(nums)):\\n\\t\\t\\tnums[i] = nums[i] % 2\\n\\n\\t\\tif 0 in nums:\\n\\n\\t\\t\\ti = nums.index(0)\\n\\t\\t\\tlast = 0\\n\\n\\t\\t\\tfor index in range(i + 1,len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult1 = result1 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult1 = result1 + 1\\n\\n\\t\\t\\tfor index in range(i + 1, len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult2 = result2 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult2 = result2 + 1\\n\\n\\t\\tif 1 in nums:\\n\\n\\t\\t\\ti = nums.index(1)\\n\\t\\t\\tlast = 1\\n\\n\\t\\t\\tfor index in range(i + 1 ,len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult3 = result3 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult3 = result3 + 1\\n\\n\\t\\t\\tfor index in range(i + 1, len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult4 = result4 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult4 = result4 + 1\\n\\n\\t\\treturn max([result1 , result2, result3, result4])\",\n \"runtime\": \"714\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [1] * len(nums)\\n longestEven, longestOdd = 0, 0\\n evenCount, oddCount = 0, 0\\n\\n if nums[0] % 2 == 0:\\n evenCount += 1\\n else:\\n oddCount += 1\\n \\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if nums[i-1] % 2 == 1:\\n dp[i] = max(dp[i-1], longestOdd) + 1\\n longestEven = max(longestEven, dp[i])\\n evenCount += 1\\n else:\\n if nums[i-1] % 2 == 0:\\n dp[i] = max(dp[i-1], longestEven) + 1\\n longestOdd = max(longestOdd, dp[i])\\n oddCount += 1\\n\\n return max(max(dp), evenCount, oddCount)\\n\\n \",\n \"runtime\": \"719\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # odd even odd even\\n def func(odd, switch):\\n length = 0\\n for i in range(len(nums)):\\n if nums[i] % 2 == 1 and odd:\\n length += 1\\n if switch:\\n odd = not odd\\n elif nums[i] % 2 == 0 and not odd:\\n length += 1\\n if switch:\\n odd = not odd\\n return length\\n\\n return max(func(True, True), func(True, False),\\n func(False, True), func(False, False))\\n\",\n \"runtime\": \"719\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n max_length = 0\\n for p0 in [0, 1]:\\n for c in [0, 1]:\\n length = 0\\n for num in nums:\\n parity = num % 2\\n expected_parity = p0 if length % 2 == 0 else p0 ^ c\\n if parity == expected_parity:\\n length += 1\\n max_length = max(max_length, length)\\n return max_length\",\n \"runtime\": \"724\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [a%2 for a in nums]\\n count_0 = 0\\n for a in nums:\\n if a==0:\\n count_0 += 1\\n count_1 = len(nums) - count_0\\n \\n c = 0\\n for idx,_ in enumerate(nums[1::]):\\n if nums[idx+1] != nums[idx]:\\n c+=1\\n print(nums[idx+1])\\n c+=1\\n print(nums)\\n return max(c, count_1, count_0)\\n\",\n \"runtime\": \"724\"\n },\n {\n \"code\": \"# Data Structures and Algorithm Used:\\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\\n\\n# Short Intuition:\\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\\n\\n# Detailed Intuition:\\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\\n# - The final result is the maximum value found in this dictionary.\\n\\n# Pseudocode:\\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\\n# 2. For each number `n` in `nums`:\\n# a. Iterate over all possible `i` from `0` to `k-1`.\\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\\n# 3. The answer is the maximum value in the `count` dictionary.\\n\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums):\\n # Step 1: Initialize the dictionary to keep track of subsequence counts\\n count = defaultdict(int)\\n \\n # Step 2: Iterate over each number in the array\\n for n in nums:\\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\\n for i in range(2):\\n # Step 2b: Update the count for the pair (i, n%k)\\n count[(i, n % 2)] = count[(n % 2, i)] + 1\\n \\n # Step 3: Return the maximum value found in the count dictionary\\n return max(count.values())\\n\\n# Time Complexity:\\n# - O(n * k) where n is the length of the array and k is the given integer. \\n# This is because for each element in the array, we perform `k` updates in the dictionary.\\n\\n# Space Complexity:\\n# - O(k^2) for storing the count of subsequences in the dictionary.\\n\",\n \"runtime\": \"729\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n def compute_max(parity):\\n total, prev = 1, -1\\n \\n for x in range(len(nums)):\\n if prev == -1:\\n prev = x\\n continue\\n \\n #print(nums[prev], nums[x], (nums[prev] + nums[x]) % 2, parity)\\n if (nums[prev] + nums[x]) % 2 == parity:\\n total += 1\\n prev = x\\n \\n return total\\n\\n odd, even = 0, 0\\n while odd < len(nums) and nums[odd] % 2 != 1: odd += 1\\n while even < len(nums) and nums[even] % 2 != 0: even += 1\\n \\n odds, evens = 0, 0\\n for v in nums:\\n if v % 2 == 0: evens += 1\\n else: odds += 1\\n \\n return max(odds, evens,\\n compute_max(0), \\n compute_max(1), \\n compute_max(0), \\n compute_max(1))\",\n \"runtime\": \"734\"\n },\n {\n \"code\": \"class Solution:\\n def maximumk(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n \\n for mod in range(k):\\n for num in nums:\\n currNum = num % k\\n prevNum = (mod - currNum) % k\\n dp[currNum][mod] = max(dp[currNum][mod], 1 + dp[prevNum][mod])\\n \\n max_value = max(max(row) for row in dp)\\n return max_value \\n\\n def maximumLength(self, nums: List[int]) -> int:\\n return self.maximumk(nums, 2)\",\n \"runtime\": \"739\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n max_length = 0\\n for target_remainder in range(k):\\n seen_remainders = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment_remainder = target_remainder - curr_remainder\\n if compliment_remainder < 0:\\n compliment_remainder = k - abs(compliment_remainder)\\n \\n if compliment_remainder in seen_remainders:\\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\\n else:\\n seen_remainders[curr_remainder] = 1\\n \\n if seen_remainders[curr_remainder] > max_length:\\n max_length = seen_remainders[curr_remainder]\\n\\n return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # count_zeros = 0\\n # count_ones = 0\\n # count_alt_zeros = 0\\n # count_alt_ones = 0\\n # for num in nums:\\n # if num % 2:\\n # count_ones += 1\\n # count_alt_zeros += 1\\n # else:\\n # count_zeros += 1\\n # count_alt_ones += 1\\n \\n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count = [0,0]\\n # ends = [0,0]\\n # for num in nums:\\n # count[num % 2] += 1\\n # ends[num % 2] = ends[1 - num % 2] + 1\\n \\n # return max( max(count), max(ends) )\\n\\n\\n # remainders = [ num % 2 for num in nums ]\\n # for \\n\\n\\n\\n # max_zero = self.get_lis(nums, 0)\\n # max_one = self.get_lis(nums, 1)\\n # return max_zero if max_zero >= max_one else max_one\\n \\n # def get_lis(self, nums, remainder):\\n # lis = [1] * len(nums)\\n # max_lis = 1 if nums else 0\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % 2 == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if lis[index] > max_lis:\\n # max_lis = lis[index]\\n \\n # return max_lis\\n\\n \",\n \"runtime\": \"744\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # odd even odd even\\n def func1(odd):\\n length = 0\\n for i in range(len(nums)):\\n if nums[i] % 2 == 1 and odd:\\n length += 1\\n odd = not odd\\n elif nums[i] % 2 == 0 and not odd:\\n length += 1\\n odd = not odd\\n return length\\n\\n len1 = max(func1(True), func1(False))\\n\\n # all odd or even\\n def func2(odd):\\n length = 0\\n for i in range(len(nums)):\\n if nums[i] % 2 == 1 and odd:\\n length += 1\\n elif nums[i] % 2 == 0 and not odd:\\n length += 1\\n return length\\n\\n len2 = max(func2(True), func2(False))\\n\\n return max(len1, len2)\\n\",\n \"runtime\": \"749\"\n },\n {\n \"code\": \"# Data Structures and Algorithm Used:\\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\\n\\n# Short Intuition:\\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\\n\\n# Detailed Intuition:\\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\\n# - The final result is the maximum value found in this dictionary.\\n\\n# Pseudocode:\\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\\n# 2. For each number `n` in `nums`:\\n# a. Iterate over all possible `i` from `0` to `k-1`.\\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\\n# 3. The answer is the maximum value in the `count` dictionary.\\n\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums):\\n # Step 1: Initialize the dictionary to keep track of subsequence counts\\n count = defaultdict(int)\\n \\n # Step 2: Iterate over each number in the array\\n for n in nums:\\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\\n for i in range(2):\\n # Step 2b: Update the count for the pair (i, n%k)\\n count[(i, n % 2)] = count[(n % 2, i)] + 1\\n \\n # Step 3: Return the maximum value found in the count dictionary\\n return max(count.values())\\n\\n# Time Complexity:\\n# - O(n * k) where n is the length of the array and k is the given integer. \\n# This is because for each element in the array, we perform `k` updates in the dictionary.\\n\\n# Space Complexity:\\n# - O(k^2) for storing the count of subsequences in the dictionary.\\n\",\n \"runtime\": \"754\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, a: List[int]) -> int:\\n even, odd = [-1, -1], [-1, -1]\\n res = 0\\n for i in range(len(a)):\\n if a[i] % 2 == 0:\\n if even[0] == -1:\\n even[0] = 1\\n else:\\n even[0] += 1\\n if even[1] == -1:\\n even[1] = 1\\n if odd[1] != -1:\\n even[1] = odd[1] + 1\\n else:\\n if odd[0] == -1:\\n odd[0] = 1\\n else:\\n odd[0] += 1\\n if odd[1] == -1:\\n odd[1] = 1\\n if even[1] != -1:\\n odd[1] = even[1] + 1\\n res = max(res, max(even), max(odd))\\n return res\\n \\n\\n \",\n \"runtime\": \"759\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n max_length = 0\\n for target_remainder in range(k):\\n seen_remainders = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment_remainder = target_remainder - curr_remainder\\n if compliment_remainder < 0:\\n compliment_remainder = k - abs(compliment_remainder)\\n \\n if compliment_remainder in seen_remainders:\\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\\n else:\\n seen_remainders[curr_remainder] = 1\\n \\n if seen_remainders[curr_remainder] > max_length:\\n max_length = seen_remainders[curr_remainder]\\n\\n return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # count_zeros = 0\\n # count_ones = 0\\n # count_alt_zeros = 0\\n # count_alt_ones = 0\\n # for num in nums:\\n # if num % 2:\\n # count_ones += 1\\n # count_alt_zeros += 1\\n # else:\\n # count_zeros += 1\\n # count_alt_ones += 1\\n \\n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count = [0,0]\\n # ends = [0,0]\\n # for num in nums:\\n # count[num % 2] += 1\\n # ends[num % 2] = ends[1 - num % 2] + 1\\n \\n # return max( max(count), max(ends) )\\n\\n\\n # remainders = [ num % 2 for num in nums ]\\n # for \\n\\n\\n\\n # max_zero = self.get_lis(nums, 0)\\n # max_one = self.get_lis(nums, 1)\\n # return max_zero if max_zero >= max_one else max_one\\n \\n # def get_lis(self, nums, remainder):\\n # lis = [1] * len(nums)\\n # max_lis = 1 if nums else 0\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % 2 == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if lis[index] > max_lis:\\n # max_lis = lis[index]\\n \\n # return max_lis\\n\\n \",\n \"runtime\": \"764\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n i,j = 1,0\\n colI, colJ = [], [] \\n while i != len(nums):\\n colI.extend([(nums[1]+nums[0])%2, nums[0]]) if not colI else colI.extend([])\\n if (colI[-1]+nums[i])%2==colI[0]:\\n colI.append(nums[i])\\n else:\\n j = i if j < 1 else j\\n i+=1\\n while j != len(nums):\\n colJ.extend([(colI[0]+1)%2, nums[j-1]]) if not colJ and j > 1 else colJ.extend([])\\n if colJ and (colJ[-1]+nums[j])%2==colJ[0]:\\n colJ.append(nums[j])\\n j+=1\\n ctO,ctE = 0,0\\n for n in nums:\\n if n%2==0:\\n ctE+=1\\n else:\\n ctO+=1\\n return max(len(colI)-1, len(colJ)-1, ctO, ctE)\",\n \"runtime\": \"764\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\\n where dp[a][b] means the length of subsequence ending with ...,a,b\\n dp[b][a % k] 表示以模数为 a % k 的数字 b 结尾的最长有效子序列的长度。\\n \\\"\\\"\\\"\\n dp = defaultdict(Counter)\\n k = 2\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n \\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"769\"\n },\n {\n \"code\": \"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\\n# similar to question 1027.\\n# simliar to question 3202.\\n# class Solution:\\n # def maximumLength(self, nums: List[int]) -> int:\\n\\n\\nclass Solution:\\n # def maximumLength(self, A: List[int]) -> int:\\n # A = [a % 2 for a in A]\\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\\n\\n def maximumLength(self, A: List[int], k = 2) -> int:\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\",\n \"runtime\": \"774\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n # dp是一个k * k的2D array\\n res = 0\\n dp = [[0] * k for _ in range(k)]\\n for a in nums:\\n for b in range(k):\\n dp[b][a%k] = dp[a%k][b] + 1\\n res = max(res, dp[b][a%k])\\n\\n return res\\n\\n\\n\\n# 当我们使用 defaultdict(Counter) 时，defaultdict 的默认工厂函数是 Counter。这意味着当访问字典中不存在的键时，会自动为这个键创建一个 Counter 作为其默认值。\\n\\n# 这个用法的典型场景：通常用于嵌套字典结构，特别是当需要记录某种二维关系时，【一个分类和每个分类下不同对象的计数】\\n\\n# from collections import defaultdict, Counter\\n\\n# d = defaultdict(Counter)\\n# d['a']['x'] += 1\\n# d['a']['y'] += 2\\n# d['b']['x'] += 3\\n\\n# print(d)\\n# defaultdict(<class 'collections.Counter'>, {'a': Counter({'y': 2, 'x': 1}), 'b': Counter({'x': 3})})\\n\",\n \"runtime\": \"779\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n import numpy as np\\n if len(nums)==2:\\n return 2\\n nums = np.array(nums)\\n n2=nums%2\\n z_count = np.sum(n2)\\n o_count = len(nums)-z_count\\n n3 = np.sum(n2[1:]!=n2[:-1])\\n # n4 = np.count(n2[1:]+n2[:-1])\\n return max(1+np.max(np.unique(n2[1:]+n2[:-1],return_counts=True)[1]),z_count,o_count)\",\n \"runtime\": \"784\"\n },\n {\n \"code\": \"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\\n# similar to question 1027.\\n# simliar to question 3202.\\n# class Solution:\\n # def maximumLength(self, nums: List[int]) -> int:\\n\\n\\nclass Solution:\\n # def maximumLength(self, A: List[int]) -> int:\\n # A = [a % 2 for a in A]\\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\\n\\n def maximumLength(self, A: List[int], k = 2) -> int:\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"789\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n # thinking as a DP problem\\n result = 0\\n\\n # if (sub[0] + sub[1]) % 2 == 0\\n # dp[0] is the max len of valid subseq ending with a value whose mod of 2 is 0\\n dp = [0, 0]\\n for v in nums:\\n x = v % 2\\n y = x\\n dp[x] = max(dp[x], dp[y] + 1)\\n result = max(result, dp[x])\\n \\n # if (sub[0] + sub[1]) % 2 == 1\\n # dp[0] is the max len of valid subseq ending with a value whose mod of 2 is 0\\n dp = [0, 0]\\n for v in nums:\\n x = v % 2\\n y = 1 - x\\n dp[x] = max(dp[x], dp[y] + 1)\\n result = max(result, dp[x])\\n \\n return result\\n \\n # case 1, all even numbers\\n # case 2, all odd numbers\\n even, odd = 0, 0\\n \\n stack = []\\n \\n for v in nums:\\n if v % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n \\n if len(stack) > 0 and v % 2 == stack[-1] % 2:\\n continue\\n stack.append(v)\\n \\n l = len(stack)\\n \\n result = max(even, odd, l)\\n return result\\n \\n \\n \\n \",\n \"runtime\": \"794\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 0 -> e,o,e\\n # 1 -> e,e,e \\n # 0 -> o,e,o\\n # 1 -> o,o,o\\n gmax = 0\\n dp = [[0,0] for i in range(len(nums))]\\n prev_e, prev_o = -1, -1\\n if nums[0] % 2 == 0:\\n prev_e = 0\\n else:\\n prev_o = 0\\n\\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if prev_e >= 0:\\n dp[i][1] = dp[prev_e][1] + 1\\n if prev_o >= 0:\\n dp[i][0] = dp[prev_o][0] + 1\\n prev_e = i\\n else:\\n if prev_e >= 0:\\n dp[i][0] = dp[prev_e][0] + 1\\n if prev_o >= 0:\\n dp[i][1] = dp[prev_o][1] + 1\\n prev_o = i\\n gmax = max(gmax, max(dp[i]))\\n \\n # add 1 for the unaccounted for last element\\n return gmax + 1 \\n \\n\\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"799\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\\"\\\"\\\"\\n check https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii\\n \\\"\\\"\\\"\\n dp = defaultdict(Counter)\\n k = 2\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"804\"\n },\n {\n \"code\": \"####################### 2D DP ###################### \\n\\n# Time O(nk)\\n# Space O(k * k)\\n# More general,\\n# dp[b][a] = max(dp[b][a], dp[a][b] + 1)\\n# where dp[a][b] means the max length of subsequence ending with ...,a (sth mod k = a),b(sth mod k = b),\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n # dp是一个k * k的2D array\\n res = 0\\n dp = [[0] * k for _ in range(k)]\\n # dp = defaultdict((Counter)) 我不建议用，过于fancy了\\n for a in nums:\\n for b in range(k):\\n dp[b][a%k] = dp[a%k][b] + 1\\n res = max(res, dp[b][a%k])\\n\\n return res\\n\\n####################### 1D DP ###################### \\n# time: O(NK)\\n# space: O(K)\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n res = 0\\n k = 2\\n for target_remainder in range(2):\\n dp = [0] * k\\n for num in nums: \\n current_remainder = num % k\\n previous_remainder = (target_remainder - current_remainder) % k\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n res = max(res, dp[current_remainder])\\n\\n return res\\n\\n\\n\\n# 当我们使用 defaultdict(Counter) 时，defaultdict 的默认工厂函数是 Counter。这意味着当访问字典中不存在的键时，会自动为这个键创建一个 Counter 作为其默认值。\\n\\n# 这个用法的典型场景：通常用于嵌套字典结构，特别是当需要记录某种二维关系时，【一个分类和每个分类下不同对象的计数】\\n\\n# from collections import defaultdict, Counter\\n\\n# d = defaultdict(Counter)\\n# d['a']['x'] += 1\\n# d['a']['y'] += 2\\n# d['b']['x'] += 3\\n\\n# print(d)\\n# defaultdict(<class 'collections.Counter'>, {'a': Counter({'y': 2, 'x': 1}), 'b': Counter({'x': 3})})\\n\",\n \"runtime\": \"804\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 0 -> e,o,e\\n # 1 -> e,e,e \\n # 0 -> o,e,o\\n # 1 -> o,o,o\\n gmax = 0\\n dp = [[0,0] for i in range(len(nums))]\\n prev_e, prev_o = -1, -1\\n if nums[0] % 2 == 0:\\n prev_e = 0\\n else:\\n prev_o = 0\\n\\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if prev_e >= 0:\\n dp[i][1] = dp[prev_e][1] + 1\\n if prev_o >= 0:\\n dp[i][0] = dp[prev_o][0] + 1\\n prev_e = i\\n else:\\n if prev_e >= 0:\\n dp[i][0] = dp[prev_e][0] + 1\\n if prev_o >= 0:\\n dp[i][1] = dp[prev_o][1] + 1\\n prev_o = i\\n gmax = max(gmax, max(dp[i]))\\n \\n # add 1 for the unaccounted for last element\\n return gmax + 1 \\n \\n\\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \",\n \"runtime\": \"809\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n evenCount, oddCount = 0, 0\\n for num in nums:\\n if num % 2 == 1:\\n oddCount += 1\\n else:\\n evenCount += 1\\n\\n ans = max(evenCount, oddCount)\\n\\n l = len(nums)\\n dp = [0] * l\\n for i in range(l):\\n dp[i] = 1\\n for j in range(i-1, -1, -1):\\n if nums[j] % 2 != nums[i] % 2:\\n dp[i] = max(dp[i], 1+dp[j])\\n break\\n \\n print(dp)\\n return max(ans, dp[l-1])\",\n \"runtime\": \"814\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n DP = [[0] * k for _ in range(k)]\\n for i in range(k):\\n DP[0][i] = 0\\n \\n for num in nums:\\n mod_num = num % k\\n temp = DP[mod_num].copy()\\n \\n for i in range(k):\\n x_mod = (mod_num + i) % k\\n temp[x_mod] = max(temp[x_mod], DP[i][x_mod] + 1)\\n DP[mod_num] = temp\\n \\n # print(DP)\\n \\n return max(max(row) for row in DP)\",\n \"runtime\": \"814\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n f = [[0] * k for _ in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j - x + k) % k\\n f[x][y] = f[y][x] + 1\\n ans = max(ans, f[x][y])\\n return ans\",\n \"runtime\": \"819\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # basically alternate nums must all be odd / all even\\n # odd/odd, even/odd, even/even\\n # we only need to do DP for even/odd\\n # LVS[i][p] is the Longest alt seq ending in parity p up to i\\n # 0: even, 1: odd\\n n = len(nums)\\n LVS = [[0,0] for _ in range(n)]\\n # base cases\\n LVS[0][nums[0] % 2] = 1\\n even = 1 if nums[0] % 2 == 0 else 0\\n # bottom up\\n for i in range(1, n):\\n if nums[i] % 2 == 0: \\n even += 1\\n for p in range(2):\\n LVS[i][p] = LVS[i-1][p]\\n LVS[i][nums[i] % 2] = LVS[i-1][1 - (nums[i] % 2)] + 1\\n # # find evens\\n # even = 0\\n # for num in nums:\\n # if num % 2 == 0:\\n # even += 1\\n return max(max(LVS[n-1]), even, n-even)\",\n \"runtime\": \"819\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0] * 2 for _ in range(n)]\\n last_even = -1\\n last_odd = -1\\n res = 0\\n\\n for i, val in enumerate(nums): \\n if val % 2 == 0: \\n last_even = i\\n if last_odd == -1: \\n dp[i] = [1, 0]\\n continue\\n dp[i][0] = dp[last_odd][0] + 1\\n dp[i][1] = dp[last_odd][1]\\n res = dp[i][0] + dp[i][1]\\n else: \\n last_odd = i\\n if last_even == -1: \\n dp[i] = [0, 1]\\n continue\\n dp[i][0] = dp[last_even][0]\\n dp[i][1] = dp[last_even][1] + 1\\n res = max(res, dp[i][0] + dp[i][1])\\n \\n countOdd = sum([1 for num in nums if num % 2 == 1])\\n countEven = sum([1 for num in nums if num % 2 == 0 ])\\n return max(res, countOdd, countEven) \\n \\n \",\n \"runtime\": \"824\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n N = len(nums)\\n dp = [[0] * 4 for _ in range(N)]\\n # i,0 -> all odd\\n # i,1 -> all even\\n # i,2 -> odd/even alt w/ last one odd\\n # i,3 -> odd/even alt w/ last one even\\n\\n dp[0][0] = dp[0][2] = 1 if nums[0]%2 != 0 else 0\\n dp[0][1] = dp[0][3] = 1 if nums[0]%2 == 0 else 0\\n\\n for i in range(1, N):\\n if nums[i]%2 == 0:\\n dp[i][0] = dp[i-1][0]\\n dp[i][1] = dp[i-1][1] + 1\\n dp[i][2] = dp[i-1][2]\\n dp[i][3] = max(dp[i-1][2] + 1, dp[i-1][2])\\n else:\\n dp[i][0] = dp[i-1][0] + 1\\n dp[i][1] = dp[i-1][1]\\n dp[i][2] = max(dp[i-1][3] + 1, dp[i-1][2])\\n dp[i][3] = dp[i-1][3]\\n \\n return max(dp[N-1])\\n\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # https://github.com/doocs/leetcode/tree/main/solution/3200-3299/3201.Find%20the%20Maximum%20Length%20of%20Valid%20Subsequence%20I\\n k = 2\\n f = [[0] * k for _ in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j - x + k) % k\\n f[x][y] = f[y][x] + 1\\n ans = max(ans, f[x][y])\\n return ans\\n\",\n \"runtime\": \"829\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n K=2\\n\\n dp = defaultdict(lambda: defaultdict(int))\\n result = 0\\n for val in nums:\\n for prev_mod in range(K):\\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\\n result = max(result, dp[prev_mod][val%K])\\n return result\\n# Time O(N*k)\\n\\n\\n\\n# %k == constant -> alternating mod values\\n # Note, also true if all mod values 0, but this also falls under alternating mod values\\n\\n# if end with element a%k, having b as prev mod\\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\\n# dp[b][a%k] = dp[a%k][b] +1\",\n \"runtime\": \"844\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0]*2 for i in range(2)]\\n maxl = 1\\n for num in nums:\\n currnum = num%2\\n for i in range(2):\\n dp[currnum][i] = max(dp[currnum][i], dp[i][currnum]+1)\\n maxl = max(dp[currnum][i],maxl)\\n return maxl\",\n \"runtime\": \"849\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # based on the current number, and the target\\n # rest, you can find the prev number in sequence\\n dp = [[0 for _ in range(2)] for _ in range(2)]\\n\\n for num in nums:\\n current = num % 2\\n\\n for k in range(2):\\n prev = (2 + k - current) % 2\\n dp[current][k] = max(dp[current][k], dp[prev][k] + 1)\\n\\n return max([max(x) for x in dp])\",\n \"runtime\": \"854\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 2d dp\\n # dp(i, j): max length if current remainder was i and previous remainder was j\\n # only possible sequences are alternating (0101.., 1010...) or same (00000..., 11111..)\\n\\n dp = [[0] * 2 for _ in range(2)]\\n res = 0\\n\\n for i in range(len(nums)):\\n curr_remainder = nums[i] % 2\\n\\n for prev_remainder in range(2):\\n dp[curr_remainder][prev_remainder] = max(dp[curr_remainder][prev_remainder], dp[prev_remainder][curr_remainder] + 1)\\n res = max(res, dp[curr_remainder][prev_remainder])\\n\\n return res\",\n \"runtime\": \"858\"\n },\n {\n \"code\": \"from collections import defaultdict, deque\\nfrom copy import deepcopy\\nfrom typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n for i in range(len(nums)):\\n nums[i] %= 2 \\n \\n zero_count = nums.count(0)\\n one_count = nums.count(1)\\n\\n index_map_01 = defaultdict(deque)\\n for i in range(len(nums)):\\n index_map_01[nums[i]].append(i)\\n\\n index_map_10 = deepcopy(index_map_01) \\n\\n max_alternating_01 = 0\\n if zero_count > 0:\\n max_alternating_01 = 1\\n\\n previous_index = index_map_01[0].popleft()\\n next_element = 1\\n\\n while index_map_01[next_element]:\\n if len(index_map_01[next_element]) > 0:\\n current_index = index_map_01[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_01 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n max_alternating_10 = 0\\n if one_count > 0:\\n max_alternating_10 = 1\\n previous_index = index_map_10[1].popleft()\\n next_element = 0\\n while index_map_10[next_element]:\\n if len(index_map_10[next_element]) > 0:\\n current_index = index_map_10[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_10 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)\",\n \"runtime\": \"863\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even = sum(n % 2 == 0 for n in nums)\\n odd = sum(n % 2 == 1 for n in nums)\\n @cache\\n def dfs(i, parity):\\n if i == len(nums):\\n return 0\\n if nums[i] % 2 == parity:\\n return 1 + dfs(i + 1, 1 - parity)\\n return dfs(i + 1, parity)\\n return max(\\n even,\\n odd,\\n dfs(0, 1),\\n dfs(0, 0)\\n )\\n\\n \\n \\n \",\n \"runtime\": \"868\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n max_lens_odd = [1] * n\\n max_lens_even = [1] * n\\n for i in range(n):\\n update_odd = update_even = False\\n for j in range(i - 1, -1, -1):\\n if update_odd and update_even:\\n break\\n curr_sum = nums[i] + nums[j]\\n if curr_sum % 2 and update_odd:\\n continue\\n if curr_sum % 2 == 0 and update_even:\\n continue\\n if curr_sum % 2:\\n update_odd = True\\n if max_lens_odd[j] + 1 > max_lens_odd[i]:\\n max_lens_odd[i] = max_lens_odd[j] + 1\\n else:\\n update_even = True\\n if max_lens_even[j] + 1 > max_lens_even[i]:\\n max_lens_even[i] = max_lens_even[j] + 1\\n ans = max(max(max_lens_odd), max(max_lens_even))\\n return ans\\n\",\n \"runtime\": \"873\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = [[0]*2 for i in range(2)]\\n maxl = 1\\n for num in nums:\\n currnum = num%2\\n for i in range(2):\\n dp[currnum][i] = max(dp[currnum][i], dp[i][currnum]+1)\\n maxl = max(dp[currnum][i],maxl)\\n return maxl\",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"class Solution:\\n\\n def findParity(self, nums: List[int], i: int, parity : int) -> int:\\n if i == 0:\\n return -1\\n j = i - 1\\n while j >= 0 and (nums[i] + nums[j]) % 2 !=parity:\\n j -= 1\\n return j\\n\\n def findSameParity(self, nums: List[int], i: int) -> int:\\n return self.findParity(nums, i, 0)\\n\\n def findOppositeParity(self, nums: List[int], i: int) -> int:\\n return self.findParity(nums, i, 1)\\n\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n if n <= 2:\\n return n\\n dpEven = [None] * n\\n dpOdd = [None] * n\\n dpEven[0] = dpOdd[0] = 1\\n for i in range(1, n):\\n j = self.findSameParity(nums, i)\\n if j < 0:\\n dpEven[i] = 1\\n else:\\n dpEven[i] = 1 + dpEven[j]\\n k = self.findOppositeParity(nums, i)\\n if k < 0:\\n dpOdd[i] = 1\\n else:\\n if j < 0:\\n dpOdd[i] = 1 + dpOdd[k]\\n else:\\n dpOdd[i] = max(1 + dpOdd[k], dpOdd[j])\\n return max(max(dpEven),max(dpOdd))\\n\\n\\n \",\n \"runtime\": \"883\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n #create a dp 3 * len(nums) array where dp[i][j] = longest subsequence at index i with state even-even, odd-odd, even-odd\\n \\n dp = {}\\n dp[(-1, 'o')] = 0\\n dp[(-1, 'eo')] = 0\\n dp[(-1, 'e')] = 0\\n \\n last_even = -1\\n last_odd = -1\\n for i in range(len(nums)):\\n if nums[i] % 2 == 0:\\n dp[(i,'e')] = 1 + dp[(last_even, 'e')]\\n dp[(i, 'eo')] = 1 + dp[(last_odd, 'eo')]\\n dp[(i, 'o')] = 0\\n last_even = i\\n else:\\n dp[(i,'e')] = 0\\n dp[(i, 'eo')] = 1 + dp[(last_even, 'eo')]\\n dp[(i, 'o')] = 1 + dp[(last_odd, 'o')]\\n last_odd = i\\n #print(dp)\\n n = len(nums) - 1\\n return max(dp.values())\",\n \"runtime\": \"888\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n count1 = count0 = 0\\n for i in range(len(nums)):\\n nums[i] = nums[i] % 2\\n if nums[i] == 0:\\n count0 += 1\\n else:\\n count1 += 1\\n \\n @cache\\n def dp(index,odd):\\n if index >= len(nums):\\n return 0\\n if nums[index] % 2 == odd:\\n return 1 + dp(index+1,1-odd)\\n else:\\n return dp(index+1,odd)\\n \\n return max(count0,count1,dp(0,0),dp(0,1))\\n \\n \\n \\n\\n \",\n \"runtime\": \"893\"\n },\n {\n \"code\": \"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\\n# similar to the question 1027.\\nclass Solution:\\n def maximumLength(self, A: List[int]) -> int:\\n\\n\\n # A = [a % 2 for a in A]\\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\\n\\n k=2\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = max(dp[b][a % k], dp[a % k][b] + 1)\\n return max(max(dp[a].values()) for a in range(k))\\n\\n\\n \",\n \"runtime\": \"898\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n odd = 0\\n even = 0\\n alternating = 0\\n exp = nums[0] % 2\\n \\n for num in nums:\\n rem = num % 2\\n \\n # if odd\\n if rem: \\n odd += 1\\n else:\\n even += 1\\n \\n if rem != exp:\\n alternating += 1\\n exp = rem\\n print(odd, even, alternating)\\n return max(odd, even, alternating + 1)\",\n \"runtime\": \"903\"\n },\n {\n \"code\": \"# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-i/solutions/5389361/java-c-python-dp/\\n# similar to the question 1027.\\nclass Solution:\\n def maximumLength(self, A: List[int]) -> int:\\n\\n\\n # A = [a % 2 for a in A]\\n # return max(A.count(0), A.count(1), len(list(groupby(A))))\\n\\n k=2\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = max(dp[b][a % k], dp[a % k][b] + 1)\\n return max(max(dp[a].values()) for a in range(k))\\n\\n\\n \",\n \"runtime\": \"908\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":103,"string":"103"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n N = len(nums)\n for i in range(N):\n nums[i] %= 2\n ret = max(nums.count(0),nums.count(1))\n dp = [0]*2\n for i in range(N):\n dp[nums[i]] = dp[1-nums[i]]+1\n return max(ret,dp[0],dp[1])","memory":"35200"},{"code":"class Solution:\n\tdef maximumLength(self, nums: List[int]) -> int:\n\n\t\tresult1, result3 , result2 , result4 = 1 , 1 , 1 , 1\n\n\t\tfor i in range(len(nums)):\n\t\t\tnums[i] = nums[i] % 2\n\n\t\tif 0 in nums:\n\n\t\t\ti = nums.index(0)\n\t\t\tlast = 0\n\n\t\t\tfor index in range(i + 1,len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult1 = result1 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult1 = result1 + 1\n\n\t\t\tfor index in range(i + 1, len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult2 = result2 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult2 = result2 + 1\n\n\t\tif 1 in nums:\n\n\t\t\ti = nums.index(1)\n\t\t\tlast = 1\n\n\t\t\tfor index in range(i + 1 ,len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult3 = result3 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult3 = result3 + 1\n\n\t\t\tfor index in range(i + 1, len(nums)):\n\n\t\t\t\tif nums[index] == 0 and last == 1:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult4 = result4 + 1\n\n\t\t\t\tif nums[index] == 1 and last == 0:\n\t\t\t\t\tlast = nums[index]\n\t\t\t\t\tresult4 = result4 + 1\n\n\t\treturn max([result1 , result2, result3, result4])","memory":"35300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n flagEvenOdd, flagOddEven = True, False\n cntEven, cntOdd, cntEvenOdd, cntOddEven = 0, 0, 0, 0\n for i in range(len(nums)):\n nums[i] %= 2\n for num in nums:\n val = num % 2\n if val == 1:\n cntOdd += 1\n if val == 0:\n cntEven += 1\n if val == flagEvenOdd:\n cntEvenOdd += 1\n flagEvenOdd = not flagEvenOdd\n if val == flagOddEven:\n cntOddEven += 1\n flagOddEven = not flagOddEven\n\n return max(cntEven, cntOdd, cntEvenOdd, cntOddEven)","memory":"35900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n if len(nums) == 2:\n return 2\n for i in range(0, len(nums)):\n nums[i] = nums[i] % 2\n\n maxEndingWithOne = 0\n maxEndingWithZero = 0\n\n maxNumberOfZeros = 0\n maxNumberOfOnes = 0\n\n if nums[0] == 1:\n maxEndingWithOne = 1\n maxNumberOfOnes = 1\n else:\n maxEndingWithZero = 1\n maxNumberOfZeros = 1\n\n for i in range(1, len(nums)):\n if nums[i] == 0:\n maxEndingWithZero = max(maxEndingWithZero, maxEndingWithOne + 1)\n maxNumberOfZeros += 1\n else:\n maxEndingWithOne = max(maxEndingWithOne, maxEndingWithZero + 1)\n maxNumberOfOnes += 1\n\n return max(maxEndingWithOne, maxEndingWithZero, maxNumberOfOnes, maxNumberOfZeros)\n\n\n\n ","memory":"36000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n\n n=len(nums)\n for i in range(n):\n nums[i]%=2\n \n n1=sum(nums)\n n0=n-n1\n res=max(n0,n1)\n\n n01=0\n f0=0\n n10=0\n f1=1\n for x in nums:\n if x==f0:\n n01+=1\n f0=1-f0\n if x==f1:\n n10+=1\n f1=1-f1 \n\n return max(res,max(n01,n10))\n\n\n\n\n ","memory":"36100"},{"code":"from collections import defaultdict, deque\nfrom copy import deepcopy\nfrom typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n for i in range(len(nums)):\n nums[i] %= 2 \n \n zero_count = nums.count(0)\n one_count = nums.count(1)\n\n index_map_01 = defaultdict(deque)\n for i in range(len(nums)):\n index_map_01[nums[i]].append(i)\n\n index_map_10 = deepcopy(index_map_01) \n\n max_alternating_01 = 0\n if zero_count > 0:\n max_alternating_01 = 1\n\n previous_index = index_map_01[0].popleft()\n next_element = 1\n\n while index_map_01[next_element]:\n if len(index_map_01[next_element]) > 0:\n current_index = index_map_01[next_element].popleft()\n if current_index > previous_index:\n max_alternating_01 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n max_alternating_10 = 0\n if one_count > 0:\n max_alternating_10 = 1\n previous_index = index_map_10[1].popleft()\n next_element = 0\n while index_map_10[next_element]:\n if len(index_map_10[next_element]) > 0:\n current_index = index_map_10[next_element].popleft()\n if current_index > previous_index:\n max_alternating_10 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)","memory":"36800"},{"code":"from collections import defaultdict, deque\nfrom copy import deepcopy\nfrom typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n for i in range(len(nums)):\n nums[i] %= 2 \n \n zero_count = nums.count(0)\n one_count = nums.count(1)\n\n index_map_01 = defaultdict(deque)\n for i in range(len(nums)):\n index_map_01[nums[i]].append(i)\n\n index_map_10 = deepcopy(index_map_01) \n\n max_alternating_01 = 0\n if zero_count > 0:\n max_alternating_01 = 1\n\n previous_index = index_map_01[0].popleft()\n next_element = 1\n\n while index_map_01[next_element]:\n if len(index_map_01[next_element]) > 0:\n current_index = index_map_01[next_element].popleft()\n if current_index > previous_index:\n max_alternating_01 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n max_alternating_10 = 0\n if one_count > 0:\n max_alternating_10 = 1\n previous_index = index_map_10[1].popleft()\n next_element = 0\n while index_map_10[next_element]:\n if len(index_map_10[next_element]) > 0:\n current_index = index_map_10[next_element].popleft()\n if current_index > previous_index:\n max_alternating_10 += 1\n previous_index = current_index\n next_element = not next_element\n else:\n break\n\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)","memory":"36900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n return max(\n sum(int(num % 2 == 0) for num in nums),\n sum(int(num % 2 == 1) for num in nums),\n sum(nums[j-1] % 2 != nums[j] % 2 for j in range(1, len(nums))) + 1,\n )","memory":"37600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n def compute_max(parity):\n total, prev = 1, 0\n \n for x in range(1, len(nums)):\n if (nums[prev] + nums[x]) % 2 == parity:\n total += 1\n prev = x\n \n return total\n \n odds, evens = 0, 0\n for v in nums:\n if v % 2 == 0: evens += 1\n else: odds += 1\n \n return max(odds, evens,\n compute_max(0), \n compute_max(1), \n compute_max(0), \n compute_max(1))","memory":"37900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 前后要么都是奇偶，要么是偶偶 奇奇\n n = len(nums)\n for i in range(n):\n if nums[i] % 2 == 0:\n nums[i] = 0\n else:\n nums[i] = 1\n \n res_even = 0\n res_odd = 0\n for num in nums:\n if num == 0:\n res_even += 1\n else:\n res_odd += 1\n \n res_odd_even = 1 \n res_even_odd = 1 \n \n last_odd_even = nums[0]\n last_even_odd = nums[0]\n \n for i in range(1, n):\n if nums[i] != last_odd_even:\n res_odd_even += 1\n last_odd_even = nums[i]\n \n if nums[i] != last_even_odd:\n res_even_odd += 1\n last_even_odd = nums[i]\n \n # 返回最长的子序列\n return max(res_even, res_odd, res_odd_even, res_even_odd)","memory":"38000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n for i in range(len(nums)):\n nums[i] = nums[i] % 2\n count1 = sum(nums)\n count0 = len(nums) - sum(nums)\n \n \n for start_0 in range(len(nums)):\n if nums[start_0] == 0:\n break\n for start_1 in range(len(nums)):\n if nums[start_1] == 1:\n break\n \n res_01 = 1\n for i in range(start_0 + 1, len(nums)):\n if res_01 % 2 == 1:\n if nums[i] == 1:\n res_01 += 1\n else:\n if nums[i] == 0:\n res_01 += 1\n \n res_10 = 1\n for i in range(start_1 + 1, len(nums)):\n if res_10 % 2 == 1:\n if nums[i] == 0:\n res_10 += 1\n else:\n if nums[i] == 1:\n res_10 += 1\n \n \n return max(count1, count0, res_01, res_10)","memory":"38100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [1 % 2 for i in nums]\n l = 0\n r = 0\n ans = 0\n while r < len(nums) - 3:\n if nums[r] + nums[r + 1] == nums[r + 2] + nums[r + 3]:\n r += 4\n else:\n ans = max(ans, r - l)\n r += 1\n l = r\n ans = max(ans, r - l)\n return ans\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [i % 2 for i in nums]\n curr = nums[0]\n idx = 0\n ans = 0\n while curr in nums[idx:]:\n idx = nums[idx:].index(curr) + idx + 1\n curr ^= 1\n ans += 1\n return max([ans, nums.count(0), nums.count(1)])\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [i % 2 for i in nums]\n curr = nums[0]\n a1, a2, a3 = 0, 0, 0\n for i in nums:\n if i == curr:\n a1 += 1\n curr ^= 1\n if i == 1:\n a2 += 1\n else:\n a3 += 1\n return max([a1, a2, a3])\n","memory":"38200"},{"code":"class Solution(object):\n def help(self, nums, flag):\n even_odd = flag\n cnt1, cnt2 = 0, 0\n for num in nums:\n if num%2 == flag:\n cnt1 += 1\n flag = not flag\n if num%2 == even_odd:\n cnt2 += 1\n return max(cnt1, cnt2)\n\n def maximumLength(self, nums):\n ans1 = self.help(nums, True)\n ans2 = self.help(nums, False)\n return max(ans1, ans2)","memory":"38300"},{"code":"class Solution(object):\n def help(self, nums, flag):\n even_odd = flag\n cnt1, cnt2 = 0, 0\n for num in nums:\n if num%2 == flag:\n cnt1 += 1\n flag = not flag\n if num%2 == even_odd:\n cnt2 += 1\n return max(cnt1, cnt2)\n\n def maximumLength(self, nums):\n ans1 = self.help(nums, True)\n ans2 = self.help(nums, False)\n return max(ans1, ans2)","memory":"38400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n dp = defaultdict(int) # prev, remainder\n primers = set() \n res = 0 \n \n for n in nums: \n n %= 2\n if not primers: \n primers.add(n)\n continue \n for key in list(dp): \n prev, remainder = key \n if (prev + n ) % 2 == remainder:\n dp[(n, remainder)] = max(dp[(n, remainder)], dp[(prev, remainder)] + 1)\n for primer in primers: \n if dp[(n, (primer + n) % 2)] == 0: \n dp[(n, (primer + n) % 2)] += 2 \n primers.add(n) \n for key in dp: \n res = max(dp[key], res)\n return res\n \n ","memory":"38500"},{"code":"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\n# L(i) = 1 [if i == 0]\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\n# L(i) = L(i-1) ow\n\n# oo = e\n# ee = e\n# eo/oe = o\n\n# \n# eeeeo\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n EE = 0\n EO = 1\n OO = 1\n OE = 0\n \n if nums[0] % 2 == 0:\n OE = 1\n EE = 1\n OO = 0\n EO = 0\n\n mx = 0\n # EE = 0,1,1,2\n # EO = 1,1,2,2\n # OE = 0,2,2,4\n # OO = 1,1,3,3\n\n # EE = 0, 1, 1, 1,2,2,3\n # EO = 1, 1, 2, 3,3,4,4\n # OE = 0, 2, 2,|2,4,4,6 \n # OO = 1, 1, 3, 3,3,5,5\n \n for i in range(1, len(nums)):\n \n if nums[i] % 2 == 0:\n EE = EE + 1\n OE = OO + 1\n else:\n EO = EO + 1\n OO = OE + 1\n\n mx = max(mx, EE, EO, OO, OE)\n\n return mx","memory":"38600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even_same = 0\n odd_same = 0\n\n even_dif = 0\n odd_dif = 0\n\n for i in range(len(nums)):\n if nums[i] % 2 == 0:\n even_dif = max(even_dif, odd_dif+1)\n even_same+=1\n else:\n odd_dif = max(odd_dif, even_dif+1)\n odd_same+=1\n\n return max(even_same, odd_same, even_dif, odd_dif)\n\n ","memory":"38900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n q=[num%2 for num in nums]\n s,k,prev = sum(q),1,q[0]\n for x in q[1:]:\n if prev!=x:\n k+=1\n prev=x\n return max(s,len(q)-s,k) ","memory":"39000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even = odd = alt = 0\n prev_parity = nums[0] & 1\n\n for num in nums:\n current_parity = num & 1\n if current_parity:\n odd += 1\n else:\n even += 1\n\n if current_parity == prev_parity:\n alt += 1\n prev_parity ^= 1\n return max(even, odd, alt)\n ","memory":"39000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [v % 2 for v in nums]\n v1, v2 = nums.count(0), nums.count(1)\n \n v3, prev = 1, nums[0]\n for i in range(1, len(nums)):\n if nums[i] != prev:\n v3 += 1\n prev = nums[i]\n \n return max(v1, v2, v3)","memory":"39100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n total = 1\n pre = nums[0]%2\n for i in range(1, len(nums)):\n if (nums[i]%2 != pre):\n total += 1\n pre = nums[i]%2\n\n res0 = total\n res1, res2 = 0, 0\n for x in nums:\n if x%2 == 0:\n res1 += 1\n else:\n res2 += 1\n res = max(res0, res1, res2)\n return res \n ","memory":"39200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n even = 0\n odd = 0\n odd_even = 0\n odd_even_flipper = 1\n even_odd = 0\n even_odd_flipper = 0\n for i in range(len(nums)):\n if nums[i] % 2 == 0:\n even += 1\n else:\n odd += 1\n if nums[i] % 2 == odd_even_flipper:\n odd_even += 1\n odd_even_flipper = not odd_even_flipper\n if nums[i] % 2 == even_odd_flipper:\n even_odd += 1\n even_odd_flipper = not even_odd_flipper\n\n return max(even, odd, even_odd, odd_even)\n ","memory":"39300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n evens = []\n odds = []\n eo = []\n oe = []\n lasteo = 1\n lastoe = 0\n for x in nums:\n if not x % 2:\n evens.append(x)\n if lasteo:\n eo.append(x)\n lasteo = 0\n if lastoe:\n oe.append(x)\n lastoe = 0\n elif x % 2:\n odds.append(x)\n if not lastoe:\n oe.append(x)\n lastoe = 1\n if not lasteo:\n eo.append(x)\n lasteo = 1\n return len(max(evens, odds, eo, oe, key=len))\n\n","memory":"39500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n remainers = [num % 2 for num in nums]\n counter = collections.Counter(remainers)\n groups = 1\n curr = remainers[0]\n for r in remainers:\n if r != curr:\n groups += 1\n curr = r\n return max([counter[0], counter[1], groups])\n","memory":"39600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n previous = nums[0] % 2\n alternating = 1\n length = 1\n odds_count = previous\n for num in nums[1:]:\n length += 1\n remainder_2 = num % 2\n odds_count += remainder_2\n if previous != remainder_2:\n alternating += 1\n previous = remainder_2\n return max(alternating, odds_count, length - odds_count)\n","memory":"39700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums = [a % 2 for a in nums]\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))","memory":"39800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums_rem = [x%2 for x in nums]\n total = 1\n pre = nums_rem[0]\n for i in range(1, len(nums_rem)):\n if (nums_rem[i] != pre):\n total += 1\n pre = nums_rem[i]\n\n res0 = total\n res1, res2 = 0, 0\n for x in nums_rem:\n if x == 0:\n res1 += 1\n else:\n res2 += 1\n res = max(res0, res1, res2)\n return res \n ","memory":"39900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n arr = []\n n = len(nums)\n even_count = 0\n odd_count = 0\n\n even_indices = []\n odd_indices = []\n\n for idx in range(n):\n if nums[idx] % 2 == 0:\n arr.append(0)\n even_count += 1\n even_indices.append(idx)\n else:\n arr.append(1)\n odd_count += 1\n odd_indices.append(idx)\n \n if odd_count == 0 or even_count == 0:\n return max(odd_count, even_count)\n \n odd_ptr = 0\n even_ptr = 0\n alternate_count = 0\n\n ptr = \"odd\" if odd_indices[odd_ptr] < even_indices[even_ptr] else \"even\"\n search = True\n prev_idx = -1\n\n while search:\n if ptr == \"odd\" and odd_ptr >= len(odd_indices):\n search = False\n break\n \n if ptr == \"even\" and even_ptr >= len(even_indices):\n search = False\n break\n \n if ptr == \"odd\":\n idx = odd_indices[odd_ptr]\n if idx <= prev_idx:\n odd_ptr += 1\n else:\n odd_ptr += 1\n ptr = \"even\"\n alternate_count += 1\n prev_idx = idx\n else:\n idx = even_indices[even_ptr]\n if idx <= prev_idx:\n even_ptr += 1\n else:\n even_ptr += 1\n ptr = \"odd\"\n alternate_count += 1\n prev_idx = idx\n \n return max(alternate_count, odd_count, even_count)\n\n\n\n","memory":"40000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n previous = nums[0] % 2\n alternating = 1\n length = 1\n odds_count = previous\n for num in nums[1:]:\n length += 1\n remainder_2 = num % 2\n odds_count += remainder_2\n if previous != remainder_2:\n alternating += 1\n previous = remainder_2\n return max(alternating, odds_count, length - odds_count)\n","memory":"40600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n max_length = 0\n for target_remainder in range(k):\n seen_remainders = {}\n for num in nums:\n curr_remainder = num % k\n compliment_remainder = target_remainder - curr_remainder\n if compliment_remainder < 0:\n compliment_remainder = k - abs(compliment_remainder)\n \n if compliment_remainder in seen_remainders:\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\n else:\n seen_remainders[curr_remainder] = 1\n \n if seen_remainders[curr_remainder] > max_length:\n max_length = seen_remainders[curr_remainder]\n\n return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # count_zeros = 0\n # count_ones = 0\n # count_alt_zeros = 0\n # count_alt_ones = 0\n # for num in nums:\n # if num % 2:\n # count_ones += 1\n # count_alt_zeros += 1\n # else:\n # count_zeros += 1\n # count_alt_ones += 1\n \n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count = [0,0]\n # ends = [0,0]\n # for num in nums:\n # count[num % 2] += 1\n # ends[num % 2] = ends[1 - num % 2] + 1\n \n # return max( max(count), max(ends) )\n\n\n # remainders = [ num % 2 for num in nums ]\n # for \n\n\n\n # max_zero = self.get_lis(nums, 0)\n # max_one = self.get_lis(nums, 1)\n # return max_zero if max_zero >= max_one else max_one\n \n # def get_lis(self, nums, remainder):\n # lis = [1] * len(nums)\n # max_lis = 1 if nums else 0\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % 2 == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if lis[index] > max_lis:\n # max_lis = lis[index]\n \n # return max_lis\n\n ","memory":"41200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n k = 2\n max_length = 0\n for target_remainder in range(k):\n seen_remainders = {}\n for num in nums:\n curr_remainder = num % k\n compliment_remainder = target_remainder - curr_remainder\n if compliment_remainder < 0:\n compliment_remainder = k - abs(compliment_remainder)\n \n if compliment_remainder in seen_remainders:\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\n else:\n seen_remainders[curr_remainder] = 1\n \n if seen_remainders[curr_remainder] > max_length:\n max_length = seen_remainders[curr_remainder]\n\n return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # count_zeros = 0\n # count_ones = 0\n # count_alt_zeros = 0\n # count_alt_ones = 0\n # for num in nums:\n # if num % 2:\n # count_ones += 1\n # count_alt_zeros += 1\n # else:\n # count_zeros += 1\n # count_alt_ones += 1\n \n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # count = [0,0]\n # ends = [0,0]\n # for num in nums:\n # count[num % 2] += 1\n # ends[num % 2] = ends[1 - num % 2] + 1\n \n # return max( max(count), max(ends) )\n\n\n # remainders = [ num % 2 for num in nums ]\n # for \n\n\n\n # max_zero = self.get_lis(nums, 0)\n # max_one = self.get_lis(nums, 1)\n # return max_zero if max_zero >= max_one else max_one\n \n # def get_lis(self, nums, remainder):\n # lis = [1] * len(nums)\n # max_lis = 1 if nums else 0\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % 2 == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if lis[index] > max_lis:\n # max_lis = lis[index]\n \n # return max_lis\n\n ","memory":"41300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n nums_rem = [x%2 for x in nums]\n stack = [nums_rem[0]]\n for i in range(1, len(nums_rem)):\n if (nums_rem[i] != stack[-1]):\n stack.append(nums_rem[i])\n res0 = len(stack)\n print (stack)\n res1 = len([x for x in nums_rem if x == 0])\n res2 = len([x for x in nums_rem if x == 1])\n res = max(res0, res1, res2)\n return res \n ","memory":"41400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n evenCount, oddCount = 0, 0\n for num in nums:\n if num % 2 == 1:\n oddCount += 1\n else:\n evenCount += 1\n\n ans = max(evenCount, oddCount)\n\n l = len(nums)\n dp = [0] * l\n for i in range(l):\n dp[i] = 1\n for j in range(i-1, -1, -1):\n if nums[j] % 2 != nums[i] % 2:\n dp[i] = max(dp[i], 1+dp[j])\n break\n \n print(dp)\n return max(ans, dp[l-1])","memory":"41500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n alter = []\n odd = []\n even = []\n for i in nums:\n if i%2 == 0:\n even.append(i)\n else:\n odd.append(i)\n if len(alter)==0 or alter[-1]%2 != i%2:\n alter.append(i)\n return max(len(alter), len(odd), len(even))","memory":"42100"},{"code":"class Solution:\n def maximumLength(self, xs: List[int]) -> int:\n result = 0\n evens = []\n odds = []\n alternating_0 = []\n alternating_1 = []\n\n for i, x in enumerate(xs):\n if x % 2 == 0:\n evens.append(x)\n else:\n odds.append(x)\n \n if not alternating_0:\n if x % 2 == 0:\n alternating_0.append(x)\n elif (x + alternating_0[-1]) % 2 == 1:\n alternating_0.append(x)\n\n if not alternating_1:\n if x % 2 == 1:\n alternating_1.append(x)\n elif (x + alternating_1[-1]) % 2 == 1:\n alternating_1.append(x)\n\n return max(map(len, [evens, odds, alternating_0, alternating_1]))","memory":"42200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n max_lens_odd = [1] * n\n max_lens_even = [1] * n\n for i in range(n):\n update_odd = update_even = False\n for j in range(i - 1, -1, -1):\n if update_odd and update_even:\n break\n curr_sum = nums[i] + nums[j]\n if curr_sum % 2 and update_odd:\n continue\n if curr_sum % 2 == 0 and update_even:\n continue\n if curr_sum % 2:\n update_odd = True\n if max_lens_odd[j] + 1 > max_lens_odd[i]:\n max_lens_odd[i] = max_lens_odd[j] + 1\n else:\n update_even = True\n if max_lens_even[j] + 1 > max_lens_even[i]:\n max_lens_even[i] = max_lens_even[j] + 1\n ans = max(max(max_lens_odd), max(max_lens_even))\n return ans\n","memory":"42900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # record the lastest index of odd or even\n # for each num, find index of same/diff parity\n # increment len\n n = len(nums)\n index = [None, None]\n ans = 0\n same = [0] * n\n diff = [0] * n\n for i in range(n)[::-1]:\n num = nums[i]%2\n # same parity\n idx = index[num]\n if idx is not None:\n same[i] = same[idx] + 1\n # diff\n idx = index[1-num]\n if idx is not None:\n diff[i] = diff[idx] + 1\n index[num] = i\n ans = max(max(same), max(diff))\n return ans + 1","memory":"43000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n \n dp = [[0] * 2 for _ in range(len(nums))]\n ans = 0\n\n for i in nums:\n\n x = i%2\n\n for j in range(2):\n y = (j - x + 2) % 2\n dp[x][y] = dp[y][x] + 1\n\n ans = max(ans, dp[x][y])\n\n return ans","memory":"43700"},{"code":"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\n# L(i) = 1 [if i == 0]\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\n# L(i) = L(i-1) ow\n\n# oo = e\n# ee = e\n# eo/oe = o\n\n# \n# eeeeo\n\nclass Solution:\n def maximumLength(self, nums: List[int]) -> int:\n EE = [0]\n EO = [1]\n OO = [1]\n OE = [0]\n p = 1\n if nums[0] % 2 == 0:\n OE[0] = 1\n EE[0] = 1\n p = 0\n OO[0] = 0\n EO[0] = 0\n\n mx = 0\n # EE = 0,1,1,2\n # EO = 1,1,2,2\n # OE = 0,2,2,4\n # OO = 1,1,3,3\n\n # EE = 0, 1, 1, 1,2,2,3\n # EO = 1, 1, 2, 3,3,4,4\n # OE = 0, 2, 2,|2,4,4,6 \n # OO = 1, 1, 3, 3,3,5,5\n \n for i in range(1, len(nums)):\n # print(L)\n if nums[i] % 2 == 0:\n EE.append(EE[i-1] + 1)\n EO.append(EO[i-1])\n OE.append(OO[i-1] + 1)\n OO.append(OO[i-1])\n else:\n EO.append(EO[i-1] + 1)\n EE.append(EE[i-1])\n OO.append(OE[i-1] + 1)\n OE.append(OE[i-1])\n\n mx = max(mx, EE[i], EO[i], OO[i], OE[i])\n\n return mx","memory":"47900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # basically alternate nums must all be odd / all even\n # odd/odd, even/odd, even/even\n # we only need to do DP for even/odd\n # LVS[i][p] is the Longest alt seq ending in parity p up to i\n # 0: even, 1: odd\n n = len(nums)\n LVS = [[0,0] for _ in range(n)]\n # base cases\n LVS[0][nums[0] % 2] = 1\n even = 1 if nums[0] % 2 == 0 else 0\n # bottom up\n for i in range(1, n):\n if nums[i] % 2 == 0: \n even += 1\n for p in range(2):\n LVS[i][p] = LVS[i-1][p]\n LVS[i][nums[i] % 2] = LVS[i-1][1 - (nums[i] % 2)] + 1\n # # find evens\n # even = 0\n # for num in nums:\n # if num % 2 == 0:\n # even += 1\n return max(max(LVS[n-1]), even, n-even)","memory":"49900"},{"code":"class Solution:\n def maximumLength(self, L: List[int]) -> int:\n odd=0\n for j in range (0,len(L)):\n if L[j]%2==1:\n odd=odd+1\n even=0\n for j in range (0,len(L)):\n if L[j]%2==0:\n even=even+1\n dp=[]\n for j in range (0,len(L)):\n dp.append([0,0])\n if L[0]%2==0:\n dp[0][1]=dp[0][1]+1\n if L[0]%2==1:\n dp[0][0]=dp[0][0]+1\n for j in range (1,len(L)):\n if L[j]%2==0:\n dp[j][0]=dp[j-1][0]\n dp[j][1]=max(dp[j-1][0]+1,dp[j-1][1])\n if L[j]%2==1:\n dp[j][1]=dp[j-1][1]\n dp[j][0]=max(dp[j-1][1]+1,dp[j-1][0])\n return max(odd,even,dp[-1][0],dp[-1][1])\n \n ","memory":"50200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n dp = [[0] * 2 for _ in range(n)]\n last_even = -1\n last_odd = -1\n res = 0\n\n for i, val in enumerate(nums): \n if val % 2 == 0: \n last_even = i\n if last_odd == -1: \n dp[i] = [1, 0]\n continue\n dp[i][0] = dp[last_odd][0] + 1\n dp[i][1] = dp[last_odd][1]\n res = dp[i][0] + dp[i][1]\n else: \n last_odd = i\n if last_even == -1: \n dp[i] = [0, 1]\n continue\n dp[i][0] = dp[last_even][0]\n dp[i][1] = dp[last_even][1] + 1\n res = max(res, dp[i][0] + dp[i][1])\n \n countOdd = sum([1 for num in nums if num % 2 == 1])\n countEven = sum([1 for num in nums if num % 2 == 0 ])\n return max(res, countOdd, countEven) \n \n ","memory":"51500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n import numpy as np\n if len(nums)==2:\n return 2\n nums = np.array(nums)\n n2=nums%2\n z_count = np.sum(n2)\n o_count = len(nums)-z_count\n n3 = np.sum(n2[1:]!=n2[:-1])\n # n4 = np.count(n2[1:]+n2[:-1])\n return max(1+np.max(np.unique(n2[1:]+n2[:-1],return_counts=True)[1]),z_count,o_count)","memory":"52300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 0 -> e,o,e\n # 1 -> e,e,e \n # 0 -> o,e,o\n # 1 -> o,o,o\n gmax = 0\n dp = [[0,0] for i in range(len(nums))]\n prev_e, prev_o = -1, -1\n if nums[0] % 2 == 0:\n prev_e = 0\n else:\n prev_o = 0\n\n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if prev_e >= 0:\n dp[i][1] = dp[prev_e][1] + 1\n if prev_o >= 0:\n dp[i][0] = dp[prev_o][0] + 1\n prev_e = i\n else:\n if prev_e >= 0:\n dp[i][0] = dp[prev_e][0] + 1\n if prev_o >= 0:\n dp[i][1] = dp[prev_o][1] + 1\n prev_o = i\n gmax = max(gmax, max(dp[i]))\n \n # add 1 for the unaccounted for last element\n return gmax + 1 \n \n\n\n \n\n\n\n\n \n\n\n ","memory":"56400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n # 0 -> e,o,e\n # 1 -> e,e,e \n # 0 -> o,e,o\n # 1 -> o,o,o\n gmax = 0\n dp = [[0,0] for i in range(len(nums))]\n prev_e, prev_o = -1, -1\n if nums[0] % 2 == 0:\n prev_e = 0\n else:\n prev_o = 0\n\n for i in range(1, len(nums)):\n if nums[i] % 2 == 0:\n if prev_e >= 0:\n dp[i][1] = dp[prev_e][1] + 1\n if prev_o >= 0:\n dp[i][0] = dp[prev_o][0] + 1\n prev_e = i\n else:\n if prev_e >= 0:\n dp[i][0] = dp[prev_e][0] + 1\n if prev_o >= 0:\n dp[i][1] = dp[prev_o][1] + 1\n prev_o = i\n gmax = max(gmax, max(dp[i]))\n \n # add 1 for the unaccounted for last element\n return gmax + 1 \n \n\n\n \n\n\n\n\n \n\n\n ","memory":"56400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int]) -> int:\n n = len(nums)\n longest = [[0] * 2 for _ in range(n)]\n best = 0\n for i in range(1, n):\n remainders = set()\n for j in reversed(range(i)):\n if len(remainders) == 2:\n break\n d = (nums[i] + nums[j]) % 2\n remainders.add(d)\n longest[i][d] = max(longest[i][d], longest[j][d] + 1)\n best = max(best, longest[i][d])\n return best + 1","memory":"57100"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n N = len(nums)\\n for i in range(N):\\n nums[i] %= 2\\n ret = max(nums.count(0),nums.count(1))\\n dp = [0]*2\\n for i in range(N):\\n dp[nums[i]] = dp[1-nums[i]]+1\\n return max(ret,dp[0],dp[1])\",\n \"memory\": \"35200\"\n },\n {\n \"code\": \"class Solution:\\n\\tdef maximumLength(self, nums: List[int]) -> int:\\n\\n\\t\\tresult1, result3 , result2 , result4 = 1 , 1 , 1 , 1\\n\\n\\t\\tfor i in range(len(nums)):\\n\\t\\t\\tnums[i] = nums[i] % 2\\n\\n\\t\\tif 0 in nums:\\n\\n\\t\\t\\ti = nums.index(0)\\n\\t\\t\\tlast = 0\\n\\n\\t\\t\\tfor index in range(i + 1,len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult1 = result1 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult1 = result1 + 1\\n\\n\\t\\t\\tfor index in range(i + 1, len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult2 = result2 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult2 = result2 + 1\\n\\n\\t\\tif 1 in nums:\\n\\n\\t\\t\\ti = nums.index(1)\\n\\t\\t\\tlast = 1\\n\\n\\t\\t\\tfor index in range(i + 1 ,len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult3 = result3 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult3 = result3 + 1\\n\\n\\t\\t\\tfor index in range(i + 1, len(nums)):\\n\\n\\t\\t\\t\\tif nums[index] == 0 and last == 1:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult4 = result4 + 1\\n\\n\\t\\t\\t\\tif nums[index] == 1 and last == 0:\\n\\t\\t\\t\\t\\tlast = nums[index]\\n\\t\\t\\t\\t\\tresult4 = result4 + 1\\n\\n\\t\\treturn max([result1 , result2, result3, result4])\",\n \"memory\": \"35300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n flagEvenOdd, flagOddEven = True, False\\n cntEven, cntOdd, cntEvenOdd, cntOddEven = 0, 0, 0, 0\\n for i in range(len(nums)):\\n nums[i] %= 2\\n for num in nums:\\n val = num % 2\\n if val == 1:\\n cntOdd += 1\\n if val == 0:\\n cntEven += 1\\n if val == flagEvenOdd:\\n cntEvenOdd += 1\\n flagEvenOdd = not flagEvenOdd\\n if val == flagOddEven:\\n cntOddEven += 1\\n flagOddEven = not flagOddEven\\n\\n return max(cntEven, cntOdd, cntEvenOdd, cntOddEven)\",\n \"memory\": \"35900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n if len(nums) == 2:\\n return 2\\n for i in range(0, len(nums)):\\n nums[i] = nums[i] % 2\\n\\n maxEndingWithOne = 0\\n maxEndingWithZero = 0\\n\\n maxNumberOfZeros = 0\\n maxNumberOfOnes = 0\\n\\n if nums[0] == 1:\\n maxEndingWithOne = 1\\n maxNumberOfOnes = 1\\n else:\\n maxEndingWithZero = 1\\n maxNumberOfZeros = 1\\n\\n for i in range(1, len(nums)):\\n if nums[i] == 0:\\n maxEndingWithZero = max(maxEndingWithZero, maxEndingWithOne + 1)\\n maxNumberOfZeros += 1\\n else:\\n maxEndingWithOne = max(maxEndingWithOne, maxEndingWithZero + 1)\\n maxNumberOfOnes += 1\\n\\n return max(maxEndingWithOne, maxEndingWithZero, maxNumberOfOnes, maxNumberOfZeros)\\n\\n\\n\\n \",\n \"memory\": \"36000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n\\n n=len(nums)\\n for i in range(n):\\n nums[i]%=2\\n \\n n1=sum(nums)\\n n0=n-n1\\n res=max(n0,n1)\\n\\n n01=0\\n f0=0\\n n10=0\\n f1=1\\n for x in nums:\\n if x==f0:\\n n01+=1\\n f0=1-f0\\n if x==f1:\\n n10+=1\\n f1=1-f1 \\n\\n return max(res,max(n01,n10))\\n\\n\\n\\n\\n \",\n \"memory\": \"36100\"\n },\n {\n \"code\": \"from collections import defaultdict, deque\\nfrom copy import deepcopy\\nfrom typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n for i in range(len(nums)):\\n nums[i] %= 2 \\n \\n zero_count = nums.count(0)\\n one_count = nums.count(1)\\n\\n index_map_01 = defaultdict(deque)\\n for i in range(len(nums)):\\n index_map_01[nums[i]].append(i)\\n\\n index_map_10 = deepcopy(index_map_01) \\n\\n max_alternating_01 = 0\\n if zero_count > 0:\\n max_alternating_01 = 1\\n\\n previous_index = index_map_01[0].popleft()\\n next_element = 1\\n\\n while index_map_01[next_element]:\\n if len(index_map_01[next_element]) > 0:\\n current_index = index_map_01[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_01 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n max_alternating_10 = 0\\n if one_count > 0:\\n max_alternating_10 = 1\\n previous_index = index_map_10[1].popleft()\\n next_element = 0\\n while index_map_10[next_element]:\\n if len(index_map_10[next_element]) > 0:\\n current_index = index_map_10[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_10 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)\",\n \"memory\": \"36800\"\n },\n {\n \"code\": \"from collections import defaultdict, deque\\nfrom copy import deepcopy\\nfrom typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n for i in range(len(nums)):\\n nums[i] %= 2 \\n \\n zero_count = nums.count(0)\\n one_count = nums.count(1)\\n\\n index_map_01 = defaultdict(deque)\\n for i in range(len(nums)):\\n index_map_01[nums[i]].append(i)\\n\\n index_map_10 = deepcopy(index_map_01) \\n\\n max_alternating_01 = 0\\n if zero_count > 0:\\n max_alternating_01 = 1\\n\\n previous_index = index_map_01[0].popleft()\\n next_element = 1\\n\\n while index_map_01[next_element]:\\n if len(index_map_01[next_element]) > 0:\\n current_index = index_map_01[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_01 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n max_alternating_10 = 0\\n if one_count > 0:\\n max_alternating_10 = 1\\n previous_index = index_map_10[1].popleft()\\n next_element = 0\\n while index_map_10[next_element]:\\n if len(index_map_10[next_element]) > 0:\\n current_index = index_map_10[next_element].popleft()\\n if current_index > previous_index:\\n max_alternating_10 += 1\\n previous_index = current_index\\n next_element = not next_element\\n else:\\n break\\n\\n return max(max_alternating_01, max_alternating_10, zero_count, one_count)\",\n \"memory\": \"36900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n return max(\\n sum(int(num % 2 == 0) for num in nums),\\n sum(int(num % 2 == 1) for num in nums),\\n sum(nums[j-1] % 2 != nums[j] % 2 for j in range(1, len(nums))) + 1,\\n )\",\n \"memory\": \"37600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n def compute_max(parity):\\n total, prev = 1, 0\\n \\n for x in range(1, len(nums)):\\n if (nums[prev] + nums[x]) % 2 == parity:\\n total += 1\\n prev = x\\n \\n return total\\n \\n odds, evens = 0, 0\\n for v in nums:\\n if v % 2 == 0: evens += 1\\n else: odds += 1\\n \\n return max(odds, evens,\\n compute_max(0), \\n compute_max(1), \\n compute_max(0), \\n compute_max(1))\",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 前后要么都是奇偶，要么是偶偶 奇奇\\n n = len(nums)\\n for i in range(n):\\n if nums[i] % 2 == 0:\\n nums[i] = 0\\n else:\\n nums[i] = 1\\n \\n res_even = 0\\n res_odd = 0\\n for num in nums:\\n if num == 0:\\n res_even += 1\\n else:\\n res_odd += 1\\n \\n res_odd_even = 1 \\n res_even_odd = 1 \\n \\n last_odd_even = nums[0]\\n last_even_odd = nums[0]\\n \\n for i in range(1, n):\\n if nums[i] != last_odd_even:\\n res_odd_even += 1\\n last_odd_even = nums[i]\\n \\n if nums[i] != last_even_odd:\\n res_even_odd += 1\\n last_even_odd = nums[i]\\n \\n # 返回最长的子序列\\n return max(res_even, res_odd, res_odd_even, res_even_odd)\",\n \"memory\": \"38000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n for i in range(len(nums)):\\n nums[i] = nums[i] % 2\\n count1 = sum(nums)\\n count0 = len(nums) - sum(nums)\\n \\n \\n for start_0 in range(len(nums)):\\n if nums[start_0] == 0:\\n break\\n for start_1 in range(len(nums)):\\n if nums[start_1] == 1:\\n break\\n \\n res_01 = 1\\n for i in range(start_0 + 1, len(nums)):\\n if res_01 % 2 == 1:\\n if nums[i] == 1:\\n res_01 += 1\\n else:\\n if nums[i] == 0:\\n res_01 += 1\\n \\n res_10 = 1\\n for i in range(start_1 + 1, len(nums)):\\n if res_10 % 2 == 1:\\n if nums[i] == 0:\\n res_10 += 1\\n else:\\n if nums[i] == 1:\\n res_10 += 1\\n \\n \\n return max(count1, count0, res_01, res_10)\",\n \"memory\": \"38100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [1 % 2 for i in nums]\\n l = 0\\n r = 0\\n ans = 0\\n while r < len(nums) - 3:\\n if nums[r] + nums[r + 1] == nums[r + 2] + nums[r + 3]:\\n r += 4\\n else:\\n ans = max(ans, r - l)\\n r += 1\\n l = r\\n ans = max(ans, r - l)\\n return ans\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [i % 2 for i in nums]\\n curr = nums[0]\\n idx = 0\\n ans = 0\\n while curr in nums[idx:]:\\n idx = nums[idx:].index(curr) + idx + 1\\n curr ^= 1\\n ans += 1\\n return max([ans, nums.count(0), nums.count(1)])\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [i % 2 for i in nums]\\n curr = nums[0]\\n a1, a2, a3 = 0, 0, 0\\n for i in nums:\\n if i == curr:\\n a1 += 1\\n curr ^= 1\\n if i == 1:\\n a2 += 1\\n else:\\n a3 += 1\\n return max([a1, a2, a3])\\n\",\n \"memory\": \"38200\"\n },\n {\n \"code\": \"class Solution(object):\\n def help(self, nums, flag):\\n even_odd = flag\\n cnt1, cnt2 = 0, 0\\n for num in nums:\\n if num%2 == flag:\\n cnt1 += 1\\n flag = not flag\\n if num%2 == even_odd:\\n cnt2 += 1\\n return max(cnt1, cnt2)\\n\\n def maximumLength(self, nums):\\n ans1 = self.help(nums, True)\\n ans2 = self.help(nums, False)\\n return max(ans1, ans2)\",\n \"memory\": \"38300\"\n },\n {\n \"code\": \"class Solution(object):\\n def help(self, nums, flag):\\n even_odd = flag\\n cnt1, cnt2 = 0, 0\\n for num in nums:\\n if num%2 == flag:\\n cnt1 += 1\\n flag = not flag\\n if num%2 == even_odd:\\n cnt2 += 1\\n return max(cnt1, cnt2)\\n\\n def maximumLength(self, nums):\\n ans1 = self.help(nums, True)\\n ans2 = self.help(nums, False)\\n return max(ans1, ans2)\",\n \"memory\": \"38400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n dp = defaultdict(int) # prev, remainder\\n primers = set() \\n res = 0 \\n \\n for n in nums: \\n n %= 2\\n if not primers: \\n primers.add(n)\\n continue \\n for key in list(dp): \\n prev, remainder = key \\n if (prev + n ) % 2 == remainder:\\n dp[(n, remainder)] = max(dp[(n, remainder)], dp[(prev, remainder)] + 1)\\n for primer in primers: \\n if dp[(n, (primer + n) % 2)] == 0: \\n dp[(n, (primer + n) % 2)] += 2 \\n primers.add(n) \\n for key in dp: \\n res = max(dp[key], res)\\n return res\\n \\n \",\n \"memory\": \"38500\"\n },\n {\n \"code\": \"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\\n# L(i) = 1 [if i == 0]\\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\\n# L(i) = L(i-1) ow\\n\\n# oo = e\\n# ee = e\\n# eo/oe = o\\n\\n# \\n# eeeeo\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n EE = 0\\n EO = 1\\n OO = 1\\n OE = 0\\n \\n if nums[0] % 2 == 0:\\n OE = 1\\n EE = 1\\n OO = 0\\n EO = 0\\n\\n mx = 0\\n # EE = 0,1,1,2\\n # EO = 1,1,2,2\\n # OE = 0,2,2,4\\n # OO = 1,1,3,3\\n\\n # EE = 0, 1, 1, 1,2,2,3\\n # EO = 1, 1, 2, 3,3,4,4\\n # OE = 0, 2, 2,|2,4,4,6 \\n # OO = 1, 1, 3, 3,3,5,5\\n \\n for i in range(1, len(nums)):\\n \\n if nums[i] % 2 == 0:\\n EE = EE + 1\\n OE = OO + 1\\n else:\\n EO = EO + 1\\n OO = OE + 1\\n\\n mx = max(mx, EE, EO, OO, OE)\\n\\n return mx\",\n \"memory\": \"38600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even_same = 0\\n odd_same = 0\\n\\n even_dif = 0\\n odd_dif = 0\\n\\n for i in range(len(nums)):\\n if nums[i] % 2 == 0:\\n even_dif = max(even_dif, odd_dif+1)\\n even_same+=1\\n else:\\n odd_dif = max(odd_dif, even_dif+1)\\n odd_same+=1\\n\\n return max(even_same, odd_same, even_dif, odd_dif)\\n\\n \",\n \"memory\": \"38900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n q=[num%2 for num in nums]\\n s,k,prev = sum(q),1,q[0]\\n for x in q[1:]:\\n if prev!=x:\\n k+=1\\n prev=x\\n return max(s,len(q)-s,k) \",\n \"memory\": \"39000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even = odd = alt = 0\\n prev_parity = nums[0] & 1\\n\\n for num in nums:\\n current_parity = num & 1\\n if current_parity:\\n odd += 1\\n else:\\n even += 1\\n\\n if current_parity == prev_parity:\\n alt += 1\\n prev_parity ^= 1\\n return max(even, odd, alt)\\n \",\n \"memory\": \"39000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [v % 2 for v in nums]\\n v1, v2 = nums.count(0), nums.count(1)\\n \\n v3, prev = 1, nums[0]\\n for i in range(1, len(nums)):\\n if nums[i] != prev:\\n v3 += 1\\n prev = nums[i]\\n \\n return max(v1, v2, v3)\",\n \"memory\": \"39100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n total = 1\\n pre = nums[0]%2\\n for i in range(1, len(nums)):\\n if (nums[i]%2 != pre):\\n total += 1\\n pre = nums[i]%2\\n\\n res0 = total\\n res1, res2 = 0, 0\\n for x in nums:\\n if x%2 == 0:\\n res1 += 1\\n else:\\n res2 += 1\\n res = max(res0, res1, res2)\\n return res \\n \",\n \"memory\": \"39200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n even = 0\\n odd = 0\\n odd_even = 0\\n odd_even_flipper = 1\\n even_odd = 0\\n even_odd_flipper = 0\\n for i in range(len(nums)):\\n if nums[i] % 2 == 0:\\n even += 1\\n else:\\n odd += 1\\n if nums[i] % 2 == odd_even_flipper:\\n odd_even += 1\\n odd_even_flipper = not odd_even_flipper\\n if nums[i] % 2 == even_odd_flipper:\\n even_odd += 1\\n even_odd_flipper = not even_odd_flipper\\n\\n return max(even, odd, even_odd, odd_even)\\n \",\n \"memory\": \"39300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n evens = []\\n odds = []\\n eo = []\\n oe = []\\n lasteo = 1\\n lastoe = 0\\n for x in nums:\\n if not x % 2:\\n evens.append(x)\\n if lasteo:\\n eo.append(x)\\n lasteo = 0\\n if lastoe:\\n oe.append(x)\\n lastoe = 0\\n elif x % 2:\\n odds.append(x)\\n if not lastoe:\\n oe.append(x)\\n lastoe = 1\\n if not lasteo:\\n eo.append(x)\\n lasteo = 1\\n return len(max(evens, odds, eo, oe, key=len))\\n\\n\",\n \"memory\": \"39500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n remainers = [num % 2 for num in nums]\\n counter = collections.Counter(remainers)\\n groups = 1\\n curr = remainers[0]\\n for r in remainers:\\n if r != curr:\\n groups += 1\\n curr = r\\n return max([counter[0], counter[1], groups])\\n\",\n \"memory\": \"39600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n previous = nums[0] % 2\\n alternating = 1\\n length = 1\\n odds_count = previous\\n for num in nums[1:]:\\n length += 1\\n remainder_2 = num % 2\\n odds_count += remainder_2\\n if previous != remainder_2:\\n alternating += 1\\n previous = remainder_2\\n return max(alternating, odds_count, length - odds_count)\\n\",\n \"memory\": \"39700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums = [a % 2 for a in nums]\\n return max(nums.count(0), nums.count(1), len(list(groupby(nums))))\",\n \"memory\": \"39800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums_rem = [x%2 for x in nums]\\n total = 1\\n pre = nums_rem[0]\\n for i in range(1, len(nums_rem)):\\n if (nums_rem[i] != pre):\\n total += 1\\n pre = nums_rem[i]\\n\\n res0 = total\\n res1, res2 = 0, 0\\n for x in nums_rem:\\n if x == 0:\\n res1 += 1\\n else:\\n res2 += 1\\n res = max(res0, res1, res2)\\n return res \\n \",\n \"memory\": \"39900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n arr = []\\n n = len(nums)\\n even_count = 0\\n odd_count = 0\\n\\n even_indices = []\\n odd_indices = []\\n\\n for idx in range(n):\\n if nums[idx] % 2 == 0:\\n arr.append(0)\\n even_count += 1\\n even_indices.append(idx)\\n else:\\n arr.append(1)\\n odd_count += 1\\n odd_indices.append(idx)\\n \\n if odd_count == 0 or even_count == 0:\\n return max(odd_count, even_count)\\n \\n odd_ptr = 0\\n even_ptr = 0\\n alternate_count = 0\\n\\n ptr = \\\"odd\\\" if odd_indices[odd_ptr] < even_indices[even_ptr] else \\\"even\\\"\\n search = True\\n prev_idx = -1\\n\\n while search:\\n if ptr == \\\"odd\\\" and odd_ptr >= len(odd_indices):\\n search = False\\n break\\n \\n if ptr == \\\"even\\\" and even_ptr >= len(even_indices):\\n search = False\\n break\\n \\n if ptr == \\\"odd\\\":\\n idx = odd_indices[odd_ptr]\\n if idx <= prev_idx:\\n odd_ptr += 1\\n else:\\n odd_ptr += 1\\n ptr = \\\"even\\\"\\n alternate_count += 1\\n prev_idx = idx\\n else:\\n idx = even_indices[even_ptr]\\n if idx <= prev_idx:\\n even_ptr += 1\\n else:\\n even_ptr += 1\\n ptr = \\\"odd\\\"\\n alternate_count += 1\\n prev_idx = idx\\n \\n return max(alternate_count, odd_count, even_count)\\n\\n\\n\\n\",\n \"memory\": \"40000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n previous = nums[0] % 2\\n alternating = 1\\n length = 1\\n odds_count = previous\\n for num in nums[1:]:\\n length += 1\\n remainder_2 = num % 2\\n odds_count += remainder_2\\n if previous != remainder_2:\\n alternating += 1\\n previous = remainder_2\\n return max(alternating, odds_count, length - odds_count)\\n\",\n \"memory\": \"40600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n max_length = 0\\n for target_remainder in range(k):\\n seen_remainders = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment_remainder = target_remainder - curr_remainder\\n if compliment_remainder < 0:\\n compliment_remainder = k - abs(compliment_remainder)\\n \\n if compliment_remainder in seen_remainders:\\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\\n else:\\n seen_remainders[curr_remainder] = 1\\n \\n if seen_remainders[curr_remainder] > max_length:\\n max_length = seen_remainders[curr_remainder]\\n\\n return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # count_zeros = 0\\n # count_ones = 0\\n # count_alt_zeros = 0\\n # count_alt_ones = 0\\n # for num in nums:\\n # if num % 2:\\n # count_ones += 1\\n # count_alt_zeros += 1\\n # else:\\n # count_zeros += 1\\n # count_alt_ones += 1\\n \\n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count = [0,0]\\n # ends = [0,0]\\n # for num in nums:\\n # count[num % 2] += 1\\n # ends[num % 2] = ends[1 - num % 2] + 1\\n \\n # return max( max(count), max(ends) )\\n\\n\\n # remainders = [ num % 2 for num in nums ]\\n # for \\n\\n\\n\\n # max_zero = self.get_lis(nums, 0)\\n # max_one = self.get_lis(nums, 1)\\n # return max_zero if max_zero >= max_one else max_one\\n \\n # def get_lis(self, nums, remainder):\\n # lis = [1] * len(nums)\\n # max_lis = 1 if nums else 0\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % 2 == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if lis[index] > max_lis:\\n # max_lis = lis[index]\\n \\n # return max_lis\\n\\n \",\n \"memory\": \"41200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n k = 2\\n max_length = 0\\n for target_remainder in range(k):\\n seen_remainders = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment_remainder = target_remainder - curr_remainder\\n if compliment_remainder < 0:\\n compliment_remainder = k - abs(compliment_remainder)\\n \\n if compliment_remainder in seen_remainders:\\n if curr_remainder not in seen_remainders or seen_remainders[curr_remainder] < seen_remainders[compliment_remainder] + 1:\\n seen_remainders[curr_remainder] = seen_remainders[compliment_remainder] + 1\\n else:\\n seen_remainders[curr_remainder] = 1\\n \\n if seen_remainders[curr_remainder] > max_length:\\n max_length = seen_remainders[curr_remainder]\\n\\n return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # count_zeros = 0\\n # count_ones = 0\\n # count_alt_zeros = 0\\n # count_alt_ones = 0\\n # for num in nums:\\n # if num % 2:\\n # count_ones += 1\\n # count_alt_zeros += 1\\n # else:\\n # count_zeros += 1\\n # count_alt_ones += 1\\n \\n # return max(count_zeros, count_ones, count_alt_zeros, count_alt_ones)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # count = [0,0]\\n # ends = [0,0]\\n # for num in nums:\\n # count[num % 2] += 1\\n # ends[num % 2] = ends[1 - num % 2] + 1\\n \\n # return max( max(count), max(ends) )\\n\\n\\n # remainders = [ num % 2 for num in nums ]\\n # for \\n\\n\\n\\n # max_zero = self.get_lis(nums, 0)\\n # max_one = self.get_lis(nums, 1)\\n # return max_zero if max_zero >= max_one else max_one\\n \\n # def get_lis(self, nums, remainder):\\n # lis = [1] * len(nums)\\n # max_lis = 1 if nums else 0\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % 2 == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if lis[index] > max_lis:\\n # max_lis = lis[index]\\n \\n # return max_lis\\n\\n \",\n \"memory\": \"41300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n nums_rem = [x%2 for x in nums]\\n stack = [nums_rem[0]]\\n for i in range(1, len(nums_rem)):\\n if (nums_rem[i] != stack[-1]):\\n stack.append(nums_rem[i])\\n res0 = len(stack)\\n print (stack)\\n res1 = len([x for x in nums_rem if x == 0])\\n res2 = len([x for x in nums_rem if x == 1])\\n res = max(res0, res1, res2)\\n return res \\n \",\n \"memory\": \"41400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n evenCount, oddCount = 0, 0\\n for num in nums:\\n if num % 2 == 1:\\n oddCount += 1\\n else:\\n evenCount += 1\\n\\n ans = max(evenCount, oddCount)\\n\\n l = len(nums)\\n dp = [0] * l\\n for i in range(l):\\n dp[i] = 1\\n for j in range(i-1, -1, -1):\\n if nums[j] % 2 != nums[i] % 2:\\n dp[i] = max(dp[i], 1+dp[j])\\n break\\n \\n print(dp)\\n return max(ans, dp[l-1])\",\n \"memory\": \"41500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n alter = []\\n odd = []\\n even = []\\n for i in nums:\\n if i%2 == 0:\\n even.append(i)\\n else:\\n odd.append(i)\\n if len(alter)==0 or alter[-1]%2 != i%2:\\n alter.append(i)\\n return max(len(alter), len(odd), len(even))\",\n \"memory\": \"42100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, xs: List[int]) -> int:\\n result = 0\\n evens = []\\n odds = []\\n alternating_0 = []\\n alternating_1 = []\\n\\n for i, x in enumerate(xs):\\n if x % 2 == 0:\\n evens.append(x)\\n else:\\n odds.append(x)\\n \\n if not alternating_0:\\n if x % 2 == 0:\\n alternating_0.append(x)\\n elif (x + alternating_0[-1]) % 2 == 1:\\n alternating_0.append(x)\\n\\n if not alternating_1:\\n if x % 2 == 1:\\n alternating_1.append(x)\\n elif (x + alternating_1[-1]) % 2 == 1:\\n alternating_1.append(x)\\n\\n return max(map(len, [evens, odds, alternating_0, alternating_1]))\",\n \"memory\": \"42200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n max_lens_odd = [1] * n\\n max_lens_even = [1] * n\\n for i in range(n):\\n update_odd = update_even = False\\n for j in range(i - 1, -1, -1):\\n if update_odd and update_even:\\n break\\n curr_sum = nums[i] + nums[j]\\n if curr_sum % 2 and update_odd:\\n continue\\n if curr_sum % 2 == 0 and update_even:\\n continue\\n if curr_sum % 2:\\n update_odd = True\\n if max_lens_odd[j] + 1 > max_lens_odd[i]:\\n max_lens_odd[i] = max_lens_odd[j] + 1\\n else:\\n update_even = True\\n if max_lens_even[j] + 1 > max_lens_even[i]:\\n max_lens_even[i] = max_lens_even[j] + 1\\n ans = max(max(max_lens_odd), max(max_lens_even))\\n return ans\\n\",\n \"memory\": \"42900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # record the lastest index of odd or even\\n # for each num, find index of same/diff parity\\n # increment len\\n n = len(nums)\\n index = [None, None]\\n ans = 0\\n same = [0] * n\\n diff = [0] * n\\n for i in range(n)[::-1]:\\n num = nums[i]%2\\n # same parity\\n idx = index[num]\\n if idx is not None:\\n same[i] = same[idx] + 1\\n # diff\\n idx = index[1-num]\\n if idx is not None:\\n diff[i] = diff[idx] + 1\\n index[num] = i\\n ans = max(max(same), max(diff))\\n return ans + 1\",\n \"memory\": \"43000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n \\n dp = [[0] * 2 for _ in range(len(nums))]\\n ans = 0\\n\\n for i in nums:\\n\\n x = i%2\\n\\n for j in range(2):\\n y = (j - x + 2) % 2\\n dp[x][y] = dp[y][x] + 1\\n\\n ans = max(ans, dp[x][y])\\n\\n return ans\",\n \"memory\": \"43700\"\n },\n {\n \"code\": \"# L(i) = length of longest subsequence that contains i in nums[:i] with % 2 == p\\n# L(i) = 1 [if i == 0]\\n# L(i) = L(i-1) + 1 [if (nums[i] + nums[i-1]) % 2 == p]\\n# L(i) = L(i-1) ow\\n\\n# oo = e\\n# ee = e\\n# eo/oe = o\\n\\n# \\n# eeeeo\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n EE = [0]\\n EO = [1]\\n OO = [1]\\n OE = [0]\\n p = 1\\n if nums[0] % 2 == 0:\\n OE[0] = 1\\n EE[0] = 1\\n p = 0\\n OO[0] = 0\\n EO[0] = 0\\n\\n mx = 0\\n # EE = 0,1,1,2\\n # EO = 1,1,2,2\\n # OE = 0,2,2,4\\n # OO = 1,1,3,3\\n\\n # EE = 0, 1, 1, 1,2,2,3\\n # EO = 1, 1, 2, 3,3,4,4\\n # OE = 0, 2, 2,|2,4,4,6 \\n # OO = 1, 1, 3, 3,3,5,5\\n \\n for i in range(1, len(nums)):\\n # print(L)\\n if nums[i] % 2 == 0:\\n EE.append(EE[i-1] + 1)\\n EO.append(EO[i-1])\\n OE.append(OO[i-1] + 1)\\n OO.append(OO[i-1])\\n else:\\n EO.append(EO[i-1] + 1)\\n EE.append(EE[i-1])\\n OO.append(OE[i-1] + 1)\\n OE.append(OE[i-1])\\n\\n mx = max(mx, EE[i], EO[i], OO[i], OE[i])\\n\\n return mx\",\n \"memory\": \"47900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # basically alternate nums must all be odd / all even\\n # odd/odd, even/odd, even/even\\n # we only need to do DP for even/odd\\n # LVS[i][p] is the Longest alt seq ending in parity p up to i\\n # 0: even, 1: odd\\n n = len(nums)\\n LVS = [[0,0] for _ in range(n)]\\n # base cases\\n LVS[0][nums[0] % 2] = 1\\n even = 1 if nums[0] % 2 == 0 else 0\\n # bottom up\\n for i in range(1, n):\\n if nums[i] % 2 == 0: \\n even += 1\\n for p in range(2):\\n LVS[i][p] = LVS[i-1][p]\\n LVS[i][nums[i] % 2] = LVS[i-1][1 - (nums[i] % 2)] + 1\\n # # find evens\\n # even = 0\\n # for num in nums:\\n # if num % 2 == 0:\\n # even += 1\\n return max(max(LVS[n-1]), even, n-even)\",\n \"memory\": \"49900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, L: List[int]) -> int:\\n odd=0\\n for j in range (0,len(L)):\\n if L[j]%2==1:\\n odd=odd+1\\n even=0\\n for j in range (0,len(L)):\\n if L[j]%2==0:\\n even=even+1\\n dp=[]\\n for j in range (0,len(L)):\\n dp.append([0,0])\\n if L[0]%2==0:\\n dp[0][1]=dp[0][1]+1\\n if L[0]%2==1:\\n dp[0][0]=dp[0][0]+1\\n for j in range (1,len(L)):\\n if L[j]%2==0:\\n dp[j][0]=dp[j-1][0]\\n dp[j][1]=max(dp[j-1][0]+1,dp[j-1][1])\\n if L[j]%2==1:\\n dp[j][1]=dp[j-1][1]\\n dp[j][0]=max(dp[j-1][1]+1,dp[j-1][0])\\n return max(odd,even,dp[-1][0],dp[-1][1])\\n \\n \",\n \"memory\": \"50200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n dp = [[0] * 2 for _ in range(n)]\\n last_even = -1\\n last_odd = -1\\n res = 0\\n\\n for i, val in enumerate(nums): \\n if val % 2 == 0: \\n last_even = i\\n if last_odd == -1: \\n dp[i] = [1, 0]\\n continue\\n dp[i][0] = dp[last_odd][0] + 1\\n dp[i][1] = dp[last_odd][1]\\n res = dp[i][0] + dp[i][1]\\n else: \\n last_odd = i\\n if last_even == -1: \\n dp[i] = [0, 1]\\n continue\\n dp[i][0] = dp[last_even][0]\\n dp[i][1] = dp[last_even][1] + 1\\n res = max(res, dp[i][0] + dp[i][1])\\n \\n countOdd = sum([1 for num in nums if num % 2 == 1])\\n countEven = sum([1 for num in nums if num % 2 == 0 ])\\n return max(res, countOdd, countEven) \\n \\n \",\n \"memory\": \"51500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n import numpy as np\\n if len(nums)==2:\\n return 2\\n nums = np.array(nums)\\n n2=nums%2\\n z_count = np.sum(n2)\\n o_count = len(nums)-z_count\\n n3 = np.sum(n2[1:]!=n2[:-1])\\n # n4 = np.count(n2[1:]+n2[:-1])\\n return max(1+np.max(np.unique(n2[1:]+n2[:-1],return_counts=True)[1]),z_count,o_count)\",\n \"memory\": \"52300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 0 -> e,o,e\\n # 1 -> e,e,e \\n # 0 -> o,e,o\\n # 1 -> o,o,o\\n gmax = 0\\n dp = [[0,0] for i in range(len(nums))]\\n prev_e, prev_o = -1, -1\\n if nums[0] % 2 == 0:\\n prev_e = 0\\n else:\\n prev_o = 0\\n\\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if prev_e >= 0:\\n dp[i][1] = dp[prev_e][1] + 1\\n if prev_o >= 0:\\n dp[i][0] = dp[prev_o][0] + 1\\n prev_e = i\\n else:\\n if prev_e >= 0:\\n dp[i][0] = dp[prev_e][0] + 1\\n if prev_o >= 0:\\n dp[i][1] = dp[prev_o][1] + 1\\n prev_o = i\\n gmax = max(gmax, max(dp[i]))\\n \\n # add 1 for the unaccounted for last element\\n return gmax + 1 \\n \\n\\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n # 0 -> e,o,e\\n # 1 -> e,e,e \\n # 0 -> o,e,o\\n # 1 -> o,o,o\\n gmax = 0\\n dp = [[0,0] for i in range(len(nums))]\\n prev_e, prev_o = -1, -1\\n if nums[0] % 2 == 0:\\n prev_e = 0\\n else:\\n prev_o = 0\\n\\n for i in range(1, len(nums)):\\n if nums[i] % 2 == 0:\\n if prev_e >= 0:\\n dp[i][1] = dp[prev_e][1] + 1\\n if prev_o >= 0:\\n dp[i][0] = dp[prev_o][0] + 1\\n prev_e = i\\n else:\\n if prev_e >= 0:\\n dp[i][0] = dp[prev_e][0] + 1\\n if prev_o >= 0:\\n dp[i][1] = dp[prev_o][1] + 1\\n prev_o = i\\n gmax = max(gmax, max(dp[i]))\\n \\n # add 1 for the unaccounted for last element\\n return gmax + 1 \\n \\n\\n\\n \\n\\n\\n\\n\\n \\n\\n\\n \",\n \"memory\": \"56400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int]) -> int:\\n n = len(nums)\\n longest = [[0] * 2 for _ in range(n)]\\n best = 0\\n for i in range(1, n):\\n remainders = set()\\n for j in reversed(range(i)):\\n if len(remainders) == 2:\\n break\\n d = (nums[i] + nums[j]) % 2\\n remainders.add(d)\\n longest[i][d] = max(longest[i][d], longest[j][d] + 1)\\n best = max(best, longest[i][d])\\n return best + 1\",\n \"memory\": \"57100\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":46,"string":"46"}}},{"rowIdx":2474,"cells":{"question_id":{"kind":"number","value":3491,"string":"3,491"},"name":{"kind":"string","value":"find-the-maximum-length-of-valid-subsequence-ii"},"content":{"kind":"string","value":"You are given an integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.\n<p>A <span data-keyword=\"subsequence-array\">subsequence</span> <code>sub</code> of <code>nums</code> with length <code>x</code> is called <strong>valid</strong> if it satisfies:</p>\n\n<ul>\n\t<li><code>(sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ... == (sub[x - 2] + sub[x - 1]) % k.</code></li>\n</ul>\nReturn the length of the <strong>longest</strong> <strong>valid</strong> subsequence of <code>nums</code>.\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,2,3,4,5], k = 2</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">5</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The longest valid subsequence is <code>[1, 2, 3, 4, 5]</code>.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">nums = [1,4,2,3,1,4], k = 3</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">4</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>The longest valid subsequence is <code>[1, 4, 1, 4]</code>.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>2 <= nums.length <= 10<sup>3</sup></code></li>\n\t<li><code>1 <= nums[i] <= 10<sup>7</sup></code></li>\n\t<li><code>1 <= k <= 10<sup>3</sup></code></li>\n</ul>\n"},"acRate":{"kind":"number","value":39.59620835463036,"string":"39.596208"},"difficulty":{"kind":"string","value":"Medium"},"topics":{"kind":"list like","value":["array","dynamic-programming"],"string":"[\n \"array\",\n \"dynamic-programming\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"182\", 1.6058000000000001], [\"228\", 0.4588], [\"274\", 0.2294], [\"320\", 0.2294], [\"366\", 0.2294], [\"412\", 0.6881999999999999], [\"458\", 0.2294], [\"504\", 0.2294], [\"550\", 0.4587], [\"596\", 0.2294], [\"642\", 0.2294], [\"689\", 0.2294], [\"735\", 0.4588], [\"781\", 5.2755], [\"827\", 2.294], [\"873\", 0.9176], [\"919\", 0.6881999999999999], [\"965\", 0.6881999999999999], [\"1011\", 1.8352000000000002], [\"1057\", 1.8352000000000002], [\"1103\", 0.6881999999999999], [\"1149\", 1.6058000000000001], [\"1195\", 0.9176], [\"1242\", 0.6881999999999999], [\"1288\", 1.147], [\"1334\", 1.3764], [\"1380\", 1.8352000000000002], [\"1426\", 1.147], [\"1472\", 0.6881999999999999], [\"1518\", 1.3764], [\"1564\", 0.6881999999999999], [\"1610\", 0.6881999999999999], [\"1656\", 1.3763], [\"1702\", 1.8352000000000002], [\"1749\", 2.5233000000000003], [\"1795\", 1.3764], [\"1841\", 1.8352000000000002], [\"1887\", 1.6058000000000001], [\"1933\", 2.2939000000000003], [\"1979\", 2.0645000000000002], [\"2025\", 0.9176], [\"2071\", 1.3763], [\"2117\", 1.3763], [\"2163\", 0.2294], [\"2209\", 0.4588], [\"2255\", 0.9176], [\"2302\", 1.3764], [\"2348\", 1.6058000000000001], [\"2394\", 2.5232], [\"2440\", 3.8997000000000006], [\"2486\", 2.5231], [\"2532\", 2.294], [\"2578\", 1.147], [\"2624\", 1.3764], [\"2670\", 1.6058000000000001], [\"2716\", 0.9176], [\"2762\", 1.147], [\"2809\", 1.6058000000000001], [\"2855\", 1.3764], [\"2901\", 1.147], [\"2947\", 3.8996000000000004], [\"2993\", 1.8351000000000002], [\"3039\", 2.0645000000000002], [\"3085\", 0.6881999999999999], [\"3131\", 1.6057000000000001], [\"3177\", 1.6057000000000001], [\"3223\", 1.147], [\"3269\", 0.2294], [\"3315\", 0.4588], [\"3362\", 0.4588], [\"3408\", 0.2294], [\"3454\", 0.4588], [\"3500\", 0.4588], [\"3546\", 0.2294], [\"3592\", 0.6881999999999999], [\"3638\", 0.2294], [\"3684\", 0.2294], [\"3730\", 0.6881999999999999], [\"3776\", 0.4588], [\"3822\", 0.6881999999999999]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"16400\", 0.2294], [\"16500\", 0.9174], [\"16600\", 0.6881], [\"16700\", 4.1284], [\"16800\", 8.2569], [\"16900\", 6.8807], [\"17000\", 2.7523], [\"17100\", 0.6881], [\"22500\", 0.2294], [\"24300\", 0.2294], [\"24400\", 3.4404], [\"24500\", 8.945], [\"24600\", 19.7248], [\"24700\", 12.844], [\"24800\", 1.8349], [\"24900\", 0.2294], [\"25100\", 0.2294], [\"25200\", 2.7523], [\"25300\", 2.5229], [\"25400\", 5.0459], [\"25500\", 0.4587], [\"32299\", 0.2294], [\"35400\", 0.4587], [\"37900\", 0.2294], [\"38000\", 0.2294], [\"38400\", 0.2294], [\"38500\", 0.9174], [\"38600\", 0.2294], [\"39800\", 0.2294], [\"44600\", 0.2294], [\"44700\", 0.4587], [\"44800\", 0.4587], [\"45000\", 0.2294], [\"48400\", 0.2294], [\"49300\", 0.2294], [\"49400\", 0.2294], [\"49500\", 0.4587], [\"49600\", 2.7523], [\"49700\", 0.4587], [\"68400\", 0.2294], [\"75800\", 0.2294], [\"81000\", 0.2294], [\"88600\", 0.4587], [\"88700\", 0.4587], [\"89600\", 0.2294], [\"94300\", 0.2294], [\"110700\", 0.2294], [\"110800\", 0.2294], [\"110900\", 0.2294], [\"111000\", 0.2294], [\"111300\", 0.2294]]}"},"rt_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nums = [num % k for num in nums]\n def check(a, b):\n alternating = [num for num in nums if num == a or num == b]\n return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\n \n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\n best = counts[0][0]\n for i in range(len(counts)-1):\n countA, a = counts[i]\n for j in range(i+1, len(counts)):\n countB, b = counts[j]\n if countA + countB <= best:\n break\n best = max(best, check(a, b))\n return best","runtime":"182"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nums = [num % k for num in nums]\n def check(a, b):\n alternating = (num for num in nums if num == a or num == b)\n return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\n \n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\n best = counts[0][0]\n for i in range(len(counts)-1):\n countA, a = counts[i]\n for j in range(i+1, len(counts)):\n countB, b = counts[j]\n if countA + countB <= best:\n break\n best = max(best, check(a, b))\n return best","runtime":"182"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nums = [num % k for num in nums]\n def check(a, b):\n curr = -1\n total = 0\n for i in range(len(nums)):\n if nums[i] == a and curr != a:\n total += 1\n curr = a\n elif nums[i] == b and curr != b:\n total += 1\n curr = b\n return total\n # alternating = [num for num in nums if num == a or num == b]\n # return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\n \n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\n best = counts[0][0]\n for i in range(len(counts)-1):\n countA, a = counts[i]\n for j in range(i+1, len(counts)):\n countB, b = counts[j]\n if countA + countB <= best:\n break\n best = max(best, check(a, b))\n return best","runtime":"228"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n remainders = defaultdict(list)\n for i, n in enumerate(nums):\n remainders[n % k].append(i)\n max_len = max(2, max([len(remainders[a]) for a in remainders.keys()]))\n\n\n\n for i in remainders.keys():\n for j in remainders.keys():\n if i == j or len(remainders[i]) + len(remainders[j]) <= max_len:\n continue\n\n pos1 = remainders[i][0]\n l = 1\n while True:\n pos2 = bisect_right(remainders[j], pos1)\n if pos2 == len(remainders[j]):\n break\n pos2 = remainders[j][pos2]\n l += 1\n pos1 = bisect_right(remainders[i], pos2)\n if pos1 == len(remainders[i]):\n break\n pos1 = remainders[i][pos1]\n l += 1\n\n # print(f\"pos1={pos1}, pos2={pos2}\")\n max_len = max(max_len, l)\n return max_len\n ","runtime":"228"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, num in enumerate(nums):\n groups[num % k].append(j)\n ans = max(len(group) for group in groups)\n for i, y in enumerate(groups):\n for x in groups[:i]:\n if len(x) + len(y) <= ans:\n continue\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\n if cand > ans:\n ans = cand\n return ans","runtime":"274"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, num in enumerate(nums):\n groups[num % k].append(j)\n ans = max(len(group) for group in groups)\n for i, y in enumerate(groups):\n for x in groups[:i]:\n if len(x) + len(y) <= ans:\n continue\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\n if cand > ans:\n ans = cand\n return ans","runtime":"320"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, num in enumerate(nums):\n groups[num % k].append(j)\n ans = max(len(group) for group in groups)\n for i, y in enumerate(groups):\n for x in groups[:i]:\n if len(x) + len(y) <= ans:\n continue\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\n if cand > ans:\n ans = cand\n return ans","runtime":"366"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, (num, _) in enumerate(itertools.groupby(nums)):\n groups[num % k].append(j)\n ans = max(collections.Counter(num % k for num in nums).values())\n for i, y in enumerate(groups):\n for x in groups[:i]:\n if len(x) + len(y) <= ans:\n continue\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\n if cand > ans:\n ans = cand\n return ans","runtime":"412"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, (num, _) in enumerate(itertools.groupby(nums)):\n groups[num % k].append(j)\n ans = max(collections.Counter(num % k for num in nums).values())\n for i, y in enumerate(groups):\n for x in groups[:i]:\n if len(x) + len(y) <= ans:\n continue\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\n if cand > ans:\n ans = cand\n return ans","runtime":"412"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # 根据mod性质，有效子序列的奇数项都关于模 k 同余，偶数项都关于模 k 同余。\n # 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。\n # f[y][x]=f[x][y]+1\n f = [[0] * k for _ in range(k)]\n for x in nums:\n x %= k\n for y, fxy in enumerate(f[x]):\n f[y][x] = fxy + 1\n return max(map(max, f))\n\n# 时间复杂度：O(k^2+nk)，其中 n 是 nums 的长度。注意创建大小为 k^2 的二维数组需要 O(k^2) 的时间。\n# 空间复杂度：O(k^2)。\n\n# 方法二：枚举余数，考察子序列的最后一项\n# 如果知道了子序列的最后一项（假设是 x），那么子序列的倒数第二项也就确定了，即 (m−x mod k+k) mod k\n# 加 k 再模 k 是为了在 m<xmodk 时，保证计算结果非负。\n# Python，由于允许负数下标，可以直接用 f[m−xmodk] 作为转移来源。\n# f[x]=f[(m−xmodk+k)modk]+1\n# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# ans = 0\n# for m in range(k):\n# f = [0] * k\n# for x in nums:\n# x %= k\n# f[x] = f[m - x] + 1\n# ans = max(ans, max(f))\n# return ans\n# 时间复杂度：O(k(k+n))，其中 n 是 nums 的长度。注意创建大小为 k 的数组需要 O(k) 的时间。\n# 空间复杂度：O(k)。","runtime":"458"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * k for _ in range(k)]\n for x in nums:\n x %= k\n for y, fxy in enumerate(f[x]):\n f[y][x] = fxy + 1\n return max(map(max, f))\n# https://leetcode.cn/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/2826591/deng-jie-zhuan-huan-dong-tai-gui-hua-pyt-z2fs/?envType=company&envId=google&favoriteSlug=google-thirty-days","runtime":"504"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * k for _ in range(k)]\n for x in nums:\n x %= k\n for y in range(k):\n f[y][x] = f[x][y] + 1\n return max(map(max, f))","runtime":"550"},{"code":"# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\n# # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\n# # complexity O(n*k)\n \n# numsMods = [n % k for n in nums]\n\n# from collections import defaultdict\n# harsh = defaultdict(int)\n\n# for n in numsMods:\n# for c in range(k):\n# if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\n# elif (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\n \n# return max(harsh.values())\n\n\n\n# from a submission's solution. It is the same thing as my solution above, but using arr instead of harsh tables. It looks cleaner nad easier to understand.\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\n # complexity O(n*k)\n \n dp = [[0]*k for _ in range(k)]\n\n for x in nums:\n x = x % k\n for y in range(k):\n dp[y][x] = dp[x][y] + 1\n\n return max([max(row) for row in dp])\n\n\n# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\n# # complexity O(n*k*k) to slow\n \n# numsMods = [n % k for n in nums]\n \n# counts = []\n# for m in range(k):\n# for c in range(k):\n# cond = m\n# count = 0\n# for n in numsMods:\n# if n == cond:\n# count += 1\n# cond = c if cond == m else m\n# counts.append(count)\n \n# return max(counts)","runtime":"596"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n for num in nums:\n r = num % k\n for pr in range(k):\n dp[pr][r] = dp[r][pr] + 1\n ans = 0\n for row in dp:\n ans = max(ans, max(row))\n return ans","runtime":"642"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n (a + b) mod k = (b + c) mod k\n (a + b - (b + c)) mod k = 0\n (a - c) mod k = 0\n a 和 c 关于 模 k 同余\n a and c are congruent modulo k\n 如果把nums[i] 变成 nums[i]mod k, 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。（即 a，c）\n 动态规划表: dp[i][j]，其中 i 和 j 分别表示模 k 的结果。dp[i][j] 表示以模 i 和 j 结尾的最长有效子序列的长度。\n consider “子序列奇数项都相同，偶数项都相同”\n 递推更新：对于每个元素 nums[i]，遍历更新动态规划表，检查当前元素与之前的元素是否可以形成一个有效的子序列。如果可以，就更新 dp 表，例如 dp[x % k][y] = dp[y][x % k] + 1，其中 x 为当前元素，y 表示前面的元素。\n \"\"\"\n # 创建一个二维DP表 f[y][x]，表示以模k的值y和x为结尾的最长子序列长度\n dp = [[0] * k for _ in range(k)]\n\n # 遍历数组中的每个数字\n for x in nums:\n x %= k\n # 对于模k的每个可能的值y，更新dp[y][x]，表示以y和x为结尾的子序列长度\n # 此处倒序遍历dp表，避免覆盖更新的值影响后续计算\n for y in range(k): # 这个 for loop是所有可能的 mod值\n dp[y][x] = dp[x][y] + 1 # 更新dp表，将当前数x加入到以y结尾的子序列中\n \n return max(max(row) for row in dp)\n\n","runtime":"689"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n table = [[0] * k for _ in range(k)] # table[i][j] = the length of subseq ending with ... i, j\n for n in nums:\n modk = n % k\n for i in range(k):\n table[i][modk] = table[modk][i] + 1\n \n return max(map(max, table))","runtime":"735"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n return max(map(max, dp))","runtime":"735"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for j in range(k):\n dp[x][j] = 1 + dp[j][x]; \n #dp[x][1] = 1 + dp[1][x]; \n return max(map(max, dp))","runtime":"781"},{"code":"# 解題思路：\n# 這個解法的目的是找到最長的有效子序列，使得 (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ...，其中 k 是給定的正整數。\n# 我們使用動態規劃來解決這個問題，並且維護一個 dp 二維數組，其中 dp[x][y] 表示以 x 開頭、y 結尾的有效子序列的長度。\n\n# 具體步驟：\n\n# 模運算處理：將每個數字 x 對 k 取模，這樣我們只關心每個數字的模數結果。\n\n# 動態規劃：對於每一個數字，我們更新二維 dp 陣列來追蹤不同模數值之間形成的子序列長度。\n# dp[x][y] 代表以模數 y 結尾，並且剛剛加上模數 x 的有效子序列長度。\n\n# 結果提取：最後，我們找出二維數組 dp 中的最大值，這就是最長的有效子序列長度。\n\n# 詳細解釋：\n# x 是當前遍歷的數字對 k 取模後的結果。\n# y 是我們在 dp 中考慮的另一個模數。\n# dp[y][x] 表示之前已經形成的、以模數 y 開頭、以模數 x 結尾的最長子序列。\n\n# 當我們遇到新的數字 x 時：\n# 如果之前已經有一個以模數 y 結尾的子序列，那麼我們可以將這個數字 x 添加到這個子序列中。\n# 因此，我們更新 dp[x][y]，使其值為 1 + dp[y][x]，表示在原來的子序列長度基礎上再加上當前的數字。\n\n# 這裡的遞歸關係 dp[x][y] = 1 + dp[y][x] 是基於以下邏輯：\n# dp[y][x] 表示以 y 為結尾、以 x 為倒數第二個數字的最長有效子序列長度。\n# 當我們加入一個新的元素 x 時，它會接在以 y 為結尾的子序列後面，構成一個新的更長的子序列，因此長度增加 1。\n# dp[x][y] = 1 + dp[y][x] 表示在加入這個新元素 x 之後，新的子序列長度是 dp[y][x]（舊的序列長度）加上新加入的 1。\n# dp[x][y] = 1 + dp[y][x] 是在構造新的子序列時，根據前面已經計算好的結果來延長子序列。\n# 而 dp[x][y] = 1 + dp[y][x] + dp[x][y] 會導致遞歸計算中包含自己，造成無限遞歸問題。\n\n# 這裡的 dp[x][y] 儲存的是以 x 結尾並且可以接上以 y 結尾的子序列的最長長度。\n\n# dp[0][0]、dp[0][1]、dp[0][2] 具體解釋：\n# dp[0][0]：表示以 0 取模的數字結尾的序列長度，並且這個序列的倒數第二個數字也是以 0 取模的數字。例如，數字 3 對 3 取模後等於 0，所以 dp[0][0] 表示我們能在以 0 結尾並且倒數第二個數字也取模為 0 的序列後加入這個數字（這裡代表的是所有模 0 的數字結尾的序列長度）。\n\n# dp[0][1]：表示以 0 取模的數字結尾的序列長度，但倒數第二個數字是以 1 取模的數字。例如，當前數字 3 取模後為 0，而倒數第二個數字可以是模 1 的數字，像是數字 1。這樣我們可以在以 1 結尾的序列後加入數字 3，構成一個新的序列。\n\n# dp[0][2]：表示以 0 取模的數字結尾的序列長度，但倒數第二個數字是以 2 取模的數字。例如，如果倒數第二個數字是模 2 的數字（像是數字 2），我們可以在這個序列後加入數字 3，形成一個新的子序列。\n\n# dp[x][y] 的模式：\n# x 代表當前數字對 k 取模後的結果，也就是序列結尾的數字的模數。\n# y 代表序列中倒數第二個數字的模數。\n\n# 遞歸的關係： dp[x][y] = 1 + dp[y][x] 表示我們將一個新的元素 x 加入到之前以 y 為結尾的子序列中，這樣子序列的長度就增加了 1。\n\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\n# return max(map(max, dp)) \n\n# DP 2D,\n# O(n * k), S: O(k * 2)\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n\n return max(map(max, dp)) ","runtime":"781"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n return max(map(max, dp))","runtime":"827"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n return max(map(max, dp))","runtime":"827"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n for i, x in enumerate(nums):\n nums[i] %= k\n ans = 0\n for i in range(k):\n dp = [0] * k\n for x in nums:\n c = i - x\n if c < 0:\n c += k\n dp[x] = dp[c] + 1\n ans = max(ans, max(dp))\n return ans","runtime":"873"},{"code":"from typing import List\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n vt = [[] for _ in range(k)] # List of lists to store indices based on modulo k\n mx = 0 # Variable to store the maximum length\n\n # Populate the vt list with indices of nums based on modulo k\n for i in range(n):\n idx = nums[i] % k\n vt[idx].append(i)\n mx = max(mx, len(vt[idx]))\n\n # Compare pairs of different modulo groups to find the maximum length\n for i in range(k - 1):\n for j in range(i + 1, k):\n vi, vj = vt[i], vt[j]\n if not vi or not vj:\n continue\n\n l, m = 0, 0\n si, sj = len(vi), len(vj)\n ar = 1 # Variable to store the alternating sequence length\n f1 = vi[l] < vj[m]\n\n # Merge the two sorted lists vi and vj to find the longest alternating sequence\n while l < si and m < sj:\n if f1:\n while m < sj and vj[m] < vi[l]:\n m += 1\n if m >= sj:\n break\n ar += 1\n l += 1\n else:\n while l < si and vi[l] < vj[m]:\n l += 1\n if l >= si:\n break\n ar += 1\n m += 1\n f1 = not f1 # Toggle the flag\n\n mx = max(mx, ar)\n\n return mx # Return the maximum length of the alternating sequence\n\n# Example usage:\n# sol = Solution()\n# print(sol.maximumLength([1, 2, 3, 4, 5, 6], 2)) # Example input","runtime":"873"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for num in nums:\n rem = num % k\n for i in range(k):\n dp[i][rem] = dp[i][i-rem] + 1\n return max(max(row) for row in dp)","runtime":"919"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n nums = [x%k for x in nums]\n \n res = 0\n for i in range(k):\n dp = [0]*k\n for x in nums: \n dp[x] = dp[(i-x)%k] +1\n res = max(res, *dp)\n return res\n\n","runtime":"919"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n groups = [[] for _ in range(k)]\n for j, num in enumerate(nums):\n groups[num % k].append(j)\n solids = max(len(group) for group in groups)\n if solids == len(nums):\n return solids\n stripes = max(\n stripe(x, y, solids) for i, y in enumerate(groups)\n for x in groups[:i]\n )\n return max(solids, stripes)\n\n\ndef stripe(x, y, cut):\n if len(x) + len(y) <= cut:\n return cut\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\n return 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))","runtime":"965"},{"code":"import bisect\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n mod_positions = [-1] * k \n dp = [[0 for _ in range(k)] for _ in range(n)]\n\n for idx in range(n - 1, -1, -1):\n nums[idx] %= k\n if idx == n - 1:\n for k_value in range(k):\n dp[idx][k_value] = 1\n else:\n for k_value in range(k):\n next_idx = mod_positions[k_value]\n\n if next_idx == -1:\n dp[idx][k_value] = 1\n continue\n \n dp[idx][k_value] = 1 + dp[next_idx][nums[idx]]\n \n mod_positions[nums[idx]] = idx\n \n return max(max(row) for row in dp) \n\n \n\n ","runtime":"965"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n ans = 0\n\n for m in range(k): # loop every possible value of (x[0] + x[1]) % k\n dp = [0] * k # dp[value]: longest subsequence length ending in value = nums[i] % k\n for num in nums:\n dp[num % k] = dp[(m - num) % k] + 1\n ans = max(ans, max(dp))\n\n return ans","runtime":"1011"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n res = 0\n for v in range(k): # Enumearet the sub sum v = (sub[0] + sub[1]) % k\n dp = [0] * k # dp[a % k] means the longest of subarray ending with a % k\n for a in nums:\n dp[a % k] = dp[(v - a) % k] + 1 # a can be the next element after (v - a) % k\n res = max(res, max(dp))\n return res","runtime":"1011"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n # another dp approach\n # what are chaning\n # 1. ith value we are considering\n # 2. the ith value mod\n # 3. the i-1 th value and its mod\n \n # mod will be in the range of [0, k-1]\n # we are doing space compaction already\n \n l = len(nums)\n dp = [[0 for y in range(k)] for x in range(k)]\n result = 0\n for i in range(1, l+1):\n val = nums[i-1]\n m = val % k\n \n for j in range(k):\n # if j == m:\n # dp[m][j] = dp[m][j] + 1\n # else:\n \n # current mod is m, prev value in the subseq has a mod of j\n # then to make the equation, the prev prev value should also have a mod of m\n # so dp[x][y] = dp[y][x] + 1\n\n # since this also applies when j == m, so we can safely remove the if else\n dp[m][j] = dp[j][m] + 1\n result = max(result, max(dp[m]))\n return result\n \n \n # (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k\n # where (sub[0] + sub[1]) % k can be any value [0, k-1]\n \n result = 0\n for u in range(k):\n # dp[i] means when v is the mod of the equation above\n # what is the length of the longest valid subseq with\n # a ending value whose mod is i\n dp = [0 for y in range(k)]\n for v in nums:\n m = v % k\n # for a given m as ending value\n # the prev value should be someone with mod (u + k - m) % k\n dp[m] = max(dp[m], dp[(u + k - m) % k] + 1)\n result = max(result, dp[m])\n return result\n \n \n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/discuss/5389322/Yes-it's-a-2d-DP-!!\n l = len(nums)\n dp = [[0 for y in range(k)] for x in range(k)]\n \n result = 0\n \n for i in range(1, l+1):\n val = nums[i-1] % k\n for j in range(k):\n prev_val = (j + k - val) % k\n dp[val][j] = max(dp[val][j], dp[prev_val][j] + 1)\n \n result = max(result, dp[val][j])\n return result","runtime":"1057"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1] * k for _ in range(n)]\n for i in range(n):\n for j in range(i):\n r = (nums[j] + nums[i]) % k\n dp[i][r] = dp[j][r] + 1\n return max([max(x) for x in dp])\n\n \n","runtime":"1057"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n def solve(t):\n remainders = [0] * k\n for x in nums:\n remainders[x % k] = 1 + remainders[(k - x - t) % k]\n return max(remainders)\n\n ans = 0\n for i in range(0, k):\n ans = max(ans, solve(i))\n return ans","runtime":"1103"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[i][j] := the maximum length of a valid subsequence, where the last\n # number mod k equal to i and the next desired number mod k equal to j\n dp = [[0] * k for _ in range(k)]\n\n # Extend the pattern xyxyxy...xy.\n for x in nums:\n for y in range(k):\n dp[x % k][y] = dp[y][x % k] + 1\n\n return max(map(max, dp))","runtime":"1103"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n for i in range(n):\n nums[i] = nums[i]%k\n cnt = Counter(nums)\n res = max(cnt.values())\n visited = [[False]*k for _ in range(k)]\n for i in range(n):\n a = nums[i]\n for j in range(i+1,n):\n b = nums[j]\n if visited[a][b] or visited[b][a] or cnt[a]+cnt[b] <= res:\n continue\n visited[a][b] = True\n visited[b][a] = True\n c = 2\n f = False\n for k in range(j+1,n):\n if f and (nums[k] == b):\n c += 1\n f = False\n elif (not f) and (nums[k] == a):\n c += 1\n f = True\n if c>res:\n res = c\n\n return res\n ","runtime":"1149"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0] * k for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1149"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n data = [[0]*k for _ in range(k)]\n for num in nums:\n for i in range(k):\n data[i][num%k] = data[i][i-num%k] + 1\n return max(max(row) for row in data)","runtime":"1195"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * k for _ in range(k)]\n for i in range(n):\n for j in range(k):\n dp[nums[i] % k][j] = 1 + dp[j][nums[i] % k]\n return max(max(dp[i]) for i in range(k))","runtime":"1195"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n dp = [[1] * k for _ in range(N)]\n ret = 1\n\n for i in range(N - 2, -1 ,-1):\n for j in range(i + 1, N):\n num = (nums[i] + nums[j])%k\n if dp[i][num] == 1:\n dp[i][num] = 1 + dp[j][num]\n ret = max(ret, dp[i][num])\n \n return ret\n","runtime":"1242"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n 1 4 2 3 1 4\n 3\n\n 1 1 2 0 1 1\n\n 1. try find the longest subseq where every 2 consecutive elements sum up to 0\n\n 1 1 2 0 1 1 \n create a dict to track longest subseq that ends with a certain value\n {\n 1: 3,\n 2: 2,\n 0: 1,\n }\n \n \"\"\"\n nums = [n % k for n in nums]\n res = 0\n for tar_sum in range(k):\n longest_length_ends_with_val = {}\n for n in nums:\n prev_val = tar_sum - n\n if prev_val < 0:\n prev_val += k\n longest_length_ends_with_val[n] = longest_length_ends_with_val.get(prev_val, 0) + 1\n\n res = max(res, max(longest_length_ends_with_val.values()))\n return res","runtime":"1242"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [{} for _ in range(0, len(nums))]\n\n max = 0\n\n for i in range(1, len(nums)):\n for j in range(i - 1, -1, -1):\n remainder = (nums[i] + nums[j]) % k\n\n if remainder in dp[i]:\n continue\n\n if remainder in dp[j]:\n dp[i][remainder] = dp[j][remainder] + 1\n else:\n dp[i][remainder] = 2\n\n if dp[i][remainder] > max:\n max = dp[i][remainder]\n \n\n #print(dp)\n return max\n\n ","runtime":"1288"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n for i in range(len(nums)):\n nums[i] %= k\n\n hashMap = {}\n for i in range(len(nums)):\n if nums[i] in hashMap:\n hashMap[nums[i]] += [i]\n else:\n hashMap[nums[i]] = [i]\n\n hashSet = set(nums)\n result = 0\n for a in hashSet:\n for b in hashSet:\n if a == b:\n result = max(result, len(hashMap[a]))\n continue\n else:\n arrA = hashMap[a]\n arrB = hashMap[b]\n\n length = 0\n current = -1\n r = 0\n for l in range(len(arrA)):\n if arrA[l] > current:\n current = arrA[l]\n length += 1\n\n while r < len(arrB) and arrB[r] < current:\n r += 1\n\n if r < len(arrB):\n current = arrB[r]\n length += 1\n else:\n break\n else:\n continue\n\n result = max(result, length)\n\n return result","runtime":"1288"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n for i in range(len(nums)):\n nums[i] %= k\n\n hashMap = {}\n for i in range(len(nums)):\n if nums[i] in hashMap:\n hashMap[nums[i]] += [i]\n else:\n hashMap[nums[i]] = [i]\n\n hashSet = set(nums)\n result = 0\n for a in hashSet:\n for b in hashSet:\n if a == b:\n result = max(result, len(hashMap[a]))\n continue\n else:\n arrA = hashMap[a]\n arrB = hashMap[b]\n\n length = 0\n current = -1\n r = 0\n for l in range(len(arrA)):\n if arrA[l] > current:\n current = arrA[l]\n length += 1\n\n while r < len(arrB) and arrB[r] < current:\n r += 1\n\n if r < len(arrB):\n current = arrB[r]\n length += 1\n else:\n break\n else:\n continue\n\n result = max(result, length)\n\n return result","runtime":"1334"},{"code":"class Solution:\n def maximumLength(self, nums: list[int], k: int) -> int:\n ans=[]\n for i in range(k):\n arr=[]\n for _ in range(k):\n arr.append(0)\n for x in nums:\n arr[x%k]=arr[(i-x)%k]+1\n ans.append(max(arr))\n return max(ans)","runtime":"1334"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nums = [n % k for n in nums]\n res = 0\n for i in range(k):\n dp = {}\n for n in nums:\n prev = i - n\n if prev < 0:\n prev += k\n dp[n] = dp.get(prev, 0) + 1\n if dp[n] > res:\n res = dp[n]\n return res\n","runtime":"1380"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 2:\n return 2\n \n r = (nums[n-1] + nums[n-2]) % k\n res = dict()\n res = [dict()]\n res.append({r: 2})\n mm = 2\n for i in range(2, n):\n re = dict()\n idx = n - i - 1\n for j in range(idx+1, n):\n r = (nums[idx] + nums[j])%k\n if r not in re:\n re[r] = res[n-j-1].get(r, 1) + 1\n if re[r] > mm:\n mm = re[r]\n res.append(re)\n return mm\n\n","runtime":"1380"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1426"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n # we borrow some code from #3201:\n\n mods = [N % k for N in nums]\n print(f'{mods[:10]=}')\n\n counts = Counter(mods)\n print(f'counts{tuple(counts.items())[:10]}')\n\n cases = []\n\n # case group 1: all the same\n for mod, count in counts.items():\n cases.append(count)\n # print(f'case group 1: all {mod} = {count}')\n \n best_case_1 = max(cases, default=0)\n print(f'{best_case_1=}')\n cases = []\n\n # case group 2: any pair, alternating\n for first, firstCount in counts.items():\n for second, secondCount in counts.items():\n # print(f'Try {first}, {second}:')\n if first == second:\n # print(f' No: same')\n continue\n if min(firstCount, secondCount) * 2 + 1 <= best_case_1:\n # series will be alternating, e.g. [1 2 1 2 1]\n # our limiting reagent is the 2's (minimum count):\n # any extra 1's will be unused\n # print(f' No: {firstCount},{secondCount} cant beat best case 1')\n continue\n\n prior = first\n index = mods.index(prior)\n this_case = 1\n # print(f'{this_case=} [{index}]{prior}')\n while True:\n next = second if (prior == first) else first # 1st->2nd, 2nd->1st\n try:\n index = mods.index(next, index + 1)\n except ValueError:\n break\n prior = mods[index]\n this_case += 1\n # print(f'{this_case=} [{index}]{prior}')\n cases.append(this_case)\n # print(f'case group 2: {first},{second} = {this_case}')\n best_case_2 = max(cases, default=0)\n print(f'{best_case_2=}')\n\n return max(best_case_1, best_case_2)\n","runtime":"1426"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1472"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1472"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # ex: k is 3\n # 1 5 4\n # 5 is random filling, but 1 and 4 should always have the same remainder\n # (the problem is that once the random filling is chosen, you have to stick\n # to numbers having the same remainder)\n availableRests = set([x % k for x in nums])\n\n # dp[i][j] - length of the longest subsequence with\n # the remainder j ending in nums[i] % k\n n = len(nums)\n dp = [[0 for _ in range(k)] for _ in range(k)]\n \n alternating = []\n for num in nums:\n current = num % k\n\n # iterate through all the possible rests of the sum(a, b) % k\n for rest in range(k):\n prev = (k + rest - current) % k\n dp[current][rest] = dp[prev][rest] + 1\n return max([max(x) for x in dp])","runtime":"1518"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n last_r = [-1]*k\n n = len(nums)\n dp = [[0]*k for _ in range(n)]\n ans = 0\n \n for i in range(n):\n for r in range(k):\n d = (r - nums[i]%k + k) % k\n if last_r[d] != -1:\n j = last_r[d]\n dp[i][r] = dp[j][r] + 1\n ans = max(ans, dp[i][r])\n else:\n dp[i][r] = 1\n last_r[nums[i]%k] = i \n\n return ans","runtime":"1518"},{"code":"import collections\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 0\n grid = [[0] * k for _ in range(k)]\n for val in nums:\n rem = val % k\n for i in range(k):\n grid[i][rem] = grid[rem][i] + 1\n ans = max(ans, grid[i][rem])\n return ans\n\n \n\n ","runtime":"1564"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n dp = [[0] * k for x in range(k)]\n ans = 0\n for num in nums:\n i = num % k\n for y in range(k):\n dp[i][y] = dp[y][i] + 1\n ans = max(ans, dp[i][y])\n return ans\n\n","runtime":"1564"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n for i in range(n):\n nums[i] = nums[i]%k\n cnt = Counter(nums)\n res = max(cnt.values())\n visited = {}\n for i in range(n):\n a = nums[i]\n for j in range(i+1,n):\n b = nums[j]\n if ((a,b) in visited) or ((b,a) in visited):\n continue\n visited[(a,b)] = True\n visited[(b,a)] = True\n if cnt[a]+cnt[b] <= res:\n continue\n c = 2\n f = False\n for k in range(j+1,n):\n if f and (nums[k] == b):\n c += 1\n f = False\n elif (not f) and (nums[k] == a):\n c += 1\n f = True\n res = max(c,res)\n\n return res\n ","runtime":"1610"},{"code":"from collections import defaultdict\n\nclass Solution:\n\n def longest(self, values1: List[int], values2: List[int]) -> int:\n l_ptr = 0\n r_ptr = 0\n count = 0\n # left == True means to pull from values 1\n left = bool(values1[0] < values2[0])\n while True:\n count += 1\n if left:\n curr = values1[l_ptr]\n while r_ptr < len(values2) and values2[r_ptr] < curr:\n r_ptr += 1\n if r_ptr >= len(values2) or values2[r_ptr] < curr:\n break\n else:\n curr = values2[r_ptr]\n while l_ptr < len(values1) and values1[l_ptr] < curr:\n l_ptr += 1\n if l_ptr >= len(values1) or values1[l_ptr] < curr:\n break\n left = not left\n return count\n\n def maximumLength(self, nums: List[int], k: int) -> int:\n k_dict = defaultdict(list)\n for i, num in enumerate(nums):\n k_dict[num % k].append(i)\n curr_max = 0\n for k, values in k_dict.items():\n for k2, values2 in k_dict.items():\n if k == k2:\n curr_max = max(curr_max, len(values))\n continue\n curr_max = max(curr_max, self.longest(values, values2))\n return curr_max\n ","runtime":"1610"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n paths = [[0 for j in range(k)] for i in range(k)]\n ans = 0\n for num in nums:\n cur = num % k\n for i in range(k):\n paths[i][cur] = paths[cur][i] + 1\n ans = max(ans, paths[i][cur])\n return ans","runtime":"1656"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n lookup = defaultdict(lambda : -1)\n\n dp_start = [[0] * k for _ in range(n)]\n dp = [0] * (n + 1)\n for i in range(n - 1, -1, -1):\n for x in range(k):\n pair = lookup[(x - nums[i]) % k]\n dp_start[i][x] = 1 + (dp_start[pair][x] if pair >= 0 else 0)\n take = max(dp_start[i][x] for x in range(k))\n skip = dp[i + 1]\n dp[i] = max(take, skip)\n\n lookup[nums[i] % k] = i\n\n return dp[0]","runtime":"1656"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n best=0\n def find_max(c):\n hashmap=defaultdict(int)\n for i in nums:\n i%=k\n hashmap[i]=hashmap[(c-i)%k]+1\n return max(hashmap.values())\n for i in range(k):\n best=max(best,find_max(i))\n return best\n \n\n \n \n\n ","runtime":"1702"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # dp[j][k1], j -> ends in j, with mod k, value is max\n dp = [[1] * k for _ in range(len(nums))]\n # dp = [1] * k \n\n max_seen = 0\n for i in range(len(nums)):\n for j in range(i + 1, len(nums)):\n k1 = (nums[i] + nums[j]) % k\n dp[j][k1] = dp[i][k1] + 1\n max_seen = max(max_seen, dp[j][k1])\n\n return max_seen\n \n\n ","runtime":"1702"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n def pdp(dp):\n for i,r in enumerate(dp):\n print(\"A\",i,r)\n print()\n dp = [[0 for _ in range(k)] for _ in range(k)]\n nums = [n%k for n in nums]\n #print(nums)\n \n res = 0\n for a in nums:\n for b in range(k):\n dp[a][b] = dp[b][a]+1\n res = max(res,dp[a][b])\n #print(\"A\",a,\" B\",b)\n #pdp(dp)\n return res\n \n\n \n \n\n\n\n ","runtime":"1841"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n def fn(r, k):\n dp = [0] * k\n for x in nums:\n rx = x % k\n dp[rx] = max(dp[rx], dp[(r - rx) % k] + 1)\n res = max(dp)\n return res\n\n ans = max(fn(r, k) for r in range(k))\n print(ans)\n return ans","runtime":"1841"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n\n for remainder in range(k):\n remainder_counts = [0] * k\n\n for num in nums:\n # Calculate the remainder of the current number when divided by k\n current_remainder = num % k\n \n # Calculate the remainder that would achieve the target remainder when added to the current number\n previous_remainder = (remainder - current_remainder) % k\n\n # Update the dp array\n remainder_counts[current_remainder] = max(remainder_counts[current_remainder], remainder_counts[previous_remainder] + 1)\n \n # Update the result with the maximum value found in the dp array for the current target remainder\n max_length = max(max_length, max(remainder_counts))\n \n return max_length\n\n\n\n\n\n # max_len = 0\n # remainders = [ [0] * k for remainder in range(k) ]\n # for num in nums:\n # for remainder_value in range(k):\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n # if max_len < remainders[remainder_value][num % k]:\n # max_len = remainders[remainder_value][num % k]\n \n # return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1887"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n \n for target_remainder in range(k):\n\n dp = [0] * k\n \n for num in nums:\n current_remainder = num % k\n previous_remainder = target_remainder - current_remainder\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n \n max_length = max(max_length, max(dp))\n \n return max_length","runtime":"1887"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = -float('inf')\n\n for target in range(k):\n\n dp = [0] * k\n\n for num in nums:\n current_remainder = num % k\n previous_remainder = target - current_remainder\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n\n max_length = max(max_length, max(dp))\n\n return max_length","runtime":"1933"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n \n # Iterate over each possible remainder value from 0 to k-1\n for target_remainder in range(k):\n\n # Initialize the dynamic programming array to store the maximum length for each remainder\n dp = [0] * k\n \n # Iterate over each number in the input array\n for num in nums:\n # Calculate the remainder of the current number when divided by k\n current_remainder = num % k\n \n # Calculate the remainder that would achieve the target remainder when added to the current number\n previous_remainder = (target_remainder - num) % k\n\n # Update the dp array\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n \n # Update the result with the maximum value found in the dp array for the current target remainder\n max_length = max(max_length, max(dp))\n \n return max_length\n\n\n\n\n\n # max_len = 0\n # remainders = [ [0] * k for remainder in range(k) ]\n # for num in nums:\n # for remainder_value in range(k):\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n # if max_len < remainders[remainder_value][num % k]:\n # max_len = remainders[remainder_value][num % k]\n \n # return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","runtime":"1933"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0 # Initialize the maximum length of the valid subsequence\n length = len(nums) # Length of the input array nums\n\n # Iterate over all possible remainders (0 to k-1)\n for i in range(k):\n mp = {} # Dictionary to store the count of each remainder\n for j in range(length):\n # Calculate the required remainder that should match with current subsequence\n lookup_key = ((i + k) - (nums[j] % k)) % k\n \n # If the lookup_key is not found in the dictionary, initialize it\n if mp.get(lookup_key) is None:\n mp[nums[j] % k] = 1\n continue\n \n # Calculate the length of the current subsequence ending at index j\n current_length = mp[lookup_key] + 1\n \n # Update the maximum length if the current subsequence length is greater\n max_length = max(max_length, current_length)\n \n # Update the dictionary with the count of the current remainder\n mp[nums[j] % k] = current_length\n \n return max_length # Return the maximum length of the valid subsequence","runtime":"1979"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if not nums: return 0\n \n \n n = len(nums)\n res = 0\n for i in range(k):\n mem = [0] * k\n for n in nums: \n cur = n % k\n prev = (i - n) % k\n mem[cur] = max(mem[cur], mem[prev]+1)\n \n res = max(res, max(mem))\n \n \n \n return res\n","runtime":"1979"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * k for _ in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j - x + k) % k\n f[x][y] = f[y][x] + 1\n ans = max(ans, f[x][y])\n return ans\n","runtime":"2025"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for _ in range(k)] for _ in range(len(nums))]\n mx = 0\n for i in range(len(nums) - 2, -1, -1):\n for j in range(i + 1, len(nums)):\n v = (nums[i] + nums[j]) % k\n temp = 1 + dp[j][v]\n dp[i][v] = max(dp[i][v], temp)\n mx = max(mx, max(dp[i]))\n return mx + 1","runtime":"2025"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n lookup = defaultdict(lambda : -1)\n\n dp = [[0] * k for _ in range(n)]\n ans = 0\n for i in range(n - 1, -1, -1):\n for x in range(k):\n pair = lookup[(x - nums[i]) % k]\n dp[i][x] = 1 + (dp[pair][x] if pair >= 0 else 0)\n ans = max(ans, dp[i][x])\n lookup[nums[i] % k] = i\n\n return ans","runtime":"2071"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * k for _ in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j - x + k) % k\n f[x][y] = f[y][x] + 1\n ans = max(ans, f[x][y])\n return ans","runtime":"2071"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n DP = [[0] * k for _ in range(k)]\n for i in range(k):\n DP[0][i] = 0\n \n for num in nums:\n mod_num = num % k\n temp = DP[mod_num].copy()\n \n for i in range(k):\n x_mod = (mod_num + i) % k\n temp[x_mod] = max(temp[x_mod], DP[i][x_mod] + 1)\n DP[mod_num] = temp\n \n # print(DP)\n \n return max(max(row) for row in DP)","runtime":"2117"},{"code":"# Let A be subsequence , with some mod\n# say mod = (A[i] + A[i+1]) % k = (A[i + 1] + A[i + 2]) % k = ...\n# DP[currNum][mod] denotes the maximum length of the mod subsequence (subsequence having this mod) ending with currNum\n# Say we at index i , currNum = nums[i]\n# This currNum can be a part of any of subsequence having mod = [0 , k-1]\n# So , we'll try to make our currNum to be a part of all possible subsequenes and choose the maximum out of it\n# For currNum to be a part of mod subsequence\n# => (currNum + prevNum) % k = mod\n# => prevNum = (mod - currNum + k) % k\n# DP[currNum][mod] = max(DP[currNum][mod] , 1 + DP[prevNum][mod])\n\n# Time Complexity : O(N * K)\n# Space Complexity : O(K * K)\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n f = [[0] * k for _ in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j - x + k) % k\n f[x][y] = f[y][x] + 1\n ans = max(ans, f[x][y])\n return ans\n\nclass SolutionDP:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n maxi = 1\n for num in nums:\n currNum = num % k\n for mod in range(k):\n prevNum = (mod - currNum + k) % k\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\n maxi = max(maxi , dp[currNum][mod])\n return maxi\n\n# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# hashMap = collections.defaultdict(int)\n# prevMod = float(\"inf\")\n\n# for i in range(len(nums) - 1):\n# mod = (nums[i] + nums[i + 1]) % k\n# if mod == prevMod:\n# hashMap[mod] += 1\n# else:\n# prevMod = mod\n# hashMap[mod] += 2\n\n# return max(hashMap.values())\n\n# [1,4,2,3,1,4]\n# 1, 4 % 3 = 2\n# 4, 2 % 3 = 3\n# 2, 3 % 3 = 2\n# 3, 1 % 3 = 1\n# 1, 4 % 3 = 2\n\n1, 4, 2, 3, 1,4","runtime":"2117"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n for num in nums:\n mod = num % k\n for i in range(k):\n dp[i][mod] = max(dp[i][mod], 1 + dp[i][(i - mod + k) % k])\n return max(max(row) for row in dp)\n","runtime":"2163"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(len(nums))]\n last = [-1] * k\n ret = 0\n\n n = len(nums)\n for i in range(n):\n for r in range(k):\n d = (r - nums[i] % k + k) % k\n if last[d] != -1:\n j = last[d]\n dp[i][r] = dp[j][r] + 1\n else:\n dp[i][r] = 1\n ret = max(ret, dp[i][r])\n\n last[nums[i] % k] = i\n\n return ret","runtime":"2209"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n ans = 0\n for y in nums:\n for x in range(k):\n dp[y % k][x] = 1 + dp[(x - y) % k][x]\n ans = max(ans, dp[y % k][x])\n return ans","runtime":"2209"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = [[1] * k for _ in range(n)]\n ans = 1\n for i in range(1, n):\n for j in range(i):\n f[i][(nums[i] + nums[j]) % k] = f[j][(nums[i] + nums[j]) % k] + 1\n ans = max(ans, f[i][(nums[i] + nums[j]) % k])\n return ans\n","runtime":"2255"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n rem_dict = [{} for i in range(n)]\n max_len = 0\n for i in range(n):\n for j in range(i):\n rem = (nums[i] + nums[j])%k\n if rem in rem_dict[j]:\n rem_dict[i][rem] = rem_dict[j][rem] + 1\n else:\n rem_dict[i][rem] = 2\n max_len = max(max_len, rem_dict[i][rem])\n return max_len","runtime":"2255"},{"code":"class Solution:\n def __init__(self):\n self.dp = None\n self.k = 0\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k)] for j in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j-x+k)%k\n dp[x][y] = dp[y][x]+1\n ans = max(ans, dp[x][y])\n return ans","runtime":"2302"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0]*k for _ in range(n)]\n res = 0\n \n last = defaultdict(int)\n for i in range(n):\n for t in range(k):\n d = ((t-nums[i]%k)+k)%k\n if d in last:\n j = last[d]\n dp[i][t] = dp[j][t] + 1\n \n else:\n dp[i][t] = 1\n res = max(res, dp[i][t])\n \n last[nums[i]%k] = i\n \n return res\n ","runtime":"2302"},{"code":"\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if len(nums) <= 2:\n return len(nums)\n\n max_lengths = [[1] * k for _ in range(len(nums))]\n\n answer = 2\n for i in range(len(nums)):\n for j in range(i):\n m = (nums[i] + nums[j]) % k\n max_lengths[i][m] = max(\n max_lengths[i][m],\n 1 + max_lengths[j][m],\n )\n answer = max(\n answer,\n max_lengths[i][m],\n )\n\n return answer","runtime":"2348"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # 7:15\n\n matrix = [[0]*k for _ in range(k)]\n ans = 0\n\n for v in nums:\n v = v % k\n for j in range(k):\n matrix[v][j] = max(matrix[v][j], matrix[j][v] + 1)\n ans = max(ans, matrix[v][j])\n return ans\n\n","runtime":"2348"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # (sub[0] + sub[1])%k == (sub[1] + sub[2]%k)\n\n\n # the interesting thing that one item has to be part of 2 elements\n # two sums\n # (x + y)%k == (y+z)%k\n # (x + y) == (y+z)*d\n # x + y == dy + dz\n # x + dz == (d-1)y\n\n\n # 1 4 2\n # for all remainders 1-7 \n # 1 4 3\n\n # for all endings with remainder 0 ... k-1, that have a previous ending at cur remainder\n\n\n dp = [[0]*k for _ in range(k)]\n\n res = 0\n\n for num in nums:\n rem = num%k\n\n for i in range(k):\n dp[rem][i] = max(dp[rem][i], 1 + dp[i][rem])\n res = max(res, dp[rem][i])\n\n return res\n ","runtime":"2394"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # ex: k is 3\n # 1 5 4\n # 5 is random filling, but 1 and 4 should always have the same remainder\n # (the problem is that once the random filling is chosen, you have to stick\n # to numbers having the same remainder)\n availableRests = set([x % k for x in nums])\n\n # dp[i][j] - length of the longest subsequence with\n # the remainder j ending in nums[i] % k\n n = len(nums)\n dp = [[0 for _ in range(k)] for _ in range(k)]\n \n alternating = []\n for num in nums:\n current = num % k\n\n # iterate through all the possible rests of the sum(a, b) % k\n for rest in range(k):\n prev = (k + rest - current) % k\n dp[current][rest] = max(dp[current][rest], dp[prev][rest] + 1)\n return max([max(x) for x in dp])","runtime":"2394"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # we can have a dynamic programming table of size\n # k called remainders, \n # Overal time compleity is O(n * n) because the \n # lookup of the table is O(1) essentially LIS\n n = len(nums)\n dp = [[1] * k for _ in range(n)]\n MAX = 1\n for i in range(n):\n for j in range(i):\n rem = (nums[i] + nums[j]) % k\n dp[i][ rem ] = max(dp[j][rem] + 1, dp[i][rem])\n MAX = max(MAX, dp[i][rem])\n return MAX","runtime":"2440"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # exp: https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5389322/yes-it-s-a-2d-dp/\n # O(nk) O(k^2)\n\n # 2D dp with mod\n # dp[currNum][mod] denotes the maximum length of the mod subsequence (subsequence having this mod) ending with currNum\n dp = [[0] * k for _ in range(k)]\n max_len = 0\n \n for num in nums:\n cur = num % k\n for mod in range(k):\n dp[cur][mod] = max(dp[cur][mod], dp[mod][cur] + 1)\n max_len = max(max_len, dp[cur][mod])\n \n return max_len","runtime":"2440"},{"code":"class Solution:\n def maximumLength(self, nums: list[int], k: int) -> int:\n ans=[]\n for i in range(k):\n arr=[]\n for _ in range(k):\n arr.append(0)\n for x in nums:\n arr[x%k]=max(arr[(i+k-x%k)%k]+1, arr[x%k])\n ans.append(max(arr))\n return max(ans)","runtime":"2486"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''\n dp[i][mod] = dp[j][mod] + 1\n '''\n n = len(nums)\n if n == 0 or k <= 0:\n return 0\n dp = [[0]*k for _ in range(n)] ##record each position, how many elements in there\n result = 0\n for i in range(n):\n for j in range(i):\n mod = (nums[i] + nums[j])%k\n dp[i][mod] = max(dp[i][mod], dp[j][mod]+1)\n result = max(result, dp[i][mod])\n return result+1\n ","runtime":"2486"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = {}\n for right in range(len(nums)):\n for left in range(right):\n curr = (nums[right]+nums[left])%k\n dp[(right, curr)] = dp.get((left, curr), 1) + 1\n return max(dp.values())","runtime":"2532"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for j in range(k):\n dp[j][nums[0]%k] = 1\n for i in range(1, len(nums)):\n for j in range(k):\n # dp[j][nums[i]%k] = max(dp[nums[i]%k][j] + 1, dp[j][nums[i]%k])\n dp[j][nums[i]%k] = dp[nums[i]%k][j] + 1\n \n ans = 0\n for i in range(k):\n for j in range(k):\n ans = max(ans, dp[i][j])\n return ans\n\n\n\n # ids = defaultdict(list)\n # for i, num in enumerate(nums):\n # ids[num%k].append(i)\n # ans = -1\n # for i in range(k):\n # for j in range(i+1, k):\n # if ans >= len(ids[i])+len(ids[j]):\n # break\n \n","runtime":"2532"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n N = len(nums)\n dp = [[0] * k for _ in range(N)]\n res = 0\n for i in reversed(range(N - 1)):\n for j in range(i + 1, N):\n mod = (nums[i] + nums[j]) % k\n dp[i][mod] = max(dp[i][mod], 1 + dp[j][mod])\n res = max(res, dp[i][mod] + 1)\n return res\n ","runtime":"2578"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n max_len = 0\n \n for num in nums:\n for j in range(k):\n remainder = num % k\n dp[remainder][j] = max(dp[remainder][j], dp[j][remainder] + 1)\n max_len = max(max_len, dp[remainder][j])\n \n return max_len","runtime":"2578"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1] * k for _ in range(n)]\n res = 0\n for i in range(n):\n for j in range(i):\n s = (nums[i] + nums[j]) % k\n dp[i][s] = max(dp[i][s], 1 + dp[j][s])\n for s in range(k):\n res = max(res, dp[i][s])\n return res\n","runtime":"2624"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n max_len = 0\n for num in nums:\n for j in range(k):\n remainder = num % k\n dp[remainder][j] = max(dp[remainder][j], dp[j][remainder] + 1)\n max_len = max(max_len, dp[remainder][j])\n return max_len","runtime":"2624"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''dp = [[[-1 for _ in range(k)] for _ in range(len(nums))] for _ in range(len(nums))]\n def rec(i,prev_index,prev_rem):\n if i>=len(nums):\n return 0\n if dp[i][prev_index][prev_rem]!=-1:\n return dp[i][prev_index][prev_rem]\n new_rem = k + 1\n if prev_index!=-1:\n new_rem = abs(nums[i]+nums[prev_index])%k\n max_len = 0\n if prev_index == -1:\n max_len = max(rec(i+1,i,prev_rem),rec(i+1,prev_index,prev_rem))\n elif prev_rem == -1:\n max_len = max(1 + rec(i+1,i,abs(nums[i]-nums[prev_index])%k),rec(i+1,prev_index,prev_rem))\n elif new_rem==prev_rem:\n max_len = 1 + rec(i+1,i,new_rem)\n else:\n max_len = rec(i+1,prev_index,prev_rem)\n dp[i][prev_index][prev_rem] = max_len\n return max_len'''\n n = len(nums) \n ans = 1\n dp = [[1 for _ in range(k)] for _ in range(n)]\n for j in range(n):\n for i in range(j+1,n):\n x = (nums[i] + nums[j])%k\n dp[i][x] = max(dp[i][x], 1 + dp[j][x])\n ans = max(ans,dp[i][x])\n return ans","runtime":"2670"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [{} for _ in range(len(nums))]\n ans = 0\n for i in range(len(nums)):\n for j in range(i):\n rem = (nums[i] + nums[j]) % k\n if dp[i].get(rem, 0) < dp[j].get(rem, 0) + 1:\n dp[i][rem] = dp[j].get(rem, 0) + 1\n ans = max(ans, dp[i][rem])\n return ans + 1\n\n \n \n ","runtime":"2670"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n dp = [[0] * k for _ in range(k)]\n nums_proc = [n % k for n in nums]\n\n #print(f'{nums_proc=}')\n\n result = -math.inf\n for n_mod in nums_proc:\n #print(f'ending in {n_mod=}')\n\n for sum_mod in range(k):\n #print(f' subsequence sum {sum_mod=}')\n target_prev_mod = (sum_mod - n_mod) % k\n #print(f' target mod {target_prev_mod=}')\n dp[n_mod][sum_mod] = max(dp[n_mod][sum_mod], 1 + dp[target_prev_mod][sum_mod])\n result = max(result, dp[n_mod][sum_mod])\n\n #print(f'{dp=}')\n return result","runtime":"2716"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * k for _ in range(k)]\n\n ans = 0\n for num in nums:\n for j in range(k):\n m = num % k\n dp[m][j] = max(dp[m][j], dp[j][m] + 1)\n ans = max(ans, dp[m][j])\n\n \n return ans","runtime":"2716"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n lookup = defaultdict(list)\n for i, x in enumerate(nums):\n lookup[x % k].append(i)\n\n dp_start = [[0] * k for _ in range(n)]\n dp = [0] * (n + 1)\n for i in range(n - 1, -1, -1):\n for x in range(k):\n pair = lookup[(x - nums[i]) % k]\n l, r = 0, len(pair)\n while l < r:\n m = (l + r) // 2\n if pair[m] > i:\n r = m\n else:\n l = m + 1\n dp_start[i][x] = 1 + (dp_start[pair[l]][x] if l < len(pair) else 0)\n take = max(dp_start[i][x] for x in range(k))\n skip = dp[i + 1]\n dp[i] = max(take, skip)\n\n return dp[0]","runtime":"2762"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # 7:15\n\n matrix = [[0]*k for _ in range(k)]\n ans = 0\n\n for v in nums:\n v = v % k\n for i in range(k):\n j = (i+v) % k\n matrix[v][j] = max(matrix[v][j], matrix[i][j] + 1)\n ans = max(ans, matrix[v][j])\n return ans\n\n","runtime":"2762"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n positions = collections.defaultdict(list)\n for pos, val in enumerate(nums):\n v = val % k\n nums[pos] = v\n positions[v].append(pos)\n\n ans = 0\n for p in range(k):\n arr = [1] * n\n for i in range(n-1, -1, -1):\n r = (p-nums[i]) % k\n idx = bisect_right(positions[r], i)\n if idx < len(positions[r]):\n arr[i] = max(arr[i], arr[positions[r][idx]] + 1)\n ans = max(ans, arr[i])\n return ans","runtime":"2809"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n dp = [[0] * k for _ in range(k)] # cur, rem\n res = 0\n for n in nums:\n cur = n % k\n for rem in range(k):\n prev = (rem - cur) % k\n dp[cur][rem] = max(dp[cur][rem], dp[prev][rem] + 1)\n res = max(res, dp[cur][rem])\n return res","runtime":"2809"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n maxi = 1\n for num in nums:\n rem = num % k\n for i in range(k):\n pn = (i-rem+k)%k\n dp[rem][i] = max(dp[rem][i], 1 + dp[pn][i])\n maxi = max(maxi, dp[rem][i])\n return maxi","runtime":"2855"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n # [target mod, last number]\n dp = [[0 for _ in range(k)] for _ in range(k)]\n\n for num in nums:\n for t in range(k):\n ln = (t - num) % k\n dp[t][num % k] = max(dp[t][num % k], dp[t][ln] + 1)\n\n # print(dp)\n\n return max(max(dp[i]) for i in range(k))\n","runtime":"2855"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n maxi = 1\n for num in nums:\n currNum = num % k\n for mod in range(k):\n prevNum = (mod - currNum + k) % k\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\n maxi = max(maxi , dp[currNum][mod])\n return maxi","runtime":"2901"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [ [1] * len(nums) for i in range(k) ]\n # print(dp)\n max_length = 0\n for i in range(len(nums)):\n for j in range(i-1, -1, -1):\n cur_sum = nums[i] + nums[j]\n dp[cur_sum % k][i] = max(dp[cur_sum % k][i], dp[cur_sum % k][j] + 1)\n max_length = max(max_length, dp[cur_sum % k][i])\n return max_length\n\n ","runtime":"2901"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = {}\n for i in range(n):\n for j in range(i):\n f[(i,(nums[i]+nums[j])%k)] = 1 + f.get((j,(nums[i]+nums[j])%k),1)\n return max(f.values())\n ","runtime":"2947"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n Optimized DP approach.\n Time: O(n * k)\n Space: O(k * k)\n \"\"\"\n dp = [[0] * k for _ in range(k)]\n res = 1\n for num in nums:\n cur = num % k\n for mod in range(k):\n # cuz (prev + cur) % k = mod -> prev = (mod - cur) % k, then + k to make it non-negative\n prev = (mod - cur + k) % k\n dp[cur][mod] = max(dp[cur][mod] , 1 + dp[prev][mod])\n res = max(res , dp[cur][mod])\n return res\n","runtime":"2947"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = [[0]*k for _ in range(k)]\n maxi = 1\n for num in nums:\n curr = num%k\n for mod in range(k):\n prev = (mod - curr+k) %k \n ans[curr][mod] = max(ans[curr][mod], 1+ans[prev][mod])\n maxi = max(maxi,ans[curr][mod])\n \n return maxi\n \n ","runtime":"2993"},{"code":"'''\n\nFor currNum to be a part of mod subsequence\n=> (currNum + prevNum) % k = mod\n=> prevNum = (mod - currNum + k) % k\nmod lies between (0, k)\nDP[currNum][mod] = max(DP[currNum][mod] , 1 + DP[prevNum][mod])\nO(n*k)\nO(n*k)\n'''\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n ##2d array in python: arr = [[0]*cols]*rows\n maxi = 1\n for num in nums:\n currNum = num % k\n for mod in range(k): ## in range of k\n prevNum = (mod - currNum + k) % k\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\n maxi = max(maxi , dp[currNum][mod])\n return maxi","runtime":"2993"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''\n 變成%k了, 不過長度只有1000\n 可以吃n平方\n 變成\n 0~k-1種數字的cnt\n 因為長度短所以大概N*N下去吧 \n # 718 / 732 testcases passed TLE\n 是DP題目\n \n '''\n\n dp = defaultdict(Counter)\n for n in nums:\n for p in range(k):\n n_mod = n % k \n dp[p][n_mod] = dp[n_mod][p] +1\n \n return max(max(cnts.values())for cnts in dp.values())","runtime":"3039"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n 2D DP\n Time: O(n * k)\n Space: O(k * k)\n \"\"\"\n # dp[i][j] means the len of the longest valid subsequence that ends with a number mod k equals i, \n # and the sum of every two consecutive elements in this subsequence mod k equals to j\n dp = [[0] * k for _ in range(k)]\n res = 1\n for num in nums:\n cur = num % k\n for mod in range(k):\n # cuz (prev + cur) % k = mod -> prev = (mod - cur) % k, then + k to make it non-negative\n prev = (mod - cur + k) % k\n dp[cur][mod] = max(dp[cur][mod] , 1 + dp[prev][mod])\n res = max(res , dp[cur][mod])\n return res\n","runtime":"3039"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k) -> int:\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n","runtime":"3085"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)] #[i][j] the length of the subsequence with remainder i and module j\n max_len = 0\n\n # (x + y) % k = mod => x % k + y % k = mod\n \n for num in nums:\n currNum = num % k\n for j in range(k):\n prev = (j - currNum) % k\n dp[currNum][j] = max(dp[currNum][j], dp[prev][j] + 1)\n max_len = max(max_len, dp[currNum][j])\n\n return max_len","runtime":"3085"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], K: int) -> int:\n pos_to_next_mod = [{} for _ in range(len(nums))]\n mod_to_earliest_pos = {}\n mod_to_earliest_pos[nums[len(nums)-1]%K] = len(nums)-1\n\n for i in range(len(nums)-2, -1, -1):\n pos_to_next_mod[i] = mod_to_earliest_pos.copy()\n mod_to_earliest_pos[nums[i]%K] = i\n\n \n # @cache\n def max_length_starting_from(i, prev_mod):\n result = 1\n if prev_mod in pos_to_next_mod[i]:\n result += max_length_starting_from(pos_to_next_mod[i][prev_mod], nums[i]%K)\n return result\n\n\n result = 0\n for start_i in range(len(nums)):\n for start_mod in range(K):\n result = max(result, max_length_starting_from(start_i, start_mod))\n return result\n\n\n# Time O(N*k)\n# Space O(N*k)","runtime":"3131"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\n dp[a][b] 的含义是：以模数 a 结尾，并且前一个数字的模数为 b 的最长子序列的长度。\n\t 状态转移公式 dp[b][a % k] = dp[a % k][b] + 1 的目的是通过动态规划，将每个数字 a 逐步加入子序列\n \"\"\"\n dp = defaultdict(Counter)\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n \n return max(max(dp[a].values()) for a in range(k))\n","runtime":"3131"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\n where dp[a][b] means the length of subsequence ending with ...,a,b\n dp[b][a % k] 表示以模数为 a % k 的数字 b 结尾的最长有效子序列的长度。\n \"\"\"\n dp = defaultdict(Counter)\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n \n return max(max(dp[a].values()) for a in range(k))\n","runtime":"3177"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/discuss/5389322/Yes-it's-a-2d-DP-!!\n l = len(nums)\n dp = [[0 for y in range(k)] for x in range(k)]\n \n result = 0\n \n for i in range(1, l+1):\n val = nums[i-1] % k\n for j in range(k):\n prev_val = (j + k - val) % k\n dp[val][j] = max(dp[val][j], dp[prev_val][j] + 1)\n \n result = max(result, dp[val][j])\n return result","runtime":"3177"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = defaultdict(Counter)\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n ","runtime":"3223"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n if not nums: return 0\n \n \n mem = collections.defaultdict(Counter)\n n = len(nums)\n res = 0\n for n in nums:\n for i in range(k):\n mem[i][n % k] = mem[n % k][i] + 1 \n \n \n return max(max(mem[a].values()) for a in range(k))\n","runtime":"3269"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0 for _ in range(k)] for _ in range(k)]\n \n max_len = 0\n for num in nums:\n curr = num % k\n for mod in range(k):\n prev = (mod + k - curr) % k\n dp[curr][mod] = max(dp[curr][mod], dp[prev][mod] + 1)\n max_len = max(max_len, dp[curr][mod])\n \n return max_len\n","runtime":"3315"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n dp = [[0 for _ in range(k)] for _ in range(k)]\n maxLen = 0\n \n for mod in range(k):\n for num in nums:\n curr = num % k\n prev = (mod - curr + k ) % k\n \n dp[curr][mod] = max(dp[curr][mod], dp[prev][mod] + 1)\n maxLen = max(maxLen, dp[curr][mod])\n \n return maxLen\n ","runtime":"3315"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], K: int) -> int:\n dp = defaultdict(lambda: defaultdict(int))\n result = 0\n for val in nums:\n for prev_mod in range(K):\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\n result = max(result, dp[prev_mod][val%K])\n return result\n\n\n# Time O(N*k)\n# Space O(N*k)\n\n# %k == constant -> alternating mod values\n # Note, also true if all mod values 0, but this also falls under alternating mod values\n\n# if end with element a%k, having b as prev mod\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\n# dp[b][a%k] = dp[a%k][b] +1","runtime":"3362"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n\n\n","runtime":"3362"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \"\"\"\n (a + b) mod k = (b + c) mod k\n (a + b - (b + c)) mod k = 0\n (a - c) mod k = 0\n a 和 c 关于 模 k 同余\n a and c are congruent modulo k\n 如果把nums[i] 变成 nums[i]mod k, 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。（即 a，c）\n dp[y][x] : 表示最后两项模 k 分别为 y 和 x 的子序列的长度. \n dp[y][x] = dp[x][y] + 1， consider “子序列奇数项都相同，偶数项都相同”\n \"\"\"\n dp = defaultdict(Counter)\n for a in nums:\n for b in range(k): # 这个 for loop是所有可能的 mod值\n dp[b][a % k] = dp[a % k][b] + 1\n \n return max(max(dp[a].values()) for a in range(k))\n","runtime":"3408"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0 for j in range(k)] for i in range(n)]\n \n dp[0][nums[0]%k] = 1\n for i in range(1, n):\n dp[i][nums[i]%k] = 1\n for j in range(i-1, -1, -1):\n new_num = (nums[j] + nums[i])%k\n dp[i][new_num] = max(dp[i][new_num], max(dp[j][new_num] + 1, 2))\n ans = 0\n for i in range(1, n):\n for j in range(k):\n ans = max(ans, dp[i][j])\n return ans\n ","runtime":"3454"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n n = len(nums)\n for i in range(n):\n nums[i] %= k\n\n\n dp = [[-1]*k for i in range(k)]\n ans = [[0]*k for i in range(k)]\n pr = max(Counter(nums).values())\n for i, num in enumerate(nums):\n for x in range(k):\n if num != x and dp[num][x] == 1:\n dp[num][x] = 0\n ans[num][x] = max(ans[x][num] + 1, ans[num][x])\n pr = max(pr, ans[num][x])\n \n \n for y in range(k):\n if num != y and dp[y][num] != 1:\n dp[y][num] = 1\n ans[y][num] = max(ans[y][num], ans[num][y] + 1)\n pr = max(pr, ans[y][num])\n\n return pr\n\n ","runtime":"3454"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n ans = 0\n for i in nums:\n cur = i%k\n for j in range(k):\n # dp[(j+cur)%k][cur] = max(dp[(j+cur)%k][cur],dp[(j+cur)%k][j]+1)\n dp[cur][(j+cur)%k] = max(dp[cur][(j+cur)%k],dp[j][(j+cur)%k]+1)\n ans = max(ans,dp[cur][(j+cur)%k])\n # ans = max(ans,max(dp[cur]))\n return ans","runtime":"3500"},{"code":"# Data Structures and Algorithm Used:\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\n\n# Short Intuition:\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\n\n# Detailed Intuition:\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\n# - The final result is the maximum value found in this dictionary.\n\n# Pseudocode:\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\n# 2. For each number `n` in `nums`:\n# a. Iterate over all possible `i` from `0` to `k-1`.\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\n# 3. The answer is the maximum value in the `count` dictionary.\n\nfrom collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n # Step 1: Initialize the dictionary to keep track of subsequence counts\n count = defaultdict(int)\n \n # Step 2: Iterate over each number in the array\n for n in nums:\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\n for i in range(k):\n # Step 2b: Update the count for the pair (i, n%k)\n count[(i, n % k)] = count[(n % k, i)] + 1\n \n # Step 3: Return the maximum value found in the count dictionary\n return max(count.values())\n\n# Time Complexity:\n# - O(n * k) where n is the length of the array and k is the given integer. \n# This is because for each element in the array, we perform `k` updates in the dictionary.\n\n# Space Complexity:\n# - O(k^2) for storing the count of subsequences in the dictionary.\n","runtime":"3500"},{"code":"import collections\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n d = [[] for _ in range(k)]\n for i in range(len(nums)):\n d[nums[i] % k].append(i)\n print(d)\n opt = max(len(x) for x in d)\n for i in range(k):\n for j in range(k):\n if i == j:\n continue\n #print(\"i, j: \", i, j)\n if not d[i] and not d[j]:\n continue\n c = 1\n x, y = 0, 0\n prev = -1\n if not d[i] or not d[j]:\n opt = max(opt, 1)\n continue\n else:\n prev = nums[min(d[i][x], d[j][y])] % k\n while x < len(d[i]) or y < len(d[j]):\n if x >= len(d[i]):\n if prev != nums[d[j][y]] % k:\n c += 1\n break\n elif y >= len(d[j]):\n if prev != nums[d[i][x]] % k:\n c += 1\n break\n else:\n if d[i][x] < d[j][y]:\n if nums[d[i][x]] % k == prev:\n x += 1\n continue\n prev = nums[d[i][x]] % k\n x += 1 \n c += 1\n else:\n if nums[d[j][y]] % k == prev:\n y += 1\n continue\n prev = nums[d[j][y]] % k\n y += 1\n c += 1\n #print(\"c: \", c) \n opt = max(opt, c) \n return opt","runtime":"3546"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k) -> int:\n count = defaultdict(int)\n for n in nums:\n for i in range(k):\n count[(i, n%k)] = count[(n%k, i)] + 1\n return max(count.values())","runtime":"3592"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\n # complexity O(n*k)\n \n numsMods = [n % k for n in nums]\n\n from collections import defaultdict\n harsh = defaultdict(int)\n \n sol = 0\n for n in numsMods:\n # print(n, harsh)\n\n for c in range(k):\n if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\n if (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\n # else: harsh[(c,n)] += 1\n\n for key, count in harsh.items():\n sol = max(sol, count)\n \n # print(numsMods)\n # print(harsh)\n \n return sol\n\n\n\n# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\n# # complexity O(n*k*k) to slow\n \n# numsMods = [n % k for n in nums]\n \n# counts = []\n# for m in range(k):\n# for c in range(k):\n# cond = m\n# count = 0\n# for n in numsMods:\n# if n == cond:\n# count += 1\n# cond = c if cond == m else m\n# counts.append(count)\n \n# return max(counts)","runtime":"3592"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n counts = defaultdict(int)\n seen = set()\n nums = [n%k for n in nums]\n for n in nums:\n for i in range(k):\n counts[(i, n)] = counts[(n, i)]+1\n return max([counts[x] for x in counts])\n \n\n","runtime":"3638"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(k)]\n maxi = 1\n for num in nums:\n currNum = num % k\n for mod in range(k):\n prevNum = (mod - currNum + k) % k\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\n maxi = max(maxi , dp[currNum][mod])\n return maxi","runtime":"3684"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k) -> int:\n count = defaultdict(int)\n for n in nums:\n for i in range(k):\n count[(i, n%k)] = count[(n%k, i)] + 1\n return max(count.values())","runtime":"3730"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n from collections import Counter\n from itertools import permutations\n\n # Make it simpler by converting into mod k\n nums = [num % k for num in nums]\n\n # Answers can be composed of only one mod type\n modCounter = Counter(nums)\n ans = max(modCounter.values())\n\n alternativeSeqDict = {}\n # Try all combinations\n for i, j in list(permutations(range(k), 2)):\n\n # If maximum possible sequence is shorter than already found, we skip\n if modCounter[i] + modCounter[j] <= ans:\n continue\n if (j, i) in alternativeSeqDict and alternativeSeqDict[(j, i)] + 1 <= ans:\n continue\n\n # Find sequence with alternating (i, j)\n alternateSeq, searchIdx = 0, 0\n searchNums = [i, j]\n for num in nums:\n if num == searchNums[searchIdx]:\n searchIdx = 1 - searchIdx\n alternateSeq += 1\n\n # Store the value for (i, j)-alternating sequence for time efficiency\n alternativeSeqDict[(i, j)] = alternateSeq\n\n # Update max value\n ans = max(ans, alternateSeq)\n\n return ans","runtime":"3730"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n ans = 0\n dp = [defaultdict(int) for i in range(n)]\n for i in range(n):\n for j in range(i):\n mod = (nums[i]+nums[j]) % k\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\n ans = max(ans, dp[i][mod])\n # print(dp)\n return ans + 1","runtime":"3776"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\n # complexity O(n*k)\n \n numsMods = [n % k for n in nums]\n\n from collections import defaultdict\n harsh = defaultdict(int)\n \n sol = 0\n for n in numsMods:\n # print(n, harsh)\n\n for c in range(k):\n if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\n\n for c in range(k):\n if (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\n # else: harsh[(c,n)] += 1\n\n for key, count in harsh.items():\n sol = max(sol, count)\n \n # print(numsMods)\n # print(harsh)\n \n return sol\n\n\n\n# class Solution:\n# def maximumLength(self, nums: List[int], k: int) -> int:\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\n# # complexity O(n*k*k) to slow\n \n# numsMods = [n % k for n in nums]\n \n# counts = []\n# for m in range(k):\n# for c in range(k):\n# cond = m\n# count = 0\n# for n in numsMods:\n# if n == cond:\n# count += 1\n# cond = c if cond == m else m\n# counts.append(count)\n \n# return max(counts)","runtime":"3776"},{"code":"# Data Structures and Algorithm Used:\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\n\n# Short Intuition:\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\n\n# Detailed Intuition:\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\n# - The final result is the maximum value found in this dictionary.\n\n# Pseudocode:\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\n# 2. For each number `n` in `nums`:\n# a. Iterate over all possible `i` from `0` to `k-1`.\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\n# 3. The answer is the maximum value in the `count` dictionary.\n\nfrom collections import defaultdict\n\nclass Solution:\n def maximumLength(self, nums, k):\n # Step 1: Initialize the dictionary to keep track of subsequence counts\n count = defaultdict(int)\n \n # Step 2: Iterate over each number in the array\n for n in nums:\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\n for i in range(k):\n # Step 2b: Update the count for the pair (i, n%k)\n count[(i, n % k)] = count[(n % k, i)] + 1\n \n # Step 3: Return the maximum value found in the count dictionary\n return max(count.values())\n\n# Time Complexity:\n# - O(n * k) where n is the length of the array and k is the given integer. \n# This is because for each element in the array, we perform `k` updates in the dictionary.\n\n# Space Complexity:\n# - O(k^2) for storing the count of subsequences in the dictionary.\n","runtime":"3822"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k) -> int:\n count = defaultdict(int)\n for n in nums:\n for i in range(k):\n count[(i, n%k)] = count[(n%k, i)] + 1\n return max(count.values())","runtime":"3822"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nums = [num % k for num in nums]\\n def check(a, b):\\n alternating = [num for num in nums if num == a or num == b]\\n return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\\n \\n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\\n best = counts[0][0]\\n for i in range(len(counts)-1):\\n countA, a = counts[i]\\n for j in range(i+1, len(counts)):\\n countB, b = counts[j]\\n if countA + countB <= best:\\n break\\n best = max(best, check(a, b))\\n return best\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nums = [num % k for num in nums]\\n def check(a, b):\\n alternating = (num for num in nums if num == a or num == b)\\n return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\\n \\n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\\n best = counts[0][0]\\n for i in range(len(counts)-1):\\n countA, a = counts[i]\\n for j in range(i+1, len(counts)):\\n countB, b = counts[j]\\n if countA + countB <= best:\\n break\\n best = max(best, check(a, b))\\n return best\",\n \"runtime\": \"182\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nums = [num % k for num in nums]\\n def check(a, b):\\n curr = -1\\n total = 0\\n for i in range(len(nums)):\\n if nums[i] == a and curr != a:\\n total += 1\\n curr = a\\n elif nums[i] == b and curr != b:\\n total += 1\\n curr = b\\n return total\\n # alternating = [num for num in nums if num == a or num == b]\\n # return 1 + sum([1 for a, b in pairwise(alternating) if a != b])\\n \\n counts = sorted([(count, val) for val, count in Counter(nums).items()], reverse=True)\\n best = counts[0][0]\\n for i in range(len(counts)-1):\\n countA, a = counts[i]\\n for j in range(i+1, len(counts)):\\n countB, b = counts[j]\\n if countA + countB <= best:\\n break\\n best = max(best, check(a, b))\\n return best\",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n remainders = defaultdict(list)\\n for i, n in enumerate(nums):\\n remainders[n % k].append(i)\\n max_len = max(2, max([len(remainders[a]) for a in remainders.keys()]))\\n\\n\\n\\n for i in remainders.keys():\\n for j in remainders.keys():\\n if i == j or len(remainders[i]) + len(remainders[j]) <= max_len:\\n continue\\n\\n pos1 = remainders[i][0]\\n l = 1\\n while True:\\n pos2 = bisect_right(remainders[j], pos1)\\n if pos2 == len(remainders[j]):\\n break\\n pos2 = remainders[j][pos2]\\n l += 1\\n pos1 = bisect_right(remainders[i], pos2)\\n if pos1 == len(remainders[i]):\\n break\\n pos1 = remainders[i][pos1]\\n l += 1\\n\\n # print(f\\\"pos1={pos1}, pos2={pos2}\\\")\\n max_len = max(max_len, l)\\n return max_len\\n \",\n \"runtime\": \"228\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, num in enumerate(nums):\\n groups[num % k].append(j)\\n ans = max(len(group) for group in groups)\\n for i, y in enumerate(groups):\\n for x in groups[:i]:\\n if len(x) + len(y) <= ans:\\n continue\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\\n if cand > ans:\\n ans = cand\\n return ans\",\n \"runtime\": \"274\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, num in enumerate(nums):\\n groups[num % k].append(j)\\n ans = max(len(group) for group in groups)\\n for i, y in enumerate(groups):\\n for x in groups[:i]:\\n if len(x) + len(y) <= ans:\\n continue\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\\n if cand > ans:\\n ans = cand\\n return ans\",\n \"runtime\": \"320\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, num in enumerate(nums):\\n groups[num % k].append(j)\\n ans = max(len(group) for group in groups)\\n for i, y in enumerate(groups):\\n for x in groups[:i]:\\n if len(x) + len(y) <= ans:\\n continue\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\\n if cand > ans:\\n ans = cand\\n return ans\",\n \"runtime\": \"366\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, (num, _) in enumerate(itertools.groupby(nums)):\\n groups[num % k].append(j)\\n ans = max(collections.Counter(num % k for num in nums).values())\\n for i, y in enumerate(groups):\\n for x in groups[:i]:\\n if len(x) + len(y) <= ans:\\n continue\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\\n if cand > ans:\\n ans = cand\\n return ans\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, (num, _) in enumerate(itertools.groupby(nums)):\\n groups[num % k].append(j)\\n ans = max(collections.Counter(num % k for num in nums).values())\\n for i, y in enumerate(groups):\\n for x in groups[:i]:\\n if len(x) + len(y) <= ans:\\n continue\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n cand = 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\\n if cand > ans:\\n ans = cand\\n return ans\",\n \"runtime\": \"412\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # 根据mod性质，有效子序列的奇数项都关于模 k 同余，偶数项都关于模 k 同余。\\n # 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。\\n # f[y][x]=f[x][y]+1\\n f = [[0] * k for _ in range(k)]\\n for x in nums:\\n x %= k\\n for y, fxy in enumerate(f[x]):\\n f[y][x] = fxy + 1\\n return max(map(max, f))\\n\\n# 时间复杂度：O(k^2+nk)，其中 n 是 nums 的长度。注意创建大小为 k^2 的二维数组需要 O(k^2) 的时间。\\n# 空间复杂度：O(k^2)。\\n\\n# 方法二：枚举余数，考察子序列的最后一项\\n# 如果知道了子序列的最后一项（假设是 x），那么子序列的倒数第二项也就确定了，即 (m−x mod k+k) mod k\\n# 加 k 再模 k 是为了在 m<xmodk 时，保证计算结果非负。\\n# Python，由于允许负数下标，可以直接用 f[m−xmodk] 作为转移来源。\\n# f[x]=f[(m−xmodk+k)modk]+1\\n# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# ans = 0\\n# for m in range(k):\\n# f = [0] * k\\n# for x in nums:\\n# x %= k\\n# f[x] = f[m - x] + 1\\n# ans = max(ans, max(f))\\n# return ans\\n# 时间复杂度：O(k(k+n))，其中 n 是 nums 的长度。注意创建大小为 k 的数组需要 O(k) 的时间。\\n# 空间复杂度：O(k)。\",\n \"runtime\": \"458\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * k for _ in range(k)]\\n for x in nums:\\n x %= k\\n for y, fxy in enumerate(f[x]):\\n f[y][x] = fxy + 1\\n return max(map(max, f))\\n# https://leetcode.cn/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/2826591/deng-jie-zhuan-huan-dong-tai-gui-hua-pyt-z2fs/?envType=company&envId=google&favoriteSlug=google-thirty-days\",\n \"runtime\": \"504\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * k for _ in range(k)]\\n for x in nums:\\n x %= k\\n for y in range(k):\\n f[y][x] = f[x][y] + 1\\n return max(map(max, f))\",\n \"runtime\": \"550\"\n },\n {\n \"code\": \"# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\\n# # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\\n# # complexity O(n*k)\\n \\n# numsMods = [n % k for n in nums]\\n\\n# from collections import defaultdict\\n# harsh = defaultdict(int)\\n\\n# for n in numsMods:\\n# for c in range(k):\\n# if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\\n# elif (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\\n \\n# return max(harsh.values())\\n\\n\\n\\n# from a submission's solution. It is the same thing as my solution above, but using arr instead of harsh tables. It looks cleaner nad easier to understand.\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\\n # complexity O(n*k)\\n \\n dp = [[0]*k for _ in range(k)]\\n\\n for x in nums:\\n x = x % k\\n for y in range(k):\\n dp[y][x] = dp[x][y] + 1\\n\\n return max([max(row) for row in dp])\\n\\n\\n# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\\n# # complexity O(n*k*k) to slow\\n \\n# numsMods = [n % k for n in nums]\\n \\n# counts = []\\n# for m in range(k):\\n# for c in range(k):\\n# cond = m\\n# count = 0\\n# for n in numsMods:\\n# if n == cond:\\n# count += 1\\n# cond = c if cond == m else m\\n# counts.append(count)\\n \\n# return max(counts)\",\n \"runtime\": \"596\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n for num in nums:\\n r = num % k\\n for pr in range(k):\\n dp[pr][r] = dp[r][pr] + 1\\n ans = 0\\n for row in dp:\\n ans = max(ans, max(row))\\n return ans\",\n \"runtime\": \"642\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n (a + b) mod k = (b + c) mod k\\n (a + b - (b + c)) mod k = 0\\n (a - c) mod k = 0\\n a 和 c 关于 模 k 同余\\n a and c are congruent modulo k\\n 如果把nums[i] 变成 nums[i]mod k, 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。（即 a，c）\\n 动态规划表: dp[i][j]，其中 i 和 j 分别表示模 k 的结果。dp[i][j] 表示以模 i 和 j 结尾的最长有效子序列的长度。\\n consider “子序列奇数项都相同，偶数项都相同”\\n 递推更新：对于每个元素 nums[i]，遍历更新动态规划表，检查当前元素与之前的元素是否可以形成一个有效的子序列。如果可以，就更新 dp 表，例如 dp[x % k][y] = dp[y][x % k] + 1，其中 x 为当前元素，y 表示前面的元素。\\n \\\"\\\"\\\"\\n # 创建一个二维DP表 f[y][x]，表示以模k的值y和x为结尾的最长子序列长度\\n dp = [[0] * k for _ in range(k)]\\n\\n # 遍历数组中的每个数字\\n for x in nums:\\n x %= k\\n # 对于模k的每个可能的值y，更新dp[y][x]，表示以y和x为结尾的子序列长度\\n # 此处倒序遍历dp表，避免覆盖更新的值影响后续计算\\n for y in range(k): # 这个 for loop是所有可能的 mod值\\n dp[y][x] = dp[x][y] + 1 # 更新dp表，将当前数x加入到以y结尾的子序列中\\n \\n return max(max(row) for row in dp)\\n\\n\",\n \"runtime\": \"689\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n table = [[0] * k for _ in range(k)] # table[i][j] = the length of subseq ending with ... i, j\\n for n in nums:\\n modk = n % k\\n for i in range(k):\\n table[i][modk] = table[modk][i] + 1\\n \\n return max(map(max, table))\",\n \"runtime\": \"735\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n return max(map(max, dp))\",\n \"runtime\": \"735\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for j in range(k):\\n dp[x][j] = 1 + dp[j][x]; \\n #dp[x][1] = 1 + dp[1][x]; \\n return max(map(max, dp))\",\n \"runtime\": \"781\"\n },\n {\n \"code\": \"# 解題思路：\\n# 這個解法的目的是找到最長的有效子序列，使得 (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k == ...，其中 k 是給定的正整數。\\n# 我們使用動態規劃來解決這個問題，並且維護一個 dp 二維數組，其中 dp[x][y] 表示以 x 開頭、y 結尾的有效子序列的長度。\\n\\n# 具體步驟：\\n\\n# 模運算處理：將每個數字 x 對 k 取模，這樣我們只關心每個數字的模數結果。\\n\\n# 動態規劃：對於每一個數字，我們更新二維 dp 陣列來追蹤不同模數值之間形成的子序列長度。\\n# dp[x][y] 代表以模數 y 結尾，並且剛剛加上模數 x 的有效子序列長度。\\n\\n# 結果提取：最後，我們找出二維數組 dp 中的最大值，這就是最長的有效子序列長度。\\n\\n# 詳細解釋：\\n# x 是當前遍歷的數字對 k 取模後的結果。\\n# y 是我們在 dp 中考慮的另一個模數。\\n# dp[y][x] 表示之前已經形成的、以模數 y 開頭、以模數 x 結尾的最長子序列。\\n\\n# 當我們遇到新的數字 x 時：\\n# 如果之前已經有一個以模數 y 結尾的子序列，那麼我們可以將這個數字 x 添加到這個子序列中。\\n# 因此，我們更新 dp[x][y]，使其值為 1 + dp[y][x]，表示在原來的子序列長度基礎上再加上當前的數字。\\n\\n# 這裡的遞歸關係 dp[x][y] = 1 + dp[y][x] 是基於以下邏輯：\\n# dp[y][x] 表示以 y 為結尾、以 x 為倒數第二個數字的最長有效子序列長度。\\n# 當我們加入一個新的元素 x 時，它會接在以 y 為結尾的子序列後面，構成一個新的更長的子序列，因此長度增加 1。\\n# dp[x][y] = 1 + dp[y][x] 表示在加入這個新元素 x 之後，新的子序列長度是 dp[y][x]（舊的序列長度）加上新加入的 1。\\n# dp[x][y] = 1 + dp[y][x] 是在構造新的子序列時，根據前面已經計算好的結果來延長子序列。\\n# 而 dp[x][y] = 1 + dp[y][x] + dp[x][y] 會導致遞歸計算中包含自己，造成無限遞歸問題。\\n\\n# 這裡的 dp[x][y] 儲存的是以 x 結尾並且可以接上以 y 結尾的子序列的最長長度。\\n\\n# dp[0][0]、dp[0][1]、dp[0][2] 具體解釋：\\n# dp[0][0]：表示以 0 取模的數字結尾的序列長度，並且這個序列的倒數第二個數字也是以 0 取模的數字。例如，數字 3 對 3 取模後等於 0，所以 dp[0][0] 表示我們能在以 0 結尾並且倒數第二個數字也取模為 0 的序列後加入這個數字（這裡代表的是所有模 0 的數字結尾的序列長度）。\\n\\n# dp[0][1]：表示以 0 取模的數字結尾的序列長度，但倒數第二個數字是以 1 取模的數字。例如，當前數字 3 取模後為 0，而倒數第二個數字可以是模 1 的數字，像是數字 1。這樣我們可以在以 1 結尾的序列後加入數字 3，構成一個新的序列。\\n\\n# dp[0][2]：表示以 0 取模的數字結尾的序列長度，但倒數第二個數字是以 2 取模的數字。例如，如果倒數第二個數字是模 2 的數字（像是數字 2），我們可以在這個序列後加入數字 3，形成一個新的子序列。\\n\\n# dp[x][y] 的模式：\\n# x 代表當前數字對 k 取模後的結果，也就是序列結尾的數字的模數。\\n# y 代表序列中倒數第二個數字的模數。\\n\\n# 遞歸的關係： dp[x][y] = 1 + dp[y][x] 表示我們將一個新的元素 x 加入到之前以 y 為結尾的子序列中，這樣子序列的長度就增加了 1。\\n\\n# dp[mode][each k(previous mode)] = 1 + dp[each k(previous mode)][mode]\\n# return max(map(max, dp)) \\n\\n# DP 2D,\\n# O(n * k), S: O(k * 2)\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n\\n return max(map(max, dp)) \",\n \"runtime\": \"781\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n return max(map(max, dp))\",\n \"runtime\": \"827\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n return max(map(max, dp))\",\n \"runtime\": \"827\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n for i, x in enumerate(nums):\\n nums[i] %= k\\n ans = 0\\n for i in range(k):\\n dp = [0] * k\\n for x in nums:\\n c = i - x\\n if c < 0:\\n c += k\\n dp[x] = dp[c] + 1\\n ans = max(ans, max(dp))\\n return ans\",\n \"runtime\": \"873\"\n },\n {\n \"code\": \"from typing import List\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n vt = [[] for _ in range(k)] # List of lists to store indices based on modulo k\\n mx = 0 # Variable to store the maximum length\\n\\n # Populate the vt list with indices of nums based on modulo k\\n for i in range(n):\\n idx = nums[i] % k\\n vt[idx].append(i)\\n mx = max(mx, len(vt[idx]))\\n\\n # Compare pairs of different modulo groups to find the maximum length\\n for i in range(k - 1):\\n for j in range(i + 1, k):\\n vi, vj = vt[i], vt[j]\\n if not vi or not vj:\\n continue\\n\\n l, m = 0, 0\\n si, sj = len(vi), len(vj)\\n ar = 1 # Variable to store the alternating sequence length\\n f1 = vi[l] < vj[m]\\n\\n # Merge the two sorted lists vi and vj to find the longest alternating sequence\\n while l < si and m < sj:\\n if f1:\\n while m < sj and vj[m] < vi[l]:\\n m += 1\\n if m >= sj:\\n break\\n ar += 1\\n l += 1\\n else:\\n while l < si and vi[l] < vj[m]:\\n l += 1\\n if l >= si:\\n break\\n ar += 1\\n m += 1\\n f1 = not f1 # Toggle the flag\\n\\n mx = max(mx, ar)\\n\\n return mx # Return the maximum length of the alternating sequence\\n\\n# Example usage:\\n# sol = Solution()\\n# print(sol.maximumLength([1, 2, 3, 4, 5, 6], 2)) # Example input\",\n \"runtime\": \"873\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for num in nums:\\n rem = num % k\\n for i in range(k):\\n dp[i][rem] = dp[i][i-rem] + 1\\n return max(max(row) for row in dp)\",\n \"runtime\": \"919\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n nums = [x%k for x in nums]\\n \\n res = 0\\n for i in range(k):\\n dp = [0]*k\\n for x in nums: \\n dp[x] = dp[(i-x)%k] +1\\n res = max(res, *dp)\\n return res\\n\\n\",\n \"runtime\": \"919\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n groups = [[] for _ in range(k)]\\n for j, num in enumerate(nums):\\n groups[num % k].append(j)\\n solids = max(len(group) for group in groups)\\n if solids == len(nums):\\n return solids\\n stripes = max(\\n stripe(x, y, solids) for i, y in enumerate(groups)\\n for x in groups[:i]\\n )\\n return max(solids, stripes)\\n\\n\\ndef stripe(x, y, cut):\\n if len(x) + len(y) <= cut:\\n return cut\\n mixed = sorted([(X, 0) for X in x] + [(Y, 1) for Y in y])\\n return 1 + sum(u != v for (_, u), (_, v) in zip(mixed[:-1], mixed[1:]))\",\n \"runtime\": \"965\"\n },\n {\n \"code\": \"import bisect\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n mod_positions = [-1] * k \\n dp = [[0 for _ in range(k)] for _ in range(n)]\\n\\n for idx in range(n - 1, -1, -1):\\n nums[idx] %= k\\n if idx == n - 1:\\n for k_value in range(k):\\n dp[idx][k_value] = 1\\n else:\\n for k_value in range(k):\\n next_idx = mod_positions[k_value]\\n\\n if next_idx == -1:\\n dp[idx][k_value] = 1\\n continue\\n \\n dp[idx][k_value] = 1 + dp[next_idx][nums[idx]]\\n \\n mod_positions[nums[idx]] = idx\\n \\n return max(max(row) for row in dp) \\n\\n \\n\\n \",\n \"runtime\": \"965\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n ans = 0\\n\\n for m in range(k): # loop every possible value of (x[0] + x[1]) % k\\n dp = [0] * k # dp[value]: longest subsequence length ending in value = nums[i] % k\\n for num in nums:\\n dp[num % k] = dp[(m - num) % k] + 1\\n ans = max(ans, max(dp))\\n\\n return ans\",\n \"runtime\": \"1011\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n res = 0\\n for v in range(k): # Enumearet the sub sum v = (sub[0] + sub[1]) % k\\n dp = [0] * k # dp[a % k] means the longest of subarray ending with a % k\\n for a in nums:\\n dp[a % k] = dp[(v - a) % k] + 1 # a can be the next element after (v - a) % k\\n res = max(res, max(dp))\\n return res\",\n \"runtime\": \"1011\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n # another dp approach\\n # what are chaning\\n # 1. ith value we are considering\\n # 2. the ith value mod\\n # 3. the i-1 th value and its mod\\n \\n # mod will be in the range of [0, k-1]\\n # we are doing space compaction already\\n \\n l = len(nums)\\n dp = [[0 for y in range(k)] for x in range(k)]\\n result = 0\\n for i in range(1, l+1):\\n val = nums[i-1]\\n m = val % k\\n \\n for j in range(k):\\n # if j == m:\\n # dp[m][j] = dp[m][j] + 1\\n # else:\\n \\n # current mod is m, prev value in the subseq has a mod of j\\n # then to make the equation, the prev prev value should also have a mod of m\\n # so dp[x][y] = dp[y][x] + 1\\n\\n # since this also applies when j == m, so we can safely remove the if else\\n dp[m][j] = dp[j][m] + 1\\n result = max(result, max(dp[m]))\\n return result\\n \\n \\n # (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k\\n # where (sub[0] + sub[1]) % k can be any value [0, k-1]\\n \\n result = 0\\n for u in range(k):\\n # dp[i] means when v is the mod of the equation above\\n # what is the length of the longest valid subseq with\\n # a ending value whose mod is i\\n dp = [0 for y in range(k)]\\n for v in nums:\\n m = v % k\\n # for a given m as ending value\\n # the prev value should be someone with mod (u + k - m) % k\\n dp[m] = max(dp[m], dp[(u + k - m) % k] + 1)\\n result = max(result, dp[m])\\n return result\\n \\n \\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/discuss/5389322/Yes-it's-a-2d-DP-!!\\n l = len(nums)\\n dp = [[0 for y in range(k)] for x in range(k)]\\n \\n result = 0\\n \\n for i in range(1, l+1):\\n val = nums[i-1] % k\\n for j in range(k):\\n prev_val = (j + k - val) % k\\n dp[val][j] = max(dp[val][j], dp[prev_val][j] + 1)\\n \\n result = max(result, dp[val][j])\\n return result\",\n \"runtime\": \"1057\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1] * k for _ in range(n)]\\n for i in range(n):\\n for j in range(i):\\n r = (nums[j] + nums[i]) % k\\n dp[i][r] = dp[j][r] + 1\\n return max([max(x) for x in dp])\\n\\n \\n\",\n \"runtime\": \"1057\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n def solve(t):\\n remainders = [0] * k\\n for x in nums:\\n remainders[x % k] = 1 + remainders[(k - x - t) % k]\\n return max(remainders)\\n\\n ans = 0\\n for i in range(0, k):\\n ans = max(ans, solve(i))\\n return ans\",\n \"runtime\": \"1103\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[i][j] := the maximum length of a valid subsequence, where the last\\n # number mod k equal to i and the next desired number mod k equal to j\\n dp = [[0] * k for _ in range(k)]\\n\\n # Extend the pattern xyxyxy...xy.\\n for x in nums:\\n for y in range(k):\\n dp[x % k][y] = dp[y][x % k] + 1\\n\\n return max(map(max, dp))\",\n \"runtime\": \"1103\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n for i in range(n):\\n nums[i] = nums[i]%k\\n cnt = Counter(nums)\\n res = max(cnt.values())\\n visited = [[False]*k for _ in range(k)]\\n for i in range(n):\\n a = nums[i]\\n for j in range(i+1,n):\\n b = nums[j]\\n if visited[a][b] or visited[b][a] or cnt[a]+cnt[b] <= res:\\n continue\\n visited[a][b] = True\\n visited[b][a] = True\\n c = 2\\n f = False\\n for k in range(j+1,n):\\n if f and (nums[k] == b):\\n c += 1\\n f = False\\n elif (not f) and (nums[k] == a):\\n c += 1\\n f = True\\n if c>res:\\n res = c\\n\\n return res\\n \",\n \"runtime\": \"1149\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0] * k for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1149\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n data = [[0]*k for _ in range(k)]\\n for num in nums:\\n for i in range(k):\\n data[i][num%k] = data[i][i-num%k] + 1\\n return max(max(row) for row in data)\",\n \"runtime\": \"1195\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * k for _ in range(k)]\\n for i in range(n):\\n for j in range(k):\\n dp[nums[i] % k][j] = 1 + dp[j][nums[i] % k]\\n return max(max(dp[i]) for i in range(k))\",\n \"runtime\": \"1195\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n dp = [[1] * k for _ in range(N)]\\n ret = 1\\n\\n for i in range(N - 2, -1 ,-1):\\n for j in range(i + 1, N):\\n num = (nums[i] + nums[j])%k\\n if dp[i][num] == 1:\\n dp[i][num] = 1 + dp[j][num]\\n ret = max(ret, dp[i][num])\\n \\n return ret\\n\",\n \"runtime\": \"1242\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n 1 4 2 3 1 4\\n 3\\n\\n 1 1 2 0 1 1\\n\\n 1. try find the longest subseq where every 2 consecutive elements sum up to 0\\n\\n 1 1 2 0 1 1 \\n create a dict to track longest subseq that ends with a certain value\\n {\\n 1: 3,\\n 2: 2,\\n 0: 1,\\n }\\n \\n \\\"\\\"\\\"\\n nums = [n % k for n in nums]\\n res = 0\\n for tar_sum in range(k):\\n longest_length_ends_with_val = {}\\n for n in nums:\\n prev_val = tar_sum - n\\n if prev_val < 0:\\n prev_val += k\\n longest_length_ends_with_val[n] = longest_length_ends_with_val.get(prev_val, 0) + 1\\n\\n res = max(res, max(longest_length_ends_with_val.values()))\\n return res\",\n \"runtime\": \"1242\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [{} for _ in range(0, len(nums))]\\n\\n max = 0\\n\\n for i in range(1, len(nums)):\\n for j in range(i - 1, -1, -1):\\n remainder = (nums[i] + nums[j]) % k\\n\\n if remainder in dp[i]:\\n continue\\n\\n if remainder in dp[j]:\\n dp[i][remainder] = dp[j][remainder] + 1\\n else:\\n dp[i][remainder] = 2\\n\\n if dp[i][remainder] > max:\\n max = dp[i][remainder]\\n \\n\\n #print(dp)\\n return max\\n\\n \",\n \"runtime\": \"1288\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n for i in range(len(nums)):\\n nums[i] %= k\\n\\n hashMap = {}\\n for i in range(len(nums)):\\n if nums[i] in hashMap:\\n hashMap[nums[i]] += [i]\\n else:\\n hashMap[nums[i]] = [i]\\n\\n hashSet = set(nums)\\n result = 0\\n for a in hashSet:\\n for b in hashSet:\\n if a == b:\\n result = max(result, len(hashMap[a]))\\n continue\\n else:\\n arrA = hashMap[a]\\n arrB = hashMap[b]\\n\\n length = 0\\n current = -1\\n r = 0\\n for l in range(len(arrA)):\\n if arrA[l] > current:\\n current = arrA[l]\\n length += 1\\n\\n while r < len(arrB) and arrB[r] < current:\\n r += 1\\n\\n if r < len(arrB):\\n current = arrB[r]\\n length += 1\\n else:\\n break\\n else:\\n continue\\n\\n result = max(result, length)\\n\\n return result\",\n \"runtime\": \"1288\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n for i in range(len(nums)):\\n nums[i] %= k\\n\\n hashMap = {}\\n for i in range(len(nums)):\\n if nums[i] in hashMap:\\n hashMap[nums[i]] += [i]\\n else:\\n hashMap[nums[i]] = [i]\\n\\n hashSet = set(nums)\\n result = 0\\n for a in hashSet:\\n for b in hashSet:\\n if a == b:\\n result = max(result, len(hashMap[a]))\\n continue\\n else:\\n arrA = hashMap[a]\\n arrB = hashMap[b]\\n\\n length = 0\\n current = -1\\n r = 0\\n for l in range(len(arrA)):\\n if arrA[l] > current:\\n current = arrA[l]\\n length += 1\\n\\n while r < len(arrB) and arrB[r] < current:\\n r += 1\\n\\n if r < len(arrB):\\n current = arrB[r]\\n length += 1\\n else:\\n break\\n else:\\n continue\\n\\n result = max(result, length)\\n\\n return result\",\n \"runtime\": \"1334\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: list[int], k: int) -> int:\\n ans=[]\\n for i in range(k):\\n arr=[]\\n for _ in range(k):\\n arr.append(0)\\n for x in nums:\\n arr[x%k]=arr[(i-x)%k]+1\\n ans.append(max(arr))\\n return max(ans)\",\n \"runtime\": \"1334\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nums = [n % k for n in nums]\\n res = 0\\n for i in range(k):\\n dp = {}\\n for n in nums:\\n prev = i - n\\n if prev < 0:\\n prev += k\\n dp[n] = dp.get(prev, 0) + 1\\n if dp[n] > res:\\n res = dp[n]\\n return res\\n\",\n \"runtime\": \"1380\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 2:\\n return 2\\n \\n r = (nums[n-1] + nums[n-2]) % k\\n res = dict()\\n res = [dict()]\\n res.append({r: 2})\\n mm = 2\\n for i in range(2, n):\\n re = dict()\\n idx = n - i - 1\\n for j in range(idx+1, n):\\n r = (nums[idx] + nums[j])%k\\n if r not in re:\\n re[r] = res[n-j-1].get(r, 1) + 1\\n if re[r] > mm:\\n mm = re[r]\\n res.append(re)\\n return mm\\n\\n\",\n \"runtime\": \"1380\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1426\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n # we borrow some code from #3201:\\n\\n mods = [N % k for N in nums]\\n print(f'{mods[:10]=}')\\n\\n counts = Counter(mods)\\n print(f'counts{tuple(counts.items())[:10]}')\\n\\n cases = []\\n\\n # case group 1: all the same\\n for mod, count in counts.items():\\n cases.append(count)\\n # print(f'case group 1: all {mod} = {count}')\\n \\n best_case_1 = max(cases, default=0)\\n print(f'{best_case_1=}')\\n cases = []\\n\\n # case group 2: any pair, alternating\\n for first, firstCount in counts.items():\\n for second, secondCount in counts.items():\\n # print(f'Try {first}, {second}:')\\n if first == second:\\n # print(f' No: same')\\n continue\\n if min(firstCount, secondCount) * 2 + 1 <= best_case_1:\\n # series will be alternating, e.g. [1 2 1 2 1]\\n # our limiting reagent is the 2's (minimum count):\\n # any extra 1's will be unused\\n # print(f' No: {firstCount},{secondCount} cant beat best case 1')\\n continue\\n\\n prior = first\\n index = mods.index(prior)\\n this_case = 1\\n # print(f'{this_case=} [{index}]{prior}')\\n while True:\\n next = second if (prior == first) else first # 1st->2nd, 2nd->1st\\n try:\\n index = mods.index(next, index + 1)\\n except ValueError:\\n break\\n prior = mods[index]\\n this_case += 1\\n # print(f'{this_case=} [{index}]{prior}')\\n cases.append(this_case)\\n # print(f'case group 2: {first},{second} = {this_case}')\\n best_case_2 = max(cases, default=0)\\n print(f'{best_case_2=}')\\n\\n return max(best_case_1, best_case_2)\\n\",\n \"runtime\": \"1426\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1472\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1472\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # ex: k is 3\\n # 1 5 4\\n # 5 is random filling, but 1 and 4 should always have the same remainder\\n # (the problem is that once the random filling is chosen, you have to stick\\n # to numbers having the same remainder)\\n availableRests = set([x % k for x in nums])\\n\\n # dp[i][j] - length of the longest subsequence with\\n # the remainder j ending in nums[i] % k\\n n = len(nums)\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n \\n alternating = []\\n for num in nums:\\n current = num % k\\n\\n # iterate through all the possible rests of the sum(a, b) % k\\n for rest in range(k):\\n prev = (k + rest - current) % k\\n dp[current][rest] = dp[prev][rest] + 1\\n return max([max(x) for x in dp])\",\n \"runtime\": \"1518\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n last_r = [-1]*k\\n n = len(nums)\\n dp = [[0]*k for _ in range(n)]\\n ans = 0\\n \\n for i in range(n):\\n for r in range(k):\\n d = (r - nums[i]%k + k) % k\\n if last_r[d] != -1:\\n j = last_r[d]\\n dp[i][r] = dp[j][r] + 1\\n ans = max(ans, dp[i][r])\\n else:\\n dp[i][r] = 1\\n last_r[nums[i]%k] = i \\n\\n return ans\",\n \"runtime\": \"1518\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 0\\n grid = [[0] * k for _ in range(k)]\\n for val in nums:\\n rem = val % k\\n for i in range(k):\\n grid[i][rem] = grid[rem][i] + 1\\n ans = max(ans, grid[i][rem])\\n return ans\\n\\n \\n\\n \",\n \"runtime\": \"1564\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n dp = [[0] * k for x in range(k)]\\n ans = 0\\n for num in nums:\\n i = num % k\\n for y in range(k):\\n dp[i][y] = dp[y][i] + 1\\n ans = max(ans, dp[i][y])\\n return ans\\n\\n\",\n \"runtime\": \"1564\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n for i in range(n):\\n nums[i] = nums[i]%k\\n cnt = Counter(nums)\\n res = max(cnt.values())\\n visited = {}\\n for i in range(n):\\n a = nums[i]\\n for j in range(i+1,n):\\n b = nums[j]\\n if ((a,b) in visited) or ((b,a) in visited):\\n continue\\n visited[(a,b)] = True\\n visited[(b,a)] = True\\n if cnt[a]+cnt[b] <= res:\\n continue\\n c = 2\\n f = False\\n for k in range(j+1,n):\\n if f and (nums[k] == b):\\n c += 1\\n f = False\\n elif (not f) and (nums[k] == a):\\n c += 1\\n f = True\\n res = max(c,res)\\n\\n return res\\n \",\n \"runtime\": \"1610\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n\\n def longest(self, values1: List[int], values2: List[int]) -> int:\\n l_ptr = 0\\n r_ptr = 0\\n count = 0\\n # left == True means to pull from values 1\\n left = bool(values1[0] < values2[0])\\n while True:\\n count += 1\\n if left:\\n curr = values1[l_ptr]\\n while r_ptr < len(values2) and values2[r_ptr] < curr:\\n r_ptr += 1\\n if r_ptr >= len(values2) or values2[r_ptr] < curr:\\n break\\n else:\\n curr = values2[r_ptr]\\n while l_ptr < len(values1) and values1[l_ptr] < curr:\\n l_ptr += 1\\n if l_ptr >= len(values1) or values1[l_ptr] < curr:\\n break\\n left = not left\\n return count\\n\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n k_dict = defaultdict(list)\\n for i, num in enumerate(nums):\\n k_dict[num % k].append(i)\\n curr_max = 0\\n for k, values in k_dict.items():\\n for k2, values2 in k_dict.items():\\n if k == k2:\\n curr_max = max(curr_max, len(values))\\n continue\\n curr_max = max(curr_max, self.longest(values, values2))\\n return curr_max\\n \",\n \"runtime\": \"1610\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n paths = [[0 for j in range(k)] for i in range(k)]\\n ans = 0\\n for num in nums:\\n cur = num % k\\n for i in range(k):\\n paths[i][cur] = paths[cur][i] + 1\\n ans = max(ans, paths[i][cur])\\n return ans\",\n \"runtime\": \"1656\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n lookup = defaultdict(lambda : -1)\\n\\n dp_start = [[0] * k for _ in range(n)]\\n dp = [0] * (n + 1)\\n for i in range(n - 1, -1, -1):\\n for x in range(k):\\n pair = lookup[(x - nums[i]) % k]\\n dp_start[i][x] = 1 + (dp_start[pair][x] if pair >= 0 else 0)\\n take = max(dp_start[i][x] for x in range(k))\\n skip = dp[i + 1]\\n dp[i] = max(take, skip)\\n\\n lookup[nums[i] % k] = i\\n\\n return dp[0]\",\n \"runtime\": \"1656\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n best=0\\n def find_max(c):\\n hashmap=defaultdict(int)\\n for i in nums:\\n i%=k\\n hashmap[i]=hashmap[(c-i)%k]+1\\n return max(hashmap.values())\\n for i in range(k):\\n best=max(best,find_max(i))\\n return best\\n \\n\\n \\n \\n\\n \",\n \"runtime\": \"1702\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # dp[j][k1], j -> ends in j, with mod k, value is max\\n dp = [[1] * k for _ in range(len(nums))]\\n # dp = [1] * k \\n\\n max_seen = 0\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n k1 = (nums[i] + nums[j]) % k\\n dp[j][k1] = dp[i][k1] + 1\\n max_seen = max(max_seen, dp[j][k1])\\n\\n return max_seen\\n \\n\\n \",\n \"runtime\": \"1702\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n def pdp(dp):\\n for i,r in enumerate(dp):\\n print(\\\"A\\\",i,r)\\n print()\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n nums = [n%k for n in nums]\\n #print(nums)\\n \\n res = 0\\n for a in nums:\\n for b in range(k):\\n dp[a][b] = dp[b][a]+1\\n res = max(res,dp[a][b])\\n #print(\\\"A\\\",a,\\\" B\\\",b)\\n #pdp(dp)\\n return res\\n \\n\\n \\n \\n\\n\\n\\n \",\n \"runtime\": \"1841\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n def fn(r, k):\\n dp = [0] * k\\n for x in nums:\\n rx = x % k\\n dp[rx] = max(dp[rx], dp[(r - rx) % k] + 1)\\n res = max(dp)\\n return res\\n\\n ans = max(fn(r, k) for r in range(k))\\n print(ans)\\n return ans\",\n \"runtime\": \"1841\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n\\n for remainder in range(k):\\n remainder_counts = [0] * k\\n\\n for num in nums:\\n # Calculate the remainder of the current number when divided by k\\n current_remainder = num % k\\n \\n # Calculate the remainder that would achieve the target remainder when added to the current number\\n previous_remainder = (remainder - current_remainder) % k\\n\\n # Update the dp array\\n remainder_counts[current_remainder] = max(remainder_counts[current_remainder], remainder_counts[previous_remainder] + 1)\\n \\n # Update the result with the maximum value found in the dp array for the current target remainder\\n max_length = max(max_length, max(remainder_counts))\\n \\n return max_length\\n\\n\\n\\n\\n\\n # max_len = 0\\n # remainders = [ [0] * k for remainder in range(k) ]\\n # for num in nums:\\n # for remainder_value in range(k):\\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n # if max_len < remainders[remainder_value][num % k]:\\n # max_len = remainders[remainder_value][num % k]\\n \\n # return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1887\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n \\n for target_remainder in range(k):\\n\\n dp = [0] * k\\n \\n for num in nums:\\n current_remainder = num % k\\n previous_remainder = target_remainder - current_remainder\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n \\n max_length = max(max_length, max(dp))\\n \\n return max_length\",\n \"runtime\": \"1887\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = -float('inf')\\n\\n for target in range(k):\\n\\n dp = [0] * k\\n\\n for num in nums:\\n current_remainder = num % k\\n previous_remainder = target - current_remainder\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n\\n max_length = max(max_length, max(dp))\\n\\n return max_length\",\n \"runtime\": \"1933\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n \\n # Iterate over each possible remainder value from 0 to k-1\\n for target_remainder in range(k):\\n\\n # Initialize the dynamic programming array to store the maximum length for each remainder\\n dp = [0] * k\\n \\n # Iterate over each number in the input array\\n for num in nums:\\n # Calculate the remainder of the current number when divided by k\\n current_remainder = num % k\\n \\n # Calculate the remainder that would achieve the target remainder when added to the current number\\n previous_remainder = (target_remainder - num) % k\\n\\n # Update the dp array\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n \\n # Update the result with the maximum value found in the dp array for the current target remainder\\n max_length = max(max_length, max(dp))\\n \\n return max_length\\n\\n\\n\\n\\n\\n # max_len = 0\\n # remainders = [ [0] * k for remainder in range(k) ]\\n # for num in nums:\\n # for remainder_value in range(k):\\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n # if max_len < remainders[remainder_value][num % k]:\\n # max_len = remainders[remainder_value][num % k]\\n \\n # return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"runtime\": \"1933\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0 # Initialize the maximum length of the valid subsequence\\n length = len(nums) # Length of the input array nums\\n\\n # Iterate over all possible remainders (0 to k-1)\\n for i in range(k):\\n mp = {} # Dictionary to store the count of each remainder\\n for j in range(length):\\n # Calculate the required remainder that should match with current subsequence\\n lookup_key = ((i + k) - (nums[j] % k)) % k\\n \\n # If the lookup_key is not found in the dictionary, initialize it\\n if mp.get(lookup_key) is None:\\n mp[nums[j] % k] = 1\\n continue\\n \\n # Calculate the length of the current subsequence ending at index j\\n current_length = mp[lookup_key] + 1\\n \\n # Update the maximum length if the current subsequence length is greater\\n max_length = max(max_length, current_length)\\n \\n # Update the dictionary with the count of the current remainder\\n mp[nums[j] % k] = current_length\\n \\n return max_length # Return the maximum length of the valid subsequence\",\n \"runtime\": \"1979\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if not nums: return 0\\n \\n \\n n = len(nums)\\n res = 0\\n for i in range(k):\\n mem = [0] * k\\n for n in nums: \\n cur = n % k\\n prev = (i - n) % k\\n mem[cur] = max(mem[cur], mem[prev]+1)\\n \\n res = max(res, max(mem))\\n \\n \\n \\n return res\\n\",\n \"runtime\": \"1979\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * k for _ in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j - x + k) % k\\n f[x][y] = f[y][x] + 1\\n ans = max(ans, f[x][y])\\n return ans\\n\",\n \"runtime\": \"2025\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for _ in range(k)] for _ in range(len(nums))]\\n mx = 0\\n for i in range(len(nums) - 2, -1, -1):\\n for j in range(i + 1, len(nums)):\\n v = (nums[i] + nums[j]) % k\\n temp = 1 + dp[j][v]\\n dp[i][v] = max(dp[i][v], temp)\\n mx = max(mx, max(dp[i]))\\n return mx + 1\",\n \"runtime\": \"2025\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n lookup = defaultdict(lambda : -1)\\n\\n dp = [[0] * k for _ in range(n)]\\n ans = 0\\n for i in range(n - 1, -1, -1):\\n for x in range(k):\\n pair = lookup[(x - nums[i]) % k]\\n dp[i][x] = 1 + (dp[pair][x] if pair >= 0 else 0)\\n ans = max(ans, dp[i][x])\\n lookup[nums[i] % k] = i\\n\\n return ans\",\n \"runtime\": \"2071\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * k for _ in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j - x + k) % k\\n f[x][y] = f[y][x] + 1\\n ans = max(ans, f[x][y])\\n return ans\",\n \"runtime\": \"2071\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n DP = [[0] * k for _ in range(k)]\\n for i in range(k):\\n DP[0][i] = 0\\n \\n for num in nums:\\n mod_num = num % k\\n temp = DP[mod_num].copy()\\n \\n for i in range(k):\\n x_mod = (mod_num + i) % k\\n temp[x_mod] = max(temp[x_mod], DP[i][x_mod] + 1)\\n DP[mod_num] = temp\\n \\n # print(DP)\\n \\n return max(max(row) for row in DP)\",\n \"runtime\": \"2117\"\n },\n {\n \"code\": \"# Let A be subsequence , with some mod\\n# say mod = (A[i] + A[i+1]) % k = (A[i + 1] + A[i + 2]) % k = ...\\n# DP[currNum][mod] denotes the maximum length of the mod subsequence (subsequence having this mod) ending with currNum\\n# Say we at index i , currNum = nums[i]\\n# This currNum can be a part of any of subsequence having mod = [0 , k-1]\\n# So , we'll try to make our currNum to be a part of all possible subsequenes and choose the maximum out of it\\n# For currNum to be a part of mod subsequence\\n# => (currNum + prevNum) % k = mod\\n# => prevNum = (mod - currNum + k) % k\\n# DP[currNum][mod] = max(DP[currNum][mod] , 1 + DP[prevNum][mod])\\n\\n# Time Complexity : O(N * K)\\n# Space Complexity : O(K * K)\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n f = [[0] * k for _ in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j - x + k) % k\\n f[x][y] = f[y][x] + 1\\n ans = max(ans, f[x][y])\\n return ans\\n\\nclass SolutionDP:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n maxi = 1\\n for num in nums:\\n currNum = num % k\\n for mod in range(k):\\n prevNum = (mod - currNum + k) % k\\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\\n maxi = max(maxi , dp[currNum][mod])\\n return maxi\\n\\n# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# hashMap = collections.defaultdict(int)\\n# prevMod = float(\\\"inf\\\")\\n\\n# for i in range(len(nums) - 1):\\n# mod = (nums[i] + nums[i + 1]) % k\\n# if mod == prevMod:\\n# hashMap[mod] += 1\\n# else:\\n# prevMod = mod\\n# hashMap[mod] += 2\\n\\n# return max(hashMap.values())\\n\\n# [1,4,2,3,1,4]\\n# 1, 4 % 3 = 2\\n# 4, 2 % 3 = 3\\n# 2, 3 % 3 = 2\\n# 3, 1 % 3 = 1\\n# 1, 4 % 3 = 2\\n\\n1, 4, 2, 3, 1,4\",\n \"runtime\": \"2117\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n for num in nums:\\n mod = num % k\\n for i in range(k):\\n dp[i][mod] = max(dp[i][mod], 1 + dp[i][(i - mod + k) % k])\\n return max(max(row) for row in dp)\\n\",\n \"runtime\": \"2163\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(len(nums))]\\n last = [-1] * k\\n ret = 0\\n\\n n = len(nums)\\n for i in range(n):\\n for r in range(k):\\n d = (r - nums[i] % k + k) % k\\n if last[d] != -1:\\n j = last[d]\\n dp[i][r] = dp[j][r] + 1\\n else:\\n dp[i][r] = 1\\n ret = max(ret, dp[i][r])\\n\\n last[nums[i] % k] = i\\n\\n return ret\",\n \"runtime\": \"2209\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n ans = 0\\n for y in nums:\\n for x in range(k):\\n dp[y % k][x] = 1 + dp[(x - y) % k][x]\\n ans = max(ans, dp[y % k][x])\\n return ans\",\n \"runtime\": \"2209\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = [[1] * k for _ in range(n)]\\n ans = 1\\n for i in range(1, n):\\n for j in range(i):\\n f[i][(nums[i] + nums[j]) % k] = f[j][(nums[i] + nums[j]) % k] + 1\\n ans = max(ans, f[i][(nums[i] + nums[j]) % k])\\n return ans\\n\",\n \"runtime\": \"2255\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n rem_dict = [{} for i in range(n)]\\n max_len = 0\\n for i in range(n):\\n for j in range(i):\\n rem = (nums[i] + nums[j])%k\\n if rem in rem_dict[j]:\\n rem_dict[i][rem] = rem_dict[j][rem] + 1\\n else:\\n rem_dict[i][rem] = 2\\n max_len = max(max_len, rem_dict[i][rem])\\n return max_len\",\n \"runtime\": \"2255\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.dp = None\\n self.k = 0\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k)] for j in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j-x+k)%k\\n dp[x][y] = dp[y][x]+1\\n ans = max(ans, dp[x][y])\\n return ans\",\n \"runtime\": \"2302\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0]*k for _ in range(n)]\\n res = 0\\n \\n last = defaultdict(int)\\n for i in range(n):\\n for t in range(k):\\n d = ((t-nums[i]%k)+k)%k\\n if d in last:\\n j = last[d]\\n dp[i][t] = dp[j][t] + 1\\n \\n else:\\n dp[i][t] = 1\\n res = max(res, dp[i][t])\\n \\n last[nums[i]%k] = i\\n \\n return res\\n \",\n \"runtime\": \"2302\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if len(nums) <= 2:\\n return len(nums)\\n\\n max_lengths = [[1] * k for _ in range(len(nums))]\\n\\n answer = 2\\n for i in range(len(nums)):\\n for j in range(i):\\n m = (nums[i] + nums[j]) % k\\n max_lengths[i][m] = max(\\n max_lengths[i][m],\\n 1 + max_lengths[j][m],\\n )\\n answer = max(\\n answer,\\n max_lengths[i][m],\\n )\\n\\n return answer\",\n \"runtime\": \"2348\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # 7:15\\n\\n matrix = [[0]*k for _ in range(k)]\\n ans = 0\\n\\n for v in nums:\\n v = v % k\\n for j in range(k):\\n matrix[v][j] = max(matrix[v][j], matrix[j][v] + 1)\\n ans = max(ans, matrix[v][j])\\n return ans\\n\\n\",\n \"runtime\": \"2348\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # (sub[0] + sub[1])%k == (sub[1] + sub[2]%k)\\n\\n\\n # the interesting thing that one item has to be part of 2 elements\\n # two sums\\n # (x + y)%k == (y+z)%k\\n # (x + y) == (y+z)*d\\n # x + y == dy + dz\\n # x + dz == (d-1)y\\n\\n\\n # 1 4 2\\n # for all remainders 1-7 \\n # 1 4 3\\n\\n # for all endings with remainder 0 ... k-1, that have a previous ending at cur remainder\\n\\n\\n dp = [[0]*k for _ in range(k)]\\n\\n res = 0\\n\\n for num in nums:\\n rem = num%k\\n\\n for i in range(k):\\n dp[rem][i] = max(dp[rem][i], 1 + dp[i][rem])\\n res = max(res, dp[rem][i])\\n\\n return res\\n \",\n \"runtime\": \"2394\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # ex: k is 3\\n # 1 5 4\\n # 5 is random filling, but 1 and 4 should always have the same remainder\\n # (the problem is that once the random filling is chosen, you have to stick\\n # to numbers having the same remainder)\\n availableRests = set([x % k for x in nums])\\n\\n # dp[i][j] - length of the longest subsequence with\\n # the remainder j ending in nums[i] % k\\n n = len(nums)\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n \\n alternating = []\\n for num in nums:\\n current = num % k\\n\\n # iterate through all the possible rests of the sum(a, b) % k\\n for rest in range(k):\\n prev = (k + rest - current) % k\\n dp[current][rest] = max(dp[current][rest], dp[prev][rest] + 1)\\n return max([max(x) for x in dp])\",\n \"runtime\": \"2394\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # we can have a dynamic programming table of size\\n # k called remainders, \\n # Overal time compleity is O(n * n) because the \\n # lookup of the table is O(1) essentially LIS\\n n = len(nums)\\n dp = [[1] * k for _ in range(n)]\\n MAX = 1\\n for i in range(n):\\n for j in range(i):\\n rem = (nums[i] + nums[j]) % k\\n dp[i][ rem ] = max(dp[j][rem] + 1, dp[i][rem])\\n MAX = max(MAX, dp[i][rem])\\n return MAX\",\n \"runtime\": \"2440\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # exp: https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5389322/yes-it-s-a-2d-dp/\\n # O(nk) O(k^2)\\n\\n # 2D dp with mod\\n # dp[currNum][mod] denotes the maximum length of the mod subsequence (subsequence having this mod) ending with currNum\\n dp = [[0] * k for _ in range(k)]\\n max_len = 0\\n \\n for num in nums:\\n cur = num % k\\n for mod in range(k):\\n dp[cur][mod] = max(dp[cur][mod], dp[mod][cur] + 1)\\n max_len = max(max_len, dp[cur][mod])\\n \\n return max_len\",\n \"runtime\": \"2440\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: list[int], k: int) -> int:\\n ans=[]\\n for i in range(k):\\n arr=[]\\n for _ in range(k):\\n arr.append(0)\\n for x in nums:\\n arr[x%k]=max(arr[(i+k-x%k)%k]+1, arr[x%k])\\n ans.append(max(arr))\\n return max(ans)\",\n \"runtime\": \"2486\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''\\n dp[i][mod] = dp[j][mod] + 1\\n '''\\n n = len(nums)\\n if n == 0 or k <= 0:\\n return 0\\n dp = [[0]*k for _ in range(n)] ##record each position, how many elements in there\\n result = 0\\n for i in range(n):\\n for j in range(i):\\n mod = (nums[i] + nums[j])%k\\n dp[i][mod] = max(dp[i][mod], dp[j][mod]+1)\\n result = max(result, dp[i][mod])\\n return result+1\\n \",\n \"runtime\": \"2486\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = {}\\n for right in range(len(nums)):\\n for left in range(right):\\n curr = (nums[right]+nums[left])%k\\n dp[(right, curr)] = dp.get((left, curr), 1) + 1\\n return max(dp.values())\",\n \"runtime\": \"2532\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for j in range(k):\\n dp[j][nums[0]%k] = 1\\n for i in range(1, len(nums)):\\n for j in range(k):\\n # dp[j][nums[i]%k] = max(dp[nums[i]%k][j] + 1, dp[j][nums[i]%k])\\n dp[j][nums[i]%k] = dp[nums[i]%k][j] + 1\\n \\n ans = 0\\n for i in range(k):\\n for j in range(k):\\n ans = max(ans, dp[i][j])\\n return ans\\n\\n\\n\\n # ids = defaultdict(list)\\n # for i, num in enumerate(nums):\\n # ids[num%k].append(i)\\n # ans = -1\\n # for i in range(k):\\n # for j in range(i+1, k):\\n # if ans >= len(ids[i])+len(ids[j]):\\n # break\\n \\n\",\n \"runtime\": \"2532\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n N = len(nums)\\n dp = [[0] * k for _ in range(N)]\\n res = 0\\n for i in reversed(range(N - 1)):\\n for j in range(i + 1, N):\\n mod = (nums[i] + nums[j]) % k\\n dp[i][mod] = max(dp[i][mod], 1 + dp[j][mod])\\n res = max(res, dp[i][mod] + 1)\\n return res\\n \",\n \"runtime\": \"2578\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n max_len = 0\\n \\n for num in nums:\\n for j in range(k):\\n remainder = num % k\\n dp[remainder][j] = max(dp[remainder][j], dp[j][remainder] + 1)\\n max_len = max(max_len, dp[remainder][j])\\n \\n return max_len\",\n \"runtime\": \"2578\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1] * k for _ in range(n)]\\n res = 0\\n for i in range(n):\\n for j in range(i):\\n s = (nums[i] + nums[j]) % k\\n dp[i][s] = max(dp[i][s], 1 + dp[j][s])\\n for s in range(k):\\n res = max(res, dp[i][s])\\n return res\\n\",\n \"runtime\": \"2624\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n max_len = 0\\n for num in nums:\\n for j in range(k):\\n remainder = num % k\\n dp[remainder][j] = max(dp[remainder][j], dp[j][remainder] + 1)\\n max_len = max(max_len, dp[remainder][j])\\n return max_len\",\n \"runtime\": \"2624\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''dp = [[[-1 for _ in range(k)] for _ in range(len(nums))] for _ in range(len(nums))]\\n def rec(i,prev_index,prev_rem):\\n if i>=len(nums):\\n return 0\\n if dp[i][prev_index][prev_rem]!=-1:\\n return dp[i][prev_index][prev_rem]\\n new_rem = k + 1\\n if prev_index!=-1:\\n new_rem = abs(nums[i]+nums[prev_index])%k\\n max_len = 0\\n if prev_index == -1:\\n max_len = max(rec(i+1,i,prev_rem),rec(i+1,prev_index,prev_rem))\\n elif prev_rem == -1:\\n max_len = max(1 + rec(i+1,i,abs(nums[i]-nums[prev_index])%k),rec(i+1,prev_index,prev_rem))\\n elif new_rem==prev_rem:\\n max_len = 1 + rec(i+1,i,new_rem)\\n else:\\n max_len = rec(i+1,prev_index,prev_rem)\\n dp[i][prev_index][prev_rem] = max_len\\n return max_len'''\\n n = len(nums) \\n ans = 1\\n dp = [[1 for _ in range(k)] for _ in range(n)]\\n for j in range(n):\\n for i in range(j+1,n):\\n x = (nums[i] + nums[j])%k\\n dp[i][x] = max(dp[i][x], 1 + dp[j][x])\\n ans = max(ans,dp[i][x])\\n return ans\",\n \"runtime\": \"2670\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [{} for _ in range(len(nums))]\\n ans = 0\\n for i in range(len(nums)):\\n for j in range(i):\\n rem = (nums[i] + nums[j]) % k\\n if dp[i].get(rem, 0) < dp[j].get(rem, 0) + 1:\\n dp[i][rem] = dp[j].get(rem, 0) + 1\\n ans = max(ans, dp[i][rem])\\n return ans + 1\\n\\n \\n \\n \",\n \"runtime\": \"2670\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n dp = [[0] * k for _ in range(k)]\\n nums_proc = [n % k for n in nums]\\n\\n #print(f'{nums_proc=}')\\n\\n result = -math.inf\\n for n_mod in nums_proc:\\n #print(f'ending in {n_mod=}')\\n\\n for sum_mod in range(k):\\n #print(f' subsequence sum {sum_mod=}')\\n target_prev_mod = (sum_mod - n_mod) % k\\n #print(f' target mod {target_prev_mod=}')\\n dp[n_mod][sum_mod] = max(dp[n_mod][sum_mod], 1 + dp[target_prev_mod][sum_mod])\\n result = max(result, dp[n_mod][sum_mod])\\n\\n #print(f'{dp=}')\\n return result\",\n \"runtime\": \"2716\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * k for _ in range(k)]\\n\\n ans = 0\\n for num in nums:\\n for j in range(k):\\n m = num % k\\n dp[m][j] = max(dp[m][j], dp[j][m] + 1)\\n ans = max(ans, dp[m][j])\\n\\n \\n return ans\",\n \"runtime\": \"2716\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n lookup = defaultdict(list)\\n for i, x in enumerate(nums):\\n lookup[x % k].append(i)\\n\\n dp_start = [[0] * k for _ in range(n)]\\n dp = [0] * (n + 1)\\n for i in range(n - 1, -1, -1):\\n for x in range(k):\\n pair = lookup[(x - nums[i]) % k]\\n l, r = 0, len(pair)\\n while l < r:\\n m = (l + r) // 2\\n if pair[m] > i:\\n r = m\\n else:\\n l = m + 1\\n dp_start[i][x] = 1 + (dp_start[pair[l]][x] if l < len(pair) else 0)\\n take = max(dp_start[i][x] for x in range(k))\\n skip = dp[i + 1]\\n dp[i] = max(take, skip)\\n\\n return dp[0]\",\n \"runtime\": \"2762\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # 7:15\\n\\n matrix = [[0]*k for _ in range(k)]\\n ans = 0\\n\\n for v in nums:\\n v = v % k\\n for i in range(k):\\n j = (i+v) % k\\n matrix[v][j] = max(matrix[v][j], matrix[i][j] + 1)\\n ans = max(ans, matrix[v][j])\\n return ans\\n\\n\",\n \"runtime\": \"2762\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n positions = collections.defaultdict(list)\\n for pos, val in enumerate(nums):\\n v = val % k\\n nums[pos] = v\\n positions[v].append(pos)\\n\\n ans = 0\\n for p in range(k):\\n arr = [1] * n\\n for i in range(n-1, -1, -1):\\n r = (p-nums[i]) % k\\n idx = bisect_right(positions[r], i)\\n if idx < len(positions[r]):\\n arr[i] = max(arr[i], arr[positions[r][idx]] + 1)\\n ans = max(ans, arr[i])\\n return ans\",\n \"runtime\": \"2809\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n dp = [[0] * k for _ in range(k)] # cur, rem\\n res = 0\\n for n in nums:\\n cur = n % k\\n for rem in range(k):\\n prev = (rem - cur) % k\\n dp[cur][rem] = max(dp[cur][rem], dp[prev][rem] + 1)\\n res = max(res, dp[cur][rem])\\n return res\",\n \"runtime\": \"2809\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n maxi = 1\\n for num in nums:\\n rem = num % k\\n for i in range(k):\\n pn = (i-rem+k)%k\\n dp[rem][i] = max(dp[rem][i], 1 + dp[pn][i])\\n maxi = max(maxi, dp[rem][i])\\n return maxi\",\n \"runtime\": \"2855\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n # [target mod, last number]\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n\\n for num in nums:\\n for t in range(k):\\n ln = (t - num) % k\\n dp[t][num % k] = max(dp[t][num % k], dp[t][ln] + 1)\\n\\n # print(dp)\\n\\n return max(max(dp[i]) for i in range(k))\\n\",\n \"runtime\": \"2855\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n maxi = 1\\n for num in nums:\\n currNum = num % k\\n for mod in range(k):\\n prevNum = (mod - currNum + k) % k\\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\\n maxi = max(maxi , dp[currNum][mod])\\n return maxi\",\n \"runtime\": \"2901\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [ [1] * len(nums) for i in range(k) ]\\n # print(dp)\\n max_length = 0\\n for i in range(len(nums)):\\n for j in range(i-1, -1, -1):\\n cur_sum = nums[i] + nums[j]\\n dp[cur_sum % k][i] = max(dp[cur_sum % k][i], dp[cur_sum % k][j] + 1)\\n max_length = max(max_length, dp[cur_sum % k][i])\\n return max_length\\n\\n \",\n \"runtime\": \"2901\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = {}\\n for i in range(n):\\n for j in range(i):\\n f[(i,(nums[i]+nums[j])%k)] = 1 + f.get((j,(nums[i]+nums[j])%k),1)\\n return max(f.values())\\n \",\n \"runtime\": \"2947\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n Optimized DP approach.\\n Time: O(n * k)\\n Space: O(k * k)\\n \\\"\\\"\\\"\\n dp = [[0] * k for _ in range(k)]\\n res = 1\\n for num in nums:\\n cur = num % k\\n for mod in range(k):\\n # cuz (prev + cur) % k = mod -> prev = (mod - cur) % k, then + k to make it non-negative\\n prev = (mod - cur + k) % k\\n dp[cur][mod] = max(dp[cur][mod] , 1 + dp[prev][mod])\\n res = max(res , dp[cur][mod])\\n return res\\n\",\n \"runtime\": \"2947\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = [[0]*k for _ in range(k)]\\n maxi = 1\\n for num in nums:\\n curr = num%k\\n for mod in range(k):\\n prev = (mod - curr+k) %k \\n ans[curr][mod] = max(ans[curr][mod], 1+ans[prev][mod])\\n maxi = max(maxi,ans[curr][mod])\\n \\n return maxi\\n \\n \",\n \"runtime\": \"2993\"\n },\n {\n \"code\": \"'''\\n\\nFor currNum to be a part of mod subsequence\\n=> (currNum + prevNum) % k = mod\\n=> prevNum = (mod - currNum + k) % k\\nmod lies between (0, k)\\nDP[currNum][mod] = max(DP[currNum][mod] , 1 + DP[prevNum][mod])\\nO(n*k)\\nO(n*k)\\n'''\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n ##2d array in python: arr = [[0]*cols]*rows\\n maxi = 1\\n for num in nums:\\n currNum = num % k\\n for mod in range(k): ## in range of k\\n prevNum = (mod - currNum + k) % k\\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\\n maxi = max(maxi , dp[currNum][mod])\\n return maxi\",\n \"runtime\": \"2993\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''\\n 變成%k了, 不過長度只有1000\\n 可以吃n平方\\n 變成\\n 0~k-1種數字的cnt\\n 因為長度短所以大概N*N下去吧 \\n # 718 / 732 testcases passed TLE\\n 是DP題目\\n \\n '''\\n\\n dp = defaultdict(Counter)\\n for n in nums:\\n for p in range(k):\\n n_mod = n % k \\n dp[p][n_mod] = dp[n_mod][p] +1\\n \\n return max(max(cnts.values())for cnts in dp.values())\",\n \"runtime\": \"3039\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n 2D DP\\n Time: O(n * k)\\n Space: O(k * k)\\n \\\"\\\"\\\"\\n # dp[i][j] means the len of the longest valid subsequence that ends with a number mod k equals i, \\n # and the sum of every two consecutive elements in this subsequence mod k equals to j\\n dp = [[0] * k for _ in range(k)]\\n res = 1\\n for num in nums:\\n cur = num % k\\n for mod in range(k):\\n # cuz (prev + cur) % k = mod -> prev = (mod - cur) % k, then + k to make it non-negative\\n prev = (mod - cur + k) % k\\n dp[cur][mod] = max(dp[cur][mod] , 1 + dp[prev][mod])\\n res = max(res , dp[cur][mod])\\n return res\\n\",\n \"runtime\": \"3039\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k) -> int:\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"3085\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)] #[i][j] the length of the subsequence with remainder i and module j\\n max_len = 0\\n\\n # (x + y) % k = mod => x % k + y % k = mod\\n \\n for num in nums:\\n currNum = num % k\\n for j in range(k):\\n prev = (j - currNum) % k\\n dp[currNum][j] = max(dp[currNum][j], dp[prev][j] + 1)\\n max_len = max(max_len, dp[currNum][j])\\n\\n return max_len\",\n \"runtime\": \"3085\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], K: int) -> int:\\n pos_to_next_mod = [{} for _ in range(len(nums))]\\n mod_to_earliest_pos = {}\\n mod_to_earliest_pos[nums[len(nums)-1]%K] = len(nums)-1\\n\\n for i in range(len(nums)-2, -1, -1):\\n pos_to_next_mod[i] = mod_to_earliest_pos.copy()\\n mod_to_earliest_pos[nums[i]%K] = i\\n\\n \\n # @cache\\n def max_length_starting_from(i, prev_mod):\\n result = 1\\n if prev_mod in pos_to_next_mod[i]:\\n result += max_length_starting_from(pos_to_next_mod[i][prev_mod], nums[i]%K)\\n return result\\n\\n\\n result = 0\\n for start_i in range(len(nums)):\\n for start_mod in range(K):\\n result = max(result, max_length_starting_from(start_i, start_mod))\\n return result\\n\\n\\n# Time O(N*k)\\n# Space O(N*k)\",\n \"runtime\": \"3131\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\\n dp[a][b] 的含义是：以模数 a 结尾，并且前一个数字的模数为 b 的最长子序列的长度。\\n\\t 状态转移公式 dp[b][a % k] = dp[a % k][b] + 1 的目的是通过动态规划，将每个数字 a 逐步加入子序列\\n \\\"\\\"\\\"\\n dp = defaultdict(Counter)\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n \\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"3131\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n dp[b][a] = max(dp[b][a], dp[a][b] + 1)\\n where dp[a][b] means the length of subsequence ending with ...,a,b\\n dp[b][a % k] 表示以模数为 a % k 的数字 b 结尾的最长有效子序列的长度。\\n \\\"\\\"\\\"\\n dp = defaultdict(Counter)\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n \\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"3177\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/discuss/5389322/Yes-it's-a-2d-DP-!!\\n l = len(nums)\\n dp = [[0 for y in range(k)] for x in range(k)]\\n \\n result = 0\\n \\n for i in range(1, l+1):\\n val = nums[i-1] % k\\n for j in range(k):\\n prev_val = (j + k - val) % k\\n dp[val][j] = max(dp[val][j], dp[prev_val][j] + 1)\\n \\n result = max(result, dp[val][j])\\n return result\",\n \"runtime\": \"3177\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = defaultdict(Counter)\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n \",\n \"runtime\": \"3223\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n if not nums: return 0\\n \\n \\n mem = collections.defaultdict(Counter)\\n n = len(nums)\\n res = 0\\n for n in nums:\\n for i in range(k):\\n mem[i][n % k] = mem[n % k][i] + 1 \\n \\n \\n return max(max(mem[a].values()) for a in range(k))\\n\",\n \"runtime\": \"3269\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n \\n max_len = 0\\n for num in nums:\\n curr = num % k\\n for mod in range(k):\\n prev = (mod + k - curr) % k\\n dp[curr][mod] = max(dp[curr][mod], dp[prev][mod] + 1)\\n max_len = max(max_len, dp[curr][mod])\\n \\n return max_len\\n\",\n \"runtime\": \"3315\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n maxLen = 0\\n \\n for mod in range(k):\\n for num in nums:\\n curr = num % k\\n prev = (mod - curr + k ) % k\\n \\n dp[curr][mod] = max(dp[curr][mod], dp[prev][mod] + 1)\\n maxLen = max(maxLen, dp[curr][mod])\\n \\n return maxLen\\n \",\n \"runtime\": \"3315\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], K: int) -> int:\\n dp = defaultdict(lambda: defaultdict(int))\\n result = 0\\n for val in nums:\\n for prev_mod in range(K):\\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\\n result = max(result, dp[prev_mod][val%K])\\n return result\\n\\n\\n# Time O(N*k)\\n# Space O(N*k)\\n\\n# %k == constant -> alternating mod values\\n # Note, also true if all mod values 0, but this also falls under alternating mod values\\n\\n# if end with element a%k, having b as prev mod\\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\\n# dp[b][a%k] = dp[a%k][b] +1\",\n \"runtime\": \"3362\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n\\n\\n\",\n \"runtime\": \"3362\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\\"\\\"\\\"\\n (a + b) mod k = (b + c) mod k\\n (a + b - (b + c)) mod k = 0\\n (a - c) mod k = 0\\n a 和 c 关于 模 k 同余\\n a and c are congruent modulo k\\n 如果把nums[i] 变成 nums[i]mod k, 寻找一个最长的子序列，满足子序列奇数项都相同，偶数项都相同。（即 a，c）\\n dp[y][x] : 表示最后两项模 k 分别为 y 和 x 的子序列的长度. \\n dp[y][x] = dp[x][y] + 1， consider “子序列奇数项都相同，偶数项都相同”\\n \\\"\\\"\\\"\\n dp = defaultdict(Counter)\\n for a in nums:\\n for b in range(k): # 这个 for loop是所有可能的 mod值\\n dp[b][a % k] = dp[a % k][b] + 1\\n \\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"runtime\": \"3408\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0 for j in range(k)] for i in range(n)]\\n \\n dp[0][nums[0]%k] = 1\\n for i in range(1, n):\\n dp[i][nums[i]%k] = 1\\n for j in range(i-1, -1, -1):\\n new_num = (nums[j] + nums[i])%k\\n dp[i][new_num] = max(dp[i][new_num], max(dp[j][new_num] + 1, 2))\\n ans = 0\\n for i in range(1, n):\\n for j in range(k):\\n ans = max(ans, dp[i][j])\\n return ans\\n \",\n \"runtime\": \"3454\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n n = len(nums)\\n for i in range(n):\\n nums[i] %= k\\n\\n\\n dp = [[-1]*k for i in range(k)]\\n ans = [[0]*k for i in range(k)]\\n pr = max(Counter(nums).values())\\n for i, num in enumerate(nums):\\n for x in range(k):\\n if num != x and dp[num][x] == 1:\\n dp[num][x] = 0\\n ans[num][x] = max(ans[x][num] + 1, ans[num][x])\\n pr = max(pr, ans[num][x])\\n \\n \\n for y in range(k):\\n if num != y and dp[y][num] != 1:\\n dp[y][num] = 1\\n ans[y][num] = max(ans[y][num], ans[num][y] + 1)\\n pr = max(pr, ans[y][num])\\n\\n return pr\\n\\n \",\n \"runtime\": \"3454\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n ans = 0\\n for i in nums:\\n cur = i%k\\n for j in range(k):\\n # dp[(j+cur)%k][cur] = max(dp[(j+cur)%k][cur],dp[(j+cur)%k][j]+1)\\n dp[cur][(j+cur)%k] = max(dp[cur][(j+cur)%k],dp[j][(j+cur)%k]+1)\\n ans = max(ans,dp[cur][(j+cur)%k])\\n # ans = max(ans,max(dp[cur]))\\n return ans\",\n \"runtime\": \"3500\"\n },\n {\n \"code\": \"# Data Structures and Algorithm Used:\\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\\n\\n# Short Intuition:\\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\\n\\n# Detailed Intuition:\\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\\n# - The final result is the maximum value found in this dictionary.\\n\\n# Pseudocode:\\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\\n# 2. For each number `n` in `nums`:\\n# a. Iterate over all possible `i` from `0` to `k-1`.\\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\\n# 3. The answer is the maximum value in the `count` dictionary.\\n\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n # Step 1: Initialize the dictionary to keep track of subsequence counts\\n count = defaultdict(int)\\n \\n # Step 2: Iterate over each number in the array\\n for n in nums:\\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\\n for i in range(k):\\n # Step 2b: Update the count for the pair (i, n%k)\\n count[(i, n % k)] = count[(n % k, i)] + 1\\n \\n # Step 3: Return the maximum value found in the count dictionary\\n return max(count.values())\\n\\n# Time Complexity:\\n# - O(n * k) where n is the length of the array and k is the given integer. \\n# This is because for each element in the array, we perform `k` updates in the dictionary.\\n\\n# Space Complexity:\\n# - O(k^2) for storing the count of subsequences in the dictionary.\\n\",\n \"runtime\": \"3500\"\n },\n {\n \"code\": \"import collections\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n d = [[] for _ in range(k)]\\n for i in range(len(nums)):\\n d[nums[i] % k].append(i)\\n print(d)\\n opt = max(len(x) for x in d)\\n for i in range(k):\\n for j in range(k):\\n if i == j:\\n continue\\n #print(\\\"i, j: \\\", i, j)\\n if not d[i] and not d[j]:\\n continue\\n c = 1\\n x, y = 0, 0\\n prev = -1\\n if not d[i] or not d[j]:\\n opt = max(opt, 1)\\n continue\\n else:\\n prev = nums[min(d[i][x], d[j][y])] % k\\n while x < len(d[i]) or y < len(d[j]):\\n if x >= len(d[i]):\\n if prev != nums[d[j][y]] % k:\\n c += 1\\n break\\n elif y >= len(d[j]):\\n if prev != nums[d[i][x]] % k:\\n c += 1\\n break\\n else:\\n if d[i][x] < d[j][y]:\\n if nums[d[i][x]] % k == prev:\\n x += 1\\n continue\\n prev = nums[d[i][x]] % k\\n x += 1 \\n c += 1\\n else:\\n if nums[d[j][y]] % k == prev:\\n y += 1\\n continue\\n prev = nums[d[j][y]] % k\\n y += 1\\n c += 1\\n #print(\\\"c: \\\", c) \\n opt = max(opt, c) \\n return opt\",\n \"runtime\": \"3546\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k) -> int:\\n count = defaultdict(int)\\n for n in nums:\\n for i in range(k):\\n count[(i, n%k)] = count[(n%k, i)] + 1\\n return max(count.values())\",\n \"runtime\": \"3592\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\\n # complexity O(n*k)\\n \\n numsMods = [n % k for n in nums]\\n\\n from collections import defaultdict\\n harsh = defaultdict(int)\\n \\n sol = 0\\n for n in numsMods:\\n # print(n, harsh)\\n\\n for c in range(k):\\n if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\\n if (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\\n # else: harsh[(c,n)] += 1\\n\\n for key, count in harsh.items():\\n sol = max(sol, count)\\n \\n # print(numsMods)\\n # print(harsh)\\n \\n return sol\\n\\n\\n\\n# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\\n# # complexity O(n*k*k) to slow\\n \\n# numsMods = [n % k for n in nums]\\n \\n# counts = []\\n# for m in range(k):\\n# for c in range(k):\\n# cond = m\\n# count = 0\\n# for n in numsMods:\\n# if n == cond:\\n# count += 1\\n# cond = c if cond == m else m\\n# counts.append(count)\\n \\n# return max(counts)\",\n \"runtime\": \"3592\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n counts = defaultdict(int)\\n seen = set()\\n nums = [n%k for n in nums]\\n for n in nums:\\n for i in range(k):\\n counts[(i, n)] = counts[(n, i)]+1\\n return max([counts[x] for x in counts])\\n \\n\\n\",\n \"runtime\": \"3638\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(k)]\\n maxi = 1\\n for num in nums:\\n currNum = num % k\\n for mod in range(k):\\n prevNum = (mod - currNum + k) % k\\n dp[currNum][mod] = max(dp[currNum][mod] , 1 + dp[prevNum][mod])\\n maxi = max(maxi , dp[currNum][mod])\\n return maxi\",\n \"runtime\": \"3684\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k) -> int:\\n count = defaultdict(int)\\n for n in nums:\\n for i in range(k):\\n count[(i, n%k)] = count[(n%k, i)] + 1\\n return max(count.values())\",\n \"runtime\": \"3730\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n from collections import Counter\\n from itertools import permutations\\n\\n # Make it simpler by converting into mod k\\n nums = [num % k for num in nums]\\n\\n # Answers can be composed of only one mod type\\n modCounter = Counter(nums)\\n ans = max(modCounter.values())\\n\\n alternativeSeqDict = {}\\n # Try all combinations\\n for i, j in list(permutations(range(k), 2)):\\n\\n # If maximum possible sequence is shorter than already found, we skip\\n if modCounter[i] + modCounter[j] <= ans:\\n continue\\n if (j, i) in alternativeSeqDict and alternativeSeqDict[(j, i)] + 1 <= ans:\\n continue\\n\\n # Find sequence with alternating (i, j)\\n alternateSeq, searchIdx = 0, 0\\n searchNums = [i, j]\\n for num in nums:\\n if num == searchNums[searchIdx]:\\n searchIdx = 1 - searchIdx\\n alternateSeq += 1\\n\\n # Store the value for (i, j)-alternating sequence for time efficiency\\n alternativeSeqDict[(i, j)] = alternateSeq\\n\\n # Update max value\\n ans = max(ans, alternateSeq)\\n\\n return ans\",\n \"runtime\": \"3730\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n ans = 0\\n dp = [defaultdict(int) for i in range(n)]\\n for i in range(n):\\n for j in range(i):\\n mod = (nums[i]+nums[j]) % k\\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\\n ans = max(ans, dp[i][mod])\\n # print(dp)\\n return ans + 1\",\n \"runtime\": \"3776\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/description/\\n # same idea of the other solutio, but with a simplification that result in a romotion of one of the fors, since we use a harsh table.\\n # complexity O(n*k)\\n \\n numsMods = [n % k for n in nums]\\n\\n from collections import defaultdict\\n harsh = defaultdict(int)\\n \\n sol = 0\\n for n in numsMods:\\n # print(n, harsh)\\n\\n for c in range(k):\\n if (c,n) in harsh: harsh[(n,c)] = harsh[(c,n)] + 1 # continue a sequence that started with c and found n (second value); Invert the key pairs, because we are computing a sequence of alternating pairs.\\n\\n for c in range(k):\\n if (n,c) not in harsh: harsh[(n,c)] = 1 # start a new sequence where the first value is n and next is intended to be c\\n # else: harsh[(c,n)] += 1\\n\\n for key, count in harsh.items():\\n sol = max(sol, count)\\n \\n # print(numsMods)\\n # print(harsh)\\n \\n return sol\\n\\n\\n\\n# class Solution:\\n# def maximumLength(self, nums: List[int], k: int) -> int:\\n# # similar to the other exercise find-the-maximum-length-of-valid-subsequence-i, but expandes for any value of k\\n# # we take the mods of all numbers. Now the soluitins will have all with the same mod number or alternating. But what i mean by that is that we take the complement c = (k-1) - m, where m is the mod of a number, and get m then c then m then c. Example, for m = 0 and k = 2. C = (2-1) - 0 = 1. Initailly we look for 0, then for 1, then for 0, then for 1. Now for m = 1, c = (2-1) - 1 = 0, We initially look for 1, then 0, then 1 ... actually i was wrong about the c. Ccan also assume any value ... So we have to do a for loop for c as well.\\n# # complexity O(n*k*k) to slow\\n \\n# numsMods = [n % k for n in nums]\\n \\n# counts = []\\n# for m in range(k):\\n# for c in range(k):\\n# cond = m\\n# count = 0\\n# for n in numsMods:\\n# if n == cond:\\n# count += 1\\n# cond = c if cond == m else m\\n# counts.append(count)\\n \\n# return max(counts)\",\n \"runtime\": \"3776\"\n },\n {\n \"code\": \"# Data Structures and Algorithm Used:\\n# Dynamic Programming with a dictionary (defaultdict) to track the longest valid subsequence based on modular arithmetic.\\n\\n# Short Intuition:\\n# Use a dictionary to store the lengths of subsequences that end with specific modulo results, and update the maximum length found.\\n\\n# Detailed Intuition:\\n# - For each element in the array, we'll consider all possible pairs of modulo values `(i, n % k)`.\\n# - We'll use a dictionary where the key is a tuple `(i, n % k)` and the value is the length of the longest subsequence that can end with that modulo pair.\\n# - We iterate through each number `n` in the array and for each possible value `i` from `0` to `k-1`.\\n# - For each pair, update the length of the subsequence by checking if adding the current number `n` extends any valid subsequence.\\n# - The final result is the maximum value found in this dictionary.\\n\\n# Pseudocode:\\n# 1. Initialize a defaultdict `count` to keep track of the length of valid subsequences.\\n# 2. For each number `n` in `nums`:\\n# a. Iterate over all possible `i` from `0` to `k-1`.\\n# b. For each `(i, n % k)`, update the length in `count` using the value of `count[(n % k, i)] + 1`.\\n# 3. The answer is the maximum value in the `count` dictionary.\\n\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def maximumLength(self, nums, k):\\n # Step 1: Initialize the dictionary to keep track of subsequence counts\\n count = defaultdict(int)\\n \\n # Step 2: Iterate over each number in the array\\n for n in nums:\\n # Step 2a: Iterate over all possible remainders (i) from 0 to k-1\\n for i in range(k):\\n # Step 2b: Update the count for the pair (i, n%k)\\n count[(i, n % k)] = count[(n % k, i)] + 1\\n \\n # Step 3: Return the maximum value found in the count dictionary\\n return max(count.values())\\n\\n# Time Complexity:\\n# - O(n * k) where n is the length of the array and k is the given integer. \\n# This is because for each element in the array, we perform `k` updates in the dictionary.\\n\\n# Space Complexity:\\n# - O(k^2) for storing the count of subsequences in the dictionary.\\n\",\n \"runtime\": \"3822\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k) -> int:\\n count = defaultdict(int)\\n for n in nums:\\n for i in range(k):\\n count[(i, n%k)] = count[(n%k, i)] + 1\\n return max(count.values())\",\n \"runtime\": \"3822\"\n }\n]","isConversational":false},"rt_solution_count":{"kind":"number","value":140,"string":"140"},"mm_list":{"kind":"list like","value":[{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n \n # Iterate over each possible remainder value from 0 to k-1\n for target_remainder in range(k):\n\n # Initialize the dynamic programming array to store the maximum length for each remainder\n dp = [0] * k\n \n # Iterate over each number in the input array\n for num in nums:\n # Calculate the remainder of the current number when divided by k\n current_remainder = num % k\n \n # Calculate the remainder that would achieve the target remainder when added to the current number\n previous_remainder = (target_remainder - num) % k\n\n # Update the dp array\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n \n # Update the result with the maximum value found in the dp array for the current target remainder\n max_length = max(max_length, max(dp))\n \n return max_length\n\n\n\n\n\n # max_len = 0\n # remainders = [ [0] * k for remainder in range(k) ]\n # for num in nums:\n # for remainder_value in range(k):\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n # if max_len < remainders[remainder_value][num % k]:\n # max_len = remainders[remainder_value][num % k]\n \n # return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","memory":"16400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n for target in range(k):\n compliments = {}\n for num in nums:\n curr_remainder = num % k\n compliment = (target - curr_remainder)%k\n if compliment in compliments:\n compliments[curr_remainder] = compliments[compliment] + 1\n else:\n compliments[curr_remainder] = 1\n \n if compliments[curr_remainder] > max_len:\n max_len = compliments[curr_remainder]\n \n return max_len\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n # max_length = 0\n # for target in range(k):\n # compliment_lis = {}\n # for num in nums:\n # curr = num % k\n # compliment = (target - curr)%k\n \n # if compliment in compliment_lis:\n # if curr not in compliment_lis or compliment_lis[curr] < compliment_lis[compliment] + 1:\n # compliment_lis[curr] = compliment_lis[compliment] + 1\n # else:\n # compliment_lis[curr] = 1\n \n # if compliment_lis[curr] > max_length:\n # max_length = compliment_lis[curr]\n\n # return max_length\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n # max_length = 0\n\n # for remainder in range(k):\n # remainder_counts = [0] * k\n\n # for num in nums:\n # # Calculate the remainder of the current number when divided by k\n # current_remainder = num % k\n \n # # Calculate the remainder that would achieve the target remainder when added to the current number\n # # remainder = (curr_remainder + compliment_remainder) % k\n # # remainder = curr_remainder % k + compliment_remainder % k\n # # remainder - curr_remainder = compliment_remainder\n # compliment_remainder = remainder - current_remainder\n # if compliment_remainder < 0:\n # compliment_remainder = k - abs(compliment_remainder)\n\n # # Update the dp array\n # remainder_counts[current_remainder] = max(remainder_counts[current_remainder], remainder_counts[compliment_remainder] + 1)\n \n # # Update the result with the maximum value found in the dp array for the current target remainder\n # max_length = max(max_length, max(remainder_counts))\n \n # return max_length\n\n\n\n\n\n # max_len = 0\n # remainders = [ [0] * k for remainder in range(k) ]\n # for num in nums:\n # for remainder_value in range(k):\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n # if max_len < remainders[remainder_value][num % k]:\n # max_len = remainders[remainder_value][num % k]\n \n # return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","memory":"16500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = -float('inf')\n\n for target in range(k):\n\n dp = [0] * k\n for num in nums:\n curr = num % k\n dp[curr] = max(dp[curr], dp[target - curr] + 1)\n\n ans = max(ans, max(dp))\n\n return ans","memory":"16600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n res = 0 # O(nk) time, O(k) space\n for v in range(k): # Enumearet the sub sum v = (sub[0] + sub[1]) % k, v target reminder\n dp = [0] * k # dp[a % k] means the longest of subarray ending with a % k\n for a in nums: # a % k current reminder, (v-a) % prev reminder\n dp[a % k] = dp[(v - a) % k] + 1 # a can be the next element after (v - a) % k\n res = max(res, max(dp))\n return res\n# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5389350/java-c-python-1d-dp/?envType=company&envId=facebook&favoriteSlug=facebook-three-months","memory":"16700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n \n # Iterate over each possible remainder value from 0 to k-1\n for target_remainder in range(k):\n\n # Initialize the dynamic programming array to store the maximum length for each remainder\n dp = [0] * k\n \n # Iterate over each number in the input array\n for num in nums:\n # Calculate the remainder of the current number when divided by k\n current_remainder = num % k\n \n # Calculate the remainder that would achieve the target remainder when added to the current number\n previous_remainder = (target_remainder - num) % k\n\n # Update the dp array\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n \n # Update the result with the maximum value found in the dp array for the current target remainder\n max_length = max(max_length, max(dp))\n \n return max_length","memory":"16800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = 0\n \n # Iterate over each possible remainder value from 0 to k-1\n for target_remainder in range(k):\n\n # Initialize the dynamic programming array to store the maximum length for each remainder\n dp = [0] * k\n \n # Iterate over each number in the input array\n for num in nums:\n # Calculate the remainder of the current number when divided by k\n current_remainder = num % k\n \n # Calculate the remainder that would achieve the target remainder when added to the current number\n previous_remainder = target_remainder - current_remainder\n\n # Update the dp array\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n \n # Update the result with the maximum value found in the dp array for the current target remainder\n max_length = max(max_length, max(dp))\n \n return max_length","memory":"16800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_length = -float('inf')\n\n for target in range(k):\n\n dp = [0] * k\n\n for num in nums:\n current_remainder = num % k\n previous_remainder = target - current_remainder\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\n\n max_length = max(max_length, max(dp))\n\n return max_length","memory":"16900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n # we borrow some code from #3201:\n\n mods = [N % k for N in nums]\n print(f'{mods[:10]=}')\n\n counts = Counter(mods)\n print(f'counts{tuple(counts.items())[:10]}')\n\n cases = []\n\n # case group 1: all the same\n for mod, count in counts.items():\n cases.append(count)\n # print(f'case group 1: all {mod} = {count}')\n \n best_case_1 = max(cases, default=0)\n print(f'{best_case_1=}')\n cases = []\n\n # case group 2: any pair, alternating\n for first, firstCount in counts.items():\n for second, secondCount in counts.items():\n # print(f'Try {first}, {second}:')\n if first == second:\n # print(f' No: same')\n continue\n if min(firstCount, secondCount) * 2 + 1 <= best_case_1:\n # series will be alternating, e.g. [1 2 1 2 1]\n # our limiting reagent is the 2's (minimum count):\n # any extra 1's will be unused\n # print(f' No: {firstCount},{secondCount} cant beat best case 1')\n continue\n\n prior = first\n index = mods.index(prior)\n this_case = 1\n # print(f'{this_case=} [{index}]{prior}')\n while True:\n next = second if (prior == first) else first # 1st->2nd, 2nd->1st\n try:\n index = mods.index(next, index + 1)\n except ValueError:\n break\n prior = mods[index]\n this_case += 1\n # print(f'{this_case=} [{index}]{prior}')\n cases.append(this_case)\n # print(f'case group 2: {first},{second} = {this_case}')\n best_case_2 = max(cases, default=0)\n print(f'{best_case_2=}')\n\n return max(best_case_1, best_case_2)\n","memory":"17000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # Constraints indicate that n * k solution is possible\n # We can iterate over all mod values of k? k\n # again ,reduce array to \n # go through all different possible modded values\n # Then for each one, go through all unique numbers\n # Find what other number is needed to make it the target mod value\n # then see how many times we can alternate through\n # k * n since we at most go through all indices 2 times\n def alternating(a_idxes, b_idxes):\n if a_idxes == b_idxes:\n return len(a_idxes)\n jumbledup = [[x, 0] for x in a_idxes] + [[x, 1] for x in b_idxes]\n jumbledup.sort()\n prev = -1\n result = 0\n for _, source in jumbledup:\n if source != prev:\n prev = source\n result += 1\n return result\n nums = [x % k for x in nums]\n indices = defaultdict(list)\n for idx, x in enumerate(nums):\n indices[x].append(idx)\n unique_vals = set(nums)\n result = 0\n for target_mod in range(k):\n for val in unique_vals:\n if val <= target_mod:\n needed = target_mod - val\n else:\n needed = k + target_mod - val\n result = max(result, alternating(indices[val], indices[needed]))\n return result\n\n ","memory":"17100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n '''\n 1) max(chain(*dp)), to find max of a matrix\n 2) (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k => this mean that sub[0]%k == sub[2]%k\n so we find the mod of num%k, then find another mod from prev case, if you find it them you add 1 \n\n example: Input: nums = [1,4,2,3,1,4], k = 3\n 1 => 1%3 = 1\n for prev_mod = 0 => 0, for prev_mod = 1 => 0, for prev_mod = 2 => 0\n\n DP 0 1 2\n 0 1 1 1\n 1 0 0 0\n 2 0 0 0\n 4 => 4%3 = 1\n for prev_mod = 0 => 0, for prev_mod = 1 => 1, for prev_mod = 2 => 0\n DP 0 1 2\n 0 2 2 2\n 1 0 0 0\n 2 0 0 0\n\n Tags: DP\n TC: O(N*k)\n SC: O(k*k)\n '''\n dp = [[0]*k for _ in range(k)]\n\n for num in nums:\n num_mod = num % k\n for prev_mod in range(k):\n dp[num_mod][prev_mod] = max(dp[num_mod][prev_mod], dp[prev_mod][num_mod] + 1)\n \n return max(chain(*dp))\n\n ","memory":"22500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0]*k for _ in range(n)]\n res = 0\n \n last = defaultdict(int)\n for i in range(n):\n for t in range(k):\n d = ((t-nums[i]%k)+k)%k\n if d in last:\n j = last[d]\n dp[i][t] = dp[j][t] + 1\n \n else:\n dp[i][t] = 1\n res = max(res, dp[i][t])\n \n last[nums[i]%k] = i\n \n return res\n ","memory":"24300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0] * k for _ in range(len(nums))]\n last = [-1] * k\n ret = 0\n\n n = len(nums)\n for i in range(n):\n for r in range(k):\n d = (r - nums[i] % k + k) % k\n if last[d] != -1:\n j = last[d]\n dp[i][r] = dp[j][r] + 1\n else:\n dp[i][r] = 1\n ret = max(ret, dp[i][r])\n\n last[nums[i] % k] = i\n\n return ret","memory":"24400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[0] * k for _ in range(n)]\n ans = 0\n \n for i in range(n):\n for j in range(i):\n mod = (nums[i] + nums[j]) % k\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\n ans = max(ans, dp[i][mod])\n \n return ans+1","memory":"24500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = [[1] * k for _ in range(n)]\n ans = 0\n \n for i in range(n):\n for j in range(i):\n mod = (nums[i] + nums[j]) % k\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\n ans = max(ans, dp[i][mod])\n \n # print(f\"{ans} {dp}\")\n return ans","memory":"24500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ret = 0\n dp = [[0] * k for _ in range(k)]\n for a in nums:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n ret = max(ret, dp[b][a % k])\n return ret","memory":"24600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0]*k for _ in range(k)]\n for x in nums: \n x %= k \n for y in range(k): \n dp[x][y] = 1 + dp[y][x]\n return max(map(max, dp))","memory":"24700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n nums = [i % k for i in nums]\n \n n = len(nums)\n dp = [[0] * k for _ in range(k)]\n \n for j in range(k):\n dp[j][nums[0]] = 1\n\n for i in range(1, n):\n for j in range(k):\n dp[j][nums[i]] = max(dp[j][(2 * k - nums[i] + j) % k] + 1, dp[j][nums[i]])\n return max(max(x) for x in dp)\n","memory":"24800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n\n positions = collections.defaultdict(list)\n for pos, val in enumerate(nums):\n v = val % k\n nums[pos] = v\n positions[v].append(pos)\n\n dp = [[1] * len(nums) for _ in range(k)]\n\n ans = 0\n for p in range(k):\n for i in range(n-1, -1, -1):\n r = (p-nums[i]) % k\n idx = bisect_right(positions[r], i)\n if idx < len(positions[r]):\n dp[p][i] = max(dp[p][i], dp[p][positions[r][idx]] + 1)\n ans = max(ans, dp[p][i])\n return ans","memory":"24900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for _ in range(k)] for _ in range(k)]\n \n nums = [nums[i]%k for i in range(len(nums))]\n \n for v in nums:\n cur = v%k\n \n for prev in range(k):\n sumd = (v+prev)%k\n dp[cur][sumd] = dp[prev][sumd]+1\n \n \n ans = 0\n for i in range(k):\n for j in range(k):\n # print(dp[i][j])\n ans = dp[i][j] if dp[i][j]>ans else ans\n \n \n return ans\n \n \n ","memory":"25100"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","memory":"25200"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n max_len = 0\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\n for num in nums:\n for remainder_value in range(k):\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\n if max_len < remainders[remainder_value][num % k]:\n max_len = remainders[remainder_value][num % k]\n \n return max_len\n \n\n\n\n\n\n # max_len = 0\n # for remainder in range(k):\n # curr_max = self.get_max_length(nums, k, remainder)\n # if curr_max > max_len:\n # max_len = curr_max\n\n # return max_len\n \n # def get_max_length(self, nums, k, remainder):\n # lis = [1] * len(nums)\n # curr_max = 1\n # for index in range(len(nums)):\n # for subindex in range(index):\n # if (nums[index] + nums[subindex]) % k == remainder:\n # if lis[index] < lis[subindex] + 1:\n # lis[index] = lis[subindex] + 1\n \n # if curr_max < lis[index]:\n # curr_max = lis[index]\n \n # return curr_max\n\n ","memory":"25200"},{"code":"class Solution:\n def __init__(self):\n self.dp = None\n self.k = 0\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [[0 for i in range(k)] for j in range(k)]\n ans = 0\n for x in nums:\n x %= k\n for j in range(k):\n y = (j-x+k)%k\n dp[x][y] = dp[y][x]+1\n ans = max(ans, dp[x][y])\n return ans","memory":"25300"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n dp = [[0 for _ in range(k)] for _ in range(k)]\n \n # print(dp)\n \n for i, num in enumerate(nums):\n ci = num % k\n if i == 0:\n dp[ci] = [1 for _ in range(k)]\n else:\n for ri in range(k):\n dp[ci][ri] = dp[ri][ci] + 1\n # print(dp)\n out = max(map(max, dp))\n # print(out)\n return out\n ","memory":"25400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # brute force is to build all subsequences and \n # check the validity condition\n\n dp = [[1 for _ in range(len(nums))] for _ in range(k)]\n maxi = 1\n for i in range(1, len(nums)):\n for j in range(i):\n rem = (nums[i]+nums[j])%k\n dp[rem][i] = max(dp[rem][j]+1, dp[rem][i])\n maxi = max(maxi, dp[rem][i])\n\n return maxi","memory":"25500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n\n n = len(nums)\n for i in range(n):\n nums[i] %= k\n\n\n dp = [[-1]*k for i in range(k)]\n ans = [[0]*k for i in range(k)]\n pr = max(Counter(nums).values())\n for i, num in enumerate(nums):\n for x in range(k):\n if num != x and dp[num][x] == 1:\n dp[num][x] = 0\n ans[num][x] = max(ans[x][num] + 1, ans[num][x])\n pr = max(pr, ans[num][x])\n \n \n for y in range(k):\n if num != y and dp[y][num] != 1:\n dp[y][num] = 1\n ans[y][num] = max(ans[y][num], ans[num][y] + 1)\n pr = max(pr, ans[y][num])\n\n return pr\n\n ","memory":"32299"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n # need to find the longest [b]abab...ab[a] sequence, \n # where a and b are any two numbers (modulo k) in nums -\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\n # array based - using positions\n # dp/counter based - where you count alternating values automatically\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \n # where dp[a][b] means the length of subsequence ending with ...,a,b\n dp = collections.defaultdict(Counter)\n mod_A = [a%k for a in A] # need to find alternate sequences in this array \n for a in mod_A: # for each number in A\n for b in range(k): # any arr element % k is less than k so need to count all the values\n dp[b][a] = dp[a][b] + 1 # this logic is similar to the up/down dp problem (wiggle sequence)\n return max(max(dp[a].values()) for a in range(k))","memory":"35400"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n # need to find the longest [b]abab...ab[a] sequence, \n # where a and b are any two numbers (modulo k) in nums -\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\n # array based - using positions (https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5390259/supercharged-no-dp/)\n # dp/counter based - where you count alternating values automatically\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \n # where dp[a][b] means the length of subsequence ending with ...,a,b\n dp = collections.defaultdict(Counter)\n mod_A = [a%k for a in A] # need to find alternate sequences in this array \n for a in mod_A: # for each number in A\n for b in range(k): # any arr element % k is less than k so need to count all the values\n dp[b][a] = dp[a][b] + 1 # this logic is similar to the up/down dp problem (wiggle sequence)\n return max(max(dp[a].values()) for a in range(k))","memory":"35400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 2:\n return 2\n \n r = (nums[n-1] + nums[n-2]) % k\n res = dict()\n res = [dict()]\n res.append({r: 2})\n mm = 2\n for i in range(2, n):\n re = dict()\n idx = n - i - 1\n for j in range(idx+1, n):\n r = (nums[idx] + nums[j])%k\n if r not in re:\n re[r] = res[n-j-1].get(r, 1) + 1\n if re[r] > mm:\n mm = re[r]\n res.append(re)\n return mm\n\n","memory":"37900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if n == 2:\n return 2\n \n r = (nums[n-1] + nums[n-2]) % k\n res = dict()\n res = [dict()]\n res.append({r: 2})\n mm = 2\n for i in range(2, n):\n re = dict()\n idx = n - i - 1\n for j in range(idx+1, n):\n r = (nums[idx] + nums[j])%k\n if r not in re:\n re[r] = res[n-j-1].get(r, 1) + 1\n if re[r] > mm:\n mm = re[r]\n res.append(re)\n return mm\n\n","memory":"38000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [{} for _ in range(len(nums))]\n ans = 0\n for i in range(len(nums)):\n for j in range(i):\n rem = (nums[i] + nums[j]) % k\n if dp[i].get(rem, 0) < dp[j].get(rem, 0) + 1:\n dp[i][rem] = dp[j].get(rem, 0) + 1\n ans = max(ans, dp[i][rem])\n return ans + 1\n\n \n \n ","memory":"38400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n l = len(nums)\n\n dp = [None] * l\n maxx = 1\n for i in range(l):\n done = [False] * k\n dp[i] = {}\n for j in range(i-1, -1, -1):\n curr = (nums[i] + nums[j]) % k\n if done[curr]:\n continue\n\n done[curr] = True\n dp[i][curr] = dp[j].get(curr, 0)+1\n maxx = max(maxx, dp[i][curr])\n \n # print(dp)\n return maxx+1\n \n\n","memory":"38500"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n rem_dict = [{} for i in range(n)]\n max_len = 0\n for i in range(n):\n for j in range(i):\n rem = (nums[i] + nums[j])%k\n if rem in rem_dict[j]:\n rem_dict[i][rem] = rem_dict[j][rem] + 1\n else:\n rem_dict[i][rem] = 2\n max_len = max(max_len, rem_dict[i][rem])\n return max_len","memory":"38600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n # mod k to all elements\n # subsequence should be of the pattern xyxyxy...\n # dp[i][y] is the longest valid subsequence in nums[0, ..., i] and must end with nums[i]\n # at index i, x = numsK[i], y = y\n # iterate j from 0 to i-1\n # if numsK[j] == y, dp[i][y] = max(dp[j][x] + 1, dp[i][y])\n # dp[0][y] = 1\n # result is max(dp)\n \n numsK = [num % k for num in nums]\n n = len(nums)\n dp = [[1] * k for _ in range(n)]\n for i in range(1, n):\n for j in range(0, i):\n x = numsK[i]\n y = numsK[j]\n dp[i][y] = max(dp[i][y], dp[j][x]+1)\n \n return max([val for val_list in dp for val in val_list])","memory":"39800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n ans = 0\n dp = [defaultdict(int) for i in range(n)]\n for i in range(n):\n for j in range(i):\n mod = (nums[i]+nums[j]) % k\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\n ans = max(ans, dp[i][mod])\n # print(dp)\n return ans + 1","memory":"44600"},{"code":"class Solution:\n def maximumLength(self, a: List[int], k: int) -> int:\n l = len(a)\n dp = [defaultdict(int) for i in range(l)]\n\n for i in range(1, l):\n for j in range(i):\n r = (a[i] + a[j]) % k\n dp[i][r] = max(dp[i][r], dp[j][r] + 1)\n\n return max(max(dp[i].values()) + 1 for i in range(l))\n ","memory":"44700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n dp = [defaultdict(int) for _ in range(len(nums))]\n for i in range(len(nums)):\n for j in range(i+1, len(nums)):\n rem = (nums[i]+nums[j])%k\n dp[j][rem] = dp[i][rem] + 1\n return 1 + max(max(d.values()) for d in dp) \n","memory":"44800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k:int) -> int:\n indexToLenDict = defaultdict(lambda: defaultdict(lambda: 0))\n best = 0\n for i, n in enumerate(nums):\n here = n % k\n resToLenI = indexToLenDict[i]\n for j in range(i):\n prevHere = nums[j]\n what = (here + prevHere) % k\n resToLenJ = indexToLenDict[j]\n couldget = resToLenJ[what] + 1\n best = max(best, couldget)\n resToLenI[what] = couldget\n return best + 1\n","memory":"45000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n nextIdx = defaultdict(dict) # i -> r -> j\n\n for i in range(len(nums)):\n for j in range(len(nums) - 1, i, -1):\n nextIdx[i][(nums[i] + nums[j]) % k] = j\n\n result = 2\n for i in range(len(nums)):\n for r in nextIdx[i].keys():\n lenSeq = 1\n curr = i\n while curr in nextIdx and r in nextIdx[curr]:\n lenSeq += 1\n curr = nextIdx[curr][r]\n\n result = max(result, lenSeq)\n\n return result\n\n\n\n\n\n\n\n\n\n","memory":"48400"},{"code":"from collections import defaultdict, Counter\n\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n dp = defaultdict(Counter)\n\n for num in nums:\n for mod in range(k):\n dp[mod][num % k] = dp[num % k][mod] + 1\n \n return max(max(dp[mod].values()) for mod in range(k))\n\n","memory":"49300"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k: int) -> int:\n # need to find the longest [b]abab...ab[a] sequence, \n # where a and b are any two numbers (modulo k) in nums -\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\n # array based - using positions\n # dp/counter based - where you count alternating values automatically\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \n # where dp[a][b] means the length of subsequence ending with ...,a,b\n dp = collections.defaultdict(Counter)\n for a in A: # for each number in A\n for b in range(k): # any arr element % k is less than k so need to count all the values\n dp[b][a % k] = dp[a % k][b] + 1 # this logic is similar to the up/down dp problem\n return max(max(dp[a].values()) for a in range(k))","memory":"49600"},{"code":"class Solution:\n def maximumLength(self, A: List[int], k) -> int:\n dp = defaultdict(Counter)\n for a in A:\n for b in range(k):\n dp[b][a % k] = dp[a % k][b] + 1\n return max(max(dp[a].values()) for a in range(k))\n","memory":"49700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], K: int) -> int:\n dp = defaultdict(lambda: defaultdict(int))\n result = 0\n for val in nums:\n for prev_mod in range(K):\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\n result = max(result, dp[prev_mod][val%K])\n return result\n\n\n# Time O(N*k)\n# Space O(N*k)\n\n# %k == constant -> alternating mod values\n # Note, also true if all mod values 0, but this also falls under alternating mod values\n\n# if end with element a%k, having b as prev mod\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\n# dp[b][a%k] = dp[a%k][b] +1","memory":"68400"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n d = defaultdict(lambda : defaultdict(int))\n ans = 0\n for n in nums:\n for i in range(k):\n d[i][n%k] = max(d[i][n%k], d[i][(i-n)%k]+1)\n ans = max(ans, d[i][n%k] )\n return ans\n ","memory":"75800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n for i in range(n):\n nums[i] = nums[i]%k\n cnt = Counter(nums)\n res = max(cnt.values())\n visited = {}\n for i in range(n):\n a = nums[i]\n for j in range(i+1,n):\n b = nums[j]\n if ((a,b) in visited) or ((b,a) in visited):\n continue\n visited[(a,b)] = True\n visited[(b,a)] = True\n if cnt[a]+cnt[b] <= res:\n continue\n c = 2\n f = False\n for k in range(j+1,n):\n if f and (nums[k] == b):\n c += 1\n f = False\n elif (not f) and (nums[k] == a):\n c += 1\n f = True\n res = max(c,res)\n\n return res\n ","memory":"81000"},{"code":"\nclass Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n subsequence_length = {} #(index_so_far, diff) -> subsequence length\n max_length = 0\n for i in range(1, len(nums)):\n for j in range(0, i):\n diff = (nums[i] + nums[j]) % k\n length = subsequence_length.get((j, diff), 1) + 1\n max_length = max(length, max_length)\n subsequence_length[(i, diff)] = length\n return max_length","memory":"88600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n f = {}\n for i in range(n):\n for j in range(i):\n f[(i,(nums[i]+nums[j])%k)] = 1 + f.get((j,(nums[i]+nums[j])%k),1)\n return max(f.values())\n ","memory":"88700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], K: int) -> int:\n pos_to_next_mod = [{} for _ in range(len(nums))]\n mod_to_earliest_pos = {}\n mod_to_earliest_pos[nums[len(nums)-1]%K] = len(nums)-1\n\n for i in range(len(nums)-2, -1, -1):\n pos_to_next_mod[i] = mod_to_earliest_pos.copy()\n mod_to_earliest_pos[nums[i]%K] = i\n\n \n # @cache\n def max_length_starting_from(i, prev_mod):\n result = 1\n if prev_mod in pos_to_next_mod[i]:\n result += max_length_starting_from(pos_to_next_mod[i][prev_mod], nums[i]%K)\n return result\n\n\n result = 0\n for start_i in range(len(nums)):\n for start_mod in range(K):\n result = max(result, max_length_starting_from(start_i, start_mod))\n return result\n\n\n# Time O(N*k)\n# Space O(N*k)","memory":"89600"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n from collections import Counter\n from itertools import permutations\n\n # Make it simpler by converting into mod k\n nums = [num % k for num in nums]\n\n # Answers can be composed of only one mod type\n modCounter = Counter(nums)\n ans = max(modCounter.values())\n\n alternativeSeqDict = {}\n # Try all combinations\n for i, j in list(permutations(range(k), 2)):\n\n # If maximum possible sequence is shorter than already found, we skip\n if modCounter[i] + modCounter[j] <= ans:\n continue\n if (j, i) in alternativeSeqDict and alternativeSeqDict[(j, i)] + 1 <= ans:\n continue\n\n # Find sequence with alternating (i, j)\n alternateSeq, searchIdx = 0, 0\n searchNums = [i, j]\n for num in nums:\n if num == searchNums[searchIdx]:\n searchIdx = 1 - searchIdx\n alternateSeq += 1\n\n # Store the value for (i, j)-alternating sequence for time efficiency\n alternativeSeqDict[(i, j)] = alternateSeq\n\n # Update max value\n ans = max(ans, alternateSeq)\n\n return ans","memory":"94300"},{"code":"from collections import defaultdict\n\n\nclass Solution:\n\n # Problem type: Dynamic programming (LCS).\n # Time complexity: O(nk).\n # Space complexity: O(nk).\n def maximumLength(self, numbers: List[int], k: int) -> int:\n \"\"\"Find the longest subsequence with increasing pairwise sums all equal modulo k.\"\"\"\n # State: ij-th entry stores the longest sequence ending at the ith index with modulo j.\n table = defaultdict(int)\n for end in range(len(numbers)):\n # Consider all elements prior to the current element.\n for index in range(end - 1, -1, -1):\n # State transition: \n remainder = (numbers[end] + numbers[index]) % k\n table[(end, remainder)] = max(\n table[(end, remainder)],\n table[(index, remainder)] + 1,\n )\n return max(table.values()) + 1","memory":"110700"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n dp = defaultdict(lambda: 1)\n res = 0\n for i in range(n):\n for j in range(i):\n diff = (nums[i]+nums[j])%k\n dp[(i, diff)] = dp[(j, diff)]+1\n\n return max(dp.values())\n","memory":"110800"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n ans = 1\n dp = defaultdict(int)\n \n for i in range(len(nums)):\n for j in range(i):\n curr_mod = (nums[i] + nums[j]) % k\n\n if dp[(j, curr_mod)]:\n dp[(i, curr_mod)] = dp[(j, curr_mod)] + 1\n\n else:\n dp[(i, curr_mod)] = 2\n \n ans = max(ans, dp[(i, curr_mod)])\n \n return ans","memory":"110900"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n \n answer = 0\n \n x = defaultdict(int)\n for i in range(1, len(nums)):\n for j in range(0, i):\n mod_sum = (nums[j] + nums[i]) % k\n x[(i, mod_sum)] = max(x[(i, mod_sum)], x[(j, mod_sum)] + 1)\n answer = max(answer, x[(i, mod_sum)])\n\n return answer + 1","memory":"111000"},{"code":"class Solution:\n def maximumLength(self, nums: List[int], k: int) -> int:\n n = len(nums)\n if k == 1:\n return n\n max_by_pair = collections.Counter()\n \n for x in nums:\n rem = x % k\n \n for first_rem in range(k):\n max_by_pair[first_rem, rem] = max(max_by_pair[first_rem, rem], max_by_pair[rem, first_rem] + 1)\n \n return max(max_by_pair.values())","memory":"111300"}],"string":"[\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n \\n # Iterate over each possible remainder value from 0 to k-1\\n for target_remainder in range(k):\\n\\n # Initialize the dynamic programming array to store the maximum length for each remainder\\n dp = [0] * k\\n \\n # Iterate over each number in the input array\\n for num in nums:\\n # Calculate the remainder of the current number when divided by k\\n current_remainder = num % k\\n \\n # Calculate the remainder that would achieve the target remainder when added to the current number\\n previous_remainder = (target_remainder - num) % k\\n\\n # Update the dp array\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n \\n # Update the result with the maximum value found in the dp array for the current target remainder\\n max_length = max(max_length, max(dp))\\n \\n return max_length\\n\\n\\n\\n\\n\\n # max_len = 0\\n # remainders = [ [0] * k for remainder in range(k) ]\\n # for num in nums:\\n # for remainder_value in range(k):\\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n # if max_len < remainders[remainder_value][num % k]:\\n # max_len = remainders[remainder_value][num % k]\\n \\n # return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"memory\": \"16400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n for target in range(k):\\n compliments = {}\\n for num in nums:\\n curr_remainder = num % k\\n compliment = (target - curr_remainder)%k\\n if compliment in compliments:\\n compliments[curr_remainder] = compliments[compliment] + 1\\n else:\\n compliments[curr_remainder] = 1\\n \\n if compliments[curr_remainder] > max_len:\\n max_len = compliments[curr_remainder]\\n \\n return max_len\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n \\n # max_length = 0\\n # for target in range(k):\\n # compliment_lis = {}\\n # for num in nums:\\n # curr = num % k\\n # compliment = (target - curr)%k\\n \\n # if compliment in compliment_lis:\\n # if curr not in compliment_lis or compliment_lis[curr] < compliment_lis[compliment] + 1:\\n # compliment_lis[curr] = compliment_lis[compliment] + 1\\n # else:\\n # compliment_lis[curr] = 1\\n \\n # if compliment_lis[curr] > max_length:\\n # max_length = compliment_lis[curr]\\n\\n # return max_length\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n # max_length = 0\\n\\n # for remainder in range(k):\\n # remainder_counts = [0] * k\\n\\n # for num in nums:\\n # # Calculate the remainder of the current number when divided by k\\n # current_remainder = num % k\\n \\n # # Calculate the remainder that would achieve the target remainder when added to the current number\\n # # remainder = (curr_remainder + compliment_remainder) % k\\n # # remainder = curr_remainder % k + compliment_remainder % k\\n # # remainder - curr_remainder = compliment_remainder\\n # compliment_remainder = remainder - current_remainder\\n # if compliment_remainder < 0:\\n # compliment_remainder = k - abs(compliment_remainder)\\n\\n # # Update the dp array\\n # remainder_counts[current_remainder] = max(remainder_counts[current_remainder], remainder_counts[compliment_remainder] + 1)\\n \\n # # Update the result with the maximum value found in the dp array for the current target remainder\\n # max_length = max(max_length, max(remainder_counts))\\n \\n # return max_length\\n\\n\\n\\n\\n\\n # max_len = 0\\n # remainders = [ [0] * k for remainder in range(k) ]\\n # for num in nums:\\n # for remainder_value in range(k):\\n # remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n # if max_len < remainders[remainder_value][num % k]:\\n # max_len = remainders[remainder_value][num % k]\\n \\n # return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"memory\": \"16500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = -float('inf')\\n\\n for target in range(k):\\n\\n dp = [0] * k\\n for num in nums:\\n curr = num % k\\n dp[curr] = max(dp[curr], dp[target - curr] + 1)\\n\\n ans = max(ans, max(dp))\\n\\n return ans\",\n \"memory\": \"16600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n res = 0 # O(nk) time, O(k) space\\n for v in range(k): # Enumearet the sub sum v = (sub[0] + sub[1]) % k, v target reminder\\n dp = [0] * k # dp[a % k] means the longest of subarray ending with a % k\\n for a in nums: # a % k current reminder, (v-a) % prev reminder\\n dp[a % k] = dp[(v - a) % k] + 1 # a can be the next element after (v - a) % k\\n res = max(res, max(dp))\\n return res\\n# https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5389350/java-c-python-1d-dp/?envType=company&envId=facebook&favoriteSlug=facebook-three-months\",\n \"memory\": \"16700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n \\n # Iterate over each possible remainder value from 0 to k-1\\n for target_remainder in range(k):\\n\\n # Initialize the dynamic programming array to store the maximum length for each remainder\\n dp = [0] * k\\n \\n # Iterate over each number in the input array\\n for num in nums:\\n # Calculate the remainder of the current number when divided by k\\n current_remainder = num % k\\n \\n # Calculate the remainder that would achieve the target remainder when added to the current number\\n previous_remainder = (target_remainder - num) % k\\n\\n # Update the dp array\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n \\n # Update the result with the maximum value found in the dp array for the current target remainder\\n max_length = max(max_length, max(dp))\\n \\n return max_length\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = 0\\n \\n # Iterate over each possible remainder value from 0 to k-1\\n for target_remainder in range(k):\\n\\n # Initialize the dynamic programming array to store the maximum length for each remainder\\n dp = [0] * k\\n \\n # Iterate over each number in the input array\\n for num in nums:\\n # Calculate the remainder of the current number when divided by k\\n current_remainder = num % k\\n \\n # Calculate the remainder that would achieve the target remainder when added to the current number\\n previous_remainder = target_remainder - current_remainder\\n\\n # Update the dp array\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n \\n # Update the result with the maximum value found in the dp array for the current target remainder\\n max_length = max(max_length, max(dp))\\n \\n return max_length\",\n \"memory\": \"16800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_length = -float('inf')\\n\\n for target in range(k):\\n\\n dp = [0] * k\\n\\n for num in nums:\\n current_remainder = num % k\\n previous_remainder = target - current_remainder\\n dp[current_remainder] = max(dp[current_remainder], dp[previous_remainder] + 1)\\n\\n max_length = max(max_length, max(dp))\\n\\n return max_length\",\n \"memory\": \"16900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n # we borrow some code from #3201:\\n\\n mods = [N % k for N in nums]\\n print(f'{mods[:10]=}')\\n\\n counts = Counter(mods)\\n print(f'counts{tuple(counts.items())[:10]}')\\n\\n cases = []\\n\\n # case group 1: all the same\\n for mod, count in counts.items():\\n cases.append(count)\\n # print(f'case group 1: all {mod} = {count}')\\n \\n best_case_1 = max(cases, default=0)\\n print(f'{best_case_1=}')\\n cases = []\\n\\n # case group 2: any pair, alternating\\n for first, firstCount in counts.items():\\n for second, secondCount in counts.items():\\n # print(f'Try {first}, {second}:')\\n if first == second:\\n # print(f' No: same')\\n continue\\n if min(firstCount, secondCount) * 2 + 1 <= best_case_1:\\n # series will be alternating, e.g. [1 2 1 2 1]\\n # our limiting reagent is the 2's (minimum count):\\n # any extra 1's will be unused\\n # print(f' No: {firstCount},{secondCount} cant beat best case 1')\\n continue\\n\\n prior = first\\n index = mods.index(prior)\\n this_case = 1\\n # print(f'{this_case=} [{index}]{prior}')\\n while True:\\n next = second if (prior == first) else first # 1st->2nd, 2nd->1st\\n try:\\n index = mods.index(next, index + 1)\\n except ValueError:\\n break\\n prior = mods[index]\\n this_case += 1\\n # print(f'{this_case=} [{index}]{prior}')\\n cases.append(this_case)\\n # print(f'case group 2: {first},{second} = {this_case}')\\n best_case_2 = max(cases, default=0)\\n print(f'{best_case_2=}')\\n\\n return max(best_case_1, best_case_2)\\n\",\n \"memory\": \"17000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # Constraints indicate that n * k solution is possible\\n # We can iterate over all mod values of k? k\\n # again ,reduce array to \\n # go through all different possible modded values\\n # Then for each one, go through all unique numbers\\n # Find what other number is needed to make it the target mod value\\n # then see how many times we can alternate through\\n # k * n since we at most go through all indices 2 times\\n def alternating(a_idxes, b_idxes):\\n if a_idxes == b_idxes:\\n return len(a_idxes)\\n jumbledup = [[x, 0] for x in a_idxes] + [[x, 1] for x in b_idxes]\\n jumbledup.sort()\\n prev = -1\\n result = 0\\n for _, source in jumbledup:\\n if source != prev:\\n prev = source\\n result += 1\\n return result\\n nums = [x % k for x in nums]\\n indices = defaultdict(list)\\n for idx, x in enumerate(nums):\\n indices[x].append(idx)\\n unique_vals = set(nums)\\n result = 0\\n for target_mod in range(k):\\n for val in unique_vals:\\n if val <= target_mod:\\n needed = target_mod - val\\n else:\\n needed = k + target_mod - val\\n result = max(result, alternating(indices[val], indices[needed]))\\n return result\\n\\n \",\n \"memory\": \"17100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n '''\\n 1) max(chain(*dp)), to find max of a matrix\\n 2) (sub[0] + sub[1]) % k == (sub[1] + sub[2]) % k => this mean that sub[0]%k == sub[2]%k\\n so we find the mod of num%k, then find another mod from prev case, if you find it them you add 1 \\n\\n example: Input: nums = [1,4,2,3,1,4], k = 3\\n 1 => 1%3 = 1\\n for prev_mod = 0 => 0, for prev_mod = 1 => 0, for prev_mod = 2 => 0\\n\\n DP 0 1 2\\n 0 1 1 1\\n 1 0 0 0\\n 2 0 0 0\\n 4 => 4%3 = 1\\n for prev_mod = 0 => 0, for prev_mod = 1 => 1, for prev_mod = 2 => 0\\n DP 0 1 2\\n 0 2 2 2\\n 1 0 0 0\\n 2 0 0 0\\n\\n Tags: DP\\n TC: O(N*k)\\n SC: O(k*k)\\n '''\\n dp = [[0]*k for _ in range(k)]\\n\\n for num in nums:\\n num_mod = num % k\\n for prev_mod in range(k):\\n dp[num_mod][prev_mod] = max(dp[num_mod][prev_mod], dp[prev_mod][num_mod] + 1)\\n \\n return max(chain(*dp))\\n\\n \",\n \"memory\": \"22500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0]*k for _ in range(n)]\\n res = 0\\n \\n last = defaultdict(int)\\n for i in range(n):\\n for t in range(k):\\n d = ((t-nums[i]%k)+k)%k\\n if d in last:\\n j = last[d]\\n dp[i][t] = dp[j][t] + 1\\n \\n else:\\n dp[i][t] = 1\\n res = max(res, dp[i][t])\\n \\n last[nums[i]%k] = i\\n \\n return res\\n \",\n \"memory\": \"24300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0] * k for _ in range(len(nums))]\\n last = [-1] * k\\n ret = 0\\n\\n n = len(nums)\\n for i in range(n):\\n for r in range(k):\\n d = (r - nums[i] % k + k) % k\\n if last[d] != -1:\\n j = last[d]\\n dp[i][r] = dp[j][r] + 1\\n else:\\n dp[i][r] = 1\\n ret = max(ret, dp[i][r])\\n\\n last[nums[i] % k] = i\\n\\n return ret\",\n \"memory\": \"24400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[0] * k for _ in range(n)]\\n ans = 0\\n \\n for i in range(n):\\n for j in range(i):\\n mod = (nums[i] + nums[j]) % k\\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\\n ans = max(ans, dp[i][mod])\\n \\n return ans+1\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = [[1] * k for _ in range(n)]\\n ans = 0\\n \\n for i in range(n):\\n for j in range(i):\\n mod = (nums[i] + nums[j]) % k\\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\\n ans = max(ans, dp[i][mod])\\n \\n # print(f\\\"{ans} {dp}\\\")\\n return ans\",\n \"memory\": \"24500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ret = 0\\n dp = [[0] * k for _ in range(k)]\\n for a in nums:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n ret = max(ret, dp[b][a % k])\\n return ret\",\n \"memory\": \"24600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0]*k for _ in range(k)]\\n for x in nums: \\n x %= k \\n for y in range(k): \\n dp[x][y] = 1 + dp[y][x]\\n return max(map(max, dp))\",\n \"memory\": \"24700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n nums = [i % k for i in nums]\\n \\n n = len(nums)\\n dp = [[0] * k for _ in range(k)]\\n \\n for j in range(k):\\n dp[j][nums[0]] = 1\\n\\n for i in range(1, n):\\n for j in range(k):\\n dp[j][nums[i]] = max(dp[j][(2 * k - nums[i] + j) % k] + 1, dp[j][nums[i]])\\n return max(max(x) for x in dp)\\n\",\n \"memory\": \"24800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n\\n positions = collections.defaultdict(list)\\n for pos, val in enumerate(nums):\\n v = val % k\\n nums[pos] = v\\n positions[v].append(pos)\\n\\n dp = [[1] * len(nums) for _ in range(k)]\\n\\n ans = 0\\n for p in range(k):\\n for i in range(n-1, -1, -1):\\n r = (p-nums[i]) % k\\n idx = bisect_right(positions[r], i)\\n if idx < len(positions[r]):\\n dp[p][i] = max(dp[p][i], dp[p][positions[r][idx]] + 1)\\n ans = max(ans, dp[p][i])\\n return ans\",\n \"memory\": \"24900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n \\n nums = [nums[i]%k for i in range(len(nums))]\\n \\n for v in nums:\\n cur = v%k\\n \\n for prev in range(k):\\n sumd = (v+prev)%k\\n dp[cur][sumd] = dp[prev][sumd]+1\\n \\n \\n ans = 0\\n for i in range(k):\\n for j in range(k):\\n # print(dp[i][j])\\n ans = dp[i][j] if dp[i][j]>ans else ans\\n \\n \\n return ans\\n \\n \\n \",\n \"memory\": \"25100\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n max_len = 0\\n remainders = [ [0 for remainder_count in range(k)] for remainder_value in range(k) ]\\n for num in nums:\\n for remainder_value in range(k):\\n remainders[remainder_value][num % k] = remainders[num % k][remainder_value] + 1\\n if max_len < remainders[remainder_value][num % k]:\\n max_len = remainders[remainder_value][num % k]\\n \\n return max_len\\n \\n\\n\\n\\n\\n\\n # max_len = 0\\n # for remainder in range(k):\\n # curr_max = self.get_max_length(nums, k, remainder)\\n # if curr_max > max_len:\\n # max_len = curr_max\\n\\n # return max_len\\n \\n # def get_max_length(self, nums, k, remainder):\\n # lis = [1] * len(nums)\\n # curr_max = 1\\n # for index in range(len(nums)):\\n # for subindex in range(index):\\n # if (nums[index] + nums[subindex]) % k == remainder:\\n # if lis[index] < lis[subindex] + 1:\\n # lis[index] = lis[subindex] + 1\\n \\n # if curr_max < lis[index]:\\n # curr_max = lis[index]\\n \\n # return curr_max\\n\\n \",\n \"memory\": \"25200\"\n },\n {\n \"code\": \"class Solution:\\n def __init__(self):\\n self.dp = None\\n self.k = 0\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [[0 for i in range(k)] for j in range(k)]\\n ans = 0\\n for x in nums:\\n x %= k\\n for j in range(k):\\n y = (j-x+k)%k\\n dp[x][y] = dp[y][x]+1\\n ans = max(ans, dp[x][y])\\n return ans\",\n \"memory\": \"25300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n dp = [[0 for _ in range(k)] for _ in range(k)]\\n \\n # print(dp)\\n \\n for i, num in enumerate(nums):\\n ci = num % k\\n if i == 0:\\n dp[ci] = [1 for _ in range(k)]\\n else:\\n for ri in range(k):\\n dp[ci][ri] = dp[ri][ci] + 1\\n # print(dp)\\n out = max(map(max, dp))\\n # print(out)\\n return out\\n \",\n \"memory\": \"25400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # brute force is to build all subsequences and \\n # check the validity condition\\n\\n dp = [[1 for _ in range(len(nums))] for _ in range(k)]\\n maxi = 1\\n for i in range(1, len(nums)):\\n for j in range(i):\\n rem = (nums[i]+nums[j])%k\\n dp[rem][i] = max(dp[rem][j]+1, dp[rem][i])\\n maxi = max(maxi, dp[rem][i])\\n\\n return maxi\",\n \"memory\": \"25500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n\\n n = len(nums)\\n for i in range(n):\\n nums[i] %= k\\n\\n\\n dp = [[-1]*k for i in range(k)]\\n ans = [[0]*k for i in range(k)]\\n pr = max(Counter(nums).values())\\n for i, num in enumerate(nums):\\n for x in range(k):\\n if num != x and dp[num][x] == 1:\\n dp[num][x] = 0\\n ans[num][x] = max(ans[x][num] + 1, ans[num][x])\\n pr = max(pr, ans[num][x])\\n \\n \\n for y in range(k):\\n if num != y and dp[y][num] != 1:\\n dp[y][num] = 1\\n ans[y][num] = max(ans[y][num], ans[num][y] + 1)\\n pr = max(pr, ans[y][num])\\n\\n return pr\\n\\n \",\n \"memory\": \"32299\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n # need to find the longest [b]abab...ab[a] sequence, \\n # where a and b are any two numbers (modulo k) in nums -\\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\\n # array based - using positions\\n # dp/counter based - where you count alternating values automatically\\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \\n # where dp[a][b] means the length of subsequence ending with ...,a,b\\n dp = collections.defaultdict(Counter)\\n mod_A = [a%k for a in A] # need to find alternate sequences in this array \\n for a in mod_A: # for each number in A\\n for b in range(k): # any arr element % k is less than k so need to count all the values\\n dp[b][a] = dp[a][b] + 1 # this logic is similar to the up/down dp problem (wiggle sequence)\\n return max(max(dp[a].values()) for a in range(k))\",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n # need to find the longest [b]abab...ab[a] sequence, \\n # where a and b are any two numbers (modulo k) in nums -\\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\\n # array based - using positions (https://leetcode.com/problems/find-the-maximum-length-of-valid-subsequence-ii/solutions/5390259/supercharged-no-dp/)\\n # dp/counter based - where you count alternating values automatically\\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \\n # where dp[a][b] means the length of subsequence ending with ...,a,b\\n dp = collections.defaultdict(Counter)\\n mod_A = [a%k for a in A] # need to find alternate sequences in this array \\n for a in mod_A: # for each number in A\\n for b in range(k): # any arr element % k is less than k so need to count all the values\\n dp[b][a] = dp[a][b] + 1 # this logic is similar to the up/down dp problem (wiggle sequence)\\n return max(max(dp[a].values()) for a in range(k))\",\n \"memory\": \"35400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 2:\\n return 2\\n \\n r = (nums[n-1] + nums[n-2]) % k\\n res = dict()\\n res = [dict()]\\n res.append({r: 2})\\n mm = 2\\n for i in range(2, n):\\n re = dict()\\n idx = n - i - 1\\n for j in range(idx+1, n):\\n r = (nums[idx] + nums[j])%k\\n if r not in re:\\n re[r] = res[n-j-1].get(r, 1) + 1\\n if re[r] > mm:\\n mm = re[r]\\n res.append(re)\\n return mm\\n\\n\",\n \"memory\": \"37900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if n == 2:\\n return 2\\n \\n r = (nums[n-1] + nums[n-2]) % k\\n res = dict()\\n res = [dict()]\\n res.append({r: 2})\\n mm = 2\\n for i in range(2, n):\\n re = dict()\\n idx = n - i - 1\\n for j in range(idx+1, n):\\n r = (nums[idx] + nums[j])%k\\n if r not in re:\\n re[r] = res[n-j-1].get(r, 1) + 1\\n if re[r] > mm:\\n mm = re[r]\\n res.append(re)\\n return mm\\n\\n\",\n \"memory\": \"38000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [{} for _ in range(len(nums))]\\n ans = 0\\n for i in range(len(nums)):\\n for j in range(i):\\n rem = (nums[i] + nums[j]) % k\\n if dp[i].get(rem, 0) < dp[j].get(rem, 0) + 1:\\n dp[i][rem] = dp[j].get(rem, 0) + 1\\n ans = max(ans, dp[i][rem])\\n return ans + 1\\n\\n \\n \\n \",\n \"memory\": \"38400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n l = len(nums)\\n\\n dp = [None] * l\\n maxx = 1\\n for i in range(l):\\n done = [False] * k\\n dp[i] = {}\\n for j in range(i-1, -1, -1):\\n curr = (nums[i] + nums[j]) % k\\n if done[curr]:\\n continue\\n\\n done[curr] = True\\n dp[i][curr] = dp[j].get(curr, 0)+1\\n maxx = max(maxx, dp[i][curr])\\n \\n # print(dp)\\n return maxx+1\\n \\n\\n\",\n \"memory\": \"38500\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n rem_dict = [{} for i in range(n)]\\n max_len = 0\\n for i in range(n):\\n for j in range(i):\\n rem = (nums[i] + nums[j])%k\\n if rem in rem_dict[j]:\\n rem_dict[i][rem] = rem_dict[j][rem] + 1\\n else:\\n rem_dict[i][rem] = 2\\n max_len = max(max_len, rem_dict[i][rem])\\n return max_len\",\n \"memory\": \"38600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n # mod k to all elements\\n # subsequence should be of the pattern xyxyxy...\\n # dp[i][y] is the longest valid subsequence in nums[0, ..., i] and must end with nums[i]\\n # at index i, x = numsK[i], y = y\\n # iterate j from 0 to i-1\\n # if numsK[j] == y, dp[i][y] = max(dp[j][x] + 1, dp[i][y])\\n # dp[0][y] = 1\\n # result is max(dp)\\n \\n numsK = [num % k for num in nums]\\n n = len(nums)\\n dp = [[1] * k for _ in range(n)]\\n for i in range(1, n):\\n for j in range(0, i):\\n x = numsK[i]\\n y = numsK[j]\\n dp[i][y] = max(dp[i][y], dp[j][x]+1)\\n \\n return max([val for val_list in dp for val in val_list])\",\n \"memory\": \"39800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n n = len(nums)\\n ans = 0\\n dp = [defaultdict(int) for i in range(n)]\\n for i in range(n):\\n for j in range(i):\\n mod = (nums[i]+nums[j]) % k\\n dp[i][mod] = max(dp[i][mod], dp[j][mod] + 1)\\n ans = max(ans, dp[i][mod])\\n # print(dp)\\n return ans + 1\",\n \"memory\": \"44600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, a: List[int], k: int) -> int:\\n l = len(a)\\n dp = [defaultdict(int) for i in range(l)]\\n\\n for i in range(1, l):\\n for j in range(i):\\n r = (a[i] + a[j]) % k\\n dp[i][r] = max(dp[i][r], dp[j][r] + 1)\\n\\n return max(max(dp[i].values()) + 1 for i in range(l))\\n \",\n \"memory\": \"44700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n dp = [defaultdict(int) for _ in range(len(nums))]\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n rem = (nums[i]+nums[j])%k\\n dp[j][rem] = dp[i][rem] + 1\\n return 1 + max(max(d.values()) for d in dp) \\n\",\n \"memory\": \"44800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k:int) -> int:\\n indexToLenDict = defaultdict(lambda: defaultdict(lambda: 0))\\n best = 0\\n for i, n in enumerate(nums):\\n here = n % k\\n resToLenI = indexToLenDict[i]\\n for j in range(i):\\n prevHere = nums[j]\\n what = (here + prevHere) % k\\n resToLenJ = indexToLenDict[j]\\n couldget = resToLenJ[what] + 1\\n best = max(best, couldget)\\n resToLenI[what] = couldget\\n return best + 1\\n\",\n \"memory\": \"45000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n nextIdx = defaultdict(dict) # i -> r -> j\\n\\n for i in range(len(nums)):\\n for j in range(len(nums) - 1, i, -1):\\n nextIdx[i][(nums[i] + nums[j]) % k] = j\\n\\n result = 2\\n for i in range(len(nums)):\\n for r in nextIdx[i].keys():\\n lenSeq = 1\\n curr = i\\n while curr in nextIdx and r in nextIdx[curr]:\\n lenSeq += 1\\n curr = nextIdx[curr][r]\\n\\n result = max(result, lenSeq)\\n\\n return result\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\",\n \"memory\": \"48400\"\n },\n {\n \"code\": \"from collections import defaultdict, Counter\\n\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n dp = defaultdict(Counter)\\n\\n for num in nums:\\n for mod in range(k):\\n dp[mod][num % k] = dp[num % k][mod] + 1\\n \\n return max(max(dp[mod].values()) for mod in range(k))\\n\\n\",\n \"memory\": \"49300\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k: int) -> int:\\n # need to find the longest [b]abab...ab[a] sequence, \\n # where a and b are any two numbers (modulo k) in nums -\\n # https://www.youtube.com/watch?v=V_bVlBaRh-s\\n # worst case approach is O(k^2 * n) if done brute force. Two better ways:\\n # array based - using positions\\n # dp/counter based - where you count alternating values automatically\\n # dp[b][a] = max(dp[b][a], dp[a][b] + 1) \\n # where dp[a][b] means the length of subsequence ending with ...,a,b\\n dp = collections.defaultdict(Counter)\\n for a in A: # for each number in A\\n for b in range(k): # any arr element % k is less than k so need to count all the values\\n dp[b][a % k] = dp[a % k][b] + 1 # this logic is similar to the up/down dp problem\\n return max(max(dp[a].values()) for a in range(k))\",\n \"memory\": \"49600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, A: List[int], k) -> int:\\n dp = defaultdict(Counter)\\n for a in A:\\n for b in range(k):\\n dp[b][a % k] = dp[a % k][b] + 1\\n return max(max(dp[a].values()) for a in range(k))\\n\",\n \"memory\": \"49700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], K: int) -> int:\\n dp = defaultdict(lambda: defaultdict(int))\\n result = 0\\n for val in nums:\\n for prev_mod in range(K):\\n dp[prev_mod][val%K] = dp[val%K][prev_mod] + 1\\n result = max(result, dp[prev_mod][val%K])\\n return result\\n\\n\\n# Time O(N*k)\\n# Space O(N*k)\\n\\n# %k == constant -> alternating mod values\\n # Note, also true if all mod values 0, but this also falls under alternating mod values\\n\\n# if end with element a%k, having b as prev mod\\n# dp[b][a%k] = length of sequence ending with the mods b,a%k\\n# dp[b][a%k] = dp[a%k][b] +1\",\n \"memory\": \"68400\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n d = defaultdict(lambda : defaultdict(int))\\n ans = 0\\n for n in nums:\\n for i in range(k):\\n d[i][n%k] = max(d[i][n%k], d[i][(i-n)%k]+1)\\n ans = max(ans, d[i][n%k] )\\n return ans\\n \",\n \"memory\": \"75800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n for i in range(n):\\n nums[i] = nums[i]%k\\n cnt = Counter(nums)\\n res = max(cnt.values())\\n visited = {}\\n for i in range(n):\\n a = nums[i]\\n for j in range(i+1,n):\\n b = nums[j]\\n if ((a,b) in visited) or ((b,a) in visited):\\n continue\\n visited[(a,b)] = True\\n visited[(b,a)] = True\\n if cnt[a]+cnt[b] <= res:\\n continue\\n c = 2\\n f = False\\n for k in range(j+1,n):\\n if f and (nums[k] == b):\\n c += 1\\n f = False\\n elif (not f) and (nums[k] == a):\\n c += 1\\n f = True\\n res = max(c,res)\\n\\n return res\\n \",\n \"memory\": \"81000\"\n },\n {\n \"code\": \"\\nclass Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n subsequence_length = {} #(index_so_far, diff) -> subsequence length\\n max_length = 0\\n for i in range(1, len(nums)):\\n for j in range(0, i):\\n diff = (nums[i] + nums[j]) % k\\n length = subsequence_length.get((j, diff), 1) + 1\\n max_length = max(length, max_length)\\n subsequence_length[(i, diff)] = length\\n return max_length\",\n \"memory\": \"88600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n f = {}\\n for i in range(n):\\n for j in range(i):\\n f[(i,(nums[i]+nums[j])%k)] = 1 + f.get((j,(nums[i]+nums[j])%k),1)\\n return max(f.values())\\n \",\n \"memory\": \"88700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], K: int) -> int:\\n pos_to_next_mod = [{} for _ in range(len(nums))]\\n mod_to_earliest_pos = {}\\n mod_to_earliest_pos[nums[len(nums)-1]%K] = len(nums)-1\\n\\n for i in range(len(nums)-2, -1, -1):\\n pos_to_next_mod[i] = mod_to_earliest_pos.copy()\\n mod_to_earliest_pos[nums[i]%K] = i\\n\\n \\n # @cache\\n def max_length_starting_from(i, prev_mod):\\n result = 1\\n if prev_mod in pos_to_next_mod[i]:\\n result += max_length_starting_from(pos_to_next_mod[i][prev_mod], nums[i]%K)\\n return result\\n\\n\\n result = 0\\n for start_i in range(len(nums)):\\n for start_mod in range(K):\\n result = max(result, max_length_starting_from(start_i, start_mod))\\n return result\\n\\n\\n# Time O(N*k)\\n# Space O(N*k)\",\n \"memory\": \"89600\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n from collections import Counter\\n from itertools import permutations\\n\\n # Make it simpler by converting into mod k\\n nums = [num % k for num in nums]\\n\\n # Answers can be composed of only one mod type\\n modCounter = Counter(nums)\\n ans = max(modCounter.values())\\n\\n alternativeSeqDict = {}\\n # Try all combinations\\n for i, j in list(permutations(range(k), 2)):\\n\\n # If maximum possible sequence is shorter than already found, we skip\\n if modCounter[i] + modCounter[j] <= ans:\\n continue\\n if (j, i) in alternativeSeqDict and alternativeSeqDict[(j, i)] + 1 <= ans:\\n continue\\n\\n # Find sequence with alternating (i, j)\\n alternateSeq, searchIdx = 0, 0\\n searchNums = [i, j]\\n for num in nums:\\n if num == searchNums[searchIdx]:\\n searchIdx = 1 - searchIdx\\n alternateSeq += 1\\n\\n # Store the value for (i, j)-alternating sequence for time efficiency\\n alternativeSeqDict[(i, j)] = alternateSeq\\n\\n # Update max value\\n ans = max(ans, alternateSeq)\\n\\n return ans\",\n \"memory\": \"94300\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\n\\nclass Solution:\\n\\n # Problem type: Dynamic programming (LCS).\\n # Time complexity: O(nk).\\n # Space complexity: O(nk).\\n def maximumLength(self, numbers: List[int], k: int) -> int:\\n \\\"\\\"\\\"Find the longest subsequence with increasing pairwise sums all equal modulo k.\\\"\\\"\\\"\\n # State: ij-th entry stores the longest sequence ending at the ith index with modulo j.\\n table = defaultdict(int)\\n for end in range(len(numbers)):\\n # Consider all elements prior to the current element.\\n for index in range(end - 1, -1, -1):\\n # State transition: \\n remainder = (numbers[end] + numbers[index]) % k\\n table[(end, remainder)] = max(\\n table[(end, remainder)],\\n table[(index, remainder)] + 1,\\n )\\n return max(table.values()) + 1\",\n \"memory\": \"110700\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n dp = defaultdict(lambda: 1)\\n res = 0\\n for i in range(n):\\n for j in range(i):\\n diff = (nums[i]+nums[j])%k\\n dp[(i, diff)] = dp[(j, diff)]+1\\n\\n return max(dp.values())\\n\",\n \"memory\": \"110800\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n ans = 1\\n dp = defaultdict(int)\\n \\n for i in range(len(nums)):\\n for j in range(i):\\n curr_mod = (nums[i] + nums[j]) % k\\n\\n if dp[(j, curr_mod)]:\\n dp[(i, curr_mod)] = dp[(j, curr_mod)] + 1\\n\\n else:\\n dp[(i, curr_mod)] = 2\\n \\n ans = max(ans, dp[(i, curr_mod)])\\n \\n return ans\",\n \"memory\": \"110900\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n \\n answer = 0\\n \\n x = defaultdict(int)\\n for i in range(1, len(nums)):\\n for j in range(0, i):\\n mod_sum = (nums[j] + nums[i]) % k\\n x[(i, mod_sum)] = max(x[(i, mod_sum)], x[(j, mod_sum)] + 1)\\n answer = max(answer, x[(i, mod_sum)])\\n\\n return answer + 1\",\n \"memory\": \"111000\"\n },\n {\n \"code\": \"class Solution:\\n def maximumLength(self, nums: List[int], k: int) -> int:\\n n = len(nums)\\n if k == 1:\\n return n\\n max_by_pair = collections.Counter()\\n \\n for x in nums:\\n rem = x % k\\n \\n for first_rem in range(k):\\n max_by_pair[first_rem, rem] = max(max_by_pair[first_rem, rem], max_by_pair[rem, first_rem] + 1)\\n \\n return max(max_by_pair.values())\",\n \"memory\": \"111300\"\n }\n]","isConversational":false},"mm_solution_count":{"kind":"number","value":53,"string":"53"}}},{"rowIdx":2475,"cells":{"question_id":{"kind":"number","value":3439,"string":"3,439"},"name":{"kind":"string","value":"find-minimum-diameter-after-merging-two-trees"},"content":{"kind":"string","value":"<p>There exist two <strong>undirected </strong>trees with <code>n</code> and <code>m</code> nodes, numbered from <code>0</code> to <code>n - 1</code> and from <code>0</code> to <code>m - 1</code>, respectively. You are given two 2D integer arrays <code>edges1</code> and <code>edges2</code> of lengths <code>n - 1</code> and <code>m - 1</code>, respectively, where <code>edges1[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the first tree and <code>edges2[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> indicates that there is an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> in the second tree.</p>\n\n<p>You must connect one node from the first tree with another node from the second tree with an edge.</p>\n\n<p>Return the <strong>minimum </strong>possible <strong>diameter </strong>of the resulting tree.</p>\n\n<p>The <strong>diameter</strong> of a tree is the length of the <em>longest</em> path between any two nodes in the tree.</p>\n\n<p> </p>\n<p><strong class=\"example\">Example 1:</strong><img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/22/example11-transformed.png\" /></p>\n\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">3</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>We can obtain a tree of diameter 3 by connecting node 0 from the first tree with any node from the second tree.</p>\n</div>\n\n<p><strong class=\"example\">Example 2:</strong></p>\n<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2024/04/22/example211.png\" />\n<div class=\"example-block\">\n<p><strong>Input:</strong> <span class=\"example-io\">edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]</span></p>\n\n<p><strong>Output:</strong> <span class=\"example-io\">5</span></p>\n\n<p><strong>Explanation:</strong></p>\n\n<p>We can obtain a tree of diameter 5 by connecting node 0 from the first tree with node 0 from the second tree.</p>\n</div>\n\n<p> </p>\n<p><strong>Constraints:</strong></p>\n\n<ul>\n\t<li><code>1 <= n, m <= 10<sup>5</sup></code></li>\n\t<li><code>edges1.length == n - 1</code></li>\n\t<li><code>edges2.length == m - 1</code></li>\n\t<li><code>edges1[i].length == edges2[i].length == 2</code></li>\n\t<li><code>edges1[i] = [a<sub>i</sub>, b<sub>i</sub>]</code></li>\n\t<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code></li>\n\t<li><code>edges2[i] = [u<sub>i</sub>, v<sub>i</sub>]</code></li>\n\t<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> < m</code></li>\n\t<li>The input is generated such that <code>edges1</code> and <code>edges2</code> represent valid trees.</li>\n</ul>\n"},"acRate":{"kind":"number","value":35.95382746051033,"string":"35.953827"},"difficulty":{"kind":"string","value":"Hard"},"topics":{"kind":"list like","value":["tree","depth-first-search","breadth-first-search","graph"],"string":"[\n \"tree\",\n \"depth-first-search\",\n \"breadth-first-search\",\n \"graph\"\n]","isConversational":false},"runtimeDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"604\", 0.7936], [\"638\", 0.3968], [\"672\", 0.3968], [\"706\", 0.3968], [\"741\", 0.3968], [\"775\", 0.3968], [\"809\", 0.3968], [\"844\", 0.3968], [\"878\", 0.3968], [\"912\", 0.3968], [\"946\", 0.3968], [\"981\", 0.3968], [\"1015\", 0.3968], [\"1049\", 1.5873], [\"1083\", 0.3968], [\"1118\", 0.3968], [\"1152\", 0.7937], [\"1186\", 0.3968], [\"1221\", 0.3968], [\"1255\", 0.7937], [\"1289\", 0.7937], [\"1323\", 0.3968], [\"1358\", 0.3968], [\"1392\", 0.3968], [\"1426\", 0.7937], [\"1461\", 0.3968], [\"1495\", 0.7937], [\"1529\", 0.7937], [\"1563\", 0.3968], [\"1598\", 0.3968], [\"1632\", 0.3968], [\"1666\", 0.3968], [\"1700\", 0.3968], [\"1735\", 0.3968], [\"1769\", 0.3968], [\"1803\", 0.3968], [\"1838\", 0.3968], [\"1872\", 1.1905], [\"1906\", 0.3968], [\"1940\", 0.3968], [\"1975\", 0.3968], [\"2009\", 0.7937], [\"2043\", 0.3968], [\"2077\", 0.3968], [\"2112\", 0.3968], [\"2146\", 0.3968], [\"2180\", 0.3968], [\"2215\", 0.3968], [\"2249\", 0.3968], [\"2283\", 0.7937], [\"2317\", 0.7937], [\"2352\", 0.3968], [\"2386\", 0.3968], [\"2420\", 1.1905], [\"2454\", 0.3968], [\"2489\", 0.3968], [\"2523\", 6.745799999999999], [\"2557\", 15.476200000000002], [\"2592\", 8.3334], [\"2626\", 4.761799999999999], [\"2660\", 6.745799999999998], [\"2694\", 4.364999999999999], [\"2729\", 1.984], [\"2763\", 3.1743999999999994], [\"2797\", 1.1904], [\"2832\", 1.5873], [\"2866\", 2.3808], [\"2900\", 1.1905], [\"2934\", 1.1904], [\"2969\", 1.1904], [\"3003\", 0.3968], [\"3037\", 0.3968], [\"3071\", 0.3968], [\"3106\", 0.3968], [\"3140\", 0.3968], [\"3174\", 0.3968], [\"3209\", 0.3968], [\"3243\", 1.1904], [\"3277\", 1.1904], [\"3311\", 0.3968]]}"},"memoryDistribution":{"kind":"string","value":"{\"lang\": \"python3\", \"distribution\": [[\"84558\", 0.7936], [\"85074\", 0.3968], [\"85590\", 0.3968], [\"86106\", 0.3968], [\"86623\", 13.889], [\"87139\", 7.539599999999999], [\"87655\", 9.9207], [\"88171\", 3.1745999999999994], [\"88688\", 1.1905], [\"89204\", 1.5873], [\"89720\", 0.3968], [\"90236\", 1.5873], [\"90753\", 0.3968], [\"91269\", 0.3968], [\"91785\", 0.3968], [\"92301\", 0.3968], [\"92818\", 0.3968], [\"93334\", 0.3968], [\"93850\", 2.7778], [\"94366\", 6.7459999999999996], [\"94883\", 1.5873], [\"95399\", 6.7459999999999996], [\"95915\", 0.3968], [\"96431\", 3.9681999999999995], [\"96948\", 1.1905], [\"97464\", 1.1904], [\"97980\", 1.1905], [\"98496\", 1.5873], [\"99013\", 0.3968], [\"99529\", 1.1904], [\"100045\", 0.7936], [\"100561\", 0.7936], [\"101078\", 0.7936], [\"101594\", 0.7937], [\"102110\", 0.7936], [\"102626\", 0.3968], [\"103143\", 0.3968], [\"103659\", 0.3968], [\"104175\", 0.3968], [\"104691\", 0.7937], [\"105208\", 0.3968], [\"105724\", 0.7937], [\"106240\", 1.5873], [\"106756\", 0.3968], [\"107273\", 0.3968], [\"107789\", 0.3968], [\"108305\", 0.3968], [\"108821\", 0.3968], [\"109338\", 0.3968], [\"109854\", 1.1904], [\"110370\", 0.7936], [\"110886\", 1.1904], [\"111403\", 1.1905], [\"111919\", 0.3968], [\"112435\", 0.3968], [\"112951\", 0.3968], [\"113468\", 0.3968], [\"113984\", 0.3968], [\"114500\", 0.3968], [\"115016\", 0.3968], [\"115533\", 0.3968], [\"116049\", 0.3968], [\"116565\", 0.7937], [\"117081\", 0.3968], [\"117598\", 0.3968], [\"118114\", 0.3968], [\"118630\", 0.3968]]}"},"rt_list":{"kind":"list like","value":[{"code":"def diameter(edges: list[list[int]]) -> int:\n n = len(edges) + 1\n g = [[] for _ in range(n)]\n for u, v in edges:\n g[u].append(v)\n g[v].append(u)\n\n def bfs(s: int) -> list[int]:\n d = [-1] * n\n d[s] = 0\n q = deque([s])\n while q:\n v = q.popleft()\n for u in g[v]:\n if d[u] == -1:\n d[u] = d[v] + 1\n q.append(u)\n return d\n\n d0 = bfs(0)\n return max(bfs(d0.index(max(d0))))\n\n\ndef minimumDiameterAfterMerge(edges1: list[list[int]], edges2: list[list[int]]) -> int:\n d1, d2 = diameter(edges1), diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + 1 + (d2 + 1) // 2)\n\n\ndef batched(iterable, n):\n # batched('ABCDEFG', 3) → ABC DEF G\n if n < 1:\n raise ValueError('n must be at least one')\n iterator = iter(iterable)\n while batch := tuple(islice(iterator, n)):\n yield batch\n\n\nwith open(\"user.out\", \"w\") as Solution:\n for edges1, edges2 in batched(map(loads, stdin), 2):\n Solution.write(f\"{minimumDiameterAfterMerge(edges1, edges2)}\\n\")\nexit()","runtime":"604"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diameter(edge):\n N = len(edge) + 1\n if N <= 2:\n return N - 1\n degree = [0] * N\n nbrXOR = [0] * N\n for u, v in edge:\n degree[u] += 1\n degree[v] += 1\n nbrXOR[u] ^= v\n nbrXOR[v] ^= u\n q = deque([i for i in range(N) if degree[i] == 1])\n radius = 0\n while len(q) >= 2:\n radius += 1\n for _ in range(len(q)):\n u = q.popleft()\n nbr = nbrXOR[u]\n nbrXOR[nbr] ^= u # 将叶子从茎上去掉\n degree[nbr] -= 1\n if degree[nbr] == 1:\n q.append(nbr)\n dia = 2 * radius if q else 2 * radius - 1\n return dia\n\n d1 = diameter(edges1)\n d2 = diameter(edges2)\n res = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\n return max(res, d1, d2)","runtime":"604"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diameter(edge):\n N = len(edge) + 1\n if N <= 2:\n return N - 1\n degree = [0] * N\n nbrXOR = [0] * N\n for u, v in edge:\n degree[u] += 1\n degree[v] += 1\n nbrXOR[u] ^= v\n nbrXOR[v] ^= u\n q = deque([i for i in range(N) if degree[i] == 1])\n radius = 0\n while len(q) >= 2:\n radius += 1\n for _ in range(len(q)):\n u = q.popleft()\n nbr = nbrXOR[u]\n nbrXOR[nbr] ^= u\n degree[nbr] -= 1\n if degree[nbr] == 1:\n q.append(nbr)\n dia = 2 * radius if q else 2 * radius - 1\n return dia\n\n d1 = diameter(edges1)\n d2 = diameter(edges2)\n res = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\n return max(res, d1, d2) ","runtime":"638"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def get_center_dist(edge_list: List[List[int]]) -> tuple[int, bool]:\n n = len(edge_list) + 1\n neighbor_list = [set() for _ in range(n)]\n \n for x, y in edge_list:\n neighbor_list[x].add(y)\n neighbor_list[y].add(x)\n \n leaves = [i for i in range(n) if len(neighbor_list[i]) == 1]\n # seen_nodes = set()\n curr_dist = 0\n # max_dist = [0 for _ in range(n)]\n while leaves:\n curr_dist += 1\n new_leaves = []\n for leaf in leaves:\n neighbor = neighbor_list[leaf].pop()\n neighbor_neighbors = len(neighbor_list[neighbor])\n if neighbor_neighbors <= 1:\n return curr_dist, (neighbor in leaves)\n if neighbor_neighbors == 2:\n new_leaves.append(neighbor)\n neighbor_list[neighbor].discard(leaf)\n \n leaves = new_leaves\n \n return curr_dist, False\n \n dist_small, two_centers_small = get_center_dist(edges1)\n dist_large, two_centers_large = get_center_dist(edges2)\n \n if dist_small > dist_large:\n temp_small, temp_centers = dist_small, two_centers_small\n dist_small, two_centers_small = dist_large, two_centers_large\n dist_large, two_centers_large = temp_small, temp_centers\n if two_centers_large:\n curr_dists = [dist_large-1, dist_large]\n else:\n curr_dists = [dist_large, dist_large]\n curr_dists.append(dist_small+1)\n curr_dists.sort()\n return sum(curr_dists[-2:])","runtime":"672"},{"code":"class Solution:\n \n\n # def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n # def DiameterHelper(G, v):\n # n = len(G)\n # seen = [0] * n\n # seen[v] = 1\n # bfs = [v]\n # res = 1\n # node = v\n\n # for i in bfs:\n # for j in G[i]:\n # if seen[j] == 0:\n # seen[j] = seen[i] + 1\n # bfs.append(j)\n # if seen[j] > res:\n # res = seen[j]\n # node = j\n \n\n # return node, res - 1\n\n # def getDiameter(edges: List[List[int]]) -> int:\n # if not edges:\n # return 0, 0\n # n = len(edges) + 1\n # G = [[] for i in range(n)]\n # for edge in edges:\n # i = edge[0]\n # j = edge[1]\n # G[i].append(j)\n # G[j].append(i)\n\n # v1, d = DiameterHelper(G, 0)\n # v2, d = DiameterHelper(G, v1)\n # return d\n\n # d1 = getDiameter(edges1)\n # d2 = getDiameter(edges2)\n # #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n # return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"706"},{"code":"from collections import deque\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def bfs(start, n, adj):\n dist = [-1] * n\n dist[start] = 0\n q = deque([start])\n farthest_node = start\n while q:\n node = q.popleft()\n for neighbor in adj[node]:\n if dist[neighbor] == -1:\n dist[neighbor] = dist[node] + 1\n q.append(neighbor)\n farthest_node = neighbor\n return farthest_node, dist[farthest_node]\n \n def get_diameter(n, edges):\n adj = [[] for _ in range(n)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n start = 0\n farthest_node, _ = bfs(start, n, adj)\n farthest_node, diameter = bfs(farthest_node, n, adj)\n return diameter\n \n n1 = len(edges1) + 1\n n2 = len(edges2) + 1\n \n D1 = get_diameter(n1, edges1)\n D2 = get_diameter(n2, edges2)\n \n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\n \n return new_diameter\n\n ","runtime":"741"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def DiameterHelper(G, v):\n n = len(G)\n seen = [0] * n\n seen[v] = 1\n bfs = [v]\n res = 1\n node = v\n\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > res:\n res = seen[j]\n node = j\n \n\n return node, res - 1\n\n def getDiameter(edges: List[List[int]]) -> int:\n if not edges:\n return 0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for edge in edges:\n i = edge[0]\n j = edge[1]\n G[i].append(j)\n G[j].append(i)\n\n v1, d = DiameterHelper(G, 0)\n v2, d = DiameterHelper(G, v1)\n return d\n\n d1 = getDiameter(edges1)\n d2 = getDiameter(edges2)\n #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n d11 = (d1 + 1) // 2\n d21 = (d2 + 1) // 2\n return max(d1, d2, (d11 + d21 + 1))\n","runtime":"775"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def DiameterHelper(G, v):\n n = len(G)\n seen = [0] * n\n seen[v] = 1\n bfs = [v]\n res = 1\n node = v\n\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > res:\n res = seen[j]\n node = j\n \n\n return node, res - 1\n\n def getDiameter(edges: List[List[int]]) -> int:\n if not edges:\n return 0, 0, 0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for edge in edges:\n i = edge[0]\n j = edge[1]\n G[i].append(j)\n G[j].append(i)\n\n v1, d = DiameterHelper(G, 0)\n v2, d = DiameterHelper(G, v1)\n return d, v1, v2\n\n d1, i, j = getDiameter(edges1)\n d2, i, j = getDiameter(edges2)\n #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n d11 = (d1 + 1) // 2\n d21 = (d2 + 1) // 2\n return max(d1, d2, (d11 + d21 + 1))\n","runtime":"809"},{"code":"from collections import deque\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def bfs(start, n, adj):\n dist = [-1] * n\n dist[start] = 0\n q = deque([start])\n farthest_node = start\n while q:\n node = q.popleft()\n for neighbor in adj[node]:\n if dist[neighbor] == -1:\n dist[neighbor] = dist[node] + 1\n q.append(neighbor)\n farthest_node = neighbor\n return farthest_node, dist[farthest_node]\n \n def get_diameter(n, edges):\n adj = [[] for _ in range(n)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n start = 0\n farthest_node, _ = bfs(start, n, adj)\n farthest_node, diameter = bfs(farthest_node, n, adj)\n return diameter\n \n n1 = len(edges1) + 1\n n2 = len(edges2) + 1\n \n D1 = get_diameter(n1, edges1)\n D2 = get_diameter(n2, edges2)\n \n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\n \n return new_diameter\n\n #https://www.youtube.com/watch?v=vTcQjheqTVs\n\n #we add 1 as the problem statement says n-1 and m-1. ","runtime":"844"},{"code":"from collections import deque\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def bfs(start, n, adj):\n dist = [-1] * n\n dist[start] = 0\n q = deque([start])\n farthest_node = start\n while q:\n node = q.popleft()\n for neighbor in adj[node]:\n if dist[neighbor] == -1:\n dist[neighbor] = dist[node] + 1\n q.append(neighbor)\n farthest_node = neighbor\n return farthest_node, dist[farthest_node]\n \n def get_diameter(n, edges):\n adj = [[] for _ in range(n)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n start = 0\n farthest_node, _ = bfs(start, n, adj)\n farthest_node, diameter = bfs(farthest_node, n, adj)\n return diameter\n \n n1 = len(edges1) + 1\n n2 = len(edges2) + 1\n \n D1 = get_diameter(n1, edges1)\n D2 = get_diameter(n2, edges2)\n \n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\n \n return new_diameter\n\n #https://www.youtube.com/watch?v=vTcQjheqTVs\n\n ","runtime":"878"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def helper(arr):\n \n n = len(arr)+1\n deg = [0]*n\n adj =[[] for i in range(n)]\n for a,b in arr:\n adj[a].append(b)\n adj[b].append(a)\n deg[a] += 1\n deg[b] += 1\n \n dq = deque([])\n for i in range(n):\n if deg[i] == 1:\n dq.append(i)\n deg[i] -= 1\n ans = 0\n while len(dq)>1:\n L = len(dq)\n for _ in range(L):\n node = dq.popleft()\n for neigh in adj[node]:\n if deg[neigh]:\n deg[neigh] -= 1\n if deg[neigh] == 1:\n dq.append(neigh)\n ans += 1\n return 2*ans if len(dq)==1 else 2*ans-1\n a1,a2 = helper(edges1),helper(edges2)\n # print(a1,a2)\n return max(a1,a2,ceil(a1/2)+ceil(a2/2)+1)","runtime":"912"},{"code":"class Solution:\n def find_centers(self, n: int, graph: List[List[int]], in_degree: List[int]):\n q = deque([])\n if n == 1:\n return 1, 0\n if n == 2:\n return 2, 1\n for i in range (n):\n if in_degree[i] == 1:\n q.append(i)\n \n count = n\n res = 0\n while count > 2:\n count -= len(q)\n next_q = deque([])\n res += 1\n while q:\n u = q.popleft()\n for v in graph[u]:\n in_degree[v] -= 1\n if in_degree[v] == 1:\n next_q.append(v)\n q = next_q\n if count == 2:\n return res * 2 + 1, res + 1\n return res * 2, res\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n = len(edges1) + 1\n graph1 = [[] for i in range (n)]\n in_degree1 = [0 for i in range (n)]\n for i in range (n - 1):\n u, v = edges1[i]\n graph1[u].append(v)\n graph1[v].append(u)\n in_degree1[u] += 1\n in_degree1[v] += 1\n \n \n m = len(edges2) + 1\n graph2 = [[] for i in range (m)]\n in_degree2 = [0 for i in range (m)]\n for i in range (m - 1):\n u, v = edges2[i]\n graph2[u].append(v)\n graph2[v].append(u)\n in_degree2[u] += 1\n in_degree2[v] += 1\n \n diameter1, res1 = self.find_centers(n, graph1, in_degree1)\n diameter2, res2 = self.find_centers(m, graph2, in_degree2)\n \n return max(diameter1, diameter2, res1 + res2 + 1)","runtime":"946"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def bfs(s,adj,n):\n q = [s]; head = 0\n d = [n]*n\n d[s] = 0\n while head<len(q):\n v = q[head]; head += 1\n for u in adj[v]:\n if d[u]<n: continue\n q.append(u)\n d[u] = d[v]+1\n #\n v = q[-1]\n return v,d[v]\n def diameter(adj,n): # farthest of farthest\n v,dv = bfs(0,adj,n)\n u,du = bfs(v,adj,n)\n return du\n def graph(edges):\n n = len(edges)+1\n adj = [[] for i in range(n)]\n for u,v in edges:\n adj[u].append(v)\n adj[v].append(u)\n return adj,n\n #\n d1 = diameter(*graph(edges1))\n d2 = diameter(*graph(edges2))\n return max(d1,d2,(d1+1)//2+(d2+1)//2+1)","runtime":"981"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def bfs(u, graph): \n ans = 0 \n queue = deque([(u, -1)])\n while queue:\n ans += 1\n for _ in range(len(queue)): \n u, p = queue.popleft()\n for v in graph[u]: \n if v != p: \n queue.append((v, u))\n return ans, u\n \n def fn(edges): \n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for u, v in edges: \n graph[u].append(v)\n graph[v].append(u)\n _, u = bfs(0, graph)\n dia, _ = bfs(u, graph)\n return dia\n \n cnt1 = fn(edges1)\n cnt2 = fn(edges2)\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)","runtime":"1015"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, tree1: List[List[int]], tree2: List[List[int]]) -> int:\n def findFarthestNode(graph, startNode):\n numNodes = len(graph)\n queue = [startNode]\n visited = [0] * numNodes\n visited[startNode] = 1\n farthestNode = maxDistance = -1\n for node in queue:\n for neighbor in graph[node]:\n if visited[neighbor] == 0:\n visited[neighbor] = visited[node] + 1\n queue.append(neighbor)\n if visited[neighbor] > maxDistance:\n farthestNode = neighbor\n maxDistance = visited[neighbor]\n return farthestNode, maxDistance - 1\n\n def calculateDiameter(edges):\n if not edges:\n return 0, 0, 0\n numNodes = len(edges) + 1\n adjacencyList = [[] for _ in range(numNodes)]\n for node1, node2 in edges:\n adjacencyList[node1].append(node2)\n adjacencyList[node2].append(node1)\n endpoint1, distance = findFarthestNode(adjacencyList, 0)\n endpoint2, distance = findFarthestNode(adjacencyList, endpoint1)\n return distance, endpoint1, endpoint2\n\n diameter1, _, _ = calculateDiameter(tree1)\n diameter2, _, _ = calculateDiameter(tree2)\n return max(diameter1, diameter2, (diameter1 + 1) // 2 + (diameter2 + 1) // 2 + 1)\n","runtime":"1049"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def bfs(u, graph): \n \"\"\"Return \"\"\"\n ans = 0 \n queue = deque([(u, -1)])\n while queue:\n ans += 1\n for _ in range(len(queue)): \n u, p = queue.popleft()\n for v in graph[u]: \n if v != p: \n queue.append((v, u))\n return ans, u\n \n def fn(edges): \n \"\"\"Return \"\"\"\n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for u, v in edges: \n graph[u].append(v)\n graph[v].append(u)\n _, u = bfs(0, graph)\n dia, _ = bfs(u, graph)\n return dia\n \n cnt1 = fn(edges1)\n cnt2 = fn(edges2)\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)","runtime":"1083"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, v):\n n = len(G)\n bfs = [v]\n seen = [0]*n\n seen[v] = 1\n res = d = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > d:\n res = j\n d = seen[j]\n return res, d-1\n\n def diameter(edges):\n if not edges:\n return 0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for edge in edges:\n G[edge[0]].append(edge[1])\n G[edge[1]].append(edge[0])\n v1, dist = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d\n \n d1 = diameter(edges1)\n d2 = diameter(edges2)\n return max(d1, d2, (d1+1)//2 + (d2 + 1)//2 + 1)\n\n ","runtime":"1118"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1152"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1186"},{"code":"class Solution:\n def minimumDiameterAfterMerge(\n self,\n edges1: list[list[int]],\n edges2: list[list[int]],\n ) -> int:\n diameter1 = self._getDiameter(edges1)\n diameter2 = self._getDiameter(edges2)\n combinedDiameter = (diameter1 + 1) // 2 + (diameter2 + 1) // 2 + 1\n return max(diameter1, diameter2, combinedDiameter)\n\n def _getDiameter(self, edges: list[list[int]]) -> int:\n n = len(edges) + 1\n graph = [[] for _ in range(n)]\n\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n\n maxDiameter = [0]\n self._maxDepth(graph, 0, -1, maxDiameter)\n return maxDiameter[0]\n\n # Similar to 1522. Diameter of N-Ary Tree\n def _maxDepth(\n self,\n graph: list[list[int]],\n u: int,\n prev: int,\n maxDiameter: list[int],\n ) -> int:\n \"\"\"Returns the maximum depth of the subtree rooted at u.\"\"\"\n maxSubDepth1 = 0\n maxSubDepth2 = 0\n for v in graph[u]:\n if v == prev:\n continue\n maxSubDepth = self._maxDepth(graph, v, u, maxDiameter)\n if maxSubDepth > maxSubDepth1:\n maxSubDepth2 = maxSubDepth1\n maxSubDepth1 = maxSubDepth\n elif maxSubDepth > maxSubDepth2:\n maxSubDepth2 = maxSubDepth\n maxDiameter[0] = max(maxDiameter[0], maxSubDepth1 + maxSubDepth2)\n return 1 + maxSubDepth1","runtime":"1221"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def bfs(u, graph): \n \"\"\"Return \"\"\"\n ans = 0 \n queue = deque([(u, -1)])\n while queue:\n ans += 1\n for _ in range(len(queue)): \n u, p = queue.popleft()\n for v in graph[u]: \n if v != p: \n queue.append((v, u))\n return ans, u\n \n def fn(edges): \n \"\"\"Return \"\"\"\n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for u, v in edges: \n graph[u].append(v)\n graph[v].append(u)\n _, u = bfs(0, graph)\n dia, _ = bfs(u, graph)\n return dia\n \n cnt1 = fn(edges1)\n cnt2 = fn(edges2)\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)","runtime":"1255"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1289"},{"code":"\nfrom collections import defaultdict\n\nclass Solve:\n def __init__(self):\n self.tree = defaultdict(list)\n self.max_d = 0\n\n def dfs(self, node, parent):\n max1 = max2 = 0\n for neighbor in self.tree[node]:\n if neighbor != parent:\n depth = self.dfs(neighbor, node)\n if depth > max1:\n max1, max2 = depth, max1\n elif depth > max2:\n max2 = depth\n self.max_d = max(self.max_d, max1 + max2)\n return max1 + 1\n\n def treeDiameter(self, edges):\n for u, v in edges:\n self.tree[u].append(v)\n self.tree[v].append(u)\n self.dfs(0, -1)\n return self.max_d\n \nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n, m = len(edges1), len(edges2)\n a = Solve().treeDiameter(edges1)\n b = Solve().treeDiameter(edges2)\n def h(x):\n return (x + 1) // 2\n return max(a, b, h(a) + h(b) + 1)\n ","runtime":"1323"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1358"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n edges = edges1\n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for i,j in edges:\n graph[i].append(j)\n graph[j].append(i)\n d1 = 0\n def dfs(node,pa):\n nonlocal d1\n maxi = 0\n for ne in graph[node]:\n if ne==pa: continue\n x=dfs(ne,node)\n d1=max(d1,1+maxi+x)\n if x+1>maxi: maxi=x+1\n return maxi\n dfs(0,-1)\n edges = edges2\n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for i,j in edges:\n graph[i].append(j)\n graph[j].append(i)\n d2 = 0\n def dfs(node,pa):\n nonlocal d2\n maxi = 0\n for ne in graph[node]:\n if ne==pa: continue\n x=dfs(ne,node)\n d2=max(d2,1+maxi+x)\n if x+1>maxi: maxi=x+1\n return maxi\n dfs(0,-1)\n return max(d1,d2,(d1+1)//2+(d2+1)//2+1)","runtime":"1392"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farest(g,i):\n n=len(g)\n bfs=[i]\n seen=[0]*n\n seen[i]=1\n res=maxd=-1\n for i in bfs:\n for j in g[i]:\n if seen[j]==0:\n seen[j]=seen[i]+1\n bfs.append(j)\n if seen[j]>maxd:\n res=j\n maxd=seen[j]\n return res,maxd-1\n\n\n def diameter(edge):\n if not edge:\n return 0\n n=len(edge)+1\n g=[[]for i in range(n)]\n for i,j in edge:\n g[i].append(j)\n g[j].append(i)\n v1,d1=farest(g,0)\n v2,d2=farest(g,v1)\n return d2\n \n d1=diameter(edges1)\n d2=diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1426"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1461"},{"code":"from collections import deque\n\nclass Solution:\n def bfs(self, graph, node):\n n = len(graph)\n dist = [-1] * n\n q = deque()\n q.append(node)\n dist[node] = 0\n maxDist = -1\n maxNode = -1\n\n while q:\n curr = q.popleft()\n for neigh in graph[curr]:\n if dist[neigh] == -1:\n q.append(neigh)\n dist[neigh] = dist[curr] + 1\n if dist[neigh] > maxDist:\n maxDist = dist[neigh]\n maxNode = neigh\n \n return (maxNode, maxDist)\n\n def treeDiameter(self, edges):\n n = len(edges) + 1\n graph = [[] for _ in range(n)]\n for e in edges:\n graph[e[0]].append(e[1])\n graph[e[1]].append(e[0])\n \n a1 = self.bfs(graph, 0)\n a2 = self.bfs(graph, a1[0])\n return a2[1]\n\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n a = self.treeDiameter(edges1)\n b = self.treeDiameter(edges2)\n return max(a, b, (a + 1) // 2 + (b + 1) // 2 + 1)","runtime":"1495"},{"code":"class Solution:\n\n def diameter(self, edges: List[List[int]]) -> int:\n\n g = [[] for _ in range(len(edges) + 1)]\n\n for x, y in edges:\n\n g[x].append(y)\n\n g[y].append(x)\n\n res = 0\n\n def dfs(x: int, fa: int) -> int:\n\n nonlocal res\n\n max_len = 0\n\n for y in g[x]:\n\n if y != fa:\n\n sub_len = dfs(y, x) + 1\n\n res = max(res, max_len + sub_len)\n\n max_len = max(max_len, sub_len)\n\n return max_len\n\n dfs(0, -1)\n\n return res\n\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n d1 = self.diameter(edges1)\n\n d2 = self.diameter(edges2)\n\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1529"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1563"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def tree_diameter(n, edges):\n # Function to calculate the diameter of a tree given the number of nodes and the edges\n if n == 1: \n return 0\n \n # Convert edges to adjacency list\n adj = [[] for _ in range(n)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n \n # BFS to find the farthest node from an arbitrary node (say node 0)\n def bfs(node):\n queue = deque([node])\n dist = [-1] * n\n dist[node] = 0\n farthest_node = node\n \n while queue:\n u = queue.popleft()\n for v in adj[u]:\n if dist[v] == -1:\n dist[v] = dist[u] + 1\n queue.append(v)\n if dist[v] > dist[farthest_node]:\n farthest_node = v\n return farthest_node, dist[farthest_node]\n \n # First BFS to find one end of the longest path\n farthest_node, _ = bfs(0)\n # Second BFS from that farthest node to find the diameter\n _, diameter = bfs(farthest_node)\n \n return diameter\n\n\n n = len(edges1) + 1\n m = len(edges2) + 1\n \n # Get the diameters of both trees\n D1 = tree_diameter(n, edges1)\n D2 = tree_diameter(m, edges2)\n \n # The minimum possible diameter after connecting the two trees\n return max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\n","runtime":"1598"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n,m=len(edges1)+1,len(edges2)+1\n tree1=[[] for _ in range(n)]\n tree2=[[] for _ in range(m)]\n for e in edges1:\n tree1[e[0]].append(e[1])\n tree1[e[1]].append(e[0])\n for e in edges2:\n tree2[e[0]].append(e[1])\n tree2[e[1]].append(e[0])\n d1,d2=self.mindist(tree1),self.mindist(tree2)\n dm=((d1+1)//2)+((d2+1)//2)+1\n return max([d1,d2,dm])\n def mindist(self,tree:List[List[int]])->int:\n dia=[0]\n self.maxdia(tree,0,-1,dia)\n return dia[0]\n def maxdia(self,tree:List[List[int]],node:int ,par:int,dia:List[int])->None:\n sub1,sub2=0,0\n for v in tree[node]:\n if(v==par):\n continue\n dep=self.maxdia(tree,v,node,dia)\n if(dep>sub1):\n sub2=sub1\n sub1=dep\n elif dep> sub2:\n sub2=dep\n dia[0]=max(dia[0],sub1+sub2)\n return 1+sub1\n\n","runtime":"1632"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def bfs(edges):\n if not edges:\n return 0\n \n n = len(edges) + 1\n graph = defaultdict(set)\n\n \n for i, j in edges:\n graph[i].add(j)\n graph[j].add(i)\n \n leaves = []\n for i in range(n):\n if len(graph[i]) == 1:\n leaves.append(i)\n \n remain = n\n step = 0\n while remain > 2:\n remain -= len(leaves)\n new_leaves = []\n for leaf in leaves:\n neighbor = graph[leaf].pop()\n graph[neighbor].discard(leaf)\n \n if len(graph[neighbor]) == 1:\n new_leaves.append(neighbor)\n step += 1\n leaves = new_leaves\n\n return step * 2 + 1 if remain == 2 else step * 2\n \n diameter1 = bfs(edges1)\n diameter2 = bfs(edges2)\n\n d1 = math.ceil(diameter1 / 2)\n d2 = math.ceil(diameter2 / 2)\n\n return max(d1 + d2 + 1, max(diameter1, diameter2))","runtime":"1666"},{"code":"class Solution:\n\n\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def diameter(edges):\n g =[[] for _ in range(len(edges)+1)]\n for x, y in edges:\n g[x].append(y)\n g[y].append(x)\n\n ans = 0\n def dfs(node, fa):\n nonlocal ans\n\n cur_max_left = 0\n for neighbour in g[node]:\n if neighbour == fa:\n continue\n cur_right = dfs(neighbour, node) + 1\n ans = max(ans, cur_max_left + cur_right)\n cur_max_left = max(cur_max_left, cur_right)\n\n return cur_max_left\n\n dfs(0, -1)\n return ans\n\n d1 = diameter(edges1)\n d2 = diameter(edges2)\n d3 = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\n return max(d1, d2, d3)\n ","runtime":"1700"},{"code":"from collections import defaultdict\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def build_graph(edges):\n graph = defaultdict(list)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n return graph\n\n def find_tree_info(edges):\n graph = build_graph(edges)\n \n def dfs(node, parent):\n height, diameter = 0, 0\n max_height1, max_height2 = 0, 0\n for child in graph[node]:\n if child != parent:\n child_height, child_diameter = dfs(child, node)\n diameter = max(diameter, child_diameter)\n if child_height + 1 > max_height1:\n max_height2 = max_height1\n max_height1 = child_height + 1\n elif child_height + 1 > max_height2:\n max_height2 = child_height + 1\n \n diameter = max(diameter, max_height1 + max_height2)\n return max_height1, diameter\n\n _, diameter = dfs(0, -1)\n return diameter, min(len(graph) - 1, (diameter + 1) // 2)\n\n diameter1, height1 = find_tree_info(edges1)\n diameter2, height2 = find_tree_info(edges2)\n\n return max(diameter1, diameter2, height1 + height2 + 1)","runtime":"1735"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1769"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def diameter(edges):\n n = len(edges) + 1\n g = [[] for _ in range(n)]\n for i, j in edges:\n g[i].append(j)\n g[j].append(i)\n res = 0\n\n def dfs(root,fa):\n nonlocal res\n max_len = 0\n for y in g[root]:\n if y != fa:\n y_len = dfs(y, root) + 1\n res = max(res, y_len + max_len)\n max_len = max(max_len, y_len)\n return max_len\n\n dfs(0, -1)\n return res\n\n d1 = diameter(edges1)\n d2 = diameter(edges2)\n return max((d1 + 1)//2 + (d2 + 1)//2 +1, d1, d2)","runtime":"1803"},{"code":"from typing import List\n\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n: int = len(edges1) + 1\n m: int = len(edges2) + 1\n graph1: List[List[int]] = [[] for _ in range(n)]\n graph2: List[List[int]] = [[] for _ in range(m)]\n for u, v in edges1:\n graph1[u].append(v)\n graph1[v].append(u)\n for u, v in edges2:\n graph2[u].append(v)\n graph2[v].append(u)\n\n def dfs(graph: List[List[int]], start_node: int) -> List[int]:\n n: int = len(graph)\n distance: List[int] = [-1] * n\n distance[start_node] = 0\n stack: List[int] = [start_node]\n max_distance: int = 0\n farthest_node: int = start_node\n while stack:\n node: int = stack.pop()\n for neighbor in graph[node]:\n if distance[neighbor] == -1:\n distance[neighbor] = distance[node] + 1\n if distance[neighbor] > max_distance:\n max_distance = distance[neighbor]\n farthest_node = neighbor\n stack.append(neighbor)\n return [farthest_node, max_distance]\n\n farthest_node1, max_distance1 = dfs(graph1, 0)\n farthest_node2, max_distance2 = dfs(graph1, farthest_node1)\n farthest_node3, max_distance3 = dfs(graph2, 0)\n farthest_node4, max_distance4 = dfs(graph2, farthest_node3)\n diameter1: int = max_distance2\n diameter2: int = max_distance4\n candidate1: int = max(diameter1, diameter2)\n candidate2: int = (diameter1 + 1) // 2 + (diameter2 + 1) // 2 + 1\n return max(candidate1, candidate2)","runtime":"1838"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diameter(e):\n if not e:\n return 0, 0\n g = defaultdict(set)\n for u, v in e:\n g[u].add(v)\n g[v].add(u)\n q = deque([u for u, nbr in g.items() if len(nbr) == 1])\n r = 0\n s = 0\n while q:\n n = len(q)\n if s == len(g) - 2:\n return r, 1\n for _ in range(n):\n u = q.popleft()\n s += 1\n for nbr in g[u]:\n g[nbr].remove(u)\n if len(g[nbr]) == 1:\n q.append(nbr)\n r += 1\n return r - 1, 0\n \n r1, b1 = diameter(edges1)\n r2, b2 = diameter(edges2)\n return max(2 * r1 + b1, 2 * r2 + b2, r1 + b1 + r2 + b2 + 1)\n\n ","runtime":"1872"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def get_diameter(edges):\n n = len(edges)\n neighbor = [[] for _ in range(n + 1)] \n for node1, node2 in edges:\n neighbor[node1].append(node2)\n neighbor[node2].append(node1)\n \n diameter = 0\n def dfs(index, father):\n nonlocal diameter\n max_len = 0\n for node_index in neighbor[index]:\n if node_index != father:\n edge_len = dfs(node_index, index) + 1\n diameter = max(diameter, max_len + edge_len)\n max_len = max(max_len, edge_len)\n return max_len\n dfs(0, -1)\n return diameter\n d1 = get_diameter(edges1)\n d2 = get_diameter(edges2)\n ans = max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n return ans\n \n","runtime":"1906"},{"code":"from collections import deque\n\nclass Solution:\n def bfs(self, tree, start):\n n = len(tree)\n dist = [-1] * n\n q = deque([start])\n dist[start] = 0\n farthest_node = start\n max_dist = 0\n\n while q:\n node = q.popleft()\n for neighbor in tree[node]:\n if dist[neighbor] == -1:\n dist[neighbor] = dist[node] + 1\n q.append(neighbor)\n if dist[neighbor] > max_dist:\n max_dist = dist[neighbor]\n farthest_node = neighbor\n\n return farthest_node, max_dist\n\n def tree_diameter(self, tree):\n # Find the farthest node from an arbitrary start node (node 0)\n start = 0\n farthest_node, _ = self.bfs(tree, start)\n # Find the farthest node from the previously found farthest node\n farthest_node, diameter = self.bfs(tree, farthest_node)\n return diameter, farthest_node\n\n def build_tree(self, edges, n):\n tree = [[] for _ in range(n)]\n for u, v in edges:\n tree[u].append(v)\n tree[v].append(u)\n return tree\n\n def minimumDiameterAfterMerge(self, edges1, edges2):\n n = len(edges1) + 1\n m = len(edges2) + 1\n tree1 = self.build_tree(edges1, n)\n tree2 = self.build_tree(edges2, m)\n \n diameter1, farthest_node1 = self.tree_diameter(tree1)\n diameter2, farthest_node2 = self.tree_diameter(tree2)\n \n # The new diameter after merging the trees will be the maximum of the original diameters and the sum of the two longest paths + 1.\n new_diameter = max(diameter1, diameter2, (diameter1 // 2) + (diameter2 // 2) + 1 + (diameter1 % 2) + (diameter2 % 2))\n \n return new_diameter\n\n# Example usage\nedges1 = [[0, 1]]\nedges2 = [[0, 1]]\n\nsol = Solution()\nprint(sol.minimumDiameterAfterMerge(edges1, edges2))","runtime":"1940"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def farthest(G, i):\n n = len(G)\n bfs = [i]\n seen = [0] * n\n seen[i] = 1\n res = maxd = -1\n for i in bfs:\n for j in G[i]:\n if seen[j] == 0:\n seen[j] = seen[i] + 1\n bfs.append(j)\n if seen[j] > maxd:\n res = j\n maxd = seen[j]\n return res, maxd - 1\n\n def diameter(edges):\n if not edges:\n return 0,0,0\n n = len(edges) + 1\n G = [[] for i in range(n)]\n for i,j in edges:\n G[i].append(j)\n G[j].append(i)\n v1, d = farthest(G, 0)\n v2, d = farthest(G, v1)\n return d,v1,v2\n\n d1, i, j = diameter(edges1)\n d2, i, j = diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"1975"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n d1 = self.diameter(edges1)\n d2 = self.diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n def diameter(self, edges: List[List[int]]) -> int:\n g = [[] for _ in range(len(edges) + 1)]\n for x, y in edges:\n g[x].append(y)\n g[y].append(x)\n res = 0\n def dfs(x: int, fa: int) -> int:\n nonlocal res\n max_len = 0\n for y in g[x]:\n if y != fa:\n sub_len = dfs(y, x) + 1\n res = max(res, max_len + sub_len)\n max_len = max(max_len, sub_len)\n return max_len\n dfs(0, -1)\n return res","runtime":"2009"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n # def shortestPath(edges):\n # if not edges:\n # return 0\n # g = defaultdict(list)\n # for i, j in edges:\n # g[i].append(j)\n # g[j].append(i)\n # def dfs(x, pre):\n # length = 0\n # for y in g[x]:\n # if y != pre:\n # length = max(length, dfs(y, x) + 1)\n # return length\n # return min(dfs(x, x) for x in g)\n # return shortestPath(edges1) + shortestPath(edges2) + 1\n d1 = self.diameter(edges1)\n d2 = self.diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n def diameter(self, edges: List[List[int]]) -> int:\n g = [[] for _ in range(len(edges) + 1)]\n for x, y in edges:\n g[x].append(y)\n g[y].append(x)\n\n res = 0\n def dfs(x: int, fa: int) -> int:\n nonlocal res\n max_len = 0\n for y in g[x]:\n if y != fa:\n sub_len = dfs(y, x) + 1\n res = max(res, max_len + sub_len)\n max_len = max(max_len, sub_len)\n return max_len\n dfs(0, -1)\n return res","runtime":"2043"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def bfs(edges):\n if not edges:\n return 0\n \n n = len(edges) + 1\n graph = defaultdict(set)\n\n \n for i, j in edges:\n graph[i].add(j)\n graph[j].add(i)\n \n leaves = []\n for i in range(n):\n # leaves only have one neighbor\n if len(graph[i]) == 1:\n leaves.append(i)\n \n remain = n\n step = 0\n while remain > 2:\n remain -= len(leaves)\n new_leaves = []\n for leaf in leaves:\n neighbor = graph[leaf].pop()\n graph[neighbor].discard(leaf)\n \n # after removing the current leaf, \n # if the neighbor has one neighbor now, \n # then it becomes a new leaf\n if len(graph[neighbor]) == 1:\n new_leaves.append(neighbor)\n step += 1\n leaves = new_leaves\n\n # at last if we have two leaves, diameter needs to add 1,\n # otherwise just multiply with 2\n return step * 2 + 1 if remain == 2 else step * 2\n \n diameter1 = bfs(edges1)\n diameter2 = bfs(edges2)\n\n d1 = math.ceil(diameter1 / 2)\n d2 = math.ceil(diameter2 / 2)\n\n # result should be the sum of the half of the diameters of each tree, plus 1 for new added edge\n # or the max diameter of either of them\n # select the maximum\n return max(d1 + d2 + 1, max(diameter1, diameter2))","runtime":"2077"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def build_graph(edges):\n graph = collections.defaultdict(set)\n for node, other_node in edges:\n graph[node].add(other_node)\n graph[other_node].add(node)\n return graph\n\n def calculate_diameter(edges):\n graph = build_graph(edges)\n\n if len(graph.keys()) <= 1:\n return 0\n\n leaves = set()\n for node, adjacent_nodes in graph.items():\n if len(adjacent_nodes) == 1:\n leaves.add(node)\n\n diameter = 0\n while leaves:\n if len(leaves) == len(graph.keys()):\n if len(leaves) == 2:\n diameter += 1\n return diameter\n diameter += 2\n new_leaves = set()\n for leaf in leaves:\n adjacent_node = graph[leaf].pop()\n del graph[leaf]\n\n graph[adjacent_node].remove(leaf)\n if len(graph[adjacent_node]) == 1:\n new_leaves.add(adjacent_node)\n leaves = new_leaves\n return diameter\n \n diameter1 = calculate_diameter(edges1)\n diameter2 = calculate_diameter(edges2)\n return max(diameter1, diameter2, 1 + ((diameter1 + 1) // 2) + ((diameter2 + 1) // 2))\n \n","runtime":"2180"},{"code":"class Solution:\n\n\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def diameter(edges):\n g =[[] for _ in range(len(edges)+1)]\n for x, y in edges:\n g[x].append(y)\n g[y].append(x)\n\n ans = 0\n def dfs(node, fa):\n nonlocal ans\n\n cur_max_left = 0\n for neighbour in g[node]:\n if neighbour == fa:\n continue\n cur_right = dfs(neighbour, node) + 1\n ans = max(ans, cur_max_left + cur_right)\n cur_max_left = max(cur_max_left, cur_right)\n\n return cur_max_left\n\n dfs(0, -1)\n return ans\n\n d1 = diameter(edges1)\n d2 = diameter(edges2)\n d3 = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\n return max(d1, d2, d3)\n ","runtime":"2215"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def bfs(u, graph): \n \"\"\"Return \"\"\"\n ans = 0 \n queue = deque([(u, -1)])\n while queue:\n ans += 1\n for _ in range(len(queue)): \n u, p = queue.popleft()\n for v in graph[u]: \n if v != p: \n queue.append((v, u))\n return ans, u\n \n def fn(edges): \n \"\"\"Return \"\"\"\n n = len(edges)+1\n graph = [[] for _ in range(n)]\n for u, v in edges: \n graph[u].append(v)\n graph[v].append(u)\n _, u = bfs(0, graph)\n dia, _ = bfs(u, graph)\n return dia\n \n cnt1 = fn(edges1)\n cnt2 = fn(edges2)\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)","runtime":"2249"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def getDiameter(edges):\n map = defaultdict(list)\n for i, j in edges:\n map[i].append(j)\n map[j].append(i)\n \n res = [0]\n \n def dfs(node, parent):\n maxDepth = 1\n for neighbor in map[node]:\n if neighbor == parent:\n continue\n depth = dfs(neighbor, node)\n res[0] = max(res[0], maxDepth + depth)\n maxDepth = max(maxDepth, 1 + depth)\n return maxDepth\n \n dfs(0, -1)\n \n return res[0]\n \n d1 = getDiameter(edges1)\n d2 = getDiameter(edges2)\n \n return max(d1 - 1, d2 - 1, d1 // 2 + d2 // 2 + 1)","runtime":"2283"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diamiter(root):\n def dfs(i, p):\n md = 0\n for j in to[i]:\n if j != p:\n d = dfs(j, i)\n r[0] = max(r[0], md + d)\n md = max(md, d)\n return md + 1\n r = [0]\n dfs(root, -1)\n return r[0]\n\n to = defaultdict(list)\n for s, e in edges1:\n to[s].append(e)\n to[e].append(s)\n l1 = diamiter(0)\n to = defaultdict(list)\n for s, e in edges2:\n to[s].append(e)\n to[e].append(s)\n l2 = diamiter(0) \n # print(l1, l2)\n return max(l1, l2, (l1+1)//2 + (l2+1)//2 + 1)","runtime":"2317"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def tree_diameter(n, edges):\n from collections import deque\n adj = [[] for _ in range(n)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n def bfs(u):\n visited = [False] * n\n dist = [0]*n\n queue = deque([u])\n visited[u] = True\n while queue:\n curr = queue.popleft()\n for nei in adj[curr]:\n if not visited[nei]:\n visited[nei] = True\n dist[nei] = dist[curr] + 1\n queue.append(nei)\n # Early exit if possible\n max_dist = max(dist)\n farthest_node = dist.index(max_dist)\n return farthest_node, max_dist\n if n == 0:\n return 0\n u, _ = bfs(0)\n v, D = bfs(u)\n return D\n\n n1 = len(edges1) + 1\n n2 = len(edges2) + 1\n D1 = tree_diameter(n1, edges1)\n D2 = tree_diameter(n2, edges2)\n R1 = (D1 + 1) // 2\n R2 = (D2 + 1) // 2\n D = max(D1, D2, R1 + R2 + 1)\n return D\n","runtime":"2352"},{"code":"from collections import defaultdict\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n # DYS\n def build_graph(edges):\n graph = defaultdict(list)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n return graph\n\n def find_tree_info(edges):\n graph = build_graph(edges)\n \n def dfs(node, parent):\n height, diameter = 0, 0\n max_height1, max_height2 = 0, 0\n for child in graph[node]:\n if child != parent:\n child_height, child_diameter = dfs(child, node)\n diameter = max(diameter, child_diameter)\n if child_height + 1 > max_height1:\n max_height2 = max_height1\n max_height1 = child_height + 1\n elif child_height + 1 > max_height2:\n max_height2 = child_height + 1\n \n diameter = max(diameter, max_height1 + max_height2)\n return max_height1, diameter\n\n _, diameter = dfs(0, -1)\n return diameter, min(len(graph) - 1, (diameter + 1) // 2)\n\n diameter1, height1 = find_tree_info(edges1)\n diameter2, height2 = find_tree_info(edges2)\n\n return max(diameter1, diameter2, height1 + height2 + 1)","runtime":"2386"},{"code":"from typing import Tuple, List\n\n\nclass Solution:\n\n def build_tree(self, edges: List[List[int]]) -> List[List[int]]:\n tree = [[] for _ in range(len(edges) + 1)]\n for v1, v2 in edges:\n tree[v1].append(v2)\n tree[v2].append(v1)\n return tree\n\n def find_dist(self, tree: List[List[int]], v0: int) -> Tuple[int, int]:\n dist = [-1] * len(tree)\n dist[v0] = 0\n frontier, d = [v0], 0\n while frontier:\n new_frontier, d = [], d + 1\n for v1 in frontier:\n for v2 in tree[v1]:\n if dist[v2] == -1:\n dist[v2] = d\n new_frontier.append(v2)\n\n frontier = new_frontier\n\n for i in range(len(dist)):\n if dist[i] == d - 1:\n return i, d - 1\n\n return -1, - 1 # should not happen\n\n def tree_diam_center(self, tree: List[List[int]]) -> int:\n v, _ = self.find_dist(tree, 0)\n _, d = self.find_dist(tree, v)\n return d\n\n def minimumDiameterAfterMerge(self, edges_1: List[List[int]], edges_2: List[List[int]]) -> int:\n d_1 = self.tree_diam_center(self.build_tree(edges_1))\n d_2 = self.tree_diam_center(self.build_tree(edges_2))\n return max((d_1 + 1) // 2 + (d_2 + 1) // 2 + 1, d_1, d_2)","runtime":"2420"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def create_graph(edges: List[List[int]]) -> defaultdict:\n graph = defaultdict(set)\n for a, b in edges:\n graph[a].add(b)\n graph[b].add(a)\n return graph\n\n def prune(graph: defaultdict) -> Tuple[int, int]:\n if not graph:\n return 0, 0\n leaves = [node for node in graph if len(graph[node]) == 1]\n radius = 0\n \n while leaves:\n if len(graph) == 2:\n return radius + 1, 2 * radius + 1\n if len(graph) < 2:\n return radius, 2 * radius\n \n new_leaves = []\n for leaf in leaves:\n neighbor = graph[leaf].pop()\n del graph[leaf]\n graph[neighbor].remove(leaf)\n if len(graph[neighbor]) == 1:\n new_leaves.append(neighbor)\n leaves = new_leaves\n radius += 1\n \n # Create adjacency lists for both trees\n graph1, graph2 = create_graph(edges1), create_graph(edges2)\n \n # Calculate radius and diameter for both trees\n radius1, diameter1 = prune(graph1)\n radius2, diameter2 = prune(graph2)\n \n # Calculate the minimum possible diameter after merging\n return max(1 + radius1 + radius2, diameter1, diameter2)","runtime":"2454"},{"code":"\nclass Solution:\n def minimumDiameterAfterMerge(\n self, edges1: List[List[int]], edges2: List[List[int]]\n ) -> int:\n def bfs(edges):\n if not edges:\n return 0\n\n n = len(edges) + 1\n graph = defaultdict(set)\n\n for i, j in edges:\n graph[i].add(j)\n graph[j].add(i)\n\n leaves = []\n for i in range(n):\n # leaves only have one neighbor\n if len(graph[i]) == 1:\n leaves.append(i)\n\n remain = n\n step = 0\n while remain > 2:\n remain -= len(leaves)\n new_leaves = []\n for leaf in leaves:\n neighbor = graph[leaf].pop()\n graph[neighbor].discard(leaf)\n\n # after removing the current leaf,\n # if the neighbor has one neighbor now,\n # then it becomes a new leaf\n if len(graph[neighbor]) == 1:\n new_leaves.append(neighbor)\n step += 1\n leaves = new_leaves\n\n # at last if we have two leaves, diameter needs to add 1,\n # otherwise just multiply with 2\n return step * 2 + 1 if remain == 2 else step * 2\n\n diameter1 = bfs(edges1)\n diameter2 = bfs(edges2)\n\n d1 = math.ceil(diameter1 / 2)\n d2 = math.ceil(diameter2 / 2)\n\n # result should be the sum of the half of the diameters of each tree, plus 1 for new added edge\n # or the max diameter of either of them\n # select the maximum\n return max(d1 + d2 + 1, max(diameter1, diameter2))","runtime":"2489"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def getDiameter(edges):\n map = defaultdict(list)\n for i, j in edges:\n map[i].append(j)\n map[j].append(i)\n \n res = [0]\n \n def dfs(node, parent):\n maxDepth = 1\n for neighbor in map[node]:\n if neighbor == parent:\n continue\n depth = dfs(neighbor, node)\n res[0] = max(res[0], maxDepth + depth)\n maxDepth = max(maxDepth, 1 + depth)\n return maxDepth\n \n dfs(0, -1)\n \n return res[0]\n \n d1 = getDiameter(edges1)\n d2 = getDiameter(edges2)\n \n return max(d1 - 1, d2 - 1, d1 // 2 + d2 // 2 + 1)","runtime":"2523"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def treeDiameter(edges):\n graph = defaultdict(list)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n \n def dfs(root, parent):\n nonlocal res\n pre = 0\n cur = 0\n for child in graph[root]:\n if child != parent:\n cur = 1 + dfs(child, root)\n res = max(res, cur + pre)\n pre = max(pre, cur)\n return pre\n res = 0\n dfs(0, None)\n return res\n\n d1 = treeDiameter(edges1)\n d2 = treeDiameter(edges2)\n return max((d1 + 1) // 2 + (d2 + 1) // 2 + 1, max(d1, d2))\n\n \n ","runtime":"2523"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diamiter(root, edges):\n def dfs(i, p):\n md, mr = 0, 0\n for j in to[i]:\n if j == p: continue\n d, r = dfs(j, i)\n mr = max(mr, r, md + d)\n md = max(md, d)\n return md + 1, mr\n to = defaultdict(list)\n for s, e in edges:\n to[s].append(e)\n to[e].append(s) \n return dfs(root, -1)[1]\n\n l1 = diamiter(0, edges1)\n l2 = diamiter(0, edges2)\n # print(l1, l2)\n return max(l1, l2, (l1+1)//2 + (l2+1)//2 + 1)","runtime":"2557"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def getDiameter(edges):\n map = defaultdict(list)\n for i, j in edges:\n map[i].append(j)\n map[j].append(i)\n \n res = [0]\n \n def dfs(node, parent):\n maxDepth = 1\n for neighbor in map[node]:\n if neighbor == parent:\n continue\n depth = dfs(neighbor, node)\n res[0] = max(res[0], maxDepth + depth)\n maxDepth = max(maxDepth, 1 + depth)\n return maxDepth\n \n dfs(0, -1)\n \n return res[0]\n \n d1 = getDiameter(edges1)\n d2 = getDiameter(edges2)\n \n return max(d1 - 1, d2 - 1, d1 // 2 + d2 // 2 + 1)","runtime":"2557"},{"code":"class Solution:\n def minimumDiameterAfterMerge(\n self, edges1: List[List[int]], edges2: List[List[int]]\n ) -> int:\n def buildTree(edges):\n n = len(edges) + 1\n tree = [[] for _ in range(n)]\n for a, b in edges:\n tree[a].append(b)\n tree[b].append(a)\n return tree\n\n tree1 = buildTree(edges1)\n tree2 = buildTree(edges2)\n\n def farthest(tree, start):\n q = deque([start])\n d = [-1 for _ in range(len(tree))]\n d[start] = 0\n farthestNode = 0\n farthestDist = 0\n while len(q) > 0:\n cur = q.popleft()\n for adj in tree[cur]:\n if d[adj] == -1:\n d[adj] = d[cur] + 1\n q.append(adj)\n if d[adj] > farthestDist:\n farthestDist = d[adj]\n farthestNode = adj\n # print(d)\n return farthestNode, farthestDist\n\n def diameter(tree):\n n1, d1 = farthest(tree, 0)\n n2, d2 = farthest(tree, n1)\n return d2\n\n d1, d2 = diameter(tree1), diameter(tree2)\n # print(d1, d2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n","runtime":"2592"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def diameter(edges: List[List[int]]) -> int:\n graph = defaultdict(list)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n \n res = 0\n def dfs(u: int, pre: int) -> int:\n nonlocal res\n max_len = 0\n for v in graph[u]:\n if v != pre:\n sub_len = dfs(v, u) + 1\n res = max(res, max_len + sub_len)\n max_len = max(max_len, sub_len)\n return max_len\n dfs(0, -1)\n return res\n \n d1, d2 = diameter(edges1), diameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)","runtime":"2592"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def deep(edges):\n if not edges: return 0, 0\n adj = defaultdict(list)\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n def run(start):\n visited = set([start])\n q = deque([start])\n step = 0\n while q:\n step += 1\n for _ in range(len(q)):\n cur = q.popleft()\n for nei in adj[cur]:\n if nei in visited: continue\n visited.add(nei)\n q.append(nei)\n return step-1, cur\n _, d = run(u)\n l, _ = run(d)\n print(l)\n return l // 2 + l % 2, l // 2\n\n a, b = deep(edges1)\n c, d = deep(edges2)\n print(a, b, c, d)\n return max(a + max(b, c+1), c + max(d, a+1))","runtime":"2626"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n # DFS returns the depth and stores the max diameter in res\n def dfs(i, visited, map, res):\n if visited[i]:\n return 0\n visited[i] = True\n\n # The diameter of a certain tree assuming it goes\n # through i is the sum of the two greatest depths\n greatestDepth = 0\n secondGreatest = 0\n\n for j in map[i]:\n depth = dfs(j, visited, map, res)\n if depth > greatestDepth:\n secondGreatest = greatestDepth\n greatestDepth = depth\n elif depth > secondGreatest:\n secondGreatest = depth\n\n # Update the max diameter\n res[0] = max(res[0], greatestDepth + secondGreatest)\n\n # Return the depth\n return greatestDepth + 1\n \n # Create edge map\n map1 = defaultdict(list)\n map2 = defaultdict(list)\n\n for a, b in edges1:\n map1[a].append(b)\n map1[b].append(a)\n \n for a, b in edges2:\n map2[a].append(b)\n map2[b].append(a)\n\n # Create visited arrays\n visited1 = [False] * (len(edges1) + 1)\n visited2 = [False] * (len(edges2) + 1)\n\n # We use an array since python passes\n # by reference for arrays but not ints\n d1 = [0]\n d2 = [0]\n\n # Find the diameters of both trees\n dfs(0, visited1, map1, d1)\n dfs(0, visited2, map2, d2)\n\n # We return the max of the two diameters and\n # the sum of the radiuses of each tree + 1\n return max(d1[0], d2[0], (d1[0] + 1) // 2 + (d2[0] + 1) // 2 + 1)","runtime":"2626"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def helper(edges):\n n = len(edges) + 1\n g = collections.defaultdict(list)\n for a, b in edges:\n g[a].append(b)\n g[b].append(a)\n\n d1, d2 = [[0] * n for _ in range(2)]\n\n def bfs():\n parent = [-1] * n\n st = [-1, 0]\n while st:\n u = st.pop()\n if u >= 0:\n for v in filter(parent[u].__ne__, g[u]):\n parent[v] = u\n st.extend([~v, v])\n else:\n u = ~u\n for v in filter(parent[u].__ne__, g[u]):\n d = d1[v] + 1\n if d > d1[u]:\n d2[u], d1[u] = d1[u], d\n elif d > d2[u]:\n d2[u] = d\n\n bfs()\n ma = max(d1[u] + d2[u] for u in range(n))\n return ma\n\n ma1 = helper(edges1)\n ma2 = helper(edges2)\n return max((ma1 + 1) // 2 + (ma2 + 1) // 2 + 1, ma1, ma2)\n","runtime":"2660"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def find_center(edges):\n def graph(edges):\n G = defaultdict(lambda:set())\n nodes = set()\n for n1, n2 in edges:\n G[n1].add(n2)\n G[n2].add(n1)\n nodes.add(n1)\n nodes.add(n2)\n return nodes, G\n nodes, G = graph(edges)\n degree1Nodes = set()\n for n in nodes:\n if len(G[n]) == 1:\n degree1Nodes.add(n)\n width = 0\n #candidate = next(iter(nodes)) if not degree1Nodes else next(iter(degree1Nodes))\n while degree1Nodes:\n #print(degree1Nodes)\n nextDegree1Nodes = set()\n degreeZeroFound = False\n for d1n in degree1Nodes:\n nodes.discard(d1n)\n neis = G[d1n]\n for nei in neis:\n G[nei].remove(d1n)\n if len(G[nei]) == 1:\n nextDegree1Nodes.add(nei)\n if len(G[nei]) == 0:\n nextDegree1Nodes.discard(nei)\n width += 1\n degree1Nodes = nextDegree1Nodes\n #candidate = next(iter(degree1Nodes))\n if not nodes:\n return width + width - 1, width\n else:\n return width + width, width\n return width\n h1, width1 = find_center(edges1)\n h2, width2 = find_center(edges2)\n return max(width1 + width2 + 1, max(h1, h2))","runtime":"2660"},{"code":"class Solution:\n def minimumDiameterAfterMerge(\n self, edges1: List[List[int]], edges2: List[List[int]]\n ) -> int:\n d1 = self.treeDiameter(edges1)\n d2 = self.treeDiameter(edges2)\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\n\n def treeDiameter(self, edges: List[List[int]]) -> int:\n def dfs(i: int, fa: int, t: int):\n for j in g[i]:\n if j != fa:\n dfs(j, i, t + 1)\n nonlocal ans, a\n if ans < t:\n ans = t\n a = i\n\n g = defaultdict(list)\n for a, b in edges:\n g[a].append(b)\n g[b].append(a)\n ans = a = 0\n dfs(0, -1, 0)\n dfs(a, -1, 0)\n return ans","runtime":"2694"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def helper(edges):\n n = len(edges) + 1\n g = collections.defaultdict(list)\n for a, b in edges:\n g[a].append(b)\n g[b].append(a)\n\n d1, d2 = [[0] * n for _ in range(2)]\n\n def dfs():\n parent = [-1] * n\n st = [-1, 0]\n while st:\n u = st.pop()\n if u >= 0:\n for v in filter(parent[u].__ne__, g[u]):\n parent[v] = u\n st.extend([~v, v])\n else:\n u = ~u\n for v in filter(parent[u].__ne__, g[u]):\n d = d1[v] + 1\n if d > d1[u]:\n d2[u], d1[u] = d1[u], d\n elif d > d2[u]:\n d2[u] = d\n\n dfs()\n ma = max(d1[u] + d2[u] for u in range(n))\n return ma\n\n ma1 = helper(edges1)\n ma2 = helper(edges2)\n return max((ma1 + 1) // 2 + (ma2 + 1) // 2 + 1, ma1, ma2)\n","runtime":"2694"},{"code":"def bfs(src, n, adjList):\n q = deque([src])\n parent = [-1]*(n+1)\n dist = [0]*(n+1)\n parent[src] = -1\n dist[src] = 0\n endNode = src # last node at which bfs ends\n\n while q:\n root = q.popleft()\n endNode = root\n for child in adjList[root]:\n if child == parent[root]:\n continue\n q.append(child)\n dist[child] = dist[root] + 1\n parent[child] = root\n return endNode, dist[endNode], dist # ,dist if required\n\n\ndef diameterSingle(n, adjList, root=0):\n st, _, _ = bfs(root, n, adjList) # root -> st\n end, diam, stDist = bfs(st, n, adjList) # st -> end\n _, _, endDist = bfs(end, n, adjList) # end -> st\n return diam, stDist, endDist\n\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n = len(edges1) + 1\n adjList1 = [[] for _ in range(n)]\n for u, v in edges1:\n adjList1[u].append(v)\n adjList1[v].append(u)\n \n m = len(edges2) + 1\n adjList2 = [[] for _ in range(m)]\n for u, v in edges2:\n adjList2[u].append(v)\n adjList2[v].append(u)\n \n mini1 = n\n diam1, stDist, endDist = diameterSingle(n, adjList1)\n for i in range(n):\n curr = max(stDist[i], endDist[i]) # diam[i]: max dist we can travel for i\n mini1 = min(curr, mini1) # minimum of all diam[i]\n \n mini2 = m\n diam2, stDist, endDist = diameterSingle(m, adjList2)\n for i in range(m):\n curr = max(stDist[i], endDist[i]) # diam[i]: max dist we can travel for i\n mini2 = min(curr, mini2) # minimum of all diam[i]\n \n diam3 = mini1 + mini2 + 1 # diameter from two trees\n res = max(diam1, diam2, diam3)\n\n return res\n \n \n \n ","runtime":"2729"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def get_tree_diameter(edges: List[List[int]]) -> int:\n # number of nodes in longest path of tree\n adj = defaultdict(list)\n for a,b in edges:\n adj[a].append(b)\n adj[b].append(a)\n \n def explore(cur, seen, depth):\n seen[cur] = depth\n for next_node in adj[cur]:\n if next_node in seen:\n continue\n explore(next_node, seen, depth+1)\n\n depths_from_0 = {}\n explore(0, depths_from_0, 1)\n furthest_node = max([(val, key) for key, val in depths_from_0.items()])[1]\n depths_from_furthest = {}\n explore(furthest_node, depths_from_furthest, 1)\n diameter = max(depths_from_furthest.values())\n return diameter\n\n \n diameter1 = get_tree_diameter(edges1)\n diameter2 = get_tree_diameter(edges2)\n return max(\n diameter1//2 + diameter2//2 + 1, #longest occurs on merge\n diameter1-1, #longest is within tree1\n diameter2-1 #longest is within tree2\n )\n\n# Find diameter of each tree, and divide these by half\n# add up the results\n","runtime":"2729"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def minh(edges):\n g = defaultdict(list)\n ind = defaultdict(int)\n vs = set()\n for u, v in edges:\n vs.add(u)\n vs.add(v)\n g[u].append(v)\n g[v].append(u)\n ind[u] += 1\n ind[v] += 1\n q = deque([x for x in vs if ind[x] == 1])\n ans = set(vs)\n hei = 0\n while len(ans) > 2:\n for _ in range(len(q)):\n u = q.popleft()\n ans.remove(u)\n for v in g[u]:\n ind[v] -= 1\n if ind[v] == 1:\n q.append(v)\n hei += 1\n return list(ans), hei\n \n Aidx, Ah = minh(edges1)\n Bidx, Bh = minh(edges2)\n \n h1 = (Ah + 1) if len(Aidx) == 2 else Ah\n h2 = (Bh + 1) if len(Bidx) == 2 else Bh\n dia1 = Ah * 2 + 1 if len(Aidx) == 2 else Ah * 2\n dia2 = Bh * 2 + 1 if len(Bidx) == 2 else Bh * 2\n \n return max(h1 + h2 + 1, dia1, dia2)\n ","runtime":"2763"},{"code":"from typing import List\n\ndef build_graph(edges):\n n = len(edges) + 1\n graph = [[] for _ in range(n)]\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n return graph\n\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def pull(graph, u, p, hs):\n h = 0\n for v in graph[u]:\n if v != p:\n h = max(h, pull(graph, v, u, hs))\n hs[u] = 1 + h\n return hs[u]\n \n def push(graph, u, p, m, hs):\n v1 = v2 = -1\n h1 = h2 = 0\n for v in graph[u]:\n if v != p:\n if hs[v] > h1:\n v1, v2, h1, h2 = v, v1, hs[v], h1\n elif hs[v] > h2:\n v2, h2 = v, hs[v]\n for v in graph[u]:\n if v != p:\n if v == v1:\n push(graph, v, u, max(m, h2) + 1, hs)\n else:\n push(graph, v, u, max(m, h1) + 1, hs)\n hs[u] = max(m, h1) + 1\n\n def help(edges):\n graph = build_graph(edges)\n n = len(graph)\n hs = [0] * n\n pull(graph, 0, -1, hs)\n push(graph, 0, -1, 0, hs)\n return min(hs), max(hs)\n a1, a2 = help(edges1)\n b1, b2 = help(edges2)\n return max(a1 + b1, a2, b2) - 1","runtime":"2763"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n graph1 = {}\n for to, fro in edges1:\n if to not in graph1: graph1[to] = []\n if fro not in graph1: graph1[fro] = []\n graph1[to].append(fro)\n graph1[fro].append(to)\n\n graph2 = {}\n for to, fro in edges2:\n if to not in graph2: graph2[to] = []\n if fro not in graph2: graph2[fro] = []\n graph2[to].append(fro)\n graph2[fro].append(to)\n\n leaves1 = [node for node, vals in graph1.items() if len(vals) == 1]\n leaves2 = [node for node, vals in graph2.items() if len(vals) == 1]\n\n visited = set()\n diameter = 0\n def findDiameter(node, graph):\n nonlocal diameter\n max1, max2 = 0, 0\n if node in visited: \n return 0\n visited.add(node)\n\n for child in graph[node]:\n levels = findDiameter(child, graph)\n if levels > max1:\n max2 = max1\n max1 = levels\n elif levels > max2:\n max2 = levels\n diameter = max(diameter, max1 + max2)\n return 1 + max1\n \n def findCenter(graph, leaves):\n height = 0\n remaining = len(graph)\n\n while remaining > 2: \n remaining -= len(leaves)\n new_leaves = []\n for leaf in leaves:\n parent = graph[leaf].pop()\n del graph[leaf]\n graph[parent].remove(leaf)\n if len(graph[parent]) == 1:\n new_leaves.append(parent)\n leaves = new_leaves\n height += 1\n \n return height if remaining <= 1 else height + 1\n \n tree1, tree2 = 0, 0\n if 0 not in graph1 and 0 not in graph2:\n return 1\n elif 0 not in graph1: \n tree1 = 1\n elif 0 not in graph2: \n tree2 = 1\n else:\n findDiameter(0, graph2)\n tree2 = diameter\n visited, diameter = set(), 0\n findDiameter(0, graph1)\n tree1 = diameter\n\n return max(tree1, tree2, 1 + findCenter(graph1, leaves1) + findCenter(graph2, leaves2))\n","runtime":"2797"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diamiter(root):\n def dfs(i, p):\n pq = []\n for j in to[i]:\n if j != p:\n c = dfs(j, i)\n heappush(pq, c)\n if len(pq) > 2:\n heappop(pq)\n r[0] = max(r[0], sum(pq))\n #print(i, p, pq)\n return max(pq, default=0) + 1\n r = [0]\n dfs(root, -1)\n return r[0]\n\n to = defaultdict(list)\n for s, e in edges1:\n to[s].append(e)\n to[e].append(s)\n l1 = diamiter(0)\n to = defaultdict(list)\n for s, e in edges2:\n to[s].append(e)\n to[e].append(s)\n l2 = diamiter(0) \n #print(l1, l2)\n return max(l1, l2, (l1+1)//2 + (l2+1)//2 + 1)","runtime":"2797"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def topological(edges):\n n = len(edges)+1\n \n graph = defaultdict(set)\n ingress = defaultdict(int)\n\n for a, b in edges:\n graph[a].add(b)\n graph[b].add(a)\n ingress[a] += 1\n ingress[b] += 1\n dq = deque([])\n for a, b in graph.items():\n if len(b) == 1:\n dq.append(a)\n step = 0\n while n > 2:\n size = len(dq)\n n -= size\n for _ in range(size):\n node = dq.popleft()\n del ingress[node]\n for nei in graph[node]:\n ingress[nei] -= 1\n if ingress[nei] == 1:\n dq.append(nei)\n step += 1\n return step*2+1 if n == 2 else step*2\n \n a = topological(edges1)\n b = topological(edges2)\n return max(a, b, math.ceil(a/2)+math.ceil(b/2)+1)","runtime":"2832"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n n,m=len(edges1)+1,len(edges2)+1\n graph1,graph2=[[] for _ in range(n)],[[] for _ in range(m)]\n for u,v in edges1: \n graph1[u].append(v)\n graph1[v].append(u)\n for u,v in edges2:\n graph2[u].append(v)\n graph2[v].append(u)\n def solve(graph,k,st):\n dist=[sys.maxsize]*k\n dist[st]=0\n dq=deque([(st,0)])\n while dq:\n node,wt=dq.popleft()\n for nei in graph[node]:\n if dist[nei]>wt+1:\n dist[nei]=wt+1\n dq.append((nei,wt+1))\n node=st\n for i in range(k): \n if dist[i]>dist[node]: node=i\n return node,dist\n a,_=solve(graph1,n,0)\n b,dist1=solve(graph1,n,a)\n _,dist2=solve(graph1,n,b)\n u,_=solve(graph2,m,0)\n v,dist3=solve(graph2,m,u)\n _,dist4=solve(graph2,m,v)\n x,y=sys.maxsize,sys.maxsize\n res=max(dist1[b],dist3[v])\n for i in range(n):\n x=min(x,max(dist1[i],dist2[i]))\n for i in range(m):\n y=min(y,max(dist3[i],dist4[i]))\n return max(res,x+y+1)","runtime":"2832"},{"code":"class Solution:\n from collections import defaultdict\n\n def __init__(self):\n self.d1 = 0\n self.d2 = 0\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n adj1 = defaultdict(list)\n adj2 = defaultdict(list)\n\n for u, v in edges1:\n adj1[u].append(v)\n adj1[v].append(u)\n \n for u, v in edges2:\n adj2[u].append(v)\n adj2[v].append(u)\n \n\n memo1 = {}\n memo2 = {}\n\n\n def depth1(n):\n if n in memo1:\n return memo1[n]\n \n nMax = 0\n nAdd = 0\n memo1[n] = 0\n nexts = [0,0]\n for m in adj1[n]:\n nexts.append(depth1(m))\n\n nMax = max(nexts)\n nAdd = nMax\n nexts.remove(nMax)\n nAdd += max(nexts) \n\n self.d1 = max(self.d1, nAdd)\n memo1[n] = 1 + nMax\n return memo1[n]\n \n def depth2(n):\n if n in memo2:\n return memo2[n]\n \n nMax = 0\n nAdd = 0\n memo2[n] = 0\n\n nexts = [0,0]\n\n for m in adj2[n]:\n nexts.append(depth2(m))\n\n nMax = max(nexts)\n nAdd = nMax\n nexts.remove(nMax)\n nAdd += max(nexts) \n\n self.d2 = max(self.d2, nAdd)\n memo2[n] = 1 + nMax\n return memo2[n]\n \n depth1(0)\n depth2(0)\n \n return max(self.d1, self.d2, math.ceil(self.d1/2) + math.ceil(self.d2/2) + 1)\n \n\n \n \n\n\n\n\n ","runtime":"2866"},{"code":"from collections import defaultdict\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def diameter(G):\n ends = set()\n curmax = 0\n def dfs(v, d, visited):\n nonlocal curmax\n if v in visited: return\n if d > curmax:\n ends.clear()\n curmax = d\n if d == curmax:\n ends.add(v)\n visited.add(v)\n for w in G[v]:\n dfs(w, d+1, visited)\n dfs(0,0,set())\n v = next(iter(ends))\n dfs(v,0,set())\n return curmax\n G1 = defaultdict(list) \n G2 = defaultdict(list) \n for u,v in edges1:\n G1[u].append(v) \n G1[v].append(u)\n for u,v in edges2: \n G2[u].append(v) \n G2[v].append(u)\n D1 = diameter(G1)\n D2 = diameter(G2)\n return max(D1, D2, (D1+1)//2 + (D2+1)//2 + 1)","runtime":"2866"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def compute_diameter(adj_list):\n def dfs(node, depth):\n visited.add(node)\n depths[node] = depth\n for neighbor in adj_list[node]:\n if neighbor not in visited:\n dfs(neighbor, depth + 1)\n n = len(adj_list)\n visited = set()\n depths = [0] * n\n dfs(0, 0)\n farthest_node = depths.index(max(depths))\n visited = set()\n depths = [0] * n\n dfs(farthest_node, 0)\n return max(depths)\n n1, n2 = len(edges1) + 1, len(edges2) + 1\n adj_list1 = [set() for _ in range(n1)]\n adj_list2 = [set() for _ in range(n2)]\n \n for u, v in edges1:\n adj_list1[u].add(v)\n adj_list1[v].add(u)\n for u, v in edges2:\n adj_list2[u].add(v)\n adj_list2[v].add(u)\n \n diam1 = compute_diameter(adj_list1)\n diam2 = compute_diameter(adj_list2)\n \n max_diameter = max(diam1, diam2, (diam1 + 1) // 2 + (diam2 + 1) // 2 + 1)\n \n return max_diameter\n","runtime":"2900"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n def TreeDiameter(edges):\n n = len(edges) + 1\n g = defaultdict(list) \n for a , b in edges: \n g[a].append(b) \n g[b].append(a) \n\n indp , outdp = [0]*n , [0]*n \n\n def dpi(node , par): \n # indp[node] = 1\n for ch in g[node]: \n if ch != par: \n dpi(ch , node)\n indp[node] = max(indp[node] , 1 + indp[ch]) \n \n def dpii(node , par): \n\n max1 = max2 = -1 \n\n for sib in g[node]: \n if sib == par: continue \n if indp[sib] >= max1: \n max2 , max1 = max1 , max(max1 , indp[sib]) \n elif indp[sib] > max2: max2 = indp[sib]\n \n for ch in g[node]: \n if ch == par: continue \n use = max1 \n if use == indp[ch]: use = max2 \n outdp[ch] = max(1 + outdp[node] , 2 + use)\n dpii(ch , node) \n\n dpi(0 , -1) \n dpii(0 , -1) \n\n return max([indp[i] + outdp[i] for i in range(n)])\n\n d1 = TreeDiameter(edges1) \n d2 = TreeDiameter(edges2) \n\n print(d1 , d2)\n\n return max((d1 , d2 , (d1 + 1) // 2 + (d2 + 1) // 2 + 1))","runtime":"2900"},{"code":"class Solution:\n def dfs1(self, u, adj, p, f):\n f[u] = 0\n for v in adj[u]:\n if p[v] == -1 and v != 0:\n p[v] = u\n self.dfs1(v, adj, p, f)\n f[u] = max(f[u], f[v] + 1)\n \n def dfs2(self, u, adj, p, f, outer):\n fmax = -1\n fmax2 = -1\n for v in adj[u]:\n if p[v] == u:\n if f[v] >= fmax:\n fmax2 = fmax\n fmax = f[v]\n elif f[v] > fmax2:\n fmax2 = f[v]\n # print(\"*** u = \", u, \", fmax = \", fmax, \", fmax2 = \", fmax2)\n ma = max(f[u], outer)\n mi = max(f[u], outer)\n for v in adj[u]:\n if p[v] == u:\n outerv = outer + 1\n resv = max(f[v], outer + 1)\n if f[v] == fmax:\n if fmax2 >= 0:\n outerv = max(outerv, fmax2 + 2)\n resv = max(resv, fmax2 + 2)\n else:\n outerv = max(outerv, fmax + 2)\n resv = max(resv, fmax + 2) \n \n # print(\"-- v = \", v, \"; resv = \", resv)\n if ma == -1 or ma < resv:\n ma = resv\n if mi == -1 or mi > resv:\n mi = resv \n \n mav, miv = self.dfs2(v, adj, p, f, outerv)\n if mav != -1:\n if ma == -1 or ma < mav:\n ma = mav\n if miv != -1:\n if mi == -1 or mi > miv:\n mi = miv\n \n return ma, mi\n \n \n def process(self, edges): \n n = len(edges) + 1\n f = [-1] * n\n p = [-1] * n\n adj = [[] for _ in range(n)]\n for e in edges:\n u, v = e\n adj[u].append(v)\n adj[v].append(u)\n \n self.dfs1(0, adj, p, f) \n # print(\"parent array = \", p)\n \n ma, mi = self.dfs2(0, adj, p, f, 0)\n \n # print(\"ma = \", ma, \"; mi = \", mi)\n \n return ma, mi\n \n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n ma1, mi1 = self.process(edges1)\n ma2, mi2 = self.process(edges2)\n return max(ma1, ma2, mi1 + mi2 + 1)","runtime":"2934"},{"code":"def treeDiameter(edges: List[List[int]]) -> int:\n # build the adjacency list representation of the graph.\n graph = [set() for i in range(len(edges)+1)]\n for edge in edges:\n u, v = edge\n graph[u].add(v)\n graph[v].add(u)\n\n diameter = 0\n\n def dfs(curr, visited):\n \"\"\"\n return the max distance\n starting from the 'curr' node to its leaf nodes\n \"\"\"\n nonlocal diameter\n\n # the top 2 distance starting from this node\n top_1_distance, top_2_distance = 0, 0\n\n distance = 0\n visited[curr] = True\n\n for neighbor in graph[curr]:\n if not visited[neighbor]:\n distance = 1 + dfs(neighbor, visited)\n\n if distance > top_1_distance:\n top_1_distance, top_2_distance = distance, top_1_distance\n elif distance > top_2_distance:\n top_2_distance = distance\n\n # with the top 2 distance, we can update the current diameter\n diameter = max(diameter, top_1_distance + top_2_distance)\n\n return top_1_distance\n\n visited = [False for i in range(len(graph))]\n dfs(0, visited)\n\n return diameter\ndef treeDiameter2(edges: List[List[int]]) -> int:\n\n # build the adjacency list representation of the graph.\n graph = [set() for i in range(len(edges)+1)]\n for edge in edges:\n u, v = edge\n graph[u].add(v)\n graph[v].add(u)\n\n # find the outer most nodes, _i.e._ leaf nodes\n leaves = []\n for vertex, links in enumerate(graph):\n if len(links) == 1:\n leaves.append(vertex)\n\n # \"peel\" the graph layer by layer,\n # until we have the centroids left.\n layers = 0\n vertex_left = len(edges) + 1\n while vertex_left > 2:\n vertex_left -= len(leaves)\n next_leaves = []\n for leaf in leaves:\n # the only neighbor left on the leaf node.\n neighbor = graph[leaf].pop()\n graph[neighbor].remove(leaf)\n if len(graph[neighbor]) == 1:\n next_leaves.append(neighbor)\n layers += 1\n leaves = next_leaves\n\n return layers * 2 + (0 if vertex_left == 1 else 1)\nclass Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n \n \n d1 = treeDiameter(edges1)\n d2 = treeDiameter(edges2)\n print(d1, d2)\n d1 = treeDiameter2(edges1)\n d2 = treeDiameter2(edges2)\n print(d1, d2)\n return max([(d1 + 1) //2 + (d2 + 1) // 2 + 1, d1, d2])","runtime":"2934"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def find_tree_info(edges):\n if not edges or len(edges)<1:\n return 0\n if len(edges)==1:\n return 1\n \n graph=defaultdict(list)\n degrees=defaultdict(int)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n degrees[u]+=1\n degrees[v]+=1\n\n\n n=len(graph)\n q=deque([node for node in degrees if degrees[node]==1])\n order=set()\n count=0\n while q:\n size=len(q)\n for _ in range(size):\n node=q.popleft()\n order.add(node)\n count+=1\n if node in graph:\n for nei in graph[node]:\n degrees[nei]-=1\n if degrees[nei]==1:\n q.append(nei)\n if count==n-1 or count==n-2:\n break\n \n roots=[node for node in degrees if node not in order]\n\n def dfs(node):\n nonlocal diameter\n firstLongest, secondLongest = 0, 0\n seen.add(node)\n for child in graph[node]:\n if child not in seen:\n curPath=dfs(child)\n if curPath>=firstLongest:\n secondLongest=firstLongest\n firstLongest=curPath\n elif curPath>=secondLongest:\n secondLongest=curPath\n diameter=max(diameter, firstLongest+secondLongest)\n return firstLongest+1\n \n diameter=0\n seen=set()\n for root in roots:\n depth=dfs(root)\n return diameter\n\n diameter1 = find_tree_info(edges1)\n diameter2 = find_tree_info(edges2)\n \n\n return max(diameter1, diameter2, (diameter1+1)//2+(diameter2+1)//2+1)","runtime":"2969"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def find_tree_info(edges):\n if not edges or len(edges)<1:\n return 0, 0\n if len(edges)==1:\n return 1, 1\n \n graph=defaultdict(list)\n degrees=defaultdict(int)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n degrees[u]+=1\n degrees[v]+=1\n\n\n n=len(graph)\n q=deque([node for node in degrees if degrees[node]==1])\n order=set()\n count=0\n while q:\n size=len(q)\n for _ in range(size):\n node=q.popleft()\n order.add(node)\n count+=1\n if node in graph:\n for nei in graph[node]:\n degrees[nei]-=1\n if degrees[nei]==1:\n q.append(nei)\n if count==n-1 or count==n-2:\n break\n roots=[node for node in degrees if node not in order]\n\n\n def dfs(node):\n nonlocal diameter\n firstLongest, secondLongest = 0, 0\n seen.add(node)\n for child in graph[node]:\n if child not in seen:\n curPath=dfs(child)\n if curPath>=firstLongest:\n secondLongest=firstLongest\n firstLongest=curPath\n elif curPath>=secondLongest:\n secondLongest=curPath\n diameter=max(diameter, firstLongest+secondLongest)\n return firstLongest+1\n \n diameter=0\n seen=set()\n print(roots)\n for root in roots:\n dfs(root)\n return diameter,min(len(graph)-1, (diameter+1)//2)\n\n diameter1, height1 = find_tree_info(edges1)\n diameter2, height2 = find_tree_info(edges2)\n\n return max(diameter1, diameter2, height1+height2+1)","runtime":"2969"},{"code":"class Solution:\n def treeDiameter(self, edges: List[List[int]]) -> int:\n n = len(edges) + 1\n graph = {i:set([]) for i in range(n)}\n for u,v in edges:\n graph[u].add(v)\n graph[v].add(u)\n seen = [0 for i in range(n)]\n def dfs(i):\n if seen[i] == 1:\n return []\n ls = []\n seen[i] = 1\n for j in graph[i]:\n if not seen[j]:\n nextl = dfs(j)\n if len(nextl) > len(ls):\n ls = nextl\n ls += [i]\n seen[i] = 0\n return ls\n path = dfs(dfs(0)[0])\n return max(len(path) - 1,0)\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n e1 = self.treeDiameter(edges1)\n e2 = self.treeDiameter(edges2)\n #print(e1,e2)\n #if not e1 and not e2:return 1\n #if not e1:return max(e2,max(e2 // 2,1)+1)\n #if not e2:return max(e1,max(e1 // 2,1)+1)\n return max(e1,e2,(e1+1)//2+(e2+1)//2+1)\n ","runtime":"3003"},{"code":"class Solution:\n def treeDiameter(self, edges: List[List[int]]) -> int:\n n = len(edges) + 1\n graph = {i:set([]) for i in range(n)}\n for u,v in edges:\n graph[u].add(v)\n graph[v].add(u)\n seen = [0 for i in range(n)]\n def dfs(i):\n if seen[i] == 1:\n return []\n ls = []\n seen[i] = 1\n for j in graph[i]:\n if not seen[j]:\n nextl = dfs(j)\n if len(nextl) > len(ls):\n ls = nextl\n ls += [i]\n seen[i] = 0\n return ls\n path = dfs(dfs(0)[0])\n return max(len(path) - 1,0)\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n e1 = self.treeDiameter(edges1)\n e2 = self.treeDiameter(edges2)\n return max(e1,e2,(e1+1)//2+(e2+1)//2+1)","runtime":"3037"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def find_tree_info(edges):\n if not edges or len(edges)<1:\n return 0\n if len(edges)==1:\n return 1\n \n graph=defaultdict(list)\n degrees=defaultdict(int)\n for u, v in edges:\n graph[u].append(v)\n graph[v].append(u)\n degrees[u]+=1\n degrees[v]+=1\n\n # 310. Minimum Height Trees\n n=len(graph)\n q=deque([node for node in degrees if degrees[node]==1])\n order=set()\n count=0\n while q:\n size=len(q)\n for _ in range(size):\n node=q.popleft()\n order.add(node)\n count+=1\n if node in graph:\n for nei in graph[node]:\n degrees[nei]-=1\n if degrees[nei]==1:\n q.append(nei)\n if count==n-1 or count==n-2:\n break\n \n roots=[node for node in degrees if node not in order]\n\n\n def dfs(node):\n nonlocal diameter\n firstLongest, secondLongest = 0, 0\n seen.add(node)\n for child in graph[node]:\n if child not in seen:\n curPath=dfs(child)\n if curPath>=firstLongest:\n secondLongest=firstLongest\n firstLongest=curPath\n elif curPath>=secondLongest:\n secondLongest=curPath\n diameter=max(diameter, firstLongest+secondLongest)\n return firstLongest+1\n \n diameter=0\n seen=set()\n depth=0\n for root in roots:\n dfs(root)\n return diameter\n\n diameter1=find_tree_info(edges1)\n diameter2=find_tree_info(edges2)\n\n\n\n return max(diameter1, diameter2, (diameter1+1)//2+(diameter2+1)//2+1)","runtime":"3071"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n graph1 = collections.defaultdict(list)\n graph2 = collections.defaultdict(list)\n \n for a, b in edges1:\n graph1[a].append(b)\n graph1[b].append(a)\n \n for a, b in edges2:\n graph2[a].append(b)\n graph2[b].append(a)\n \n # find the center of a tree\n \n def center(graph):\n #print(\"H\")\n # find the edge nodes\n edge = []\n \n indegrees = collections.Counter()\n for node in graph:\n indegrees[node] = len(graph[node])\n if indegrees[node] == 1:\n edge.append(node)\n indegrees[node] -= 1\n \n # bfs\n level = 0\n while edge:\n n_edge = []\n for node in edge:\n for n_node in graph[node]:\n indegrees[n_node] -= 1\n if indegrees[n_node] == 1:\n n_edge.append(n_node)\n indegrees[n_node] -= 1\n if not n_edge:\n break\n edge = n_edge\n level += 1\n \n #print(edge, level)\n \n if len(edge) > 1:\n level += 1\n \n return level\n \n level1, level2 = center(graph1), center(graph2)\n \n # Function to perform DFS and return the farthest node and its distance\n def dfs(graph, node, visited):\n stack = [(node, 0)]\n visited[node] = True\n farthest_node = node\n max_distance = 0\n\n while stack:\n current_node, current_distance = stack.pop()\n\n if current_distance > max_distance:\n max_distance = current_distance\n farthest_node = current_node\n\n for neighbor in graph[current_node]:\n if not visited[neighbor]:\n visited[neighbor] = True\n stack.append((neighbor, current_distance + 1))\n\n return farthest_node, max_distance\n\n # Function to find the longest path in the graph\n def longest_path_length(graph):\n # Step 1: Perform DFS from any node (let's pick node 0)\n visited = {node: False for node in graph}\n farthest_node, _ = dfs(graph, 0, visited)\n\n # Step 2: Perform DFS from the farthest node found in step 1\n visited = {node: False for node in graph}\n _, max_distance = dfs(graph, farthest_node, visited)\n\n return max_distance\n \n #print(level1, level2)\n \n dia1, dia2 = longest_path_length(graph1), longest_path_length(graph2)\n \n return max([level1 + level2 + 1, dia1, dia2])","runtime":"3106"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n def findMinDiameter(edges):\n if not edges:\n return 0, 0\n\n paths = defaultdict(list)\n for a, b in edges:\n paths[a].append(b)\n paths[b].append(a)\n \n max_diam = defaultdict(int)\n \n def dfs(pre, curr):\n max_diam[curr] = 0\n for next_node in paths[curr]:\n if next_node == pre:\n continue\n max_diam[curr] = max(max_diam[curr], dfs(curr, next_node) + 1)\n return max_diam[curr]\n \n def dfs2(pre, curr, max_len):\n max_diam[curr] = max(max_diam[curr], max_len)\n max_lens = [(max_len, pre)]\n for next_node in paths[curr]:\n if next_node == pre:\n continue\n max_lens.append((max_diam[next_node] + 1, next_node))\n \n max_lens.sort(reverse=True)\n for next_node in paths[curr]:\n if next_node == pre:\n continue\n dfs2(curr, next_node, (max_lens[0][0] if max_lens[0][1] != next_node else max_lens[1][0]) + 1)\n \n dfs(-1, edges[0][0])\n dfs2(-1, edges[0][0], 0)\n return min(max_diam.values()), max(max_diam.values())\n \n min1, max1 = findMinDiameter(edges1)\n min2, max2 = findMinDiameter(edges2)\n return max(max1, max2, min1 + min2 + 1)","runtime":"3140"},{"code":"class Solution:\n def treeDiameter(self, edges: List[List[int]]) -> int:\n n = len(edges) + 1\n graph = {i:set([]) for i in range(n)}\n for u,v in edges:\n graph[u].add(v)\n graph[v].add(u)\n seen = [0 for i in range(n)]\n def dfs(i):\n if seen[i] == 1:\n return []\n ls = []\n seen[i] = 1\n for j in graph[i]:\n if not seen[j]:\n nextl = dfs(j)\n if len(nextl) > len(ls):\n ls = nextl\n ls += [i]\n seen[i] = 0\n return ls\n path = dfs(dfs(0)[0])\n return max(len(path) - 1,0)\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n e1 = self.treeDiameter(edges1)\n e2 = self.treeDiameter(edges2)\n return max(e1,e2,(e1+1)//2+(e2+1)//2+1)\n ","runtime":"3174"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def diameter(edges):\n # Edge case\n if len(edges) == 0: return 0\n \n # Convert to adjacency list\n adjacencyList, visited = {}, set()\n for edge in edges:\n for i in range(2):\n adjacencyList.setdefault(edge[i], set())\n adjacencyList[edge[i]].add(edge[1 - i])\n\n def bfs(node):\n # No children to visit\n if node in visited: return (0, 0)\n visited.add(node)\n\n # Add children into the BFS\n children = []\n for nbd in adjacencyList[node]:\n if not nbd in visited:\n children.append(bfs(nbd))\n\n # No children, it is a leaf\n if len(children) == 0:\n return (1, 1)\n \n # Aggregate depths & diameter from the children\n depthsFound = sorted([i for i, _ in children], reverse = True)\n depthsAdded = sum(depthsFound[0:min(2, len(children))])\n maxDiameter = max([i for _, i in children])\n\n # Get current depth & diameter\n diameter = max(depthsAdded, maxDiameter)\n depth = max(depthsFound) + 1\n return (depth, diameter)\n\n return bfs(0)[1]\n\n # Get the maximum & minimum possible diameters, find answer conditionally\n maxDiameter1, maxDiameter2 = diameter(edges1), diameter(edges2)\n minDiameter1, minDiameter2 = (maxDiameter1 + 1) // 2, (maxDiameter2 + 1) // 2\n minCombined = minDiameter1 + minDiameter2 + 1\n return max(maxDiameter1, maxDiameter2, minCombined)","runtime":"3209"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def diameter(edges):\n # Edge case\n if len(edges) == 0: return 0\n \n # Convert to adjacency list\n adjacencyList, visited = {}, set()\n for edge in edges:\n for i in range(2):\n adjacencyList.setdefault(edge[i], set())\n adjacencyList[edge[i]].add(edge[1 - i])\n\n def bfs(node):\n # No children to visit\n if node in visited: return (0, 0)\n visited.add(node)\n\n # Add children into the BFS\n children = []\n for nbd in adjacencyList[node]:\n if not nbd in visited:\n children.append(bfs(nbd))\n\n # No children, it is a leaf\n if len(children) == 0:\n return (1, 1)\n \n # Aggregate depths & diameter from the children\n depthsFound = sorted([i for i, _ in children], reverse = True)\n depthsAdded = sum(depthsFound[0:min(2, len(children))])\n maxDiameter = max([i for _, i in children])\n\n # Get current depth & diameter\n diameter = max(depthsAdded, maxDiameter)\n depth = max(depthsFound) + 1\n return (depth, diameter)\n\n return bfs(0)[1]\n\n # Get the maximum & minimum possible diameters, find answer conditionally\n maxDiameter1, maxDiameter2 = diameter(edges1), diameter(edges2)\n minDiameter1, minDiameter2 = (maxDiameter1 + 1) // 2, (maxDiameter2 + 1) // 2\n minCombined = minDiameter1 + minDiameter2 + 1\n return max(maxDiameter1, maxDiameter2, minCombined)","runtime":"3243"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n\n def diameter(edges):\n # Edge case\n if len(edges) == 0: return 0\n \n # Convert to adjacency list\n adjacencyList, visited = {}, set()\n for edge in edges:\n for i in range(2):\n adjacencyList.setdefault(edge[i], set())\n adjacencyList[edge[i]].add(edge[1 - i])\n\n def bfs(node):\n # No children to visit\n if node in visited: return (0, 0)\n visited.add(node)\n\n # Add children into the BFS\n children = []\n for nbd in adjacencyList[node]:\n if not nbd in visited:\n children.append(bfs(nbd))\n\n # No children, it is a leaf\n if len(children) == 0:\n return (1, 1)\n \n # Aggregate depths & diameter from the children\n depthsFound = sorted([i for i, _ in children], reverse = True)\n depthsAdded = sum(depthsFound[0:min(2, len(children))])\n maxDiameter = max([i for _, i in children])\n\n # Get current depth & diameter\n diameter = max(depthsAdded, maxDiameter)\n depth = max(depthsFound) + 1\n return (depth, diameter)\n\n return bfs(0)[1]\n\n # Get the maximum & minimum possible diameters, find answer conditionally\n maxDiameter1, maxDiameter2 = diameter(edges1), diameter(edges2)\n minDiameter1, minDiameter2 = (maxDiameter1 + 1) // 2, (maxDiameter2 + 1) // 2\n minCombined = minDiameter1 + minDiameter2 + 1\n return max(maxDiameter1, maxDiameter2, minCombined)","runtime":"3243"},{"code":"class Solution:\n\n class Node:\n def __init__(self,v):\n self.v=v\n self.children = []\n\n def bfs(self,q,dists):\n if not q:\n return\n n = q.pop(0)\n if not n.children:\n return\n for c in n.children:\n if dists[c.v]==-1:\n dists[c.v] = dists[n.v]+1\n q.append(c)\n return self.bfs(q,dists)\n\n def findMaxDistIndex(self,nodes,start):\n dists = [-1 for _ in nodes]\n q = []\n q.append(nodes[start])\n dists[start]=0\n self.bfs(q,dists)\n index_max = max(range(len(dists)), key=dists.__getitem__)\n return index_max,dists[index_max]\n\n def findMinDiaPath(self,nodes1,nodes2):\n # max_dist = max()\n index_max1,_ = self.findMaxDistIndex(nodes1,0)\n index_max2,dist_max1 = self.findMaxDistIndex(nodes1,index_max1)\n\n index_max11,_ = self.findMaxDistIndex(nodes2,0)\n index_max22,dist_max2 = self.findMaxDistIndex(nodes2,index_max11)\n\n # return min([])\n v1 = math.ceil(dist_max1/2) + math.ceil(dist_max2/2)+1\n return max([dist_max1,dist_max2,v1])\n\n\n\n\n\n\n\n\n\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n nodes1 = [self.Node(i) for i in range(len(edges1)+1)]\n nodes2 = [self.Node(i) for i in range(len(edges2)+1)]\n for e in edges1:\n nodes1[e[0]].children.append(nodes1[e[1]])\n nodes1[e[1]].children.append(nodes1[e[0]])\n for e in edges2:\n nodes2[e[0]].children.append(nodes2[e[1]])\n nodes2[e[1]].children.append(nodes2[e[0]])\n return self.findMinDiaPath(nodes1,nodes2)","runtime":"3277"},{"code":"class Solution:\n def getHeight(self,node,adj,vis):\n h = 0\n longestPath = 0\n vis[node] = True\n f = s = 0\n for nn in adj[node]:\n if not vis[nn]:\n ans,path = self.getHeight(nn,adj,vis)\n if ans > f:\n s = f\n f = ans\n elif ans > s:\n s = ans\n h = max(h,ans)\n longestPath = max(path,f+s)\n return [h+1,longestPath]\n \n def findMinHeight(self,deg,adj):\n if len(deg) <= 1:\n return [len(deg),len(deg)]\n q = deque([])\n l = len(deg)\n visited =[False]*l\n for key,val in deg.items():\n if val == 1:\n q.append(key)\n visited[key] = True\n n = l\n while(n>2):\n node = q.popleft()\n n -= 1\n for nn in adj[node]:\n deg[nn] -= 1\n if deg[nn] == 1 and not visited[nn]:\n visited[nn] = True\n q.append(nn)\n minheight = sys.maxsize\n longestPath = 0\n for node in q:\n visited =[False]*l\n val,path = self.getHeight(node,adj,visited)\n minheight = min( minheight, val)\n longestPath = max( longestPath, path)\n return [ minheight-1, longestPath ]\n \n \n \n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n deg1 = dict()\n deg2 = dict()\n adj1 = defaultdict(list)\n adj2 = defaultdict(list)\n for u,v in edges1:\n adj1[u].append(v)\n adj1[v].append(u)\n deg1[u] = deg1.get(u,0)+1\n deg1[v] = deg1.get(v,0)+1\n \n for u,v in edges2:\n adj2[u].append(v)\n adj2[v].append(u)\n deg2[u] = deg2.get(u,0)+1\n deg2[v] = deg2.get(v,0)+1\n \n a = self.findMinHeight(deg1,adj1)\n b = self.findMinHeight(deg2,adj2)\n return max(a[1],b[1],a[0]+b[0]+1)\n \n \n ","runtime":"3277"},{"code":"class Solution:\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\n tree1 = self.tree_builder(edges1)\n tree2 = self.tree_builder(edges2)\n\n diameter1 = self.find_diameter(tree1)\n diameter2 = self.find_diameter(tree2)\n\n minHeight1 = self.find_minHeight(tree1)\n minHeight2 = self.find_minHeight(tree2)\n\n print(\"diameter1 = {0}, height1 = {1}, diameter2 = {2}, height2 = {3}\".format(diameter1, minHeight1, diameter2, minHeight2))\n\n return self.find_min_possible_diameter(diameter1, diameter2, minHeight1, minHeight2)\n\n def find_min_possible_diameter(self, diameter1, diameter2, minHeight1, minHeight2):\n return max(diameter1, diameter2, minHeight1 + minHeight2 + 1)\n\n def find_minHeight(self, tree):\n count = len(tree)\n\n if count <= 1:\n return 0\n elif count == 2:\n return 1\n\n q = deque()\n visited = [False] * count\n\n for node, val in tree.items():\n if val['degree'] == 1:\n visited[node] = True\n val['degree'] -= 1\n q.append(node)\n count -= 1\n\n height = 1\n\n while count > 2:\n temp_q = deque()\n while len(q) > 0:\n node = q.popleft()\n\n for child in tree[node]['child']:\n if visited[child]:\n continue\n\n tree[child]['degree'] -= 1\n if tree[child]['degree'] == 1:\n visited[child] = True\n temp_q.append(child)\n count -= 1\n\n q = temp_q\n height += 1\n\n if count == 2: height += 1\n\n return height\n\n def tree_builder(self, edges):\n dict = {}\n for edge in edges:\n if edge[0] in dict:\n dict[edge[0]]['degree'] += 1\n dict[edge[0]]['child'].append(edge[1])\n else:\n dict[edge[0]] = {\n 'degree': 1,\n 'child': [edge[1]]\n }\n\n if edge[1] in dict:\n dict[edge[1]]['degree'] += 1\n dict[edge[1]]['child'].append(edge[0])\n else:\n dict[edge[1]] = {\n 'degree': 1,\n 'child': [edge[0]]\n }\n\n return dict\n\n def find_diameter(self, tree):\n n = len(tree)\n\n if n <= 1:\n return 0\n\n visited = [False] * n\n\n visited[0] = True\n height, diameter = self.dfs(0, visited, tree)\n\n return diameter\n\n def dfs(self, node, visited, tree):\n height = 0\n diameter = 0\n\n max_height = 0\n second_max_height = 0\n max_diameter = 0\n for child in tree[node]['child']:\n if not visited[child]:\n visited[child] = True\n cur_height, cur_diameter = self.dfs(child, visited, tree)\n cur_height += 1\n\n max_diameter = max(cur_diameter, max_diameter)\n second_max_height = max(cur_height, second_max_height)\n if second_max_height > max_height: max_height, second_max_height = second_max_height, max_height\n\n height = max_height\n diameter = max(max_diameter, max_height + second_max_height)\n\n return height, diameter\n\n ","runtime":"3311"}],"string":"[\n {\n \"code\": \"def diameter(edges: list[list[int]]) -> int:\\n n = len(edges) + 1\\n g = [[] for _ in range(n)]\\n for u, v in edges:\\n g[u].append(v)\\n g[v].append(u)\\n\\n def bfs(s: int) -> list[int]:\\n d = [-1] * n\\n d[s] = 0\\n q = deque([s])\\n while q:\\n v = q.popleft()\\n for u in g[v]:\\n if d[u] == -1:\\n d[u] = d[v] + 1\\n q.append(u)\\n return d\\n\\n d0 = bfs(0)\\n return max(bfs(d0.index(max(d0))))\\n\\n\\ndef minimumDiameterAfterMerge(edges1: list[list[int]], edges2: list[list[int]]) -> int:\\n d1, d2 = diameter(edges1), diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + 1 + (d2 + 1) // 2)\\n\\n\\ndef batched(iterable, n):\\n # batched('ABCDEFG', 3) → ABC DEF G\\n if n < 1:\\n raise ValueError('n must be at least one')\\n iterator = iter(iterable)\\n while batch := tuple(islice(iterator, n)):\\n yield batch\\n\\n\\nwith open(\\\"user.out\\\", \\\"w\\\") as Solution:\\n for edges1, edges2 in batched(map(loads, stdin), 2):\\n Solution.write(f\\\"{minimumDiameterAfterMerge(edges1, edges2)}\\\\n\\\")\\nexit()\",\n \"runtime\": \"604\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def diameter(edge):\\n N = len(edge) + 1\\n if N <= 2:\\n return N - 1\\n degree = [0] * N\\n nbrXOR = [0] * N\\n for u, v in edge:\\n degree[u] += 1\\n degree[v] += 1\\n nbrXOR[u] ^= v\\n nbrXOR[v] ^= u\\n q = deque([i for i in range(N) if degree[i] == 1])\\n radius = 0\\n while len(q) >= 2:\\n radius += 1\\n for _ in range(len(q)):\\n u = q.popleft()\\n nbr = nbrXOR[u]\\n nbrXOR[nbr] ^= u # 将叶子从茎上去掉\\n degree[nbr] -= 1\\n if degree[nbr] == 1:\\n q.append(nbr)\\n dia = 2 * radius if q else 2 * radius - 1\\n return dia\\n\\n d1 = diameter(edges1)\\n d2 = diameter(edges2)\\n res = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\\n return max(res, d1, d2)\",\n \"runtime\": \"604\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def diameter(edge):\\n N = len(edge) + 1\\n if N <= 2:\\n return N - 1\\n degree = [0] * N\\n nbrXOR = [0] * N\\n for u, v in edge:\\n degree[u] += 1\\n degree[v] += 1\\n nbrXOR[u] ^= v\\n nbrXOR[v] ^= u\\n q = deque([i for i in range(N) if degree[i] == 1])\\n radius = 0\\n while len(q) >= 2:\\n radius += 1\\n for _ in range(len(q)):\\n u = q.popleft()\\n nbr = nbrXOR[u]\\n nbrXOR[nbr] ^= u\\n degree[nbr] -= 1\\n if degree[nbr] == 1:\\n q.append(nbr)\\n dia = 2 * radius if q else 2 * radius - 1\\n return dia\\n\\n d1 = diameter(edges1)\\n d2 = diameter(edges2)\\n res = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\\n return max(res, d1, d2) \",\n \"runtime\": \"638\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n \\n def get_center_dist(edge_list: List[List[int]]) -> tuple[int, bool]:\\n n = len(edge_list) + 1\\n neighbor_list = [set() for _ in range(n)]\\n \\n for x, y in edge_list:\\n neighbor_list[x].add(y)\\n neighbor_list[y].add(x)\\n \\n leaves = [i for i in range(n) if len(neighbor_list[i]) == 1]\\n # seen_nodes = set()\\n curr_dist = 0\\n # max_dist = [0 for _ in range(n)]\\n while leaves:\\n curr_dist += 1\\n new_leaves = []\\n for leaf in leaves:\\n neighbor = neighbor_list[leaf].pop()\\n neighbor_neighbors = len(neighbor_list[neighbor])\\n if neighbor_neighbors <= 1:\\n return curr_dist, (neighbor in leaves)\\n if neighbor_neighbors == 2:\\n new_leaves.append(neighbor)\\n neighbor_list[neighbor].discard(leaf)\\n \\n leaves = new_leaves\\n \\n return curr_dist, False\\n \\n dist_small, two_centers_small = get_center_dist(edges1)\\n dist_large, two_centers_large = get_center_dist(edges2)\\n \\n if dist_small > dist_large:\\n temp_small, temp_centers = dist_small, two_centers_small\\n dist_small, two_centers_small = dist_large, two_centers_large\\n dist_large, two_centers_large = temp_small, temp_centers\\n if two_centers_large:\\n curr_dists = [dist_large-1, dist_large]\\n else:\\n curr_dists = [dist_large, dist_large]\\n curr_dists.append(dist_small+1)\\n curr_dists.sort()\\n return sum(curr_dists[-2:])\",\n \"runtime\": \"672\"\n },\n {\n \"code\": \"class Solution:\\n \\n\\n # def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n # def DiameterHelper(G, v):\\n # n = len(G)\\n # seen = [0] * n\\n # seen[v] = 1\\n # bfs = [v]\\n # res = 1\\n # node = v\\n\\n # for i in bfs:\\n # for j in G[i]:\\n # if seen[j] == 0:\\n # seen[j] = seen[i] + 1\\n # bfs.append(j)\\n # if seen[j] > res:\\n # res = seen[j]\\n # node = j\\n \\n\\n # return node, res - 1\\n\\n # def getDiameter(edges: List[List[int]]) -> int:\\n # if not edges:\\n # return 0, 0\\n # n = len(edges) + 1\\n # G = [[] for i in range(n)]\\n # for edge in edges:\\n # i = edge[0]\\n # j = edge[1]\\n # G[i].append(j)\\n # G[j].append(i)\\n\\n # v1, d = DiameterHelper(G, 0)\\n # v2, d = DiameterHelper(G, v1)\\n # return d\\n\\n # d1 = getDiameter(edges1)\\n # d2 = getDiameter(edges2)\\n # #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\\n # return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"706\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def bfs(start, n, adj):\\n dist = [-1] * n\\n dist[start] = 0\\n q = deque([start])\\n farthest_node = start\\n while q:\\n node = q.popleft()\\n for neighbor in adj[node]:\\n if dist[neighbor] == -1:\\n dist[neighbor] = dist[node] + 1\\n q.append(neighbor)\\n farthest_node = neighbor\\n return farthest_node, dist[farthest_node]\\n \\n def get_diameter(n, edges):\\n adj = [[] for _ in range(n)]\\n for u, v in edges:\\n adj[u].append(v)\\n adj[v].append(u)\\n start = 0\\n farthest_node, _ = bfs(start, n, adj)\\n farthest_node, diameter = bfs(farthest_node, n, adj)\\n return diameter\\n \\n n1 = len(edges1) + 1\\n n2 = len(edges2) + 1\\n \\n D1 = get_diameter(n1, edges1)\\n D2 = get_diameter(n2, edges2)\\n \\n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\\n \\n return new_diameter\\n\\n \",\n \"runtime\": \"741\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def DiameterHelper(G, v):\\n n = len(G)\\n seen = [0] * n\\n seen[v] = 1\\n bfs = [v]\\n res = 1\\n node = v\\n\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > res:\\n res = seen[j]\\n node = j\\n \\n\\n return node, res - 1\\n\\n def getDiameter(edges: List[List[int]]) -> int:\\n if not edges:\\n return 0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for edge in edges:\\n i = edge[0]\\n j = edge[1]\\n G[i].append(j)\\n G[j].append(i)\\n\\n v1, d = DiameterHelper(G, 0)\\n v2, d = DiameterHelper(G, v1)\\n return d\\n\\n d1 = getDiameter(edges1)\\n d2 = getDiameter(edges2)\\n #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\\n d11 = (d1 + 1) // 2\\n d21 = (d2 + 1) // 2\\n return max(d1, d2, (d11 + d21 + 1))\\n\",\n \"runtime\": \"775\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def DiameterHelper(G, v):\\n n = len(G)\\n seen = [0] * n\\n seen[v] = 1\\n bfs = [v]\\n res = 1\\n node = v\\n\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > res:\\n res = seen[j]\\n node = j\\n \\n\\n return node, res - 1\\n\\n def getDiameter(edges: List[List[int]]) -> int:\\n if not edges:\\n return 0, 0, 0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for edge in edges:\\n i = edge[0]\\n j = edge[1]\\n G[i].append(j)\\n G[j].append(i)\\n\\n v1, d = DiameterHelper(G, 0)\\n v2, d = DiameterHelper(G, v1)\\n return d, v1, v2\\n\\n d1, i, j = getDiameter(edges1)\\n d2, i, j = getDiameter(edges2)\\n #return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\\n d11 = (d1 + 1) // 2\\n d21 = (d2 + 1) // 2\\n return max(d1, d2, (d11 + d21 + 1))\\n\",\n \"runtime\": \"809\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def bfs(start, n, adj):\\n dist = [-1] * n\\n dist[start] = 0\\n q = deque([start])\\n farthest_node = start\\n while q:\\n node = q.popleft()\\n for neighbor in adj[node]:\\n if dist[neighbor] == -1:\\n dist[neighbor] = dist[node] + 1\\n q.append(neighbor)\\n farthest_node = neighbor\\n return farthest_node, dist[farthest_node]\\n \\n def get_diameter(n, edges):\\n adj = [[] for _ in range(n)]\\n for u, v in edges:\\n adj[u].append(v)\\n adj[v].append(u)\\n start = 0\\n farthest_node, _ = bfs(start, n, adj)\\n farthest_node, diameter = bfs(farthest_node, n, adj)\\n return diameter\\n \\n n1 = len(edges1) + 1\\n n2 = len(edges2) + 1\\n \\n D1 = get_diameter(n1, edges1)\\n D2 = get_diameter(n2, edges2)\\n \\n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\\n \\n return new_diameter\\n\\n #https://www.youtube.com/watch?v=vTcQjheqTVs\\n\\n #we add 1 as the problem statement says n-1 and m-1. \",\n \"runtime\": \"844\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def bfs(start, n, adj):\\n dist = [-1] * n\\n dist[start] = 0\\n q = deque([start])\\n farthest_node = start\\n while q:\\n node = q.popleft()\\n for neighbor in adj[node]:\\n if dist[neighbor] == -1:\\n dist[neighbor] = dist[node] + 1\\n q.append(neighbor)\\n farthest_node = neighbor\\n return farthest_node, dist[farthest_node]\\n \\n def get_diameter(n, edges):\\n adj = [[] for _ in range(n)]\\n for u, v in edges:\\n adj[u].append(v)\\n adj[v].append(u)\\n start = 0\\n farthest_node, _ = bfs(start, n, adj)\\n farthest_node, diameter = bfs(farthest_node, n, adj)\\n return diameter\\n \\n n1 = len(edges1) + 1\\n n2 = len(edges2) + 1\\n \\n D1 = get_diameter(n1, edges1)\\n D2 = get_diameter(n2, edges2)\\n \\n new_diameter = max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\\n \\n return new_diameter\\n\\n #https://www.youtube.com/watch?v=vTcQjheqTVs\\n\\n \",\n \"runtime\": \"878\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n \\n def helper(arr):\\n \\n n = len(arr)+1\\n deg = [0]*n\\n adj =[[] for i in range(n)]\\n for a,b in arr:\\n adj[a].append(b)\\n adj[b].append(a)\\n deg[a] += 1\\n deg[b] += 1\\n \\n dq = deque([])\\n for i in range(n):\\n if deg[i] == 1:\\n dq.append(i)\\n deg[i] -= 1\\n ans = 0\\n while len(dq)>1:\\n L = len(dq)\\n for _ in range(L):\\n node = dq.popleft()\\n for neigh in adj[node]:\\n if deg[neigh]:\\n deg[neigh] -= 1\\n if deg[neigh] == 1:\\n dq.append(neigh)\\n ans += 1\\n return 2*ans if len(dq)==1 else 2*ans-1\\n a1,a2 = helper(edges1),helper(edges2)\\n # print(a1,a2)\\n return max(a1,a2,ceil(a1/2)+ceil(a2/2)+1)\",\n \"runtime\": \"912\"\n },\n {\n \"code\": \"class Solution:\\n def find_centers(self, n: int, graph: List[List[int]], in_degree: List[int]):\\n q = deque([])\\n if n == 1:\\n return 1, 0\\n if n == 2:\\n return 2, 1\\n for i in range (n):\\n if in_degree[i] == 1:\\n q.append(i)\\n \\n count = n\\n res = 0\\n while count > 2:\\n count -= len(q)\\n next_q = deque([])\\n res += 1\\n while q:\\n u = q.popleft()\\n for v in graph[u]:\\n in_degree[v] -= 1\\n if in_degree[v] == 1:\\n next_q.append(v)\\n q = next_q\\n if count == 2:\\n return res * 2 + 1, res + 1\\n return res * 2, res\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n n = len(edges1) + 1\\n graph1 = [[] for i in range (n)]\\n in_degree1 = [0 for i in range (n)]\\n for i in range (n - 1):\\n u, v = edges1[i]\\n graph1[u].append(v)\\n graph1[v].append(u)\\n in_degree1[u] += 1\\n in_degree1[v] += 1\\n \\n \\n m = len(edges2) + 1\\n graph2 = [[] for i in range (m)]\\n in_degree2 = [0 for i in range (m)]\\n for i in range (m - 1):\\n u, v = edges2[i]\\n graph2[u].append(v)\\n graph2[v].append(u)\\n in_degree2[u] += 1\\n in_degree2[v] += 1\\n \\n diameter1, res1 = self.find_centers(n, graph1, in_degree1)\\n diameter2, res2 = self.find_centers(m, graph2, in_degree2)\\n \\n return max(diameter1, diameter2, res1 + res2 + 1)\",\n \"runtime\": \"946\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def bfs(s,adj,n):\\n q = [s]; head = 0\\n d = [n]*n\\n d[s] = 0\\n while head<len(q):\\n v = q[head]; head += 1\\n for u in adj[v]:\\n if d[u]<n: continue\\n q.append(u)\\n d[u] = d[v]+1\\n #\\n v = q[-1]\\n return v,d[v]\\n def diameter(adj,n): # farthest of farthest\\n v,dv = bfs(0,adj,n)\\n u,du = bfs(v,adj,n)\\n return du\\n def graph(edges):\\n n = len(edges)+1\\n adj = [[] for i in range(n)]\\n for u,v in edges:\\n adj[u].append(v)\\n adj[v].append(u)\\n return adj,n\\n #\\n d1 = diameter(*graph(edges1))\\n d2 = diameter(*graph(edges2))\\n return max(d1,d2,(d1+1)//2+(d2+1)//2+1)\",\n \"runtime\": \"981\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n \\n def bfs(u, graph): \\n ans = 0 \\n queue = deque([(u, -1)])\\n while queue:\\n ans += 1\\n for _ in range(len(queue)): \\n u, p = queue.popleft()\\n for v in graph[u]: \\n if v != p: \\n queue.append((v, u))\\n return ans, u\\n \\n def fn(edges): \\n n = len(edges)+1\\n graph = [[] for _ in range(n)]\\n for u, v in edges: \\n graph[u].append(v)\\n graph[v].append(u)\\n _, u = bfs(0, graph)\\n dia, _ = bfs(u, graph)\\n return dia\\n \\n cnt1 = fn(edges1)\\n cnt2 = fn(edges2)\\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)\",\n \"runtime\": \"1015\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, tree1: List[List[int]], tree2: List[List[int]]) -> int:\\n def findFarthestNode(graph, startNode):\\n numNodes = len(graph)\\n queue = [startNode]\\n visited = [0] * numNodes\\n visited[startNode] = 1\\n farthestNode = maxDistance = -1\\n for node in queue:\\n for neighbor in graph[node]:\\n if visited[neighbor] == 0:\\n visited[neighbor] = visited[node] + 1\\n queue.append(neighbor)\\n if visited[neighbor] > maxDistance:\\n farthestNode = neighbor\\n maxDistance = visited[neighbor]\\n return farthestNode, maxDistance - 1\\n\\n def calculateDiameter(edges):\\n if not edges:\\n return 0, 0, 0\\n numNodes = len(edges) + 1\\n adjacencyList = [[] for _ in range(numNodes)]\\n for node1, node2 in edges:\\n adjacencyList[node1].append(node2)\\n adjacencyList[node2].append(node1)\\n endpoint1, distance = findFarthestNode(adjacencyList, 0)\\n endpoint2, distance = findFarthestNode(adjacencyList, endpoint1)\\n return distance, endpoint1, endpoint2\\n\\n diameter1, _, _ = calculateDiameter(tree1)\\n diameter2, _, _ = calculateDiameter(tree2)\\n return max(diameter1, diameter2, (diameter1 + 1) // 2 + (diameter2 + 1) // 2 + 1)\\n\",\n \"runtime\": \"1049\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n \\n def bfs(u, graph): \\n \\\"\\\"\\\"Return \\\"\\\"\\\"\\n ans = 0 \\n queue = deque([(u, -1)])\\n while queue:\\n ans += 1\\n for _ in range(len(queue)): \\n u, p = queue.popleft()\\n for v in graph[u]: \\n if v != p: \\n queue.append((v, u))\\n return ans, u\\n \\n def fn(edges): \\n \\\"\\\"\\\"Return \\\"\\\"\\\"\\n n = len(edges)+1\\n graph = [[] for _ in range(n)]\\n for u, v in edges: \\n graph[u].append(v)\\n graph[v].append(u)\\n _, u = bfs(0, graph)\\n dia, _ = bfs(u, graph)\\n return dia\\n \\n cnt1 = fn(edges1)\\n cnt2 = fn(edges2)\\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)\",\n \"runtime\": \"1083\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, v):\\n n = len(G)\\n bfs = [v]\\n seen = [0]*n\\n seen[v] = 1\\n res = d = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > d:\\n res = j\\n d = seen[j]\\n return res, d-1\\n\\n def diameter(edges):\\n if not edges:\\n return 0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for edge in edges:\\n G[edge[0]].append(edge[1])\\n G[edge[1]].append(edge[0])\\n v1, dist = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d\\n \\n d1 = diameter(edges1)\\n d2 = diameter(edges2)\\n return max(d1, d2, (d1+1)//2 + (d2 + 1)//2 + 1)\\n\\n \",\n \"runtime\": \"1118\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1152\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1186\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(\\n self,\\n edges1: list[list[int]],\\n edges2: list[list[int]],\\n ) -> int:\\n diameter1 = self._getDiameter(edges1)\\n diameter2 = self._getDiameter(edges2)\\n combinedDiameter = (diameter1 + 1) // 2 + (diameter2 + 1) // 2 + 1\\n return max(diameter1, diameter2, combinedDiameter)\\n\\n def _getDiameter(self, edges: list[list[int]]) -> int:\\n n = len(edges) + 1\\n graph = [[] for _ in range(n)]\\n\\n for u, v in edges:\\n graph[u].append(v)\\n graph[v].append(u)\\n\\n maxDiameter = [0]\\n self._maxDepth(graph, 0, -1, maxDiameter)\\n return maxDiameter[0]\\n\\n # Similar to 1522. Diameter of N-Ary Tree\\n def _maxDepth(\\n self,\\n graph: list[list[int]],\\n u: int,\\n prev: int,\\n maxDiameter: list[int],\\n ) -> int:\\n \\\"\\\"\\\"Returns the maximum depth of the subtree rooted at u.\\\"\\\"\\\"\\n maxSubDepth1 = 0\\n maxSubDepth2 = 0\\n for v in graph[u]:\\n if v == prev:\\n continue\\n maxSubDepth = self._maxDepth(graph, v, u, maxDiameter)\\n if maxSubDepth > maxSubDepth1:\\n maxSubDepth2 = maxSubDepth1\\n maxSubDepth1 = maxSubDepth\\n elif maxSubDepth > maxSubDepth2:\\n maxSubDepth2 = maxSubDepth\\n maxDiameter[0] = max(maxDiameter[0], maxSubDepth1 + maxSubDepth2)\\n return 1 + maxSubDepth1\",\n \"runtime\": \"1221\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n \\n def bfs(u, graph): \\n \\\"\\\"\\\"Return \\\"\\\"\\\"\\n ans = 0 \\n queue = deque([(u, -1)])\\n while queue:\\n ans += 1\\n for _ in range(len(queue)): \\n u, p = queue.popleft()\\n for v in graph[u]: \\n if v != p: \\n queue.append((v, u))\\n return ans, u\\n \\n def fn(edges): \\n \\\"\\\"\\\"Return \\\"\\\"\\\"\\n n = len(edges)+1\\n graph = [[] for _ in range(n)]\\n for u, v in edges: \\n graph[u].append(v)\\n graph[v].append(u)\\n _, u = bfs(0, graph)\\n dia, _ = bfs(u, graph)\\n return dia\\n \\n cnt1 = fn(edges1)\\n cnt2 = fn(edges2)\\n return max(cnt1-1, cnt2-1, cnt1//2+cnt2//2+1)\",\n \"runtime\": \"1255\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1289\"\n },\n {\n \"code\": \"\\nfrom collections import defaultdict\\n\\nclass Solve:\\n def __init__(self):\\n self.tree = defaultdict(list)\\n self.max_d = 0\\n\\n def dfs(self, node, parent):\\n max1 = max2 = 0\\n for neighbor in self.tree[node]:\\n if neighbor != parent:\\n depth = self.dfs(neighbor, node)\\n if depth > max1:\\n max1, max2 = depth, max1\\n elif depth > max2:\\n max2 = depth\\n self.max_d = max(self.max_d, max1 + max2)\\n return max1 + 1\\n\\n def treeDiameter(self, edges):\\n for u, v in edges:\\n self.tree[u].append(v)\\n self.tree[v].append(u)\\n self.dfs(0, -1)\\n return self.max_d\\n \\nclass Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n n, m = len(edges1), len(edges2)\\n a = Solve().treeDiameter(edges1)\\n b = Solve().treeDiameter(edges2)\\n def h(x):\\n return (x + 1) // 2\\n return max(a, b, h(a) + h(b) + 1)\\n \",\n \"runtime\": \"1323\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1358\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n edges = edges1\\n n = len(edges)+1\\n graph = [[] for _ in range(n)]\\n for i,j in edges:\\n graph[i].append(j)\\n graph[j].append(i)\\n d1 = 0\\n def dfs(node,pa):\\n nonlocal d1\\n maxi = 0\\n for ne in graph[node]:\\n if ne==pa: continue\\n x=dfs(ne,node)\\n d1=max(d1,1+maxi+x)\\n if x+1>maxi: maxi=x+1\\n return maxi\\n dfs(0,-1)\\n edges = edges2\\n n = len(edges)+1\\n graph = [[] for _ in range(n)]\\n for i,j in edges:\\n graph[i].append(j)\\n graph[j].append(i)\\n d2 = 0\\n def dfs(node,pa):\\n nonlocal d2\\n maxi = 0\\n for ne in graph[node]:\\n if ne==pa: continue\\n x=dfs(ne,node)\\n d2=max(d2,1+maxi+x)\\n if x+1>maxi: maxi=x+1\\n return maxi\\n dfs(0,-1)\\n return max(d1,d2,(d1+1)//2+(d2+1)//2+1)\",\n \"runtime\": \"1392\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farest(g,i):\\n n=len(g)\\n bfs=[i]\\n seen=[0]*n\\n seen[i]=1\\n res=maxd=-1\\n for i in bfs:\\n for j in g[i]:\\n if seen[j]==0:\\n seen[j]=seen[i]+1\\n bfs.append(j)\\n if seen[j]>maxd:\\n res=j\\n maxd=seen[j]\\n return res,maxd-1\\n\\n\\n def diameter(edge):\\n if not edge:\\n return 0\\n n=len(edge)+1\\n g=[[]for i in range(n)]\\n for i,j in edge:\\n g[i].append(j)\\n g[j].append(i)\\n v1,d1=farest(g,0)\\n v2,d2=farest(g,v1)\\n return d2\\n \\n d1=diameter(edges1)\\n d2=diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1426\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1461\"\n },\n {\n \"code\": \"from collections import deque\\n\\nclass Solution:\\n def bfs(self, graph, node):\\n n = len(graph)\\n dist = [-1] * n\\n q = deque()\\n q.append(node)\\n dist[node] = 0\\n maxDist = -1\\n maxNode = -1\\n\\n while q:\\n curr = q.popleft()\\n for neigh in graph[curr]:\\n if dist[neigh] == -1:\\n q.append(neigh)\\n dist[neigh] = dist[curr] + 1\\n if dist[neigh] > maxDist:\\n maxDist = dist[neigh]\\n maxNode = neigh\\n \\n return (maxNode, maxDist)\\n\\n def treeDiameter(self, edges):\\n n = len(edges) + 1\\n graph = [[] for _ in range(n)]\\n for e in edges:\\n graph[e[0]].append(e[1])\\n graph[e[1]].append(e[0])\\n \\n a1 = self.bfs(graph, 0)\\n a2 = self.bfs(graph, a1[0])\\n return a2[1]\\n\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n a = self.treeDiameter(edges1)\\n b = self.treeDiameter(edges2)\\n return max(a, b, (a + 1) // 2 + (b + 1) // 2 + 1)\",\n \"runtime\": \"1495\"\n },\n {\n \"code\": \"class Solution:\\n\\n def diameter(self, edges: List[List[int]]) -> int:\\n\\n g = [[] for _ in range(len(edges) + 1)]\\n\\n for x, y in edges:\\n\\n g[x].append(y)\\n\\n g[y].append(x)\\n\\n res = 0\\n\\n def dfs(x: int, fa: int) -> int:\\n\\n nonlocal res\\n\\n max_len = 0\\n\\n for y in g[x]:\\n\\n if y != fa:\\n\\n sub_len = dfs(y, x) + 1\\n\\n res = max(res, max_len + sub_len)\\n\\n max_len = max(max_len, sub_len)\\n\\n return max_len\\n\\n dfs(0, -1)\\n\\n return res\\n\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n\\n d1 = self.diameter(edges1)\\n\\n d2 = self.diameter(edges2)\\n\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1529\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1563\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n\\n def tree_diameter(n, edges):\\n # Function to calculate the diameter of a tree given the number of nodes and the edges\\n if n == 1: \\n return 0\\n \\n # Convert edges to adjacency list\\n adj = [[] for _ in range(n)]\\n for u, v in edges:\\n adj[u].append(v)\\n adj[v].append(u)\\n \\n # BFS to find the farthest node from an arbitrary node (say node 0)\\n def bfs(node):\\n queue = deque([node])\\n dist = [-1] * n\\n dist[node] = 0\\n farthest_node = node\\n \\n while queue:\\n u = queue.popleft()\\n for v in adj[u]:\\n if dist[v] == -1:\\n dist[v] = dist[u] + 1\\n queue.append(v)\\n if dist[v] > dist[farthest_node]:\\n farthest_node = v\\n return farthest_node, dist[farthest_node]\\n \\n # First BFS to find one end of the longest path\\n farthest_node, _ = bfs(0)\\n # Second BFS from that farthest node to find the diameter\\n _, diameter = bfs(farthest_node)\\n \\n return diameter\\n\\n\\n n = len(edges1) + 1\\n m = len(edges2) + 1\\n \\n # Get the diameters of both trees\\n D1 = tree_diameter(n, edges1)\\n D2 = tree_diameter(m, edges2)\\n \\n # The minimum possible diameter after connecting the two trees\\n return max(D1, D2, (D1 + 1) // 2 + (D2 + 1) // 2 + 1)\\n\",\n \"runtime\": \"1598\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n n,m=len(edges1)+1,len(edges2)+1\\n tree1=[[] for _ in range(n)]\\n tree2=[[] for _ in range(m)]\\n for e in edges1:\\n tree1[e[0]].append(e[1])\\n tree1[e[1]].append(e[0])\\n for e in edges2:\\n tree2[e[0]].append(e[1])\\n tree2[e[1]].append(e[0])\\n d1,d2=self.mindist(tree1),self.mindist(tree2)\\n dm=((d1+1)//2)+((d2+1)//2)+1\\n return max([d1,d2,dm])\\n def mindist(self,tree:List[List[int]])->int:\\n dia=[0]\\n self.maxdia(tree,0,-1,dia)\\n return dia[0]\\n def maxdia(self,tree:List[List[int]],node:int ,par:int,dia:List[int])->None:\\n sub1,sub2=0,0\\n for v in tree[node]:\\n if(v==par):\\n continue\\n dep=self.maxdia(tree,v,node,dia)\\n if(dep>sub1):\\n sub2=sub1\\n sub1=dep\\n elif dep> sub2:\\n sub2=dep\\n dia[0]=max(dia[0],sub1+sub2)\\n return 1+sub1\\n\\n\",\n \"runtime\": \"1632\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def bfs(edges):\\n if not edges:\\n return 0\\n \\n n = len(edges) + 1\\n graph = defaultdict(set)\\n\\n \\n for i, j in edges:\\n graph[i].add(j)\\n graph[j].add(i)\\n \\n leaves = []\\n for i in range(n):\\n if len(graph[i]) == 1:\\n leaves.append(i)\\n \\n remain = n\\n step = 0\\n while remain > 2:\\n remain -= len(leaves)\\n new_leaves = []\\n for leaf in leaves:\\n neighbor = graph[leaf].pop()\\n graph[neighbor].discard(leaf)\\n \\n if len(graph[neighbor]) == 1:\\n new_leaves.append(neighbor)\\n step += 1\\n leaves = new_leaves\\n\\n return step * 2 + 1 if remain == 2 else step * 2\\n \\n diameter1 = bfs(edges1)\\n diameter2 = bfs(edges2)\\n\\n d1 = math.ceil(diameter1 / 2)\\n d2 = math.ceil(diameter2 / 2)\\n\\n return max(d1 + d2 + 1, max(diameter1, diameter2))\",\n \"runtime\": \"1666\"\n },\n {\n \"code\": \"class Solution:\\n\\n\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n\\n def diameter(edges):\\n g =[[] for _ in range(len(edges)+1)]\\n for x, y in edges:\\n g[x].append(y)\\n g[y].append(x)\\n\\n ans = 0\\n def dfs(node, fa):\\n nonlocal ans\\n\\n cur_max_left = 0\\n for neighbour in g[node]:\\n if neighbour == fa:\\n continue\\n cur_right = dfs(neighbour, node) + 1\\n ans = max(ans, cur_max_left + cur_right)\\n cur_max_left = max(cur_max_left, cur_right)\\n\\n return cur_max_left\\n\\n dfs(0, -1)\\n return ans\\n\\n d1 = diameter(edges1)\\n d2 = diameter(edges2)\\n d3 = (d1 + 1) // 2 + (d2 + 1) // 2 + 1\\n return max(d1, d2, d3)\\n \",\n \"runtime\": \"1700\"\n },\n {\n \"code\": \"from collections import defaultdict\\n\\nclass Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def build_graph(edges):\\n graph = defaultdict(list)\\n for u, v in edges:\\n graph[u].append(v)\\n graph[v].append(u)\\n return graph\\n\\n def find_tree_info(edges):\\n graph = build_graph(edges)\\n \\n def dfs(node, parent):\\n height, diameter = 0, 0\\n max_height1, max_height2 = 0, 0\\n for child in graph[node]:\\n if child != parent:\\n child_height, child_diameter = dfs(child, node)\\n diameter = max(diameter, child_diameter)\\n if child_height + 1 > max_height1:\\n max_height2 = max_height1\\n max_height1 = child_height + 1\\n elif child_height + 1 > max_height2:\\n max_height2 = child_height + 1\\n \\n diameter = max(diameter, max_height1 + max_height2)\\n return max_height1, diameter\\n\\n _, diameter = dfs(0, -1)\\n return diameter, min(len(graph) - 1, (diameter + 1) // 2)\\n\\n diameter1, height1 = find_tree_info(edges1)\\n diameter2, height2 = find_tree_info(edges2)\\n\\n return max(diameter1, diameter2, height1 + height2 + 1)\",\n \"runtime\": \"1735\"\n },\n {\n \"code\": \"class Solution:\\n def minimumDiameterAfterMerge(self, edges1: List[List[int]], edges2: List[List[int]]) -> int:\\n def farthest(G, i):\\n n = len(G)\\n bfs = [i]\\n seen = [0] * n\\n seen[i] = 1\\n res = maxd = -1\\n for i in bfs:\\n for j in G[i]:\\n if seen[j] == 0:\\n seen[j] = seen[i] + 1\\n bfs.append(j)\\n if seen[j] > maxd:\\n res = j\\n maxd = seen[j]\\n return res, maxd - 1\\n\\n def diameter(edges):\\n if not edges:\\n return 0,0,0\\n n = len(edges) + 1\\n G = [[] for i in range(n)]\\n for i,j in edges:\\n G[i].append(j)\\n G[j].append(i)\\n v1, d = farthest(G, 0)\\n v2, d = farthest(G, v1)\\n return d,v1,v2\\n\\n d1, i, j = diameter(edges1)\\n d2, i, j = diameter(edges2)\\n return max(d1, d2, (d1 + 1) // 2 + (d2 + 1) // 2 + 1)\",\n \"runtime\": \"1769\"\n },\n {\n \"code\": \"