zoj2587

题目大意：

N个supercomputers连接到一个网络。网络的拓扑结构很简单：M不同对的supercomputers通过一个光纤连接，所有的连接是双向的，数据可以通过光纤或者中间computers连接。
恐怖组织打算袭击网络。他们的目标是袭击网络中两个主要的计算机，以阻止他们通信。每一根光纤都有成本，所以需要最小化成本。
leaders想知道这个这个操作是否唯一。

解题思路：

判断最小割是否唯一，先求一次最大流，然后在残留网络中分别从源汇开始dfs一次，找出最小割[S,T]，如果SUT不包含所有点，那么最小割不唯一。假设点i不被SUT包含，那么残留网络中s不能到达i,i不能到达t,即进入i的边和从i出去的边都满流，假设某条进入i的边x满流，这些流量从若干条边y流出i，那么，如果选x为割边，或者选所有对应的y为割边，不会影响最大流，即最小割容量不变，最小割也就不唯一。

代码如下：

#include<cstdio>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;
const int E=10050*4;
const int N=850;
struct node
{
  int x,y,c,nxt;
}edge[E];

int e,head[N];
int dep[N],que[N],cur[N];
bool tag[N];
int num,num1;

void addedge(int u,int v,int c)
{
  edge[e].x=u;
  edge[e].y=v;
  edge[e].nxt=head[u];
  edge[e].c=c;
  head[u]=e++;

  edge[e].x=v;
  edge[e].y=u;
  edge[e].nxt=head[v];
  edge[e].c=0;
  head[v]=e++;
}

int maxflow(int s,int t)
{
  int i,j,k,front,rear,top,min,res=0;
  while(1)
  {
    memset(dep,-1,sizeof(dep));
    front=0;
    rear=0;
    que[rear++]=s;
    dep[s]=0;
    while(front!=rear)
    {
      i=que[front++];
      for(j=head[i];j!=-1;j=edge[j].nxt)
      {
        if(edge[j].c&&dep[edge[j].y]==-1)
        {
          dep[edge[j].y]=dep[i]+1;
          que[rear++]=edge[j].y;
        }
      }
    }
    if(dep[t]==-1)
      break;
    memcpy(cur,head,sizeof(head));
    for(i=s,top=0;;)
    {
      if(i==t)
      {
        min=inf;
        for(k=0;k<top;k++)
        {
          if(min>edge[que[k]].c)
          {
            min=edge[que[k]].c;
            front=k;
          }
        }
        for(k=0;k<top;k++)
        {
          edge[que[k]].c-=min;
          edge[que[k]^1].c+=min;
        }
        res+=min;
        i=edge[que[top=front]].x;
      }
      for(j=cur[i];cur[i]!=-1;j=cur[i]=edge[cur[i]].nxt)
      {
        if(dep[edge[j].y]==dep[i]+1&&edge[j].c)
        {
          break;
        }
      }
      if(cur[i]!=-1)
      {
        que[top++]=cur[i];
        i=edge[cur[i]].y;
      }
      else
      {
        if(top==0)
          break;
        dep[i]=-1;
        i=edge[que[--top]].x;
      }
    }
  }
  return res;
}

void dfs(int u)
{
  tag[u]=1;
  num++;
  for(int i=head[u];i!=-1;i=edge[i].nxt)
  {
    int y=edge[i].y;
    if(edge[i].c&&tag[y]==0)
      dfs(y);
  }
}

void dfs1(int u)
{
  tag[u]=1;
  num1++;
  for(int i=head[u];i!=-1;i=edge[i].nxt)
  {
    int y=edge[i].y;
    if(edge[i^1].c&&tag[y]==0)
      dfs1(y);
  }
}

int main()
{
  int n,m,S,T;
  int i,x,y,c;
  while(scanf("%d%d%d%d",&n,&m,&S,&T)!=EOF)
  {
    if(n==0&&m==0&&S==0&&T==0)
      break;
    memset(head,-1,sizeof(head));
    e=0;
    for(i=0;i<m;i++)
    {
      scanf("%d%d%d",&x,&y,&c);
      addedge(x,y,c);
      addedge(y,x,c);
    }
    maxflow(S,T);
    memset(tag,0,sizeof(tag));
    num=0;
    dfs(S);
    memset(tag,0,sizeof(tag));
    num1=0;
    dfs1(T);
    if(num1+num==n)
      printf("UNIQUE\n");
    else 
      printf("AMBIGUOUS\n");
  }
  return 0;
}