Question

只有 gcd（val [i]，val [j]）> 1

在这里

gcd（a，b） =两个数字的最大公约数。

分割数组具有一个参数

Val ：n个整数的整数数组

这是两个例子。

Sample Input 0:
5 // no of value in an integer
2
3
2
3
3
Sample Output 0:
2

Sample Input 1:
5   //no of value in an integer
3
5
7
11
2

Sample Output 1:
5

示例示例输入0

subarray [1..3] = {2,3,2}在这里gcd（2,2）> 1

subarray [4..5] = {3,3} gcd（3,3）> 1

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);

现在如何实现splitTheArray（）函数？

Answer 1

您需要找到最小数量的子数组，以便在每个子数组中，第一个和最后一个元素的 gcd > 1 。您可以通过O（Nˆ2）的复杂性轻松地做到这一点。

int splitTheArray(vector<int> val) {
 // implement this function
 int sz = val.size();
 if(sz == 0) return 0;
 int ind = sz - 1;
 int subarray = 0;
 while(ind >= 0) {
     for(int i = 0; i <= ind; i++) {
         if(__gcd(val[ind], val[i]) > 1) {
             subarray++;
             ind = i-1;
             break;
         }
     }
 }
 return subarray;
}

Answer 2

#include <iostream>
#include <vector>
#include <fstream>
#include <string>

using namespace std;

int gcd(int a, int b)
{
	if (b == 0)
		return a;
	return gcd(b, a % b);

}

int max(int a, int b)
{
	return (a > b) ? a : b;
}

int min(int a, int b)
{
	return (a < b) ? a : b;
}

int solve(vector<int> vec)
{
	int n = gcd(vec[0], vec[vec.size() - 1]);

	if (n > 1)
		return 0;

	int con = 0 , flag = 0 , j=0 , i=0 , flag2=0;

	for (i = j; i < vec.size()/2; i++)
	{
		i = j;

		if (i >= vec.size())
			break;

		int f = vec[i];

		flag = 0;

		for (j = i+1; j < vec.size(); j++)
		{
			int l = vec[j];

			int ma = max(f, l);
			int mi = min(f, l);

			n = gcd(ma, mi);

			if (flag)
			{
				if (n > 1)
					con++;
				else
					break;
			}

			if (n > 1)
			{
				flag = 1;
				flag2 = 1;
				con++;
			}
		}
	}

	if (!flag2)
		return vec.size();

	return con;
}

int main()
{
	int n;

	cin >> n;

	vector<int> vec;

	for (int i = 0; i < n; i++)
	{
		int tm;

		cin >> tm;

		vec.emplace_back(tm);
	}

	cout<<solve(vec);

	return 0;
}

Answer 3

#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
void solve()
{
    int n,i,j;
    cin>>n;
    int A[n+1],DP[n+1];
    for(i=1;i<=n;i++)
        cin>>A[i];
    memset(DP,0,sizeof(DP));
    unordered_map<int,int> M;
    for(i=1;i<=n;i++)
    {
        vector<int> Fact;
        Fact.push_back(A[i]);
        for(j=2;j*j<=A[i];j++)
        {
            if(A[i]%j==0)
            {
                if(j*j==A[i])
                {
                    Fact.push_back(j);
                }
                else
                {
                    Fact.push_back(j);
                    Fact.push_back(A[i]/j);
                }
            }
        }
        int ans=DP[i-1]+1;
        for(j=0;j<Fact.size();j++)
        {
            if(M.find(Fact[j])==M.end())
            {
                M[Fact[j]]=DP[i-1];
            }
            else
            {
                ans=min(ans,M[Fact[j]]+1);
            }
        }
        DP[i]=ans;
    }
    cout<<DP[n]<<endl;
}
int32_t main()
{
    boost;
    int  t=1;
    // cin>>t;
    for(int i=1;i<=t;i++)
    {
        //cout<<"Case #"<<i<<": ";
        solve();
    }
}

时间复杂度：N * Sqrt（max（A [i]）） P.S可以使用筛子优化因子计算，而不是每次都针对每个数字计算因子。

吐出数组，使gcd（val [i]，val [j]）> 1

3 个答案: