ZOJ 2587(判断最小割的唯一性)

dfs 从源点到汇点如果能访问到所有点说明唯一如果不能则不唯一

找出割边：
s能到达到的各点为点集S 能到到T的各点为点集T  于是S-T之间的边就是割边
从s开始深度搜索，然后判断边满足前一个点被访问过，后一个点没被访问过，满足这样的边就是割边

参考 hdu 3251

/*
* this code is made by LinMeiChen
* Problem: zoj 2587
* Type of Problem: 最小割唯一性判断
* Thinking: 最大流完 对残余网络深搜
* Feeling: 第一次做 好激动
*/
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
#include<queue>
#include<list>
using namespace std;
typedef long long lld;
typedef unsigned int ud;
#define INF_MAX 0x3f3f3f3f
#define eatline() char chch;while((chch=getchar())!='\n')continue;
#define MemsetMax(a) memset(a,0x3f,sizeof a)
#define MemsetZero(a) memset(a,0,sizeof a)
#define MemsetMin(a) memset(a,-1,sizeof a)
#define MemsetFalse(a) MemsetZero(a)
#define PQ priority_queue
#define Q queue
#define maxn 1008
#define maxm 50008
struct Edge
{
	int v, f;
	int next;
}E[maxm];
int k;
int head[maxn], h[maxn];
int level[maxn], stack[maxn];
int mark[maxn];

bool BFS(int s, int t)
{
	memset(level, 0, sizeof level);
	level[s] = 1;
	Q<int>q;
	q.push(s);
	while (!q.empty())
	{
		int u = q.front(); q.pop();
		if (u == t)
			return true;
		for (int i = head[u]; i != -1; i = E[i].next)
		{
			int v = E[i].v;
			if (!level[v] && E[i].f > 0)
			{
				level[v] = level[u] + 1;
				q.push(v);
			}
		}
	}
	return false;
}

void Dinic(int s, int t)
{
	while (BFS(s, t))
	{
		memcpy(h, head, sizeof h);
		int top = 0;
		int u = s;
		while (true)
		{
			if (u == t)
			{
				int minflow = INF_MAX, flag;
				for (int i = 0; i < top; i++)
				{
					if (minflow>E[stack[i]].f)
					{
						minflow = E[stack[i]].f;
						flag = i;
					}
				}
				for (int i = 0; i < top; i++)
				{
					E[stack[i]].f -= minflow;
					E[stack[i] ^ 1].f += minflow;
				}
				top = flag;
				u = E[stack[top] ^ 1].v;
			}
			for (int i = h[u]; i != -1; i = h[u] = E[i].next)
			{
				int v = E[i].v;
				if (level[v] == level[u] + 1 && E[i].f>0)
					break;
			}
			if (h[u] != -1)
			{
				stack[top++] = h[u];
				u = E[h[u]].v;
			}
			else
			{
				if (top == 0)
					break;
				level[u] = 0;
				u = E[stack[--top] ^ 1].v;
			}
		}
	}
}

void add_edge(int u, int v, int f)
{
	E[k].v = v;
	E[k].f = f;
	E[k].next = head[u];
	head[u] = k++;

	E[k].v = u;
	E[k].f = 0;
	E[k].next = head[v];
	head[v] = k++;
}

void DFS1(int u)
{
	
	mark[u] = 1;
	for (int i = head[u]; i != -1; i = E[i].next)
	{
		if (E[i].f > 0 && !mark[E[i].v])
			DFS1(E[i].v);
	}
}

void DFS2(int u)
{
	mark[u] = 1;
	for (int i = head[u]; i != -1; i = E[i].next)
	{
		if (E[i ^ 1].f > 0 && !mark[E[i].v])
			DFS2(E[i].v);
	}
}

int main()
{
	int n, m, a, b;
	int u, v, f;
	int s, t, i;
	while (scanf("%d%d%d%d", &n, &m, &a, &b)&&(n+m+a+b)!=0)
	{
		memset(head, -1, sizeof head);
		k = 0;
		for (i = 1; i <= m; i++)
		{
			scanf("%d%d%d", &u, &v, &f);
			add_edge(u, v, f);
			add_edge(v, u, f);
		}
		Dinic(a, b);
		memset(mark, 0, sizeof mark);
		DFS1(a);
		DFS2(b);
		for (i = 1; i <= n; i++)
		{
			if (!mark[i])
				break;
		}
		if (i > n)
			printf("UNIQUE\n");
		else
			printf("AMBIGUOUS\n");
	}
	return 0;
}