Sabotage

The regime of a small but wealthy dictatorship has been abruptly overthrown by an unexpected rebellion. Because of the enormous disturbances this is causing in world economy, an imperialist military super power has decided to invade the country and reinstall the old regime.

For this operation to be successful, communication between the capital and the largest city must be completely cut. This is a difficult task, since all cities in the country are connected by a computer network using the Internet Protocol, which allows messages to take any path through the network. Because of this, the network must be completely split in two parts, with the capital in one part and the largest city in the other, and with no connections between the parts.

There are large differences in the costs of sabotaging different connections, since some are much more easy to get to than others.

Write a program that, given a network specification and the costs of sabotaging each connection, determines which connections to cut in order to separate the capital and the largest city to the lowest possible cost.

Input

Input file contains several sets of input. The description of each set is given below.

The first line of each set has two integers, separated by a space: First one the number of cities, nin the network, which is at most 50. The second one is the total number of connections, m, at most 500.

The following m lines specify the connections. Each line has three parts separated by spaces: The first two are the cities tied together by that connection (numbers in the range 1 – n). Then follows the cost of cutting the connection (an integer in the range 1 to 40000000). Each pair of cites can appear at most once in this list.

Input is terminated by a case where values of n and m are zero. This case should not be processed. For every input set the capital is city number 1, and the largest city is number 2.

Output

For each set of input you should produce several lines of output. The description of output for each set of input is given below:

The output for each set should be the pairs of cities (i.e. numbers) between which the connection should be cut (in any order), each pair on one line with the numbers separated by a space. If there is more than one solution, any one of them will do.

Print a blank line after the output for each set of input.

Sample Input

5 8
1 4 30
1 3 70
5 3 20
4 3 5
4 5 15
5 2 10
3 2 25
2 4 50
5 8
1 4 30
1 3 70
5 3 20
4 3 5
4 5 15
5 2 10
3 2 25
2 4 50
0 0

Sample Output

4 1
3 4
3 5
3 2

4 1
3 4
3 5
3 2

这道题的意思要把一个图分成两部分，要把点1和点2分开。隔断每条边都有一个花费，求最小花费的情况下，应该切断那些边。
这题很明显是最小割，也就是最大流。把1当成源点，2当成汇点。
问题是要求最小割应该隔断那条边。


思路就是求最大流。然后残留网络下，和源点连通的分在源点一点，和汇点连通的分在汇点一边。
这样貌似就解决了。

感谢Molly美女给我看的这题。也感谢她给的代码，好简洁的最大流模板。（呜呜····又想起了当年国外赛区一题网络流没有做出来导致的杯具。。。要苦练网络流了）

附代码：

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <queue>
using namespace std;

const int MAXN=100;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN];//原图的流量
int flow[MAXN][MAXN];//最后求得最大流的流量
int path[MAXN];
int a[MAXN];
int start,end;
int n;//顶点数，编号1~n

int maxflow()
{
    queue<int>q;
    memset(flow,0,sizeof(flow));
    int max_flow=0;
    while(1)
    {
        memset(a,0,sizeof(a));
        a[start]=INF;
        while(!q.empty())q.pop();
        q.push(start);
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            if(u==end)break;  //这句不能加
            for(int v=1;v<=n;v++)
              if(!a[v]&&flow[u][v]<g[u][v])
              {
                  path[v]=u;
                  a[v]=min(a[u],g[u][v]-flow[u][v]);
                  q.push(v);
              }
        }
        if(a[end]==0)break;
        for(int u=end;u!=start;u=path[u])
        {
            flow[path[u]][u]+=a[end];
            flow[u][path[u]]-=a[end];
        }
        max_flow+=a[end];
    }
    return max_flow;
}

const int MAXM=550;
int x[MAXM],y[MAXM];
int m;
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==0&&m==0)break;
        memset(g,0,sizeof(g));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&x[i],&y[i]);
            scanf("%d",&g[x[i]][y[i]]);
            g[y[i]][x[i]]=g[x[i]][y[i]];
        }
        start=1,end=2;
        maxflow();
        for(int i=0;i<m;i++)
        {
            if((!a[x[i]]&&a[y[i]]) || (a[x[i]]&&!a[y[i]]) )
                 printf("%d %d\n", x[i], y[i]);
        }
        printf("\n");
    }
    return 0;
}