我正在寻找解决方案：
Given a array and a number P , find two numbers in array whose product equals P.
寻找比 O(n*2) 更好的解决方案。我可以使用额外的空间或其他数据结构。任何帮助表示赞赏？
【问题讨论】：
遍历数组，并将元素添加到 Hashtable。对于添加的每个元素 x，检查 P/x 是否已存在于哈希表中 - 如果存在，则 x 和 P/x 是您的解决方案之一。这将是您将获得的最佳效果。
【讨论】：
您可以尝试滑动窗口的方法。首先对所有数字进行递增排序，然后使用两个整数begin 和end 来索引当前这对数字。将begin 初始化为0，将end 初始化为最后一个位置。然后比较v[begin]和v[end]与P的乘积：
begin。end向后移动。这是一个实现了这个想法的 C++ 代码。由于排序，此解决方案为 O(n*log(n))，如果您可以假设数据已排序，那么您可以跳过 O(n) 解决方案的排序。
pair<int, int> GetProductPair(vector<int>& v, int P) {
sort(v.begin(), v.end());
int begin = 0, end = static_cast<int>(v.size()) - 1;
while (begin < end) {
const int prod = v[begin] * v[end];
if (prod == P) return make_pair(begin, end);
if (prod < P) ++begin;
else --end;
}
return make_pair(-1, -1);
}
【讨论】：
begin 移动一次太远，并且不得不将其移回以尝试一对更大的end。但是在这个心理图像中，我忽略了数组也是在end 一侧排序的......
begin，当当前乘积 > P 时将其向后移动。无论哪种方式，都是 O(n) 时间, 不包括排序时间。
这个只适用于整数： 将 P 分解为素数的乘积。通过将它们分成两组，您可以获得将 P 作为产品的对。现在您只需检查它们是否都存在于数组中，这是哈希表非常有用的地方。此外，在创建哈希表时，您还可以过滤重复值数组、大于 P 的值，甚至是 P 中不包含素因数的值。
【讨论】：
这个算法是 O(n)
【讨论】：
1.在 O(nlogn) 时间内将数字排序到数组 A 中，删除所有零
2.创建一个数组 B 使得 B[i] = P/A[I] 在 O(n) 时间内
3.对于B中的每个B[k]，在A中对该元素进行二分搜索，最坏情况下需要O(nlogn)时间
如果元素 B[k] 存在于数组 A 中的位置 m，则 A[k] * A[m] = P 否则不存在这样的对
总运行时间为O(nlogn)
当然这在真机上可能会因为浮点错误而遇到困难
【讨论】：
public boolean factors_Of_Product_In_Array(int a[],int product,int factorsLimit)
{
int i = 0,count = 0;
boolean flag = false;
if(factorsLimit==0)
flag = false;
//If product value is zero - only verify if there is any '0' value in array
else if(product==0)
{
for(i=0;i<a.length;i++)
{
if(a[i]==0)
flag = true;
}
}
//If product value is 1 - Verify at least factorsLimit number of 1's should be present in array
else if(product==1)
{
for(i=0;i<a.length;i++)
{
if(a[i]==0)
count=count+1;
}
if(count==factorsLimit)//Verifying if the number of 1's is equal to number of factors required
flag = true;
}
else
{
for(i=0; i<a.length && count!=factorsLimit ;i++)
{
if(product%a[i]==0)
{
product = product/a[i];
count = count+1;
System.out.println(" "+a[i]+" ");
}
}
if(count==factorsLimit)
flag = true;
}
return flag;
}
【讨论】：
已更新以提供实现。
O(n+P)解，忽略P等于0的情况。
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
int main(){
auto arr = new vector<int>();
int P, numOfEle, ele;
cout << "The number of elements to be entered: " << endl;
cin >> numOfEle;
cout << "Please enter the elements: " << endl;
for (int i = 0; i < numOfEle; i++){
cin >> ele;
arr->push_back(ele);
}
cout << "Please enter P: " << endl;
cin >> P;
//O(n+P) solution, ignoring the case of P equal to 0
bool* factorsInNeed = new bool[P];
for (int i = 0; i < P; i++)
factorsInNeed[i] = false;
for (auto i : *arr){
if (i != 0 && P/(double)i == P/i){ //if divisble
if (factorsInNeed[i]){
cout << "A solution: " << i << " & " << P/i << endl;
break;
}
factorsInNeed[P/i] = true;
}
}
}
【讨论】：
这是我的镜头，它只比较任何因素一次
P <- The Number
theArray <- new array[theData]
factors <- new array[]
isFactor <- new map(init: false)
factorCount <- 0
i <- 0
while i is in theArray
num <- theArray[i]
if (isFactor[num])
skip
if num modulo P == 0
isFactor[num] <- true
j <- 0
while j is in factors
if factors[j] * num == P
return (num, factors[j])
j++
factors.push(num)
factorCount++
i++
【讨论】：
factors 里面有什么东西吗？
不确定这是否是最好的解决方案，但它确实有效。你可以尝试优化一下。
public class CombInput
{
public int ID;
public string Value;
}
public List<string> GetCombinations(List<string> values)
{
List<CombInput> input = new List<CombInput>();
List<string> outputvalues = new List<string>();
int counter = 1;
foreach (String c in values)
{
input.Add(new CombInput { ID = counter, Value = c });
counter++;
}
var Output = from i in input
select i;
string Final = Output.Select(query => query.Value).Aggregate((a, b) => a + "|" + b);
while (!Output.ToList().Exists(s=>s.Value.ToString()==Final))
{
var store = Output;
var Output1=
(from o in Output
from v in input
where (v.ID < o.ID && !(store.Any(a=>a.Value==v.Value + "|" + o.Value)))
select new CombInput { ID = v.ID, Value = v.Value + "|" + o.Value });
var Outputx = (from s in store select s)
.Concat
(from s in Output1.ToList() select s);
Output = Outputx;
}
foreach (var v in Output)
outputvalues.Add(v.Value);
return outputvalues.ToList();
}
public List<string> GetProductCombinations(List<int> nums, int productCriteria)
{
List<string> input = (from i in nums
select i.ToString()).ToList();
input = GetCombinations(input);
var O = from i in input
where i.Split('|').ToList().Select(x => Convert.ToInt32(x)).ToList().Aggregate((a, b) => a * b) == productCriteria
select i;
List<string> output=new List<string>();
foreach (string o in O)
{
output.Add(o);
}
return output;
}
private void button1_Click(object sender, EventArgs e)
{
List<string> output = new List<string>();
List<int> nums = new List<int>();
int[] numsarr ={1,2,3,4,6,7,8,12};
nums = numsarr.ToList();
output = GetProductCombinations(nums, 12);
}
【讨论】：
void PrintPairOfProduct(int arr[],int size,int k) {
int i,temp[MAX];
memset(temp,1,MAX);
for(i=0;i<size;++i)
{
if(k % arr[i] == 0 && temp[arr[i]] != -1 && temp[k/arr[i]] != -1)
{
if((temp[k/arr[i]] * arr[i]) == k)
{
printf("Product of %d * %d = %d",k/arr[i],arr[i],k);``
temp[k/arr[i]] = -1;
temp[arr[i]] = -1;
}
temp[arr[i]] = arr[i];
}}
【讨论】：
#include<stdio.h>
int main()
{
int arr[]={2,15,4,5,6,7};
const int c = 30;
int i = 0,j=1;
int num =0;
while ( i<= 6 )
{
num = arr[i] * arr[j];
if ( num == 30)
{
printf("Pairs[%d,%d]\t",arr[i],arr[j]);
}
if (j == 5 )
{
i = i+1;
j = i + 1;
if (j==6)
{
break;
}
else
{
continue;
}
}
j= j+1;
}
return 0;
}
【讨论】：