LuoguP2765 魔术球问题(最大流)

题目描述

«问题描述：

假设有n根柱子，现要按下述规则在这n根柱子中依次放入编号为1，2，3，...的球。

（1）每次只能在某根柱子的最上面放球。

（2）在同一根柱子中，任何2个相邻球的编号之和为完全平方数。

试设计一个算法，计算出在n根柱子上最多能放多少个球。例如，在4 根柱子上最多可放11 个球。

«编程任务：

对于给定的n，计算在n根柱子上最多能放多少个球。

输入输出格式

输入格式：

第1 行有1个正整数n，表示柱子数。

输出格式：

程序运行结束时，将n 根柱子上最多能放的球数以及相应的放置方案输出。文件的第一行是球数。接下来的n行，每行是一根柱子上的球的编号。

解题思路：

假如说告诉你多少球，需要多少柱子是显然可求的。

那和这道题就一样了。

发现球多柱子自然多，因为球只能一个一个摞，

所以没添加一个球只能放在没添加时的合法方案上的，

所以柱子数单增。

不要二分答案，那样还要拆图，枚举就好了。

注意要记录方案。

代码：

 #include<cmath>
 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 const int oo=0x3f3f3f3f;
 namespace stb{
     template<class tnt>
     class queue{
         #define INF 1000000
         public:
             queue(){h=,t=;}
             int nxt(int x){if(x+==INF)return ;return x+;}
             bool empty(void){return nxt(t)==h;}
             void push(tnt x){t=nxt(t);l[t]=x;}
             tnt front(void){return l[h];}
             void clear(void){h=;t=;}
             void pop(void){h=nxt(h);}
         private:
             tnt l[INF];
             int h,t;
         #undef INF
     };
 };
 struct pnt{
     int hd;
     int lyr;
     int nxt;
     int now;
     bool nos;
 }p[];
 struct ent{
     int twd;
     int lst;
     int vls;
 }e[];
 int cnt;
 int n,m;
 int S,T;
 int top;
 stb::queue<int>Q;
 std::vector<int>Ans[];
 void ade(int f,int t,int v)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].vls=v;
     e[cnt].lst=p[f].hd;
     p[f].hd=cnt;
     return ;
 }
 bool Bfs(void)
 {
     Q.clear();
     for(int i=;i<=(m<<|);i++)
         p[i].lyr=;
     p[S].lyr=;
     Q.push(S);
     while(!Q.empty())
     {
         int x=Q.front();
         Q.pop();
         for(int i=p[x].hd;i;i=e[i].lst)
         {
             int to=e[i].twd;
             if(p[to].lyr==&&e[i].vls>)
             {
                 p[to].lyr=p[x].lyr+;
                 if(to==T)
                     return true;
                 Q.push(to);
             }
         }
     }
     return false;
 }
 int Dfs(int x,int fll)
 {
     if(x==T)
         return fll;
     for(int& i=p[x].now;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(p[to].lyr==p[x].lyr+&&e[i].vls>)
         {
             int ans=Dfs(to,std::min(fll,e[i].vls));
             if(ans>)
             {
                 e[i].vls-=ans;
                 e[((i-)^)+].vls+=ans;
                 p[x].nxt=to;
                 if(S!=x)
                     p[to-].nos=true;
                 return ans;
             }
         }
     }
     return ;
 }
 int Dinic(void)
 {
     int ans=;
     while(Bfs())
     {
         for(int i=;i<=(m<<|);i++)
             p[i].now=p[i].hd;
         int dlt;
         while(dlt=Dfs(S,oo))
             ans+=dlt;
     }
     return ans;
 }
 int main()
 {
     int bulp=;
     scanf("%d",&n);
     S=,T=;m=;
     for(int i=;;i++)
     {
         m++;
         ade(S,i<<,);
         ade(i<<,S,);
         ade(i<<|,T,);
         ade(T,i<<|,);
         for(int j=sqrt(i);j*j-i<i;j++)
         {
             if(j*j-i<=)
                 continue;
             ade((j*j-i)<<,i<<|,);
             ade(i<<|,(j*j-i)<<,);
         }
         bulp+=-Dinic();
         if(bulp==n+)
         {
             printf("%d\n",i-);
             break;
         }
         for(int j=;j<=top;j++)
             Ans[j].clear();
         top=;
         for(int j=;j<=i;j++)
         {
             if(!p[j<<].nos)
             {
                 top++;
                 for(int k=j<<;k!=S&&k>;k=p[k].nxt-)
                     Ans[top].push_back(k>>);
             }
         }
     }
     for(int i=;i<=top;i++)
     {
         for(int j=;j<Ans[i].size();j++)
             printf("%d ",Ans[i][j]);
         printf("\n");
     }
     return ;
 }