魔术球问题

问题描述

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

编程任务

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

数据输入

由文件input.txt提供输入数据。文件第1 行有 1个正整数n，表示柱子数。

结果输出

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

输入文件示例

input.txt
4

输出文件示例

output.txt
11
1 8
2 7 9
3 6 10
4 5 11

题解

第一眼看到这个题，什么想法也没有，但是既然是网络流24题中的一题，那肯定可以用网络流解了，所以强行往网络流上靠。

xjb建图

感觉建的图很不错，非常优美，和解题报告比较一下？

【画面太美，不忍直视

好吧。重构思路，好像可以借鉴最小路径覆盖问题诶？

xjblg

诶？输出方案又错了，

关键时刻要有xp

xp提供的方案是：

正常跑dinic，在程序最后加一个用来判断是否输出的数组，从1开始循环，遇到一个没有被输出的数就输出，然后顺着这个点沿着流量已经用尽的边往下跑，直到没有可以到达的点为止。

见图：



首先我们发现1是没有被输出过的，于是沿着1的边往下跑，到达3，输出，发现3仍然可以跑到4，就输出4。在跑的过程中，不断给这些点打上输出标记。

又发现2没有被输出过，但是它的两条边的remain值都存在，也就是在这个最大流网络中，没有从2流出的流量，于是只能输出2。程序结束。

貌似还没有讲网络流的主体。

我们可以每次加入一个点，也就是增加一个小球，然后枚举每一个小于它的编号的数，如果可以加成完全平方数，我们就从这个较小的数连一条到达这个点的边，流量为1。当我们发现当前的点数减去最大流的值，也就是所需的柱子数已经比输入要求的大了（一定是大1，这对于理解输出很有帮助），停止加点。

枚举1到现在的点数减1，也就是能放的最多的小球数，进行上面说的输出操作。

有人可能会问：现在不是已经多一个点了么？这样输出不会将多加的那个点输出么？

其实是不会出现这种情况的。因为既然多加了这一个点，所需柱子数就加一，那么这个新的点一定是独自占了一个柱子，所以只要我们在输出的时候不枚举到它就可以了。

CODE：

#include<cstdio>
#include<cstring>
const int INF=1e9;
struct queue
{
int h,t;
int a[10001];
inline void clear(){h=1,t=0;}
inline void push(int n){a[++t]=n;}
inline int front(){return a[h];}
inline void pop(){h++;}
inline bool empty(){return h>t;}
}q;
struct edge
{
int next,to,remain;
}a[50000];
int head[5000];
int deep[5000];
int number[]={0,1,4,9,16,25,36,49,64,81,100,121,144,169,196,225,256,289,324,361,400,441,484,529,576,625,676,729,784,841,900,961,1024,1089,1156,1225,1296,1369,1444,1521,1600,1681,1764,1849,1936,2025,2116,2209,2304,2401,2500,2601,2704,2809,2916,3025,3136,3249,3364,3481,3600,3721,3844,3969,4096};
bool b[5000];
bool p[5000];
int n,g,ans,num=1,tmp,S,T;
inline int min(int a,int b){return a<b?a:b;}
inline void add(int x,int y,int cap)
{
a[++num].next=head[x],a[num].to=y,a[num].remain=cap,head[x]=num;
a[++num].next=head[y],a[num].to=x,head[y]=num;
}
inline bool bfs()
{
memset(deep,0x3f,sizeof(deep));
q.clear();q.push(S);
deep[S]=0;
while(!q.empty())
{
int tmp=q.front();q.pop();
for(int i=head[tmp];i;i=a[i].next)
if(deep[a[i].to]>INF&&a[i].remain)
q.push(a[i].to),deep[a[i].to]=deep[tmp]+1;
}
return deep[T]<INF;
}
int dfs(int now,int limit)
{
if(now==T||!limit) return limit;
int flow=0,f;
for(int i=head[now];i;i=a[i].next)
if(deep[a[i].to]==deep[now]+1&&a[i].remain&&(f=dfs(a[i].to,min(limit,a[i].remain))))
{
flow+=f,limit-=f,a[i].remain-=f,a[i^1].remain+=f;
if(!limit) return flow;
}
deep[now]=-1;
return flow;
}
inline int dinic()
{
int ans=0;
while(bfs()) ans+=dfs(S,INF);
return ans;
}
inline void print(int now)
{
printf("%d ",now);
p[now]=1;
int i=head[now];
while(i)
if(a[i].to!=S&&a[i].to!=T&&!a[i].remain)
{
printf("%d ",a[i].to-2000);
p[a[i].to-2000]=1;
i=head[a[i].to-2000];
}
else i=a[i].next;
printf("\n");
}
int main()
{
scanf("%d",&n);
S=4900;T=4901;
for(int i=1;i<=64;i++)
b[number[i]]=1;
while(1)
{
g++;
add(S,g,1);
add(g+2000,T,1);
for(int i=1;i<g;i++)
if(b[g+i]) add(i,g+2000,1);
tmp+=dinic();
if(g-tmp==n) ans=g;
else if(g-tmp==n+1)
{
printf("%d\n",ans);
for(int i=1;i<=g-1;i++)
if(!p[i]) print(i);
return 0;
}
}
}