魔术球问题(网络24题，三)

                                                                   魔术球问题

题目链接:Click Here~

算法分析：

    跟第二题一样也是最短路径覆盖。但是我感觉这题比上一题难想一点，首先是在如何建图上遇到了麻烦。一开始我就没想到过用枚举的方法。于是一直想了一会儿，还是没想出来，就看了BY_void的博客说是，可以枚举。才知道了如何建图。自己还是没有坚持独立思考把这题做出来，感觉有点可惜了这题。

    这题继续是最小路径覆盖转最大流的做法。建图是别人想出来的，我就不重复了。直接copy别人的解释吧。这题确实是到好题啊！！！！真可惜自己没想到。还有这题我输出的时候忘记标记了，造成了死循环，找了半天还以为是我的最大流算法写错了

   听说这题还可以用公式的：(n^2-1)/2+n;

思路：

1. 要求相邻的 2 个球数字相加为完全平方数，则相当于从 1 开始构造出来一个有向无环图：1->3->6..

2. 模型就变成了“最小路径覆盖”的问题，找图中最少的路径数，这里的路径数就是题目的柱子数。继而建模成了“二分图匹配”求最大流的问题;

3. 因为对于数字的未知性，本题采取了枚举的方法，因为用二分的话，要每次都重新建图时间将比枚举的花费更    多。枚举的话每次都是在上一次最大流的基础上  继续增广;

4. 代码中需要用到一个很强的剪枝：在构造层次图的时候BFS（）中判断条件多了一个e.cap > 0。正常 dinic 求最大流是不需要这句话的，因为增广的时候是允许流“撤销”的，但是本题不需要流撤销自己的错误也能达到正确的结果，仔细想想可能是因为这个有向图的原因，公共节点把图分隔开，始终都是一样的;(其实这里我还是想不通为什么，我试过不加就TEL)

#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 4010;
const int OFFSET = 2000;
const int INF = 1e6;
struct Edge{
   int from,to,cap,flow;
};
vector<Edge> edges;
vector<int> G[maxn];
int d[maxn],cur[maxn];
bool vst[maxn],issquare[maxn];
int n,m,s,t;
void Init()
{
    memset(issquare,false,sizeof(issquare));
    for(int i = 1;i <= 60;++i)
        issquare[i*i] = true;
    for(int i = 0;i < maxn;++i)
        G[i].clear();
    edges.clear();
}
void AddEdge(int from,int to,int cap)
{
    edges.push_back((Edge){from,to,cap,0});
    edges.push_back((Edge){to,from,0,0});
    int sz = edges.size();
    G[from].push_back(sz-2);
    G[to].push_back(sz-1);
}
//¹¹Ôì²ã´Îͼ
bool BFS()
{
    memset(vst,false,sizeof(vst));
    queue<int> Q;
    Q.push(s);
    d[s] = 0;
    vst[s] = true;
    while(!Q.empty()){
        int u = Q.front();
        Q.pop();
        for(int i = 0;i < (int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(!vst[e.to]&&e.cap > e.flow&&e.cap > 0){
                vst[e.to] = true;
                d[e.to] = d[u] + 1;
                Q.push(e.to);
            }
        }
    }
    return vst[t];
}
int DFS(int u,int a)
{
    if(u==t||a==0)
        return a;
    int f,flow = 0;
    for(int& i = cur[u];i < (int)G[u].size();++i){
        Edge& e = edges[G[u][i]];
        if(d[u]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int Maxflow()
{
    int flow = 0;
    while(BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(s,INF);
    }
    return flow;
}
void Print(int u)
{
    vst[u] = true;
    for(int i = 0;i < (int)G[u].size();++i){
        Edge& e = edges[G[u][i]];
        if(!vst[e.to]&&e.flow == 1&&e.from!=s&&e.to!=t){
            printf(" %d",e.to-OFFSET);
            Print(e.to-OFFSET);
        }
    }
}
int main()
{
    while(~scanf("%d",&n)){
        Init();
        int flow = 0,num = 0;
        s = 0,t = 2*OFFSET+1;     //super scoure ,super sink
        while(num-flow<=n){
            num += 1;
            AddEdge(s,num,1);         //cha dian
            AddEdge(num+OFFSET,t,1);
            for(int i = 1;i < num;++i)
                if(issquare[i+num])
                   AddEdge(i,num+OFFSET,1);
            flow += Maxflow();
        }
        num -= 1;
        Init();
        for(int i = 1;i <= num;++i){
            AddEdge(s,i,1);
            AddEdge(i+OFFSET,t,1);
            for(int j = 1;j < i;++j)
                if(issquare[i+j])
                  AddEdge(j,i+OFFSET,1);
        }
        Maxflow();
        printf("%d\n",num);
        memset(vst,false,sizeof(vst));
        for(int i = 1;i <= num;++i)if(!vst[i]){
            printf("%d",i);
            Print(i);
            printf("\n");
        }
    }
    return 0;
}