Count Ways to Make Array With Product

Count Ways to Make Array With Product - Problem

Array Math Dynamic Programming Combinatorics Number Theory Hard

You are given a 2D integer array queries. For each queries[i], where queries[i] = [ni, ki], find the number of different ways you can place positive integers into an array of size ni such that the product of the integers is ki.

As the number of ways may be too large, the answer to the ith query is the number of ways modulo 10⁹ + 7.

Return an integer array answer where answer.length == queries.length, and answer[i] is the answer to the ith query.

Input & Output

Example 1 — Basic Query

$ Input: queries = [[2,6],[3,1]]

› Output: [4,1]

💡 Note: For [2,6]: arrays [1,6], [2,3], [3,2], [6,1] all have product 6, so 4 ways. For [3,1]: only [1,1,1] has product 1, so 1 way.

Example 2 — Single Element

$ Input: queries = [[1,10]]

› Output: [1]

💡 Note: Array of size 1 with product 10: only [10] works, so 1 way.

Example 3 — Larger Array

$ Input: queries = [[4,2]]

› Output: [4]

💡 Note: Arrays of size 4 with product 2: [2,1,1,1], [1,2,1,1], [1,1,2,1], [1,1,1,2], so 4 ways.

Constraints

1 ≤ queries.length ≤ 10⁴
1 ≤ ni ≤ 10⁴
1 ≤ ki ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to convert multiplication to addition using prime factorization. Each way to distribute prime factors across array positions corresponds to a valid arrangement. Best approach uses prime factorization + combinatorics with stars-and-bars formula. Time: O(√k + log k), Space: O(log k)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force Enumeration

⏱️ Time: O(k^n) Space: O(n)

For each query, generate all possible combinations of positive integers of length n that multiply to k. This involves recursive enumeration of all divisors and arrangements.

Prime Factorization + Combinatorics

⏱️ Time: O(√k + log k) Space: O(log k)

Convert the multiplication problem to an addition problem using prime factorization. Each way to distribute prime factors across array positions corresponds to a valid arrangement.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* maxSubsequence(int* nums, int numsSize, int length, int* returnSize) {
    *returnSize = length;
    if (length == 0) return NULL;
    if (length >= numsSize) {
        int* result = (int*)malloc(numsSize * sizeof(int));
        memcpy(result, nums, numsSize * sizeof(int));
        *returnSize = numsSize;
        return result;
    }
    
    int* stack = (int*)malloc(numsSize * sizeof(int));
    int stackSize = 0;
    int drop = numsSize - length;
    
    for (int i = 0; i < numsSize; i++) {
        while (stackSize > 0 && stack[stackSize-1] < nums[i] && drop > 0) {
            stackSize--;
            drop--;
        }
        stack[stackSize++] = nums[i];
    }
    
    int* result = (int*)malloc(length * sizeof(int));
    for (int i = 0; i < length; i++) {
        result[i] = stack[i];
    }
    free(stack);
    return result;
}

int compareForMerge(int* a, int aSize, int aStart, int* b, int bSize, int bStart) {
    int x = aStart, y = bStart;
    while (x < aSize || y < bSize) {
        int digitA = (x < aSize) ? a[x] : ((y < bSize) ? b[y] : -1);
        int digitB = (y < bSize) ? b[y] : ((x < aSize) ? a[x] : -1);
        
        if (digitA != digitB) {
            return digitA - digitB;
        }
        
        if (x < aSize) x++; else y++;
        if (y < bSize) y++; else x++;
    }
    return 0;
}

int* merge(int* a, int aSize, int* b, int bSize, int* returnSize) {
    *returnSize = aSize + bSize;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    int i = 0, j = 0, k = 0;
    
    while (i < aSize && j < bSize) {
        if (compareForMerge(a, aSize, i, b, bSize, j) > 0) {
            result[k++] = a[i++];
        } else {
            result[k++] = b[j++];
        }
    }
    
    while (i < aSize) result[k++] = a[i++];
    while (j < bSize) result[k++] = b[j++];
    
    return result;
}

int compare(int* a, int aSize, int* b, int bSize) {
    int minLen = (aSize < bSize) ? aSize : bSize;
    for (int i = 0; i < minLen; i++) {
        if (a[i] != b[i]) {
            return a[i] - b[i];
        }
    }
    return aSize - bSize;
}

int* solution(int* nums1, int nums1Size, int* nums2, int nums2Size, int k, int* returnSize) {
    *returnSize = k;
    int* maxResult = (int*)malloc(k * sizeof(int));
    int hasResult = 0;
    
    int start = (k - nums2Size > 0) ? k - nums2Size : 0;
    int end = (k < nums1Size) ? k : nums1Size;
    
    for (int i = start; i <= end; i++) {
        int size1, size2, mergedSize;
        int* subseq1 = maxSubsequence(nums1, nums1Size, i, &size1);
        int* subseq2 = maxSubsequence(nums2, nums2Size, k - i, &size2);
        int* merged = merge(subseq1, size1, subseq2, size2, &mergedSize);
        
        if (!hasResult || compare(merged, k, maxResult, k) > 0) {
            memcpy(maxResult, merged, k * sizeof(int));
            hasResult = 1;
        }
        
        if (subseq1) free(subseq1);
        if (subseq2) free(subseq2);
        free(merged);
    }
    
    return maxResult;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int nums1[1000], nums2[1000];
    int nums1Size = 0, nums2Size = 0, k;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums1[nums1Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line + 1, ",]");
    while (token) {
        nums2[nums2Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(nums1, nums1Size, nums2, nums2Size, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

15.6K Views

Medium Frequency

~35 min Avg. Time

420 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