LightOJ-1356 Prime Independence 质因子分解+二分图最大独立集

最新推荐文章于 2020-06-25 10:35:20 发布
最新推荐文章于 2020-06-25 10:35:20 发布
阅读量337 收藏
点赞数
分类专栏： # 数学 # 网络流、匹配问题 文章标签： ACM 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cc_Sonia/article/details/83211259
版权

感觉这道题挺好的，数论+图论。就是我太菜了，怎么都写不对啊啊啊55555...
先一搜题目，发现这道题用质因子分解+二分图最大独立集，好巧妙啊_(:з」∠)_ 
二分图最大独立集=顶点数-最大匹配数(用Hopcroft-Carp算法，匈牙利算法会TLE...)
然后自己琢磨出如下思路：（用到了“拆点”）

但是仍然TLE了QAQ...附上TLE的代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
using namespace std;
#define pb push_back
const int INF=0x3f3f3f3f;

const int MAXN=40005;
int n,a[MAXN];
map<int,int>mp;

const int MAX=500005;
int pri[MAX+1];
void getp()//得到MAX内的素数
{
    memset(pri,0,sizeof(pri));
    for(int i=2;i<MAX;i++)
    {
        if(!pri[i])
            pri[++pri[0]]=i;
        for(int j=1;j<=pri[0]&&i*pri[j]<MAX;j++)
        {
            pri[i*pri[j]]=1;
            if(i%pri[j]==0)
                break;
        }
    }
}

vector<int>g[MAXN];
int un;
int mx[MAXN],my[MAXN];
int dx[MAXN],dy[MAXN];
int dis;
bool used[MAXN];
bool SearchP()
{
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<un;i++)
        if(mx[i]==-1)
        {
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)
            break;
        for(int i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            if(dy[v]==-1)
            {
                dy[v]=dx[u]+1;
                if(my[v]==-1)
                    dis=dy[v];
                else
                {
                    dx[my[v]]=dy[v]+1;
                    Q.push(my[v]);
                }
            }
        }
    }
    return dis!=INF;
}
bool dfs(int u)
{
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(!used[v]&&dy[v]==dx[u]+1)
        {
            used[v]=true;
            if(my[v]!=-1&&dy[v]==dis)
                continue;
            if(my[v]==-1||dfs(my[v]))
            {
                my[v]=u;
                mx[u]=v;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch()
{
    int res=0;
    un=n;
    memset(mx,-1,sizeof(mx));
    memset(my,-1,sizeof(my));
    while(SearchP())
    {
        memset(used,false,sizeof(used));
        for(int i=0;i<un;i++)
            if(mx[i]==-1&&dfs(i))
                res++;
    }
    return res;
}

int main()
{
    int t;
    scanf("%d",&t);
    getp();
    for(int tt=1;tt<=t;tt++)
    {
        scanf("%d",&n);
        for(int i=0;i<=n;i++)
            g[i].clear();
        int ma=-1;
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
            ma=max(ma,a[i]);
        }
        for(int i=0;i<ma;i++)//注意不是到n!到ma！
            mp[i]=-1;//因为下标从0开始
        for(int i=0;i<n;i++)
            mp[a[i]]=i;
        //建图
        for(int i=0;i<n;i++)
        {
            for(int j=1;j<=pri[0];j++)
            {
                if(pri[j]>a[i])
                    break;
                if(a[i]%pri[j]==0)
                {
                    int k=a[i]/pri[j];
                    //cout<<"i="<<i<<" a[i]="<<a[i]<<" pri[j]="<<pri[j]<<" k="<<k<<" mp[k]="<<mp[k]<<endl;
                    if(mp[k]==-1)
                        continue;
                    g[i].pb(mp[k]);
                    g[mp[k]].pb(i);
                }
            }
        }
        int res=MaxMatch();
        //cout<<"res="<<res<<endl;
        int ans=(n*2-res)/2;
        printf("Case %d: %d\n",tt,ans);
    }
	return 0;
}

后来想想应该是建图部分复杂度有点高了，于是进行优化，只搜到sqrt(a[i])。以sqrt(a[i])为界，分为质数×合数、质数×质数、合数×质数三种情况，然后注意特判1。另外加上了一个判断MAX内的数字是否为素数的函数和数组。附上部分改后的代码：

bool isp[MAX];
void init()//判断是否为素数
{
    memset(isp,true,sizeof(isp));
    isp[0]=isp[1]=false;
    for(int i=2;i<MAX;i++)
    {
        if(isp[i])
            for(int j=i+i;j<MAX;j+=i)
                isp[j]=false;
    }
}
        //建图
        for(int i=0;i<n;i++)
        {
            for(int j=1;j<=pri[0];j++)
            {
                if(pri[j]>sqrt(1.0*a[i]))
                    break;
                if(a[i]%pri[j]==0)
                {
                    int k=a[i]/pri[j];
                    if(mp[k]!=-1)
                    {
                        g[i].pb(mp[k]);
                        g[mp[k]].pb(i);
                    }
                    
                    if(k*pri[j]==a[i])
                        break;
                    if(isp[k]&&mp[pri[j]]!=-1)//如果k为质数才加边
                    {
                        g[i].pb(mp[pri[j]]);
                        g[mp[pri[j]]].pb(i);
                    }
                }
            }
            //解决4,97,388这种情况
            for(int k=4;k<=sqrt(1.0*a[i]);k++)
            {
                if(mp[k]==-1)
                    continue;
                if(isp[k])//上边扫过了
                    continue;
                if(a[i]%k)
                    continue;
                if(isp[a[i]/k])
                {
                    g[i].pb(mp[k]);
                    g[mp[k]].pb(i);
                }
            }
        }
        if(mp[1]!=-1)//特判1
            for(int i=0;i<n;i++)
                if(isp[a[i]])
                {
                    g[mp[1]].pb(i);
                    g[i].pb(mp[1]);
                }

但最后还是TLE了55555...没办法去搜网上的题解，发现大部分都说用“奇偶性建图”，好神奇的操作_(:з」∠)_ 但是我不会啊QAQ...好不容易找到了拆点建图的题解，附上大佬博客Orz：

http://www.cnblogs.com/xiuwenli/p/9520421.html

发现其实就是自己质因子分解弄复杂了。。用到Pollard Rho算法，附上讲解博客Orz：

https://www.cnblogs.com/vipchenwei/p/7123217.html

改了改，就过了。。另外这次我把点集的起始下标改为从1开始了(方便map初始化)。
附上AC代码：（真不容易啊QAQ...我好菜啊啊啊55555...）

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
using namespace std;
#define pb push_back
const int INF=0x3f3f3f3f;

const int MAXN=40005;
int n,a[MAXN];
map<int,int>mp;

const int MAX=500005;
int pri[MAX+1];
void getp()//得到MAX内的素数
{
    memset(pri,0,sizeof(pri));
    for(int i=2;i<MAX;i++)
    {
        if(!pri[i])
            pri[++pri[0]]=i;
        for(int j=1;j<=pri[0]&&i*pri[j]<MAX;j++)
        {
            pri[i*pri[j]]=1;
            if(i%pri[j]==0)
                break;
        }
    }
}

vector<int>g[MAXN];
int un;
int mx[MAXN],my[MAXN];
int dx[MAXN],dy[MAXN];
int dis;
bool used[MAXN];
bool SearchP()
{
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=1;i<=un;i++)
        if(mx[i]==-1)
        {
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)
            break;
        for(int i=0;i<g[u].size();i++)
        {
            int v=g[u][i];
            if(dy[v]==-1)
            {
                dy[v]=dx[u]+1;
                if(my[v]==-1)
                    dis=dy[v];
                else
                {
                    dx[my[v]]=dy[v]+1;
                    Q.push(my[v]);
                }
            }
        }
    }
    return dis!=INF;
}
bool dfs(int u)
{
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(!used[v]&&dy[v]==dx[u]+1)
        {
            used[v]=true;
            if(my[v]!=-1&&dy[v]==dis)
                continue;
            if(my[v]==-1||dfs(my[v]))
            {
                my[v]=u;
                mx[u]=v;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch()
{
    int res=0;
    un=n;
    memset(mx,-1,sizeof(mx));
    memset(my,-1,sizeof(my));
    while(SearchP())
    {
        memset(used,false,sizeof(used));
        for(int i=1;i<=un;i++)
            if(mx[i]==-1&&dfs(i))
                res++;
    }
    return res;
}

int fac[MAXN];
void addedge(int num,int id)
{
    int tmp=num;
    int tot=0;
    for(int j=1;j<=pri[0];j++)
    {
        if(pri[j]*pri[j]>tmp)
            break;
        if(tmp%pri[j]==0)
        {
            fac[tot++]=pri[j];
            while(tmp%pri[j]==0)
                tmp/=pri[j];
        }
    }
    if(tmp>1)//最后一个质因数
        fac[tot++]=tmp;
    for(int i=0;i<tot;i++)
    {
        int x=num/fac[i];
        //cout<<"i="<<i<<" fac="<<fac[i]<<" x="<<x<<endl;
        if(mp[x])
        {
            g[id].pb(mp[x]);
            g[mp[x]].pb(id);
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    getp();
    for(int tt=1;tt<=t;tt++)
    {
        scanf("%d",&n);
        for(int i=0;i<=n;i++)
            g[i].clear();
        mp.clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            mp[a[i]]=i;
        }
        for(int i=1;i<=n;i++)
            addedge(a[i],i);
        int res=MaxMatch();
        //cout<<"res="<<res<<endl;
        int ans=(n*2-res)/2;
        printf("Case %d: %d\n",tt,ans);
    }
	return 0;
}

 

Cc_Sonia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LightOJ - 1356 Prime Independence（质因数分解，二分图最大独立集）
Plus Ultra！
10-03 209
链接：LightOJ - 1356 Prime Independence 题意： 定义：若aaa是bbb的质数倍，即a=k×ba=k\times ba=k×b（其中kkk为质数），则称aaa、bbb相关联； 给出N (1≤N≤40000)N\,(1\le N\le 40000)N(1≤N≤40000)个正整数x∈[1,500000]x\in [1,500000]x∈[1,500000]，求最大独立...
LightOJ-solutions
03-09
【标题】"LightOJ-solutions" 是一个与编程竞赛相关的资源，主要包含了参与 LightOJ（Light Online Judge）平台的解题方案。这个压缩包很可能是某位参赛者或编程爱好者整理的代码集合，旨在分享他们在解决 LightOJ ...
二分图HK算法[数论+二分图最大独立集]：Lightoj1356
weixin_45630722的博客
06-25 195
Prime Independence LightOJ - 1356 题目大意：给你n个数，你从这个集合中挑选出若干个数，使得这个集合的数里面两两之间a/b!=k[k是质数并且a>b] 解题思路：如果a/b是一个质数那么a的质因数分解之后质数的总共个数如果是奇数那么b分解质因数后质因子个数就是偶数个，反之亦然。那么我们就可以将质因子个数为奇数和偶数的两个点 ...
lightoj 1356 Prime Independence（最大独立集+HK算法）
shyoldman的博客
09-02 416
1356 - Prime Independence     PDF (English) Statistics Forum Time Limit: 3 second(s) Memory Limit: 32 MB A set of integers is called prime independent if none of its member is a prime...
LightOJ-1356 Prime Independence
MyWorld
09-28 1432
题意： 找出一些数字的最大质独立集，就是集合能的所有数互相之间不会出现 a[i]==t*a[j] (t是质数) 的情况。 思路： 首先想最大独立集对于一般图是NP问题，通常只有求二分图最大独立集，然后就是如何把这些数字分为二分图。 能够想到如果一个数字等于另一个数字乘以一个质数，那么这两个数字的质因子分解应该只有这一个质数的差别。也就是只会多一个质数，数字上限只有500000，完全可以
LightOJ1356 Prime Independence(数论+匹配)
天道酬勤
09-06 500
LightOJ1356题目给出n个数, 现在要选出一个”素数独立集合”, 如果一个数是另外一个数的素数倍, 这两个不能同时选入,问这个集合的最大大小是多少?思路http://tokers.cn/2015/07/11/lightoj1356-prime-independence%E6%95%B0%E8%AE%BA%E5%8C%B9%E9%85%8D/ 知道了Hopcroft-Karp算法，用二分图来
lightoj 1356 - Prime Independence 【质因子分解 奇偶构图 + HK优化】
世界很大
10-25 1431
1356 - Prime Independence PDF (English) Statistics Forum Time Limit: 3 second(s) Memory Limit: 32 MB A set of integers is called prime independent if none of
LightOJ-Solved-Code:LightOJ 解决问题代码
06-05
【标题】"LightOJ-Solved-Code"指的是一个关于在Light Online Judge平台上解决编程问题的代码集合。这个集合很可能包含了作者在LightOJ上解答各类算法问题的C++源代码。LightOJ是一个在线的编程竞赛平台，它提供了一...
lightoj-tutorial-editorial-by-sayeed:像Codeforces编辑模式一样在lightoj上发表社论​​！
03-05
标题中的“lightoj-tutorial-editorial-by-sayeed”指的是LightOJ（Light Online Judge）平台上的一篇教程或社论，由用户Sayeed撰写，旨在帮助用户了解如何在LightOJ上创建类似于Codeforces编辑模式的教程。...
问题教程：一个包含有关LightOJ问题的教程的存储库
02-05
LightOJ是一个在线编程竞赛平台，它为程序员和计算机科学爱好者提供了一系列的算法问题来解决。这个存储库是一个专门针对LightOJ问题的教程集合，旨在帮助用户更好地理解和解决这些问题。下面，我们将深入探讨其中...
LightOJ
03-19
"LightOJ"是一个在线判题系统，专为竞赛编程和算法训练而设计。它允许用户提交代码并立即获得运行结果、时间复杂度和空间复杂度等反馈。这个平台广泛支持多种编程语言，包括C++，因此在标签中提到了"C++"。现在我们...
【刷题记录】 LightOJ-1356 Prime Independence 数论+最大独立集
Hello World!
04-26 433
给出n个数字的集合，让你求一个子集，使得自己内任意两个数之间不是素数倍数关系，求这样的最大的子集大小。
Prime Independence LightOJ - 1356（二分图匹配+最大独立集）
liexss的博客
11-15 507
题目链接：qaq   题意：给你一堆数，让你找出最大一组数里面不存在一个整数是另一个整数的素数倍，输出最大数量。   思路：将数按质因子的数量奇偶分边（奇奇，偶偶的两个数都不会是素数的倍数），然后将素数倍两个整数=连边。最后就是求最大独立集的方法了   附上代码： #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;...
LightOj1356-Prime Independence
Vision
08-02 651
传送门：http://lightoj.com/login_main.php?url=volume_showproblem.php?problem=1356 A set of integers is called prime independent if none of its member is a prime multiple of another member. An
Prime Independence LightOJ - 1356（质因子分解+最大点独立集）
codeswarrior的博客
04-16 618
Prime Independence LightOJ - 1356A set of integers is called prime independent if none of its...
LightOJ 1356 Prime Independence（素数筛选法+最大独立集）（Hopcroft-Carp算法）
piaocoder
02-19 1540
Prime Independence 解题思路： 题目大意： 定义素数独立集为一个整数集(不一定全是素数)，该整数集合中的任意两个a和b，如果存在a=b*prime的情况(prime为素数)，则视为 该情况为"冲突"。独立集即不存在冲突的集合。 算法思想： 首先看到独立集就应该想到二分图，既然是二分图，每个数为一个结点，哪些是U哪些是V呢？自然而然地每个数num进行素因数分 解，
Lightoj1356
dielie6462的博客
09-21 217
题目链接：https://vjudge.net/problem/LightOJ-1356 题目大意： 　　T个 test case，每个 test case 给出一个 N 个数的集合。请找出一个最大的子集，使得子集中的任何一个数除以子集中的任意的另一个数所得到的数不是质数。 解题思路： 　　先用素数筛找出 1 到 500000 的所有质数。 　　在输入一个集合的时候，我们顺便记...
LightOJ - 1356 质因数分解+最大独立子集
Soul
08-09 410
题解思路：因为题目说有一个数除以另外一个数如果等于一个素数的话就只能一个加入集合，那么这两个数矛盾并且可以构成一个二分图，就是求二分图的最大独立子集，然后如何快速的求这些数相互矛盾呢？ 把这些数拆分成看有多少个不同的素数并且除以素数，然后看下有没有在出现过，如果有就两个位置上加入一条无向边即可。最后就是跑一遍HK就可以了。#include<iostream> #include<cstring> #
Prime Independence LightOJ - 1356
weixin_43184669的博客
10-02 116
HK+质因子分解 HK是二分图匹配中匈牙利算法的优化，时间复杂度O(sqrt(n)*m) 先通过bfs寻找多条增广路，记下每个点到源点的距离（类似于网络流dinic算法），然后用类似于匈牙利算法中dfs的方法，进行匹配。 要求图是二分的，并且根据增广路的特性 模板： #include<bits/stdc++.h> #define ll long long using namespace...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值