【BZOJ-3308】九月的咖啡店最大费用最大流 + 线性筛素数

3308: 九月的咖啡店

Time Limit: 30 Sec Memory Limit: 128 MB
Submit:
159 Solved: 56
[Submit][Status][Discuss]

Description

深绘里在九份开了一家咖啡让，如何调配咖啡民了她每天的头等大事我们假设她有N种原料，第i种原料编号为i,调配一杯咖啡则需要在这里若干种兑在一起。不过有些原料不能同时在一杯中，如果两个编号为i,j的原料，当且仅当i与j互质时，才能兑在同一杯中。现在想知道，如果用这N种原料来调同一杯咖啡，使用的原料编号之和最大可为多少。

Input

一个数字N

Output

如题

Sample Input

Sample Output

HINT

1<=N<=200000

Source

Solution

从N的范围，难以直接看出是网络流，但仔细分析，还是可以想到的

比较厉害的建图，首先需要两个结论：

1.一个数的质因子，最多有两个

2.并且这两个质因子，一个小于$\sqrt{n}$，一个大于$\sqrt{n}$

那么可以考虑筛出1~n的素数

考虑建二分图

源向小于$\sqrt{n}$的质数连边，容量为1，费用为0

大于$\sqrt{n}$的质数向汇连边，容量为1，费用为0

小于$\sqrt{n}$的质数$a$向大于$\sqrt{n}$的质数$b$连边，容量为1，费用为$V_{ab}-V_{a}-V_{b}$

$V_{a}$表示单独选$a$的最大收益$V_{a}=a^{lgn/lga}$

$V_{b}$表示单独选$b$的最大收益$V_{b}=b$

$V_{ab}$表示同时选$a$和$b$的最大收益$V_{ab}=a^{lg(n/b)/lga}*b$

这样效率并不是特别的高，那么还可以加上两个优化：

1.如果一个质数>n/2，那么它只能单独选，不用连边

2.如果一条边的费用<0，那么完全可以不连

然后考虑 最大费用最大流 即可

Code

#include<iostream>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<cstring>

#include<queue>

using namespace std;

inline int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; char ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

#define maxn 200010

#define maxm 200000*10+10

#define inf 0x7fffffff

int n,ans;

struct Edgenode{int next,to,from,cap,cost;}edge[maxm];

int head[maxn],cnt=;

//init

inline void add(int u,int v,int w,int c)

{

    cnt++; edge[cnt].next=head[u]; head[u]=cnt;

    edge[cnt].from=u; edge[cnt].to=v; edge[cnt].cap=w; edge[cnt].cost=c;

}

inline void insert(int u,int v,int w,int c)

{add(u,v,w,c); add(v,u,,-c);}

//addedge

bool mark[maxn];int dis[maxn],S,T;

inline bool spfa()

{

    queue<int>q; memset(mark,,sizeof(mark));

    for (int i=S; i<=T; i++) dis[i]=-inf;

    q.push(S); mark[S]=; dis[S]=;

    while (!q.empty())

        {

            int now=q.front(); q.pop();

            for (int i=head[now]; i; i=edge[i].next)

                if (edge[i].cap && dis[edge[i].to]<dis[now]+edge[i].cost)

                    {

                        dis[edge[i].to]=dis[now]+edge[i].cost;

                        if (!mark[edge[i].to])

                            mark[edge[i].to]=,q.push(edge[i].to);

                    }

            mark[now]=;

        }

    return dis[T]>;

}

inline int dfs(int loc,int low)

{

    mark[loc]=;

    if (loc==T) return low;

    int w,used=;

    for (int i=head[loc]; i; i=edge[i].next)

        if (edge[i].cap && dis[edge[i].to]==dis[loc]+edge[i].cost && !mark[edge[i].to])

            {

                w=dfs(edge[i].to,min(low-used,edge[i].cap));

                edge[i].cap-=w; edge[i^].cap+=w; used+=w;

                ans+=w*edge[i].cost; if (used==low) return low;

            }

    return used;

}

inline void zkw()

{

    int tmp=;

    while (spfa())

        {

            mark[T]=;

            while (mark[T])

                memset(mark,,sizeof(mark)),tmp+=dfs(S,inf);

        }

}

//MaxflowMaxcost

bool flag[maxn]; int prime[maxn],tot;

inline void prework(int maxx)

{

    flag[]=;

    for (int i=; i<=maxx; i++)

        {

            if (!flag[i]) prime[++tot]=i;

            for (int j=; j<=tot && i*prime[j]<=maxx; j++)

                {

                    flag[i*prime[j]]=;

                    if (!(i%prime[j])) break;

                }

        }

}

//get prime

inline int calc(int n,int x)

{

    long long t=x;

    while (t*x<=n) t=t*x;

    return t;

}

//calc

inline void make()

{

    S=,T=tot+; int pos=;

    for (int i=; i<=tot; i++)

        {

            if (prime[i]>=n/) {ans+=prime[i];continue;}

            if ((long long)prime[i]*prime[i]<=n)

                insert(S,i,,),ans+=calc(n,prime[i]);

            else

                pos=(!pos)?i:pos,insert(i,T,,),ans+=prime[i];

        }

    for (int i=; i<pos; i++)

        for (int j=pos; j<=tot; j++)

            {

                if ((long long)prime[i]*prime[j]>n) break;

                int tmp=calc(n/prime[j],prime[i])*prime[j]-calc(n,prime[i])-prime[j];

                if (tmp>) insert(i,j,,tmp);

            }

}

//build

int main()

{

    n=read();

    prework(n);

    make();

    zkw();

    printf("%d\n",ans+);

    return ;

}

忽略桑心病狂的inline.. && 自己YY的最大费用最大流...好像还可以？