Final Array State After K Multiplication Operations I

Final Array State After K Multiplication Operations I - Problem

You are managing a dynamic scoring system where you need to perform k boost operations on an array of scores.

Given an integer array nums, an integer k (number of operations), and an integer multiplier, you need to:

In each operation, find the minimum value in the array
If there are multiple occurrences of the minimum value, select the first one (leftmost)
Replace that minimum value with minimum_value × multiplier
Repeat this process exactly k times

Goal: Return the final state of the array after all k multiplication operations.

Example: If nums = [2,1,3,5,6], k = 5, multiplier = 2
Operation 1: min=1 at index 1 → [2,2,3,5,6]
Operation 2: min=2 at index 0 → [4,2,3,5,6]
And so on...

Input & Output

example_1.py — Python

$ Input: nums = [2,1,3,5,6], k = 5, multiplier = 2

› Output: [8,4,6,5,6]

💡 Note: Operation 1: min=1 at index 1 → [2,2,3,5,6]. Operation 2: min=2 at index 0 → [4,2,3,5,6]. Operation 3: min=2 at index 1 → [4,4,3,5,6]. Operation 4: min=3 at index 2 → [4,4,6,5,6]. Operation 5: min=4 at index 0 → [8,4,6,5,6].

example_2.py — Python

$ Input: nums = [1,2], k = 3, multiplier = 4

› Output: [16,8]

💡 Note: Operation 1: min=1 at index 0 → [4,2]. Operation 2: min=2 at index 1 → [4,8]. Operation 3: min=4 at index 0 → [16,8].

example_3.py — Python

$ Input: nums = [3,3,3], k = 2, multiplier = 3

› Output: [9,9,3]

💡 Note: All elements are equal, so we always pick the first occurrence. Operation 1: min=3 at index 0 → [9,3,3]. Operation 2: min=3 at index 1 → [9,9,3].

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
1 ≤ k ≤ 10
1 ≤ multiplier ≤ 5
All input values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Initial State

Start with nums=[2,1,3,5,6], k=5, multiplier=2

Find Minimum

Scan array to find min=1 at index 1 (first occurrence)

Multiply

Replace 1 with 1×2=2, array becomes [2,2,3,5,6]

Repeat

Continue for remaining k-1 operations

Final Result

After 5 operations: [8,4,6,5,6]

Key Takeaway

🎯 Key Insight: The problem tests your ability to handle repeated minimum-finding with tie-breaking rules. While brute force works for small inputs, understanding when to optimize with data structures like heaps is crucial for scalability.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

This problem can be solved with simulation in O(n×k) time or optimized using a min-heap for O(k log n) time. The key insight is efficiently finding the minimum element while handling tie-breaking by index. For small constraints, brute force simulation works well, but the heap approach scales better for larger inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Heap Optimization	O(k log n)	O(n)	Use priority queue to efficiently track minimum elements
Brute Force Simulation	O(n × k)	O(1)	For each of k operations, linearly search for minimum and multiply it

Min-Heap Optimization — Algorithm Steps

Create a min-heap with (value, index) pairs from the array
For each of k operations:
Extract minimum (value, index) from heap
Multiply the value at that index
Push the new (updated_value, index) back to heap
Return the final array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Create min-heap with (value,index) pairs: [(1,1), (2,0), (3,2), (5,3), (6,4)]

Extract Min

Pop (1,1), multiply 1*2=2, push (2,1) back

Continue

Each operation is O(log n) instead of O(n)

Final Result

Efficient processing of all k operations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int value;
    int index;
} Item;

typedef struct {
    Item* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->items = malloc(capacity * sizeof(Item));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(Item* a, Item* b) {
    Item temp = *a;
    *a = *b;
    *b = temp;
}

int compare(Item* a, Item* b) {
    if (a->value != b->value) return a->value - b->value;
    return a->index - b->index;
}

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (compare(&heap->items[idx], &heap->items[parent]) >= 0) break;
        swap(&heap->items[idx], &heap->items[parent]);
        idx = parent;
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (1) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && compare(&heap->items[left], &heap->items[minIdx]) < 0) {
            minIdx = left;
        }
        if (right < heap->size && compare(&heap->items[right], &heap->items[minIdx]) < 0) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        swap(&heap->items[idx], &heap->items[minIdx]);
        idx = minIdx;
    }
}

void push(MinHeap* heap, int value, int index) {
    heap->items[heap->size].value = value;
    heap->items[heap->size].index = index;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Item pop(MinHeap* heap) {
    Item min = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

int* getFinalState(int* nums, int numsSize, int k, int multiplier) {
    int* result = malloc(numsSize * sizeof(int));
    memcpy(result, nums, numsSize * sizeof(int));
    
    MinHeap* heap = createHeap(numsSize);
    
    // Initialize heap
    for (int i = 0; i < numsSize; i++) {
        push(heap, nums[i], i);
    }
    
    for (int i = 0; i < k; i++) {
        Item min = pop(heap);
        result[min.index] = min.value * multiplier;
        push(heap, min.value * multiplier, min.index);
    }
    
    free(heap->items);
    free(heap);
    return result;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k, multiplier;
    
    // Read array
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    scanf("%d %d", &k, &multiplier);
    
    int* result = getFinalState(nums, numsSize, k, multiplier);
    
    for (int i = 0; i < numsSize; i++) {
        printf("%d", result[i]);
        if (i < numsSize - 1) printf(" ");
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k log n)

Each of k operations requires O(log n) time for heap operations (extract-min and insert)

⚡ Linearithmic

Space Complexity

O(n)

The heap stores n elements as (value, index) pairs

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Min-Heap Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler