P3022 [USACO11OPEN] Odd Grad G

Titel Beschreibung

Die Kühe werden überfallen! Ihre Republik umfasst N (1 <= n <= 50.000) Städte, die mit M verbunden sind (1 <= M <= 100.000) ungerichtete Pfade zwischen zwei Städten A_i und B_i (1 <= A_i <= N; 1 <= B_i < = N;! A_i = B_i, keine doppelten Pfade auftreten). Jedoch ist die Republik nicht unbedingt verbunden ist - es können Paare von Städten, die nicht in der Lage sind, miteinander über die Wege zu erreichen.

Die Kühe kennen ihre Eindringlinge planen ein Inventar von jedem Weg innerhalb ihrer Republik zu führen, so dass sie bereit sind, verschiedene Wege zu schließen, um es so schwer wie möglich zu machen für ihre Eindringlinge zu tun.

Bitte helfen Sie die Kühe einen Weg finden, um eine Teilmenge der Wege zu schließen, so dass jede Stadt eine ungerade Anzahl von verbleibenden Wege hat mit ihm verbunden oder festzustellen, ob eine solche Teilmenge vorhanden ist.

Betrachten wir zum Beispiel die folgende Kuh Republik:

1 --- 2 \ / 3 4 --- Wenn wir halten die Bahnen 1-3, 2-3 und 3-4, und entfernen den Pfad 1-2, dann Städte 1, 2 und 4 wird ein Endpunkt sein genau einen Pfad, während Stadt 3 wird ein Endpunkt von drei Pfaden sein:

1 2 \ / 3 --- 4

Eingabeformat

* Zeile 1: Zwei Leerzeichen getrennte ganze Zahlen: N und M

* Zeilen 2..M + 1: Zeile i + 1 enthält zwei durch Leerzeichen getrennte ganze Zahlen: A_i und B_i

Ausgabeformat

* Linie 1: Eine ganze Zahl, die die Anzahl von Pfaden zu halten ist. Wenn keine Teilmenge existiert nur dann ausgegeben, eine einzige Zeile mit der ganzen Zahl -1.

* Linien 2..K + 1: Jede Zeile enthält eine Pfad ein Index im Bereich 1..M zu halten. Diese Indizes müssen paarweise verschieden sein.

Die Übersetzung der Bedeutung von Problemen

Die Bedeutung von Problemen

Die Rinder wurden überfallen zu werden. Es N N Punkte, durch eine M -freie Verbindung zur M - Seite. Ungerichteten Kanten von A_i A I bis B_i B I . Seiten Gewicht , dass keine Daten zu gewährleisten, garantiert aber nicht die Kommunikation ( das heißt, nicht in der Lage sein , von einem Punkt zu einem anderen Punkt zu erreichen).

Rinder wissen, wer ihr Inventar aller Kanten eindringen planen, so dass sie einen Teil der Kante des Eindringlings Plan so weit wie möglich Schwierigkeiten abschneiden wollen

Hier finden Sie eine Möglichkeit, einige Kanten zu verlassen, so dass jeder Punkt nur die ungeraden Kanten mit ihm verbunden. Und die Ausgangsseite des Programms hinter sich gelassen.

Hier ist ein Beispiel

1---2
 \ /
  3---4
我们把1——2那条边拆掉， 就会变成下图
1   2
 \ /
  3---4
对于每个点都只有奇数条边连接，符合题意

Liest das Ausgabeformat

lesen Format

• Die erste Zeile von zwei ganzen Zahlen  N N und  M M
• Die zweite bis M +. 1 M + . 1 Zeilen hat jede Seite eine zwei ganzen Zahlen beschrieben A_i A I und B_i B I

Ausgabeformat

• Die erste Zeile von einer ganzzahligen Anzahl von Kanten verbleiben, die Ausgabe von -1, wenn es unmöglich ist, bitte
• Nach einer Anzahl von jeder Zeile, die Anzahl der Seiten (nach der Reihenfolge der Eingabe).

Vielen @ToBiChi Übersetzung

Proben Eingangs- und Ausgangs

Input # 1Kopie

4 4 
1 2 
2 3 
3 1 
3 4

Ausgabe # 1Kopie

3 
2 
3 
4

Beschreibung / Tips

Vielen @cn: Spezielle Richter Su Qing Nian bereitgestellt

 

Denken

　　Fig beginnt Aktualisierung im Suchprozess durch die Blattkanten und sogar, wenn eine ungerade Anzahl von Blättern von der oberen Kante der aktuellen Auswahl nicht mit Blättern hinzugefügt zu zeigen braucht, kann aktualisiert Sequenz gegen dfs sein

 

CODE

 

# include   < Bits / STDC ++. h >

#define   DBG ( x )  cout  <<   #x   <<   " = "   <<  x  <<  endl

#define   eps   1 E - 8

#define   pi   acos ( - 1,0 )

mit   Namespace  std ;

typedef   lange   lange  LL ;

const   int  inf  =   0x 3f3f3f3f ;

template < class T > inline  void  read(T  & res )

{

     char c ;T flag = 1 ;

     while((c = getchar()) < ' 0 ' ||c > ' 9 ' )if(c == ' - ' )flag =- 1 ;res =c - ' 0 ' ;

     while((c = getchar()) >= ' 0 ' &&c <= ' 9 ' )res =res * 10 +c - ' 0 ' ;res *=flag ;

}

namespace _buff  {

     const  size_t BUFF  =  1  <<  19 ;

     char  ibuf [BUFF ],  *ib  = ibuf ,  *ie  = ibuf ;

     char  getc()  {

         if  (ib  == ie )  {

            ib  = ibuf ;

            ie  = ibuf  +  fread(ibuf ,  1 , BUFF , stdin );

         }

         return ib  == ie  ?  - 1  :  *ib ++ ;

     }

}

int  qread()  {

     using  namespace _buff ;

     int ret  =  0 ;

     bool pos  =  true ;

     char c  =  getc();

     for  (;  (c  <  ' 0 '  || c  >  ' 9 ' )  && c  !=  ' - ' ; c  =  getc())  {

         assert( ~c );

     }

     if  (c  ==  ' - ' )  {

        pos  =  false ;

        c  =  getc();

     }

     for  (; c  >=  ' 0 '  && c  <=  ' 9 ' ; c  =  getc())  {

        ret  =  (ret  <<  3 )  +  (ret  <<  1 )  +  (c  ^  48 );

     }

     return pos  ? ret  :  -ret ;

}

const  int maxn  =  1 e 5  +  7 ;

int n , m , cnt ;

int  edge [maxn  <<  1 ],  head [maxn  <<  1 ],  nxt [maxn  <<  1 ];

int  id [maxn  <<  1 ];

void  BuildGraph( int  u ,  int  v ,  int  idx )  {

     ++cnt ;

     edge [cnt ]  = v ;

     nxt [cnt ]  =  head [u ];

     head [u ]  = cnt ;

     id [cnt ]  = idx ;

}

vector <int> ans ;

bool  vis [maxn ];

bool  dfs( int  u ,  int  fa ,  int  idx )  {

     int du  =  0 ;

     vis [u ]  =  1 ;

     for  (  int i  =  head [u ]; i ; i  =  nxt [i ]  )  {

         int v  =  edge [i ];

         if( vis [v ]  || v  == fa )

             continue;

         if(dfs(v , u ,  id [i ]))

             ++du ;

     }

     if(du  &  1 )  {

         return  false ;

     }

     ans .push_back(idx );

     return  true ;

}

int  main()

{

     read(n );read(m );

     for  (  int i  =  1 ; i  <= m ;  ++i  )  {

         int u , v ;

         read(u );read(v );

         BuildGraph(u , v , i );

         BuildGraph(v , u , i );

     }

     for  (  int i  =  1 ; i  <= n ;  ++i  )  {

         if( vis [i ])

             continue;

         if(dfs(i ,  0 ,  0 ))  {

             puts( " -1 " );

             return  0 ;

         }

     }

     int d  =  ans .size();

    cout  << d  << endl ;

     for  (  int i  =  0 ; i  < d ;  ++i  )  {

        cout  <<  ans [i ]  << endl ;

     }

     return  0 ;

}