POj 1094 Sorting it All Out

解题思路：每增加一个点，均判断其拓扑排序，如果首先发现可以排序的情况，则不管后面的输入情况是否出现环。

  
    

   
     
   
     #include 
   
     <
   
     iostream
   
     >
   
     
#include 
   
     <
   
     stack
   
     >
   
     

   
     using
   
      
   
     namespace
   
      std;


   
     int
   
      main()
{
 
   
     int
   
      n, m, t, L;
 
   
     char
   
      u, v, ch, seq[
   
     26
   
     ];
 
   
     bool
   
      edge[
   
     26
   
     ][
   
     26
   
     ], comeOut[
   
     26
   
     ];
 
   
     int
   
      degree[
   
     26
   
     ], tdeg[
   
     26
   
     ];

 stack
   
     <
   
     int
   
     >
   
     temp;
 
   
     string
   
      str;
 
   
     bool
   
      flag1, flag2, flag;

 
   
     while
   
      (cin 
   
     >>
   
      n 
   
     >>
   
      m 
   
     &&
   
      n 
   
     *
   
      n 
   
     +
   
      m 
   
     *
   
      m)
 {
 
   
     while
   
      (
   
     !
   
     temp.empty())
 temp.pop();
 flag1 
   
     =
   
      flag2 
   
     =
   
      
   
     true
   
     ;
 t 
   
     =
   
      
   
     0
   
     ;

 fill(
   
     &
   
     edge[
   
     0
   
     ][
   
     0
   
     ], 
   
     &
   
     edge[
   
     25
   
     ][
   
     26
   
     ], 
   
     false
   
     );
 memset(degree, 
   
     0
   
     , 
   
     sizeof
   
     (
   
     int
   
     ) 
   
     *
   
      
   
     26
   
     );
 memset(comeOut, 
   
     0
   
     , 
   
     sizeof
   
     (
   
     bool
   
     ) 
   
     *
   
      
   
     26
   
     );

 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     1
   
     ; i 
   
     <=
   
      m; i
   
     ++
   
     )
 {
 cin 
   
     >>
   
      u 
   
     >>
   
      ch 
   
     >>
   
      v;
 
   
     if
   
      (
   
     !
   
     (flag1 
   
     &&
   
      flag2))
 
   
     continue
   
     ;
 
   
     if
   
      (
   
     !
   
     edge[u 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ][v 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ])
 {
 
   
     if
   
     (
   
     !
   
     comeOut[u 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ])
 {
 t
   
     ++
   
     ;
 comeOut[u 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ] 
   
     =
   
      
   
     true
   
     ;
 }
 
   
     if
   
      (
   
     !
   
     comeOut[v 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ])
 {
 t
   
     ++
   
     ;
 comeOut[v 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ] 
   
     =
   
      
   
     true
   
     ;
 }
 edge[u 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ][v 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ] 
   
     =
   
      
   
     true
   
     ;
 degree[v 
   
     -
   
      
   
     '
   
     A
   
     '
   
     ]
   
     ++
   
     ;

 flag 
   
     =
   
      (t 
   
     ==
   
      n) 
   
     ?
   
      
   
     true
   
      : 
   
     false
   
     ;
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      n; j
   
     ++
   
     )
 {
 tdeg[j] 
   
     =
   
      degree[j];
 
   
     if
   
      (comeOut[j] 
   
     &&
   
      tdeg[j] 
   
     ==
   
      
   
     0
   
     )
 temp.push(j);
 }
 
   
     if
   
      (flag 
   
     &&
   
      temp.size() 
   
     >
   
      
   
     1
   
     )
 flag 
   
     =
   
      
   
     false
   
     ;
 
   
     int
   
      index 
   
     =
   
      
   
     0
   
     ;
 
   
     while
   
      (
   
     !
   
     temp.empty())
 {
 
   
     int
   
      ts 
   
     =
   
      temp.top();
 seq[index
   
     ++
   
     ] 
   
     =
   
      
   
     '
   
     A
   
     '
   
      
   
     +
   
      ts;

 temp.pop();
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; j 
   
     <
   
      n; j
   
     ++
   
     )
 
   
     if
   
      (edge[ts][j])
 {
 tdeg[j]
   
     --
   
     ;
 
   
     if
   
      (tdeg[j] 
   
     ==
   
      
   
     0
   
     )
 temp.push(j);
 }
 
   
     if
   
      (flag 
   
     &&
   
      temp.size() 
   
     >
   
      
   
     1
   
     )
 flag 
   
     =
   
      
   
     false
   
     ;
 }
 
   
     for
   
      (
   
     int
   
      j 
   
     =
   
      
   
     0
   
     ; (j 
   
     <
   
      n) 
   
     &&
   
      flag2; j
   
     ++
   
     )
 
   
     if
   
      (tdeg[j] 
   
     !=
   
      
   
     0
   
     )
 {
 L 
   
     =
   
      i;
 flag2 
   
     =
   
      
   
     false
   
     ;
 }
 
   
     if
   
      (t 
   
     ==
   
      n 
   
     &&
   
      flag 
   
     &&
   
      flag2)
 {
 L 
   
     =
   
      i;
 flag1 
   
     =
   
      
   
     false
   
     ;
 }
 }
 }

 
   
     if
   
      (
   
     !
   
     flag1)
 {
 cout 
   
     <<
   
      
   
     "
   
     Sorted sequence determined after 
   
     "
   
      
   
     <<
   
      L 
   
     <<
   
      
   
     "
   
      relations: 
   
     "
   
     ;
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      n; i
   
     ++
   
     )
 cout 
   
     <<
   
      seq[i];
 cout 
   
     <<
   
      
   
     "
   
     .
   
     "
   
      
   
     <<
   
      endl;
 }
 
   
     else
   
      
   
     if
   
     (
   
     !
   
     flag2)
 cout 
   
     <<
   
      
   
     "
   
     Inconsistency found after 
   
     "
   
      
   
     <<
   
      L 
   
     <<
   
      
   
     "
   
      relations.
   
     "
   
     <<
   
     endl;
 
   
     else
   
     
 cout 
   
     <<
   
      
   
     "
   
     Sorted sequence cannot be determined.
   
     "
   
      
   
     <<
   
      endl;
 }
 
   
     return
   
      
   
     0
   
     ;
}