nefu486魔术球问题（增加节点最大流模板）

魔术球问题

Time Limit 1000ms Memory Limit 65536K

description

假设有n根柱子，现要按下述规则在这n根柱子中依次放入编号为1，2，3，...的球。 （1）每次只能在某根柱子的最上面放球。 （2）在同一根柱子中，任何2个相邻球的编号之和为完全平方数。 试设计一个算法，计算出在n根柱子上最多能放多少个球。例如，在4 根柱子上最多可放11 个球。 对于给定的n，计算在n根柱子上最多能放多少个球。

input

多组数据输入. 每组输入1个正整数n，表示柱子数。

output

每组输出n 根柱子上最多能放的球数。

sample_input

4

sample_output

11

【问题分析】


枚举答案转化为判定性问题，然后最小路径覆盖，可以转化成二分图最大匹配，从而用最大流解决。


【建模方法】


枚举答案A，在图中建立节点1..A。如果对于i<j有i+j为一个完全平方数，连接一条有向边(i,j)。该图是有向无环图，求最小路径覆盖。如果刚好满足最小路径覆盖数等于N，那么A是一个可行解，在所有可行解中找到最大的A，即为最优解。


具体方法可以顺序枚举A的值，当最小路径覆盖数刚好大于N时终止，A-1就是最优解。


【建模分析】


由于是顺序放球，每根柱子上的球满足这样的特征，即下面的球编号小于上面球的编号。抽象成图论，把每个球看作一个顶点，就是编号较小的顶点向编号较大的顶点连接边，条件是两个球可以相邻，即编号之和为完全平方数。每根柱子看做一条路径，N根柱子要覆盖掉所有点，一个解就是一个路径覆盖。


最小路径覆盖数随球的数量递增不递减，满足单调性，所以可以枚举答案（或二分答案），对于特定的答案求出最小路径覆盖数，一个可行解就是最小路径覆盖数等于N的答案，求出最大的可行解就是最优解。本问题更适合枚举答案而不是二分答案，因为如果顺序枚举答案，每次只需要在残量网络上增加新的节点和边，再增广一次即可。如果二分答案，就需要每次重新建图，大大增加了时间复杂度。

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int oo=1e7;
const int mm=111111;
const int mn=8888;
int node,src,dest,edge,ret;
int reach[mm],cap[mm],flow[mm],next[mm];
int head[mn],work[mn],dis[mn],q[mn];
inline int min(int a,int b)
{
    return a<b?a:b;
}
inline void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0;i<node;++i)head[i]=-1;
    edge=ret=0;
}
inline void addedge(int u,int v,int c)
{
    reach[edge]=v,cap[edge]=c,flow[edge]=0,next[edge]=head[u],head[u]=edge++;
    reach[edge]=u,cap[edge]=0,flow[edge]=0,next[edge]=head[v],head[v]=edge++;
}
bool Dinic_bfs()
{
    int i,u,v,l,r=0;
    for(i=0;i<node;++i)dis[i]=-1;
    dis[q[r++]=src]=0;
    for(l=0;l<r;++l)
        for(i=head[u=q[l]];i>=0;i=next[i])
            if(flow[i]<cap[i]&&dis[v=reach[i]]<0)
            {
                dis[q[r++]=v]=dis[u]+1;
                if(v==dest)return 1;
            }
    return 0;
}
int Dinic_dfs(int u,int exp)
{
    if(u==dest)return exp;
    for(int &i=work[u],v,tmp;i>=0;i=next[i])
        if(flow[i]<cap[i]&&dis[v=reach[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,cap[i]-flow[i])))>0)
        {
            flow[i]+=tmp;
            flow[i^1]-=tmp;
            return tmp;
        }
    return 0;
}
int Dinic_flow()
{
    int i,delta;
    while(Dinic_bfs())
    {
        for(i=0;i<node;++i)work[i]=head[i];
        while((delta=Dinic_dfs(src,oo)))ret+=delta;
    }
    return ret;
}
bool judge(int a)
{
    int b=sqrt(a);
    if(b*b==a)
        return true;
    else return false;
}
int main()
{
    int n,i,j,ans,t,tmp,u,v;
    while(~scanf("%d",&n))
    {
        prepare(n+n+2,0,1);
        for(i=2;i<=2*n+1;i++)
        {
            if(i%2==0)  addedge(src,i,1);
            else addedge(i,dest,1);
        }
        for(i=2;i<=n;i++)
        {
            for(j=1;j<i;j++)
            {
                if(judge(i+j))  addedge(2*j,2*i+1,1);
            }
        }
        ans=n;
        while(ans<=n+Dinic_flow())
        {
            ans++;
            head[u=node++]=-1;
            head[v=node++]=-1;
            addedge(src,u,1);
            addedge(v,dest,1);
            for(i=1;i<ans;i++)
                if(judge(i+ans))    addedge(i*2,ans*2+1,1);
        }
        printf("%d\n",ans-1);
    }
    return 0;
}