int main() {
for (; scanf("%d%d",&n,&m) != EOF;) {
totg = n;
tn = (n*3)/4;
for (i = 0; i <= n; i++) g[i].next = -1;
for (i = 1; i <= n; i++) addedge(0,i,-1);
for (i = 1; i <= m; i++) {
x = readint();
y = readint();
z = readint();
if (x == 1) {
addedge(y,z,0);
addedge(z,y,0);
}
else if (x == 2)addedge(y,z,-1);
else if (x == 3)addedge(z,y,0);
else if (x == 4)addedge(z,y,-1);
else addedge(y,z,0);
}
hasres = SPFA();
if (hasres == 1) {
res = 0;
for (i = 1; i <= n; i++)res += (long long)(-d[i]);
printf("%lld\n",res);
}
else printf("-1\n");
}
}
int main()
{
int i,j,c,x,y,left,mid,right;
while(EOF!=scanf("%d %d %d",&N,&M,&K))
{
for(i=1;i<=N;i++)
first[i]=-1;
tot=0;
while(M--)
{
scanf("%d %d %d",&x,&y,&c);
add(x,y,c);
add(y,x,c);
}
left=0;
right=1000000;
while(left<=right)
{
mid=(left+right)/2;
if(SPFA(mid))
right=mid-1;
else
left=mid+1;
}
if(left>1000000)
printf("-1\n");
else
printf("%d\n",left);
}
}
void solve()
{
cost=0;
while(SPFA())
track_back();
printf("%d\n",-cost);
}
int solve() {
// find a match
for (int i=0; i<n; i+=2){
match[i] = i+1;
match[i+1] = i;
}
while (true){
int found = 0;
for( int i = 0 ; i < n ; i ++ )
onstk[ i ] = dis[ i ] = 0;
for (int i=0; i<n; i++){
stk.clear();
if (!onstk[i] && SPFA(i)){
found = 1;
while (SZ(stk)>=2){
int u = stk.back(); stk.pop_back();
int v = stk.back(); stk.pop_back();
match[u] = v;
match[v] = u;
}
}
}
if (!found) break;
}
int ret = 0;
for (int i=0; i<n; i++)
ret += edge[i][match[i]];
ret /= 2;
return ret;
}
int main()
{
int i,k,j;
while (scanf("%d%d",&m,&n)==2)
{
if (!(n || m))
break;
memset(e,false,sizeof(e));
while (m--)
{
scanf("%d",&k);
for (i=1;i<=k;i++)
scanf("%d",&a[i]);
for (i=1;i<=k;i++)
for (j=1;j<=k;j++)
if (i!=j)
{
e[a[i]][a[j]]=true;
e[a[j]][a[i]]=true;
}
}
SPFA(0);
if (dist[n-1]>2000) puts("I can never know wywcgs!");
else if (dist[n-1]==1) puts("I do know wywcgs!");
else printf("I can know wywcgs by at most %d person(s)!\n",dist[n-1]-1);
}
return 0;
}
// 最小费用最大流
void mincost_maxflow(int n, int source, int sink, int &flow, int &cost) {
flow = 0, cost = 0;
while ( SPFA(n, source, sink) ) {
int delta = argument(n, source, sink);
flow += delta;
cost += sp[sink] * delta;
}
}
int main()
{
scanf("%d %d",&n,&m);
for (i = 1;i <= n;i++)//对邻接表初始化
no[i].next = 0;
totn = 0;
for (i = 1;i <= m;i++)
{
scanf("%d %d %d",&f1,&f2,&l);
getchar();//最后那个字符直接忽略掉吧，我是不知道改怎么读入了，而且我没有发现这个字母有什么实际用处。
getchar();//还要读入一个回车！
//注意，SPFA要求的是最短路，而题目是最长路，我们不妨把距离改成负数，那么不就是可以把最长路变成最短路吗？而且由于这是一个树，所以，每个点只需要遍历一次即可，所以，不需要担心负环的问题，不过，前提还是要对SPFA稍稍改动一下
add(f1,f2,-l);//加入f1-->f2
add(f2,f1,-l);//加入f2--f1
}
start = SPFA(1);//首先，找到树的一个端点
end = SPFA(start);//然后找到另一个端点
printf("%d\n",-dis[end]);//输出最长路的长度，由于边我们改成了负数，我们要加个负号让他变回正数。
return 0;
}
int maxFlow(){
int cost = 0,flow = 0;
SPFA();
while(true){
while(true){
for(int i = 0;i<node;i++) use[i] = 0;
if(!add_flow(s, INF,flow,cost)) break;
}
if(!modify_label()) break;
}
return cost;
}
int main()
{
int n=0,m=0;
int u=0,v=0,l=0;
int i=0,j=0;
struct node* pp=0;
scanf("%d%d",&n,&m);
struct shuzhu a[n+1];
//初始化 邻接表
INITIALIZE_SOURCE(a,n);
//存储输入数据到链接表中
for(i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&l);
pp=(struct node*)malloc(sizeof(struct node)*1);
pp->flag=v;
pp->wight=l;
pp->p=a[u].p;
a[u].p=pp;
}
/*
//检验存储代码的正确性
for(i=1;i<=m;i++)
{
printf("[%d %d] ",a[i].d,a[i].f);
pp=a[i].p;
for(;pp!=NULL;)
{
printf("[%d %d] ",pp->flag,pp->wight);
pp=pp->p;
}
printf("\n");
}
*/
//BELLMAN算法，计算 1号点到其他点的最短路
SPFA(a,n);
//打印结果
for(i=2;i<=n;i++)
{
printf("%d\n",a[i].d);
}
return 0;
}
int main(){
int n, m;
while( scanf("%d%d", &n, &m) != EOF ){
int i, a, b, c;
e = 0;
memset(head, -1, sizeof(head));
for( i=0; i < m; ++i )
{// b-a <= c, ÓÐÏò±ß(a, b):c £¬±ßµÄ·½Ïò£¡£¡£¡
scanf("%d%d%d", &a, &b, &c);
addedge(a, b, c);
}
printf("%d\n", SPFA(1, n));
}
return 0;
}
int main(){
read();
Dinic();
for(int i=1;i<=T;i++){
for(int j=head[i];j;j=E[j].next){
if(E[j].a>0){
if(E[j].f) addedge(i,E[j].v,E[j].f,0);
E[j].f=INF;
}
else E[j].a=0;//去掉有负环
}
}
while(SPFA());
printf("%d",mcost);
return 0;
}
int main()
{
#define debug printf("!\n")
double x;
while(scanf("%d%d%d%d", &N, &M, &L, &U) != EOF) {
for(int i = 0; i < N; i++) {
for(int j = 0; j < M; j++) {
scanf("%lf", &x);
edge[i][hash(j)] = log2(x/L);
edge[hash(j)][i] = log2(U/x);
}
}
printf(SPFA(M+N) ? "YES\n" : "NO\n");
//for(int i = 0; i < M+N; i++) printf("%lf\n", dis[i]);
}
return 0;
}
int MCMF(int s, int t, int n) {
int flow = 0; // 总流量
int i, minflow, mincost;
mincost = 0;
while(SPFA(s, t, n)){
minflow = INF + 1;
for(i = pp[t]; i != -1; i = pp[edge[i].u])
if(edge[i].cap < minflow)
minflow = edge[i].cap;
flow += minflow;
for(i = pp[t]; i != -1; i = pp[edge[i].u]){
edge[i].cap -= minflow;
edge[i^1].cap += minflow;
}
mincost += dist[t] * minflow;
}
sumFlow = flow; // 题目需要流量，用于判断
return mincost;
}
bool SPFA(int u){
if (onstk[u]) return true;
stk.PB(u);
onstk[u] = 1;
for (int v=0; v<n; v++){
if (u != v && match[u] != v && !onstk[v]){
int m = match[v];
if (dis[m] > dis[u] - edge[v][m] + edge[u][v]){
dis[m] = dis[u] - edge[v][m] + edge[u][v];
onstk[v] = 1;
stk.PB(v);
if (SPFA(m)) return true;
stk.pop_back();
onstk[v] = 0;
}
}
}
onstk[u] = 0;
stk.pop_back();
return false;
}
PIL go(ll cb=cINF) {
// cost_bound
if(!SPFA()) return MP(0,0);
pe.clear();
int fl=INF;
for(int v=n-1;v!=0;) {
for(int id:e[v]) {
int u=eg[id].to;
const E& t=eg[id^1];
if(t.ca>0 && MP(d[u].F+t.cost,d[u].S+1)==d[v]) {
fl=min(fl, t.ca);
v=u;
pe.PB(id^1);
break;
}
}
}
if(d[n-1].F>0) fl=min(1ll*fl, cb/d[n-1].F);
for(int id:pe) {
eg[id].ca-=fl;
eg[id^1].ca+=fl;
}
return MP(fl, 1ll*fl*d[n-1].F);
}
void mincostflow() {
maxflow = 0; mincost = 0;
while (SPFA()) extend();
}};
