poj 1459 power network(网络流 sa…

题意思路 见dinic 解法那篇文章 poj 1459 power network(网络流 dinic模版+详解)

该解题报告主要是讲解一下 sap算法 不明白sap原理和gap优化的 可以去下载这个资料看一下 网络流sap算法(whitecloud) 
里面对sap讲得挺详细的，但模板不敢恭维 （因为我们缺的就是时间）

下面是自己写的模板（dinic相近的部份就不注释了，且移步到看那篇文章）
原先的模板有bug 现在已经修改过来了
//      444K      94MS
#include <stdio.h>
#include <string.h>
const int VM = 110, EM = 20500, INF = 0x3f3f3f3f;
struct E
{
      int to, frm, nxt, cap;
}edge[EM];

int head[VM], e, n, src, des;
int dep[VM], gap[VM]; //gap[x]=y:说明残留网络中dep[i]=x的个数为y

void addedge(int u, int v, int c)
{
      edge[e].frm = u;
      edge[e].to = v;
      edge[e].cap = c;
      edge[e].nxt = head[u];
      head[u] = e++;
      edge[e].frm = v;
      edge[e].to = u;
      edge[e].cap = 0;
      edge[e].nxt = head[v];
      head[v] = e++;
}

void BFS()
{
      memset(dep, -1, sizeof(dep));
      memset(gap, 0, sizeof(gap));
      gap[0] = 1;    //说明此时有1个dep[i] = 0
      int Q[VM], front = 0, rear = 0;
      dep[des] = 0;
      Q[rear++] = des;
      int u, v;
      while (front != rear)
      {
            u = Q[front++];
            front = front%VM;
            for (int i=head[u]; i!=-1; i=edge[i].nxt)
            {
                  v = edge[i].to;
                  if (edge[i].cap != 0 || dep[v] != -1)
                        continue;
                  Q[rear++] = v;
                  rear = rear % VM;
                  ++gap[dep[v] = dep[u] + 1];  //求出各层次的数量
            }
      }
}

int Sap()
{
      int res = 0;
      BFS();
      int cur[VM];
      int S[VM], top = 0;
      memcpy(cur, head, sizeof(head));
      int u = src, i;
      while (dep[src] < n)
      {
            if (u == des)
            {
                  int temp = INF, inser = n;
                  for (i=0; i!=top; ++i)
                        if (temp > edge[S[i]].cap)
                        {
                              temp = edge[S[i]].cap;
                              inser = i;
                        }
                  for (i=0; i!=top; ++i)
                  {
                        edge[S[i]].cap -= temp;
                        edge[S[i]^1].cap += temp;
                  }
                  res += temp;
                  top = inser;
                  u = edge[S[top]].frm;
            }

            if (dep[u] != 0 && gap[dep[u] -1] == 0)//出现断层，无增广路
                  break;
            for (i = cur[u]; i != -1; i = edge[i].nxt)//遍历与u相连的未遍历结点
                      if (dep[edge[i].to] != -1)
                              if (edge[i].cap != 0 && dep[u] == dep[edge[i].to] + 1) //层序关系， 找到允许
                                      break;

            if (i != -1)//找到允许弧
            {
                  cur[u] = i;
                  S[top++] = i;//加入路径栈
                  u = edge[i].to;//查找下一个结点
            }
            else    //无允许的路径，修改标号 当前点的标号比与之相连的点中最小的多1
            {
                  int min = n;
                  for (i = head[u]; i != -1; i = edge[i].nxt) //找到与u相连的v中dep[v]最小的点
                  {
                        if (edge[i].cap == 0)
                              continue;
                        if (min > dep[edge[i].to])
                        {
                              min = dep[edge[i].to];
                              cur[u] = i;                  //最小标号就是最新的允许弧
                        }
                  }
                  --gap[dep[u]];                  //dep[u] 的个数变化了 所以修改gap
                  ++gap[dep[u] = min + 1]; //将dep[u]设为min(dep[v]) + 1, 同时修改相应的gap[]
                  if (u != src) //该点非源点&&以u开始的允许弧不存在，退点
                        u = edge[S[--top]].frm;
            }
      }
      return res;
}

int main()
{
      int i, np, nc, m;
      char str[10];
      while (scanf("%d %d %d %d", &n, &np, &nc, &m) != EOF)
      {
            e = 0;
            memset(head, -1, sizeof(head));
            int u, v, c;
            src = n, des = n + 1;
            n += 2;
            for (i=0; i!=m; ++i)
            {
                  scanf("%s", str);
                  sscanf(str, "(%d,%d)%d", &u, &v, &c);
                  addedge(u, v, c);
            }
            for (i=0; i!=np; ++i)
            {
                  scanf("%s", str);
                  sscanf(str, "(%d)%d", &v, &c);
                  addedge(src, v, c);
            }
            for (i=0; i!=nc; ++i)
            {
                  scanf("%s", str);
                  sscanf(str, "(%d)%d", &u, &c);
                  addedge(u, des, c);
            }
            printf("%d\n", Sap());
      }
      return 0;
}


另附一大牛的模板 shǎ崽 改成了自己的风格
//364K    94MS
#include <stdio.h>
#include <string.h>
#define VM 150
#define EM 20550
#define inf 0x3f3f3f3f
struct E
{
      int to,cap,nxt;
}edge[EM];

int head[VM],gap[VM],dist[VM],cur[VM],pre[VM];
int ep;
void addedge (int cu,int cv,int cw)
{

      edge[ep].to = cv;
      edge[ep].cap = cw;
      edge[ep].nxt = head[cu];
      head[cu] = ep;
      ep ++;
      edge[ep].to = cu;
      edge[ep].cap = 0;
      edge[ep].nxt = head[cv];
      head[cv] = ep;
      ep ++;
}
int min (int a ,int b)
{
    return a > b ? b : a;
}

int sap (int src,int des,int n)
{

      memset (dist,0,sizeof(dist));
      memset (gap,0,sizeof (dist));
      memcpy (cur,head,sizeof(dist));
      int res = 0;
      int u = pre[src] = src;
      int aug = inf;
      gap[0] = n;
      while (dist[src] < n)
      {
loop:
              for (int &i = cur[u];i != -1;i = edge[i].nxt)
              {
                      int v = edge[i].to;
                      if (edge[i].cap && dist[u] == dist[v] + 1)
                      {
                              aug = min (aug,edge[i].cap);
                              pre[v] = u;
                              u = v;
                              if (v == des)
                              {
                                      res += aug;
                                      for (u = pre[u];v != src;v = u,u = pre[u])
                                      {
                                              edge[cur[u]].cap -= aug;
                                              edge[cur[u]^1].cap += aug;
                                      }
                                      aug = inf; //
                              }
                              goto loop;
                      }
              }
              int mindist = n;  //
              for (int i = head[u];i != -1;i = edge[i].nxt)
              {
                      int v = edge[i].to;
                      if (edge[i].cap && mindist > dist[v])
                      {
                              cur[u] = i;
                              mindist = dist[v];
                      }
              }
              if ((--gap[dist[u]]) == 0)
                      break;
              dist[u] = mindist + 1;
              gap[dist[u]] ++;
              u = pre[u];
      }
      return res;
}
int main ()
{
      int n,np,nc,m,v1,v2,w;
      int src,des;
      char str[20];
      while (scanf ("%d%d%d%d",&n,&np,&nc,&m)!=EOF)
      {
              ep = 0;
              src = n;
              des = n + 1;
              memset (head,-1,sizeof(head));
              while (m --)
              {
                      scanf ("%s",str);
                      sscanf (str,"(%d,%d)%d",&v1,&v2,&w);
                      addedge (v1,v2,w);
              }
              while (np --)
              {
                      scanf ("%s",str);
                      sscanf (str,"(%d)%d",&v2,&w);
                      addedge (src,v2,w);
              }
              while (nc--)
              {
                      scanf ("%s",str);
                      sscanf (str,"(%d)%d",&v1,&w);
                      addedge (v1,des,w);
              }
              int ans = sap (src,des,n + 2);
              printf ("%d\n",ans);
      }
      return 0;
}

但发现跟自己以前定的dinic算法的时间效率竟然是一样的，难道是自己写挫了。。。