Primero q nada hola a todos, empece hace poco a programar en C.. Lo q mas me interesa es programar algoritmos de matematica discreta, y tengo problemas con uno q calcula MaxFlow en un grafo.. con el algoritmo en si no, sino con la entrada estandar.. Quiero q lea desde la entrada estandar, cosas de la siguiente manera:
a b c
donde a, b y c son enteros... Pero quiero q lea mientras una linea sea de ese tipo.. cuando llega algo q no es de ese formato, deberia dejar de leer en la entrada estandar.. entonces para q quede claro, deberia poder poner por ejemplo:
1 2 3
3 2 5
4 5 2
3

En este ejemplo, quiero q tome el 1 2 3, el 3 2 5, el 4 5 2 y q deje de leer cuando vea q la 4ta linea tiene un solo numero...

Otro ejemplo seria
1 2 3
4 5 6
2 4 5 6

Aqui deberia leer 2 lineas, y cortar cuando llega la 3ra porq tiene un entero de mas..
Y tambien tiene q cortar si llega algo asi:

1 2 3
3 4 5
hola

Lee 2 lineas, y luego corta porq llega algo q no tiene nada q ver con el formato...

Probe con scanf pero no logro q corte cuando la linea tiene caracteres de menos.. ya q el scanf se queda esperando a q se completen sus parametros...\
Por otro lado tampoco logro q corte cuando llegan caracteres de mas, ya q los guarda en el buffer para el siguiente scanf...

Asi q si me pueden ayudar, desde ya les agradezco

Podrías hacer un arreglo de cadenas e ir leyendo linea a linea, luego convertir los datos relevantes para poder operarlos. Podrías también leer una cadena con toda la expresión, para luego poder tomar los datos relevantes de dicha expresión, convertirlos y operarlos.

Pon el código que llevas hecho a ver si podemos partir de ahí para ayudarte.

Saludos

Antes q nada, muchas gracias por responder tan rapido...

El programa la verdad es bastante extenso, sobre todo la parte del algoritmo en si.. pero la parte q lee desde la entrada estandar seria algo asi :

Ya cree la estructura donde voy a guardar el network (grafo).. y ahora tengo q agregar lado por lado... esta funcion está en un ciclo.. el ciclo corta cuando el valor de esta funcion es 0.. por eso, esta funcion debe devolver 1 mientras la entrada estandar sea del formato q quiero, y 0 cuando no sea..
La funcion CargarLado se encarga de tomar los 3 enteros (q serian vertice 1 del lado, vertice 2 del lado y capacidad de ese lado) y los introduce en la esctructura del grafo.. si puede cargarlos bien, devuelve 1.. sino, devuelve 0.. El problema aca es q cuando introduzco algo por entrada estandar q tiene caracteres, pero menos de 3 o mas de 3, el programa no corta.. sino q se queda esperando.. yo necesitaria que tome la linea entera como dice Littlehorse, pero la verdad no se como hacerlo

int LeerLado (EstadoNetwork n) {
 
    res = scanf(" %u %u %u", &c1, &c2, &c3);
 
  if (res == 3)
  {
    res = CargarLado(n->network,c1,c2,c3);
  }
  else
  {
    res = 0;
  }
  return res;
}
 

Recien leo la respuesta de ghastlyx, voy a intentar hacerlo asi, pasa q no siempre van a ser numeros, asi q voy a tener q primero ver si son numeros, y si lo son ver si son la cantidad q necesito..
Estoy implementando el algoritmo de Dinic, con el paso bloqueante tambien de dinic..
Luego quizas intente wave, pero necesito poder ingresar los datos del grafo bien primero

No me había fijado que había puesto C, sin STL lo que he dicho como que no xDD.

Por si te sirve de ayuda, te dejo un código del algoritmo de Dinic que tenía hecho, sigue el formato de entrada y salida de este problema:
http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=10&page=show_problem&problem=761

/****************************************************************************************/
/* Algoritmo Dinic (usa blocking flows en lugar de caminos aumentativos) Coste: O(V^2E) */
/****************************************************************************************/
 
#include <iostream>
#include <string.h>
using namespace std;
 
//Cambiar constantes si es necesario
#define NODOS 100 
const int INF = 1000000000;
 
int adj[NODOS][NODOS], deg[NODOS], cap[NODOS][NODOS], padre[NODOS], f[NODOS][NODOS], MC[NODOS], visto[NODOS];
int n, m; // n = |V|, m = |E|
 
int Q[NODOS]; //cola
int ebp, esp;
 
bool bfs(int s, int t) {
    esp = ebp = 0;
    memset(padre, -1, sizeof(padre));
    memset(visto, 0, sizeof(visto));
    visto[s] = 1;
    padre[s] = -2;
    Q[esp++] = s;
    while (ebp != esp) {
        int u = Q[ebp++];
        for (int i = 0; i < deg[u]; ++i) {
            int v = adj[u][i];
            if (cap[u][v] - f[u][v] > 0 and not visto[v]) {
                visto[v] = 1;
                padre[v] = u;
                Q[esp++] = v;
            }
        }
    }
    return visto[t];
}
 
void mincut(int s) {
    ebp = esp = 0;
    Q[esp++] = s;
    MC[s] = 1;
    while (ebp != esp) {
        int u = Q[ebp++];
        for (int i = 0; i < deg[u]; ++i) {
            int v = adj[u][i];
            if (cap[u][v] - f[u][v] > 0 and not MC[v]) {
                MC[v] = 1;
                Q[esp++] = v;
            }
        }
    }
}
 
int maxflow(int s, int t) {
    int flow = 0;
    memset(MC, 0, sizeof(MC));
    memset(f, 0, sizeof(f));
    while (bfs(s, t)) {
        for (int i = 0; i < n; ++i) {
            if (cap[i][t] - f[i][t] > 0 and padre[i] != -1) {
                int bot = cap[i][t] - f[i][t];
                for (int v = i, u = padre[i]; u >= 0; v = u, u = padre[u])
                    bot = min(bot, cap[u][v] - f[u][v]);
                if (bot == 0) continue;
                f[i][t] += bot;
                f[t][i] -= bot;
                for (int v = i, u = padre[i]; u >= 0; v = u, u = padre[u]) {
                    f[u][v] += bot;
                    f[v][u] -= bot;
                }
                flow += bot;
            }
        }
    }
    mincut(s); //MC[u] == 1 <=> u esta en la particion de s
    return flow;
}
 
int main() {
    int net = 1;
    while (cin >> n and n > 0) {
        memset(deg, 0, sizeof(deg));
        memset(cap, 0, sizeof(cap));
        int s, t;
        cin >> s >> t >> m;
        s--; t--;
        for (int i = 0; i < m; ++i) {
            int a, b, c;
            cin >> a >> b >> c;
            --a; --b;
            if (cap[a][b] == 0) {
                adj[a][deg[a]++] = b;
                adj[b][deg[b]++] = a;
            }
            cap[a][b] += c;
            cap[b][a] += c;
        }
        cout << "Network " << net++ << endl;
        cout << "The bandwidth is " << maxflow(s,t) << "." << endl << endl;
    }
}

De nuevo gracias por la ayuda, ya me voy a tomar un tiempo y leer el algoritmo q posteaste ghasltyx, ahora voy a intentar tomar linea por linea como me recomendaron, y ver como parseo la info... luego les cuento q tal me fue