给定一个整数K ,任务是构造一个最大长度的数组,使所有数组元素的乘积等于K ,以使除第一个数组元素外的每个数组元素都可被其先前的相邻元素整除。
注意:生成的数组中的每个数组元素都必须大于1。
例子:
Input: K = 4
Output: {2, 2}
Explanation:
The second element, i.e. arr[1] (= 2) is divisible by the first element, i.e. arr[0] (= 2).
Product of the array elements = 2 * 2 = 4(= K).
Therefore, the array satisfies the required condition.
Input: K = 23
Output: {23}
方法:解决此问题的想法是找到K的所有素因子及其各自的幂,使得:
prime_factor[1]x * prime_factor[2]y … * primefactor[i]z = K
请按照以下步骤解决此问题:
- 找到具有最大功效的质因数(例如X) ,例如Y。
- 然后, Y将是所需数组的长度。
- 因此,构造一个长度为Y的数组,其中所有元素都等于X。
- 要使数组的乘积等于K ,请将最后一个元素乘以K / X y 。
下面是上述方法的实现:
C++
// C++ program for the above approach
#include
using namespace std;
// Function to construct longest array
// with product K such that each element
// is divisible by its previous element
void findLongestArray(int K)
{
// Stores the prime factors of K
vector > primefactors;
int K_temp = K;
for (int i = 2; i * i <= K; i++) {
// Stores the power to which
// primefactor i is raised
int count = 0;
while (K_temp % i == 0) {
K_temp /= i;
count++;
}
if (count > 0)
primefactors.push_back({ count, i });
}
if (K_temp != 1)
primefactors.push_back(
{ 1, K_temp });
// Sort prime factors in descending order
sort(primefactors.rbegin(),
primefactors.rend());
// Stores the final array
vector answer(
primefactors[0].first,
primefactors[0].second);
// Multiply the last element by K
answer.back() *= K;
for (int i = 0;
i < primefactors[0].first; i++) {
answer.back() /= primefactors[0].second;
}
// Print the constructed array
cout << "{";
for (int i = 0; i < (int)answer.size(); i++) {
if (i == answer.size() - 1)
cout << answer[i] << "}";
else
cout << answer[i] << ", ";
}
}
// Driver Code
int main()
{
int K = 4;
findLongestArray(K);
}
Java
// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Function to construct longest array
// with product K such that each element
// is divisible by its previous element
static void findLongestArray(int K)
{
// Stores the prime factors of K
ArrayList primefactors = new ArrayList<>();
int K_temp = K;
for (int i = 2; i * i <= K; i++) {
// Stores the power to which
// primefactor i is raised
int count = 0;
while (K_temp % i == 0) {
K_temp /= i;
count++;
}
if (count > 0)
primefactors.add(new int[] { count, i });
}
if (K_temp != 1)
primefactors.add(new int[] { 1, K_temp });
// Sort prime factors in descending order
Collections.sort(primefactors, (x, y) -> {
if (x[0] != y[0])
return y[0] - x[0];
return y[1] - x[1];
});
// Stores the final array
int n = primefactors.get(0)[0];
int val = primefactors.get(0)[1];
int answer[] = new int[n];
Arrays.fill(answer, val);
// Multiply the last element by K
answer[n - 1] *= K;
for (int i = 0; i < n; i++) {
answer[n - 1] /= val;
}
// Print the constructed array
System.out.print("{");
for (int i = 0; i < answer.length; i++) {
if (i == answer.length - 1)
System.out.print(answer[i] + "}");
else
System.out.print(answer[i] + ", ");
}
}
// Driver Code
public static void main(String[] args)
{
int K = 4;
findLongestArray(K);
}
}
// This code is contributed by Kingash.
Python3
# Python 3 program for the above approach
# Function to construct longest array
# with product K such that each element
# is divisible by its previous element
def findLongestArray(K):
# Stores the prime factors of K
primefactors = []
K_temp = K
i = 2
while i * i <= K:
# Stores the power to which
# primefactor i is raised
count = 0
while (K_temp % i == 0):
K_temp //= i
count += 1
if (count > 0):
primefactors.append([count, i])
i += 1
if (K_temp != 1):
primefactors.append(
[1, K_temp])
# Sort prime factors in descending order
primefactors.sort()
# Stores the final array
answer = [primefactors[0][0],
primefactors[0][1]]
# Multiply the last element by K
answer[-1] *= K
for i in range(primefactors[0][0]):
answer[-1] //= primefactors[0][1]
# Print the constructed array
print("{", end = "")
for i in range(len(answer)):
if (i == len(answer) - 1):
print(answer[i], end = "}")
else:
print(answer[i], end = ", ")
# Driver Code
if __name__ == "__main__":
K = 4
findLongestArray(K)
# This code is contributed by ukasp.
输出:
{2, 2}
时间复杂度: O(√(K)* log(√(K)))
辅助空间: O(√(K))