POJ 1815 Friendship | 最小割、最小点割集

这题有点难度，主要是在寻找最小字典序路径的时候遇到困难。（一开始我还以为(A1-1)*N^t+(A2-1)*N^(t-1)+...+(At-1)*N这串东西是什么东西，^难道不是异或吗= =）

题意：

人与人之间通过手机联系。

A知道B的号码，等同B也知道A的号码。

联系可以传递。A与B联系，B与C联系，则A和C也保持联系。

除了s，t外，每个人都可能发生发生不好的事情使得手机丢失。

给定s，t点。问最少多少个人发生不好的事情，会导致s和t失去联系，输出人数并且输出具体哪些人。

对于不能使s，t失去联系的，输出“NO ANSWER”

思路：

建好图后跑最大流就是第一个答案。

“NO ANSWER”可以直接判。即s，t直接有联系，则NO ANSWER

关于路径：

从序号小的人开始进行枚举。把这个人屏蔽掉，看最大流是否有变化，有变化这个人属于最大流，是答案的一部分，保存。如果最大流不变，则恢复这个人。每次跑的最大流都是原始的图。因此要把原始的图保存下来。

建图：

拆点：因为题目答案要求最小点割集。流量为1；s，t的拆点流量为INF

AC代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
#define debug cout<<"debug"<<endl;
using namespace std;
const int MAXEDGE = 5*1e5 + 5;
const int INF = 0x3f3f3f3f;
const int MAXN = 510;
int n;
bool flag[MAXN];
struct Edge
{
        int to, cap, flow, next;
}edge[MAXEDGE], backUp[MAXEDGE];

struct Dinic
{
        int s, t, pp;
        int head[MAXN], cur[MAXN], d[MAXN];
        bool vis[MAXN];
        Dinic(int ss, int tt)
        {
                s = ss, t = tt;
                pp = 0;
                memset(head, -1, sizeof(head));
        }
        void addEdge(int u, int v, int c)
        {
                edge[pp] = (Edge){v, c, 0, head[u]};
                backUp[pp] = (Edge){v, c, 0, head[u]};
                head[u] = pp++;

                edge[pp] = (Edge){u, 0, 0, head[v]};
                backUp[pp] = (Edge){u, 0, 0, head[v]};
                head[v] = pp++;
        }
        bool bfs()
        {
                memset(vis, false, sizeof(vis));
                d[s] = 0;
                queue <int> q;
                q.push(s);
                vis[s] = true;
                while(!q.empty())
                {
                        int u = q.front();
                        q.pop();
                        int next = head[u];
                        while(next != -1)
                        {
                                Edge &e = edge[next];
                                if(!vis[e.to] && e.cap > e.flow && !flag[e.to])
                                {
                                        q.push(e.to);
                                        vis[e.to] = true;
                                        d[e.to] = d[u] + 1;
                                        //cout<<"e.to = "<<e.to<<endl;
                                }
                                next = e.next;
                        }
                }
                return vis[t];
        }
        int dfs(int u, int a)
        {
                if(u == t || a == 0)    return a;
                int flow = 0, f;
                int &next = cur[u];
                while(next != -1)
                {
                        Edge &e = edge[next];
                        if(d[e.to] == d[u] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0)
                        {
                                e.flow += f;
                                edge[next^1].flow -= f;
                                flow += f;
                                a -= f;
                                if(a == 0)      break;
                        }
                        next = e.next;
                }
                return flow;
        }
        void recover()
        {
                for(int i = 0;i < pp; i++)
                {
                        edge[i] = backUp[i];
                }
        }
        int getMaxFlow()
        {
                int res = 0;
                while(bfs())
                {
                        for(int i = 1;i <= 2*n + 2; i++)
                        {
                                cur[i] = head[i];
                        }
                        res += dfs(s, INF);
                }
                return res;
        }

        void getMinCutSetPoint()
        {
                int initMaxFlow = getMaxFlow();
                cout<<initMaxFlow<<endl;
                //
                //
                int cot = 0;
                int tmp, minFlow = initMaxFlow;
                int res[MAXN];

                for(int i = 1;i <= n; i++)
                {
                        if(i == s || i == t)    continue;
                        flag[i + n] = true;
                        d[i] = -1;
                        recover();                      //recover the graph;
                        tmp = getMaxFlow();
                        //cout<<"tmp = "<<tmp<<endl;
                        if(tmp < minFlow)
                        {
                             minFlow = tmp;
                             //cout<<tmp<<endl;
                             res[cot++] = i;
                        }
                        else
                        {
                                flag[i + n] = false;
                        }
                        if(cot == initMaxFlow)  break;
                }

                //output
                for(int i = 0;i < cot; i++)
                {
                        printf("%d%c",res[i],i == cot-1 ? '\n':' ');
                }
        }
};

int a[MAXN][MAXN];
int main()
{
        int s, t;
        while(scanf("%d%d%d",&n ,&s, &t) != EOF)
        {
                memset(flag, false, sizeof(flag));
                Dinic dinic(s + n, t);
                int tmp;
                for(int i = 1;i <= n; i++)
                {
                        if(i == s || i == t)    dinic.addEdge(i+n,i,INF);
                        dinic.addEdge(i + n, i, 1);
                }

                for(int i = 1;i <= n; i++)
                {
                        for(int j = 1;j <= n; j++)
                        {
                                scanf("%d",&tmp);
                                a[i][j] = tmp;
                                if(i == j)      continue;
                                if(tmp) dinic.addEdge(i, j + n, INF);
                        }
                }
                if(a[s][t])
                {
                    puts("NO ANSWER!");
                    continue;
                }
                dinic.getMinCutSetPoint();
        }
        return 0;
}