cpper编程论坛 - Blog http://www.cpper.com/c/blog.php zh-CN Thu, 28 Aug 2008 04:52:02 GMT vBulletin 60 http://www.cpper.com/c/images/misc/rss.jpg cpper编程论坛 - Blog http://www.cpper.com/c/blog.php 急问！udp传输速率 http://www.cpper.com/_rockets/131.html Thu, 14 Aug 2008 02:58:25 GMT #include "winsock2.h" #pragma comment(lib,"Ws2_32.lib") #define RECV_IP "192.168.168.13" #define BLOCK 65504 #define NUM 10000*BLOCK void main() { WSADATA wsaData; SOCKET SendSocket; sockaddr_in RecvAddr; int Port = 27015; char SendBuf[BLOCK]; int BufLen = BLOCK; //--------------------------------------------- // Initialize Winsock WSAStartup(MAKEWORD(2,2), &wsaData); //--------------------------------------------- // Create a socket for sending data SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //--------------------------------------------- // Set up the RecvAddr structure with the IP address of // the receiver (in this example case "192.168.168.13") // and the specified port number. RecvAddr.sin_family = AF_INET; RecvAddr.sin_port = htons(Port); RecvAddr.sin_addr.s_addr = inet_addr(RECV_IP); //--------------------------------------------- // Set up the buffer of SendSocket int nSendBuf=512*1024;//设置为32K int nret =setsockopt(SendSocket,SOL_SOCKET,SO_SNDBUF,(const char*) &nSendBuf,sizeof(int)); if (nret ==SOCKET_ERROR){ printf("Set Buffer with error:%d\n",GetLastError()); return; } //--------------------------------------------- // Send a datagram to the receiver printf("Sending a datagram to the receiver...\n"); int num =NUM,sendbytes; // Get the time beginning to send a datagram SYSTEMTIME systime; GetLocalTime(&systime); //Get local time printf("发送时间是:\n"); printf("systime.wHour:%d\nsystime.wMinute:%d\nsystime.wSecond:% d\nsystime.wMilliseconds:%d\n", systime.wHour,systime.wMinute,systime.wSecond,systime.wMilliseconds); float t1 =(float)(3600*systime.wHour +60*systime.wMinute +systime.wSecond +0.001*systime.wMilliseconds); while (num >=0){ sendbytes =sendto(SendSocket, SendBuf, BufLen, 0, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr)); if (sendbytes <0){ printf("send data with error:%d\n",GetLastError()); } num =num -sendbytes; } //--------------------------------------------- // When the application is finished sending, close the socket. printf("Finished sending. Closing socket.\n"); // Get the time when sending is over GetLocalTime(&systime); //local time printf("接收时间：\n"); printf("systime.wHour:%d\nsystime.wMinute:%d\nsystime.wSecond:% d\nsystime.wMilliseconds:%d\n", systime.wHour,systime.wMinute,systime.wSecond,systime.wMilliseconds); float t2 =(float)(3600*systime.wHour +60*systime.wMinute +systime.wSecond +0.001*systime.wMilliseconds); float t =t2-t1; float v = (float)((float)(NUM*8.00)/(1024.00*1024.00*t)); printf("Time spended in sending datagram:%fseconds\n",t); printf("传输速率：%fMb/s\n",v); closesocket(SendSocket); //--------------------------------------------- // Clean up and quit. printf("Exiting.\n"); WSACleanup(); return; } --------- 服务方代码： 代码: --------- #include #include "winsock2.h" #pragma comment(lib, "Ws2_32.lib") #define BLOCK 65504 #define NUM 10000*BLOCK void main() { WSADATA wsaData; SOCKET RecvSocket; sockaddr_in RecvAddr; int Port = 27015; char RecvBuf[BLOCK]; int BufLen = BLOCK; sockaddr_in SenderAddr; int SenderAddrSize = sizeof(SenderAddr); int RecvAddrSize = sizeof(RecvAddr); //----------------------------------------------- // Initialize Winsock WSAStartup(MAKEWORD(2,2), &wsaData); //----------------------------------------------- // Create a receiver socket to receive datagrams RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //----------------------------------------------- // Bind the socket to any address and the specified port. RecvAddr.sin_family = AF_INET; RecvAddr.sin_port = htons(Port); RecvAddr.sin_addr.s_addr = inet_addr("192.168.168.13"); bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr)); // Initialize the SendAddr struct SenderAddr.sin_family = AF_INET; SenderAddr.sin_port = htons(Port); SenderAddr.sin_addr.s_addr = inet_addr("192.168.168.44"); //----------------------------------------------- //设置接受缓冲区 int nRecvBuf =512*1024 ; //设置缓冲区 int nret =setsockopt(RecvSocket, SOL_SOCKET, SO_RCVBUF,(const char *) &nRecvBuf, sizeof (int)); if (nret ==SOCKET_ERROR){ printf("set receive buffer with error:%d\n",GetLastError()); } //----------------------------------------------- // Call the recvfrom function to receive datagrams // on the bound socket. printf("Receiving datagrams...\n"); int num =NUM; int recvbytes; while (num >=0){ recvbytes =recvfrom(RecvSocket, RecvBuf, BufLen, 0, (SOCKADDR *)&SenderAddr, &SenderAddrSize); if (recvbytes <0){ printf("receive data with error:%d\n",GetLastError()); } //printf("%d\n",recvbytes); num =num -recvbytes; } //----------------------------------------------- // Close the socket when finished receiving datagrams printf("Finished receiving. Closing socket.\n"); closesocket(RecvSocket); //----------------------------------------------- // Clean up and exit. printf("Exiting.\n"); WSACleanup(); return; } --------- ]]> wywajlj 794 113 2 365

发信人: wywajlj(五台兄), 信区: NetPRG
标 题: 急问！！udp传输速率
发信站: 瀚海星云 (2008年08月14日10:19:43 星期四), 站内信件 WWWPOST

鄙人在100Mb/s的局域以太网测试时得到tcp的传输速率为：89Mb/s，而udp只有88Mb/s.
按理说这是不正常的，udp的传输速率应该高于tcp，请哪位大虾指教一下。代码如下

代码功能：从客户方向服务方传送数据，测试局域以太网路的传输速率

客户方：
代码:
#include <stdio.h>
#include "winsock2.h"
#pragma  comment(lib,"Ws2_32.lib")

#define  RECV_IP    "192.168.168.13"
#define  BLOCK       65504
#define  NUM         10000*BLOCK

void main() {
  
  WSADATA wsaData;
  SOCKET SendSocket;
  sockaddr_in RecvAddr;
  int Port = 27015;
  char SendBuf[BLOCK];
  int BufLen = BLOCK;

  //---------------------------------------------
  // Initialize Winsock
  WSAStartup(MAKEWORD(2,2), &wsaData);

  //---------------------------------------------
  // Create a socket for sending data
  SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

  //---------------------------------------------
  // Set up the RecvAddr structure with the IP address of
  // the receiver (in this example case "192.168.168.13")
  // and the specified port number.
  RecvAddr.sin_family = AF_INET;
  RecvAddr.sin_port = htons(Port);
  RecvAddr.sin_addr.s_addr = inet_addr(RECV_IP);
  
  //---------------------------------------------
  // Set up the buffer of SendSocket
  int nSendBuf=512*1024;//设置为32K
  int nret =setsockopt(SendSocket,SOL_SOCKET,SO_SNDBUF,(const char*)
&nSendBuf,sizeof(int));
  if (nret ==SOCKET_ERROR){
      printf("Set Buffer with error:%d\n",GetLastError());
      return;
  }
  //---------------------------------------------
  // Send a datagram to the receiver
  printf("Sending a datagram to the receiver...\n");
  int num =NUM,sendbytes;
  
  // Get the time beginning to send a datagram
  SYSTEMTIME systime;
  GetLocalTime(&systime);  //Get local time 
  printf("发送时间是:\n");
  printf("systime.wHour:%d\nsystime.wMinute:%d\nsystime.wSecond:%
d\nsystime.wMilliseconds:%d\n",
             
systime.wHour,systime.wMinute,systime.wSecond,systime.wMilliseconds);
        
  float t1 =(float)(3600*systime.wHour +60*systime.wMinute +systime.wSecond 
+0.001*systime.wMilliseconds);
  while (num >=0){
      sendbytes =sendto(SendSocket, SendBuf, BufLen, 0, 
      (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));
      if (sendbytes <0){
          printf("send data with error:%d\n",GetLastError());
      }
      num =num -sendbytes;
  }

  //---------------------------------------------
  // When the application is finished sending, close the socket.
  printf("Finished sending. Closing socket.\n");

  // Get the time when sending is over
  GetLocalTime(&systime);       //local time 
  printf("接收时间：\n");
  printf("systime.wHour:%d\nsystime.wMinute:%d\nsystime.wSecond:%
d\nsystime.wMilliseconds:%d\n",
             
systime.wHour,systime.wMinute,systime.wSecond,systime.wMilliseconds);


  float t2 =(float)(3600*systime.wHour +60*systime.wMinute +systime.wSecond 
+0.001*systime.wMilliseconds);
  float t =t2-t1;
  float v = (float)((float)(NUM*8.00)/(1024.00*1024.00*t));
  printf("Time spended in sending datagram:%fseconds\n",t);
  printf("传输速率：%fMb/s\n",v);
  closesocket(SendSocket);

  //---------------------------------------------
  // Clean up and quit.
  printf("Exiting.\n");
  WSACleanup();
  return;
}
服务方代码：
代码:
#include <stdio.h>
#include "winsock2.h"
#pragma  comment(lib, "Ws2_32.lib")

#define BLOCK  65504
#define NUM    10000*BLOCK

void main() {

  WSADATA wsaData;
  SOCKET RecvSocket;
  sockaddr_in RecvAddr;
  int Port = 27015;
  char RecvBuf[BLOCK];
  int  BufLen = BLOCK;
  sockaddr_in SenderAddr;
  int SenderAddrSize = sizeof(SenderAddr);
  int RecvAddrSize = sizeof(RecvAddr);

  //-----------------------------------------------
  // Initialize Winsock
  WSAStartup(MAKEWORD(2,2), &wsaData);

  //-----------------------------------------------
  // Create a receiver socket to receive datagrams
  RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

  //-----------------------------------------------
  // Bind the socket to any address and the specified port.
  RecvAddr.sin_family = AF_INET;
  RecvAddr.sin_port = htons(Port);
  RecvAddr.sin_addr.s_addr = inet_addr("192.168.168.13");

  bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));


  // Initialize the SendAddr struct
 
  SenderAddr.sin_family = AF_INET;
  SenderAddr.sin_port = htons(Port);
  SenderAddr.sin_addr.s_addr = inet_addr("192.168.168.44");

  

  //-----------------------------------------------
  //设置接受缓冲区
  int nRecvBuf =512*1024 ;   //设置缓冲区
  int nret =setsockopt(RecvSocket, SOL_SOCKET, SO_RCVBUF,(const char *)
&nRecvBuf, sizeof (int));
  if (nret ==SOCKET_ERROR){
      printf("set receive buffer with error:%d\n",GetLastError());
  }

  //-----------------------------------------------
  // Call the recvfrom function to receive datagrams
  // on the bound socket.
  printf("Receiving datagrams...\n");
  int num =NUM;
  int recvbytes;
  while (num >=0){
      recvbytes =recvfrom(RecvSocket, RecvBuf, BufLen, 0, 
      (SOCKADDR *)&SenderAddr, &SenderAddrSize);
      if (recvbytes <0){
          printf("receive data with error:%d\n",GetLastError());
      }
      //printf("%d\n",recvbytes);
      num =num -recvbytes;
  }

  //-----------------------------------------------
  // Close the socket when finished receiving datagrams
  printf("Finished receiving. Closing socket.\n");
  closesocket(RecvSocket);

  //-----------------------------------------------
  // Clean up and exit.
  printf("Exiting.\n");
  WSACleanup();
  return;
}
]]> 永远的Rockets http://www.cpper.com/c/http://www.cpper.com/_rockets/131.html <![CDATA[It's Not a Bug, It's a Language Feature!]]> http://www.cpper.com/bankrock/130.html Sun, 27 Jul 2008 15:47:37 GMT searchQueue; searchQueue.push_back(SearchItem(tree.rootImpedSegId, -1, 0)); //1 while (!searchQueue.empty()) { SearchItem& item = searchQueue.front(); int impedSegId = item.impedSegId; int parImpedSegId = item.parImpedSegId; int startLoadId = item.startLoadId; //2 ........... 横竖看起来都是人畜无害的一段代码，SearchItem是含有三个int变量的类，searchQueue是存储SearchItem元素的搜索队列，//1处push的元素在while语句中会被取出，其三个变量必然是 item.impedSegId == tree.rootImpedSegId; item.parImpedSegId == -1; item.startLoadId == 0; 可是这里却出现了存储错误，检查的结果是startLoadId值为-1163005939！deque的push_back函数里肯定发生了什么问题，才导致startLoadId从0变成了-1163005939。Debug进入push_back的定义，如下： void push_back(const value_type& __x) { if (this->_M_impl._M_finish._M_cur != this->_M_impl._M_finish._M_last - 1) { std::_Construct(this->_M_impl._M_finish._M_cur, __x); ++this->_M_impl._M_finish._M_cur; } else _M_push_back_aux(__x); } 由于deque的默认构造函数分配了一些存储空间，因此_M_cur还没到末尾，if判断为真，程序执行到++this->_M_impl._M_finish._M_cur;时出现了意想不到的情况。这里为了了解++this->_M_impl._M_finish._M_cur;做了什么，将相关的定义罗列如下： template > class deque : protected _Deque_base<_Tp, _Alloc> template class _Deque_base { .... typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator; struct _Deque_impl : public _Alloc { ......... iterator _M_finish; .......... }; _Deque_impl _M_impl; }; template struct _Deque_iterator { ......... _Tp* _M_cur; ......... } 可以看出deque中的this->_M_impl._M_finish._M_cur的类型是SearchItem*，由于SearchItem是12字节的，因此想必++this->_M_impl._M_finish._M_cur会将指针移动12个字节。实际结果却是： ---引用--- Before++: this->_M_impl._M_finish._M_cur = 0x700f38 After++: this->_M_impl._M_finish._M_cur = 0x700f40 ---结束引用--- 只增加了8字节！在程序里将SearchItem的大小输出看看，发现确实是12字节： cerr << sizeof(SearchItem) //结果是12编译器居然口是心非！想了半天突然觉察到还有另外一个文件中的算法也定义了相同名字的类，找到其定义如下： struct SearchItem { SearchItem (int searchNodeUid, int parentBranchId) : nodeUid(searchNodeUid), parBranchId(parentBranchId) {} int nodeUid; int parBranchId; }; 这个是8字节的结构，正好和++操作的结果相符。到这里才恍然大悟，C++的编译模式规定一个类如果不特别指明，它的名字作用域默认是全局的，如果在多个文件中定义了该类，则必须保证类定义完全相同。Devc++居然对两个类定义不做任何检查就用上了，编译器执行指针操作时按照8字节的SearchItem工作，导致startLoadId根本没有被存储到deque中，sizeof操作符却用了12字节的SearchItem！解决的方法很简单，将两个SearchItem加入无名名字空间，冲突就解决了。 Expert C Progamming中将C语言默认的函数名字全局可见这一Language Feature归类为Sin of Commission，也就是C语言不应该做的却做了的事情。C++为了保持兼容性，变本加厉的加入了数量巨大的其他全局外联类型。因此对于确定只用在某个编译单元中的函数，类，类成员函数和产生全局名字的无论其他什么东西，最好用static或者无名名字空间让它们安静的躺在自己的角落里，免得碰上devc++（或者说gcc）这种哑巴编译器搅浑水。 ]]>
标题这句话是维护编程语言尊严的常用语，但有时候Language Feature比Bug还要可怕，今天鄙人就被C/C++的一个Language Feature和devc++耍了一把。
首先来看看这段代码：
C++ 代码:
  1. struct SearchItem
  2. {
  3.     SearchItem(int impedanceSegId, int parentImpedSegId, int startingLoadId)
  4.         : impedSegId(impedanceSegId), parImpedSegId(parentImpedSegId), startLoadId(startingLoadId)
  5.     {  }
  6.  
  7.     int impedSegId, parImpedSegId, startLoadId;
  8. };
  9.  
  10. void GetAccImpedAndMtrxStruct(....)
  11. {
  12.     deque<SearchItem> searchQueue;
  13.      searchQueue.push_back(SearchItem(tree.rootImpedSegId, -1, 0));  //1
  14.  
  15.     while (!searchQueue.empty())
  16.     {
  17.         SearchItem& item = searchQueue.front();
  18.         int impedSegId = item.impedSegId;
  19.         int parImpedSegId = item.parImpedSegId;
  20.         int startLoadId = item.startLoadId;   //2
  21.  ...........
横竖看起来都是人畜无害的一段代码，SearchItem是含有三个int变量的类，searchQueue是存储SearchItem元素的搜索队列，//1处push的元素在while语句中会被取出，其三个变量必然是
C++ 代码:
  1. item.impedSegId == tree.rootImpedSegId; 
  2. item.parImpedSegId == -1;
  3. item.startLoadId == 0;
可是这里却出现了存储错误，检查的结果是startLoadId值为-1163005939！deque的push_back函数里肯定发生了什么问题，才导致startLoadId从0变成了-1163005939。Debug进入push_back的定义，如下：
C++ 代码:
  1. void
  2.       push_back(const value_type& __x)
  3.       {
  4.     if (this->_M_impl._M_finish._M_cur != this->_M_impl._M_finish._M_last - 1)
  5.       {
  6.         std::_Construct(this->_M_impl._M_finish._M_cur, __x);
  7.         ++this->_M_impl._M_finish._M_cur;
  8.       }
  9.     else
  10.       _M_push_back_aux(__x);
  11.       }
由于deque的默认构造函数分配了一些存储空间，因此_M_cur还没到末尾，if判断为真，程序执行到++this->_M_impl._M_finish._M_cur;时出现了意想不到的情况。这里为了了解++this->_M_impl._M_finish._M_cur;做了什么，将相关的定义罗列如下：
C++ 代码:
  1. template<typename _Tp, typename _Alloc = allocator<_Tp> >
  2.     class deque : protected _Deque_base<_Tp, _Alloc>
  3.  
  4.   template<typename _Tp, typename _Alloc>
  5.     class _Deque_base
  6.     {
  7.        ....
  8. typedef _Deque_iterator<_Tp,_Tp&,_Tp*>             iterator;
  9.       struct _Deque_impl
  10.     : public _Alloc {
  11.      .........
  12.     iterator _M_finish;
  13.       ..........
  14.       };
  15.        _Deque_impl _M_impl;
  16.     };
  17.  
  18.   template<typename _Tp, typename _Ref, typename _Ptr>
  19.     struct _Deque_iterator
  20.     {
  21.     .........
  22.       _Tp* _M_cur;
  23.     .........
  24.      }
可以看出deque<SearchItem>中的this->_M_impl._M_finish._M_cur的类型是SearchItem*，由于SearchItem是12字节的，因此想必++this->_M_impl._M_finish._M_cur会将指针移动12个字节。实际结果却是：
引用:
Before++: this->_M_impl._M_finish._M_cur = 0x700f38
After++: this->_M_impl._M_finish._M_cur = 0x700f40
只增加了8字节！在程序里将SearchItem的大小输出看看，发现确实是12字节：
C++ 代码:
  1. cerr << sizeof(SearchItem) //结果是12 
  2.  
编译器居然口是心非！想了半天突然觉察到还有另外一个文件中的算法也定义了相同名字的类，找到其定义如下：
C++ 代码:
  1. struct SearchItem
  2. {
  3.     SearchItem (int searchNodeUid, int parentBranchId)
  4.         : nodeUid(searchNodeUid), parBranchId(parentBranchId)
  5.     {}
  6.  
  7.     int nodeUid;
  8.     int parBranchId;
  9. };
这个是8字节的结构，正好和++操作的结果相符。到这里才恍然大悟，C++的编译模式规定一个类如果不特别指明，它的名字作用域默认是全局的，如果在多个文件中定义了该类，则必须保证类定义完全相同。Devc++居然对两个类定义不做任何检查就用上了，编译器执行指针操作时按照8字节的SearchItem工作，导致startLoadId根本没有被存储到deque中，sizeof操作符却用了12字节的SearchItem！解决的方法很简单，将两个SearchItem加入无名名字空间，冲突就解决了。
Expert C Progamming中将C语言默认的函数名字全局可见这一Language Feature归类为Sin of Commission，也就是C语言不应该做的却做了的事情。C++为了保持兼容性，变本加厉的加入了数量巨大的其他全局外联类型。因此对于确定只用在某个编译单元中的函数，类，类成员函数和产生全局名字的无论其他什么东西，最好用static或者无名名字空间让它们安静的躺在自己的角落里，免得碰上devc++（或者说gcc）这种哑巴编译器搅浑水。
]]> bankrock http://www.cpper.com/c/http://www.cpper.com/bankrock/130.html __mt_alloc源码分析（1） http://www.cpper.com/wqqafnd/129.html Tue, 22 Jul 2008 08:24:12 GMT http://groups.google.com/group/dl-coder/web/mt-alloc1 http://groups.google.com/group/dl-coder/web/mt-alloc1 ]]> wqqafnd http://www.cpper.com/c/http://www.cpper.com/wqqafnd/129.html hello world http://www.cpper.com/gykgod/128.html Tue, 15 Jul 2008 12:55:42 GMT 总算找到一个纯粹点的地方学习C++了，先踩一脚^_^ 总算找到一个纯粹点的地方学习C++了，先踩一脚^_^ ]]> gykgod http://www.cpper.com/c/http://www.cpper.com/gykgod/128.html 2-CNF-SAT问题图形解法的C++实现 http://www.cpper.com/bankrock/127.html Tue, 15 Jul 2008 06:40:51 GMT l2)是等价的（这里->是指IF-THEN关系），两式中l1、l2以及结果值value都符合以下的真值表： ---引用--- +-----+-----+-----+ |l1 |l2 |value| +-----+-----+-----+ |1 |1 |1 | +-----+-----+-----+ |1 |0 |1 | +-----+-----+-----+ |0 |1 |1 | +-----+-----+-----+ |0 |0 |0 | +-----+-----+-----+ ---结束引用--- 因此一个clause可以用IF-THEN关系代替，其他clause中可能出现!l1或者!l2，它们的关系也必须有所表示，这可以通过对上述IF-THEN关系取逆反得到。也就是： ---引用--- (l1 OR l2) <==> (!l1 -> l2),(!l2 -> l1) ---结束引用--- 现在开始将2-CNF转化为一个有向图。对于每个变量x建立对应literal x和!x的端点，将clause得出的每个IF-THEN关系转化为图中端点间的一条边，这里称这个有向图为G。可以看出，当2-CNF有满足结果为1的解时，它的所有clause的值都需要为1，因此由clause得出的IF-THEN关系也必须成立，也就是对于G中的每一条边，起始点和终点的literal值需要符合IF-THEN关系；同时，如果G中所有边的起始点和终点的literal值符合IF-THEN关系，并且它们推导出的变量值不相互冲突（例如x1和!x1不会都赋值为0，或者1)，那么这个变量赋值是一个满足2-CNF公式的可行解。 接下来就需要找到是否存在满足图G中的边所代表的IF-THEN关系的赋值方法。方法如下：搜索图G的所有强连通区域，如果将强连通区域收缩为一个点，则和连接这些强连通点之间边将形成一个无环有向图G'。 1.如果某个强连通区域中有互为非的literal存在，则不可能存在符合这些边所代表的IF-THEN关系，2-CNF无解。这是因为此时强连通区域内必定有1和0同时存在，由于IF-THEN关系具有传递性，如果存在1则整个强连通区域所有的literal值都需为1才能满足IF-THEN关系。因此这些IF-THEN关系无法满足。同时可以得出一个强连通区域内要么所有Literal的值都为1，要么都为0。 2.如果没有强连通区域包含互非的literal，那么根据无环有向图G'的拓扑排序关系，可以确定任意两个互非的literal l和!l间的先后关系，将在前的literal值置0，在后的literal置1，可以得出符合IF-THEN关系并且变量赋值不相互冲突的一个2-CNF解。由于0和1互非，明显literal对应的变量值不会相互冲突。因此只需证明这个赋值方法符合IF-THEN关系，证明分为两部分，一为强连通区域内的关系，二为强连通区域之间的关系： （1）上面说过满足强连通区域内关系只可能有两种情况，literal都为1或者都为0。现假设使用的赋值方法使得某个强连通区域内出现了两个不同值的literal，l1 = 1、l2 = 0，那么在拓扑排序之前的某个强连通区域F中有!l1 = 0，之后的某个强连通区域B内有!l2 = 1。由于我们构造图G的方法决定如果有边(l1,l2)，那么必然有边(!l2,!l1)，因此由l1到l2有通路可以得出!l2到!l1有通路，得出拓扑排序中B在F之前的矛盾结论，因此强连通区域不可能有不同值的Literal。 （2）强连通区域间违反IF-THEN关系的情况如下：区域A到B是有通路的，但是区域A值为1而区域B为0，用反证法可以证明这种情况在采用指定的赋值方法时是不可能出现的。假设存在这么两个强连通区域A,B，且literal a属于A，literal b属于B，那么!a所属的强连通区域C值为0在A之前，!b所属的强连通区域D值为1在B之后，且由于a可以到达b，!b也可以到达!a，那么存在D>C>A>B>D的循环拓扑排序关系，这说明强连通区域间不可能出现违反IF-THEN关系的情况。 至此我们已经证明了该算法可以有效性，而且根据这个算法可以构造出可行的2-CNF解。至于形成强连通区域的算法可以在O(V+E)的时间内完成，因此整个算法是多项式时间复杂度的。 二.2-CNF-SAT算法的C++实现 实现该算法的关键之处在于如何寻找G的强连通区域，以及检查是否有两个互非的literal存在于同一个强连通区域中。寻找强连通区域的算法由以下几个步骤组成： 1. 对G进行深度优先搜索，记录下每个节点u搜索完毕的时间f[u]。 2. 对G的节点按照搜索完毕时间f由大到小排序，并形成G的转置图Gt（转置图是由G的所有边方向都调转形成的）。 3. 对Gt按排序好节点顺序进行深度优先搜索，此时每次搜索到的点组成的集合就为一个强连通区域。在搜索过程中可以检查是否有互非的literal出现在同一个强连通区域中。 简单解释一下：这个算法第2步的作用相当于为G的强连通区域进行拓扑排序，由于G和Gt的强连通区域相同，第3步按照拓扑排序搜索Gt时，每次搜索得到一个强连通区域，而不会搜索到其他区域（由于Gt所有的边已经反转，按照拓扑排序关系，如果搜索到其他区域，那么必定是已经搜索过的）。具体的证明请看算法导论关于强连通区域的章节。 表示2-CNF的类如下： struct Literal { Literal() : pSmbl(0) {} Literal(Symbol* pSymbol, bool isNotSymbol) : pSmbl(pSymbol), isNotSmbl(isNotSymbol) {} bool Value() const { return isNotSmbl ? !pSmbl->value : pSmbl->value; } Literal operator!() const { return Literal(pSmbl, !isNotSmbl); } Symbol* pSmbl; bool isNotSmbl; friend bool FindSCCAndCheckSatisfiability(LtrlGraph& transGraph, std::vector& sccs); private: bool SetSymbolValue(StrCnnCmpnt *pSCC); }; //////////////////////////////////// struct Clause { Clause(Literal const& literal1, Literal const& literal2, size_t numDummyLiterals) : numDummyLtrl(numDummyLiterals) { ltrls[0] = literal1; ltrls[1] = literal2; } Literal ltrls[2]; size_t numDummyLtrl; }; struct TwoCNF { std::vector clauses; std::set symbols; std::vector dummySmbls; }; 其中TwoCNF中的dummySmbls指的是当clause中的literal数目小于2时生成的伪布尔变量。例如 l == (l OR RANDOM_SYMBOL) AND (l OR !RANDOM_SYMBOL)，这里的RANDOM_SYMBOL就是一个伪布尔变量。 表示由2-CNF生成的图类如下： ///////////////////////////////////////// struct Node { Node(Literal const& literal) : state(UNSEARCHED), ltrl(literal), pNewNode(0) {} Node(Node const& other) : state(UNSEARCHED), tBgnSrch(other.tBgnSrch), tEndSrch(other.tEndSrch), ltrl(other.ltrl), pNewNode(0) {} enum STATE { SEARCHED, SEARCHING, UNSEARCHED } state; size_t tBgnSrch, tEndSrch; Literal ltrl; std::vector cnnNodes; friend void TransposeAndSortGraph(LtrlGraph& graph, LtrlGraph& transGraph); private: Node *pNewNode; //Used for transposing the graph }; struct LtrlGraph { std::list nodes; }; 上述算法的C++实现分为三部分，第一部分为深度优先搜索算法： void DepthFirstSearch(LtrlGraph& graph) { InitNodesState(graph); stack searchNodes; size_t time = 0; for (list::iterator itorNode = graph.nodes.begin(); itorNode != graph.nodes.end(); ++itorNode) { Node& node = *itorNode; if (node.state != Node::UNSEARCHED) continue; searchNodes.push(&node); while (!searchNodes.empty()) { Node& node = *searchNodes.top(); if (node.state == Node::UNSEARCHED) { node.state = Node::SEARCHING; node.tBgnSrch = ++time; for (vector::iterator itorCnnNode = node.cnnNodes.begin(); itorCnnNode != node.cnnNodes.end(); ++itorCnnNode) { Node *pCnnNode = *itorCnnNode; if (pCnnNode->state == Node::UNSEARCHED) searchNodes.push(pCnnNode); } } else if (node.state == Node::SEARCHING) { node.state = Node::SEARCHED; node.tEndSrch = ++time; searchNodes.pop(); } else { //The node has already been searched, just pop it from the stack searchNodes.pop(); } } } } 这里使用栈searchNodes记录了搜索节点的顺序，以避免递归调用。searchNodes中的点如果未搜索，则将它标记为正搜索状态，然后搜寻所有相邻的未搜索点将其加入searchNodes中；如果该点的状态为正在搜索，那么说明它的所有子节点都已经搜索完毕，记录下搜索完毕时间并退栈；如果是以搜索状态，说明已经被纳入其他节点的搜索范围，直接退栈。这一步完成后我们得到了所有节点的搜索完毕时间。 接下来需要生成转置图Gt，并且按照搜索完毕时间排序节点。算法如下： struct SortingNode { SortingNode(size_t endSearchTime, Node *pOrgNode) : tEndSrch(endSearchTime), pNode(pOrgNode) {} size_t tEndSrch; Node *pNode; }; inline bool GreaterEndSearchTime(SortingNode const& n1, SortingNode const& n2) { return n1.tEndSrch > n2.tEndSrch; } void TransposeAndSortGraph(LtrlGraph& graph, LtrlGraph& transGraph) { //Sort nodes by their end search time vector sortingNodes; for (list::iterator itorNode = graph.nodes.begin(); itorNode != graph.nodes.end(); ++itorNode) { Node& node = *itorNode; sortingNodes.push_back(SortingNode(node.tEndSrch, &node)); } sort(sortingNodes.begin(), sortingNodes.end(), &GreaterEndSearchTime); //Add new nodes in the transposed graph for (vector::iterator itorSN = sortingNodes.begin(); itorSN != sortingNodes.end(); ++itorSN) { transGraph.nodes.push_back(*(itorSN->pNode)); itorSN->pNode->pNewNode = &transGraph.nodes.back(); } //Transpose the graph for (list::iterator itorNode = graph.nodes.begin(); itorNode != graph.nodes.end(); ++itorNode) { Node& node = *itorNode; for (vector::iterator itorCnnNode = node.cnnNodes.begin(); itorCnnNode != node.cnnNodes.end(); ++itorCnnNode) { Node* pCnnNode = *itorCnnNode; pCnnNode->pNewNode->cnnNodes.push_back(node.pNewNode); } } } 这里先使用了一个辅助排序的结构SortingNode按搜索完毕时间排序节点，然后对原图每个节点和连接节点形成的边，反转连接节点对该节点的边。 最后一步需要搜索强连通区域以及对变量赋值，同时检查是否有互非的两个literal在同一个强连通区域中。 //Strongly Connected Component struct StrCnnCmpnt { size_t rank; std::vector literals; }; bool FindSCCAndCheckSatisfiability(LtrlGraph& transGraph, vector& sccs) { stack searchNodes; size_t strCnnCmptRank = 0; //Lower number means higher rank for (list::iterator itorNode = transGraph.nodes.begin(); itorNode != transGraph.nodes.end(); ++itorNode) { Node& node = *itorNode; if (node.state != Node::UNSEARCHED) continue; //Create a strong connected component sccs.push_back(StrCnnCmpnt()); StrCnnCmpnt& scc = sccs.back(); scc.rank = ++strCnnCmptRank; searchNodes.push(&node); while (!searchNodes.empty()) { Node& node = *searchNodes.top(); if (node.state == Node::UNSEARCHED) { node.state = Node::SEARCHING; for (vector::iterator itorCnnNode = node.cnnNodes.begin(); itorCnnNode != node.cnnNodes.end(); ++itorCnnNode) { Node *pCnnNode = *itorCnnNode; if (pCnnNode->state == Node::UNSEARCHED) searchNodes.push(pCnnNode); } } else if (node.state == Node::SEARCHING) { node.state = Node::SEARCHED; if (!node.ltrl.SetSymbolValue(&scc)) //A symbol and its complement is in the same strong connected component, //Therefore the symbol value is undefined. No solution is available. return false; else scc.literals.push_back(node.ltrl); searchNodes.pop(); } else { searchNodes.pop(); } } } return true; } 这部分算法的主体也是深度优先搜索，但是每个节点搜索完毕后，需要调用node.ltrl.SetSymbolValue(&scc)检查literal所属的强连通区域是否和它互非的literal所属的强连通区域相同，如果相同则2-CNF-SAT无解。Literal类的SetSymbolValue方法如下： bool Literal::SetSymbolValue(StrCnnCmpnt *pSCC) { assert(pSCC != 0 && (pSmbl->cntSCC.pSCC == 0 || pSmbl->cntSCC.pNotSCC == 0)); Symbol::ContainingSCC& cntSCC = pSmbl->cntSCC; if (cntSCC.pSCC == 0 && cntSCC.pNotSCC == 0) //The first time this symbol is checked { if (isNotSmbl) { pSmbl->value = true; cntSCC.pNotSCC = pSCC; } else { pSmbl->value = false; cntSCC.pSCC = pSCC; } return true; } else //The second time this symbol is checked { isNotSmbl ? (cntSCC.pNotSCC = pSCC) : (cntSCC.pSCC = pSCC); return cntSCC.IsNotSameSCC(); } } 当该变量第一次被搜索时对其赋值并记录所属的强连通区域，第二次被搜索时检查两个互非Literal所属强连通区域是否相同。 完整的实现还包括从文件读取2-CNF公式，由TwoCNF类生成图，以及一些输出函数，在这里不罗嗦了，详细看附件里的程序。 三. 例子 这里找了几个相对比较简单的例子（其中&表示AND关系，|表示OR关系，!表示NOT）： 例1. ---引用--- (x0|x2)&(x0|!x3)&(x1|!x3)&(x1|!x4)&(x2|!x4)&(x5|x0)&(!x5|x1)&(x2|x5)&(x3|x6)&(x4|x6)&(x5|x6) ---结束引用--- 结果： ---引用--- 2-CNF: (x0|x2)&(x0|!x3)&(x1|!x3)&(x1|!x4)&(x2|!x4)&(x5|x0)&(!x5|x1)&(x2|x5)&(x3| x6)&(x4|x6)&(x5|x6) One Satisfiable Solution:(x0:0) (x1:1) (x2:1) (x3:0) (x4:0) (x5:1) (x6:1) Graph: Node x2: Node !x0: x2 !x3 x5 Node x0: Node !x2: x0 !x4 x5 Node !x3: x6 Node x3: x0 x1 Node !x1: !x3 !x4 !x5 Node x1: Node !x4: x6 Node x4: x1 x2 Node !x5: x0 x2 x6 Node x5: x1 Node x6: Node !x6: x3 x4 x5 Strongly Connected Components: The SCC of Rank 1 contains the following literals: !x6 The SCC of Rank 2 contains the following literals: x4 The SCC of Rank 3 contains the following literals: !x1 The SCC of Rank 4 contains the following literals: !x5 The SCC of Rank 5 contains the following literals: x3 The SCC of Rank 6 contains the following literals: !x2 The SCC of Rank 7 contains the following literals: !x4 The SCC of Rank 8 contains the following literals: x0 The SCC of Rank 9 contains the following literals: !x0 The SCC of Rank 10 contains the following literals: !x3 The SCC of Rank 11 contains the following literals: x6 The SCC of Rank 12 contains the following literals: x5 The SCC of Rank 13 contains the following literals: x1 The SCC of Rank 14 contains the following literals: x2 ---结束引用--- 例2. ---引用--- (x1|x2)&(x1|!x2)&(!x1|x2)&(!x1|!x2)&(!x1|x3)&(!x1|!x3)&(x2|!x3)&(x2|x4)&(!x2|x3)&(!x2|!x3)&(x3|x4)&(!x3|!x4) ---结束引用--- 结果： ---引用--- No solution to 2-CNF: (x1|x2)&(x1|!x2)&(!x1|x2)&(!x1|!x2)&(!x1|x3)&(!x1|!x3)&(x2 |!x3)&(x2|x4)&(!x2|x3)&(!x2|!x3)&(x3|x4)&(!x3|!x4) ---结束引用--- ]]> 2-CNF-SAT问题图形解法的C++实现
CNF(conjunctive normal form)是指由多个子句(clause)通过AND关系连接组成的布尔公式，每个子句由若干个文字(literal)通过OR关系连接而成，每个literal可能是一个布尔变量或者布尔变量取反。2-CNF中每个clause含有2个或两个以下的literal，而2-CNF-SAT(2-conjunctive normal form satisfiability)问题就是找出一个2-CNF公式是否有对布尔变量赋值的方法使2-CNF公式的最终结果为1。例如：
引用:
(x1 OR !x2) AND (x1 OR x2) （这里!表示NOT）
就是一个2-CNF公式，如果取x1 = 1, x2 = 0，它的值为(1 OR 1) AND (1 OR 0) = 1，因此这是一个可以满足2-CNF的变量赋值，这个公式属于2-CNF-SAT集。这里介绍一种图形算法解决2-CNF-SAT问题的方法以及C++实现。

一.2-CNF-SAT图形算法以及证明
3-CNF-SAT问题是NP-Complete的，也就是不大可能出现多项式时间复杂度的解法。但是2-CNF问题却是多项式可解的。下面的解法将2-CNF-SAT问题转化为求解一个图的强连通区域是否符合一定性质，从而判断2-CNF公式是否有解，如果解存在的话还将给出一个可行解。
2-CNF中一个含有两个literal的clause(l1 OR l2)与(!l1 -> l2)是等价的（这里->是指IF-THEN关系），两式中l1、l2以及结果值value都符合以下的真值表：
引用:
+-----+-----+-----+
|l1 |l2 |value|
+-----+-----+-----+
|1 |1 |1 |
+-----+-----+-----+
|1 |0 |1 |
+-----+-----+-----+
|0 |1 |1 |
+-----+-----+-----+
|0 |0 |0 |
+-----+-----+-----+
因此一个clause可以用IF-THEN关系代替，其他clause中可能出现!l1或者!l2，它们的关系也必须有所表示，这可以通过对上述IF-THEN关系取逆反得到。也就是：
引用:
(l1 OR l2) <==> (!l1 -> l2),(!l2 -> l1)
现在开始将2-CNF转化为一个有向图。对于每个变量x建立对应literal x和!x的端点，将clause得出的每个IF-THEN关系转化为图中端点间的一条边，这里称这个有向图为G。可以看出，当2-CNF有满足结果为1的解时，它的所有clause的值都需要为1，因此由clause得出的IF-THEN关系也必须成立，也就是对于G中的每一条边，起始点和终点的literal值需要符合IF-THEN关系；同时，如果G中所有边的起始点和终点的literal值符合IF-THEN关系，并且它们推导出的变量值不相互冲突（例如x1和!x1不会都赋值为0，或者1)，那么这个变量赋值是一个满足2-CNF公式的可行解。
接下来就需要找到是否存在满足图G中的边所代表的IF-THEN关系的赋值方法。方法如下：搜索图G的所有强连通区域，如果将强连通区域收缩为一个点，则和连接这些强连通点之间边将形成一个无环有向图G'。
1.如果某个强连通区域中有互为非的literal存在，则不可能存在符合这些边所代表的IF-THEN关系，2-CNF无解。这是因为此时强连通区域内必定有1和0同时存在，由于IF-THEN关系具有传递性，如果存在1则整个强连通区域所有的literal值都需为1才能满足IF-THEN关系。因此这些IF-THEN关系无法满足。同时可以得出一个强连通区域内要么所有Literal的值都为1，要么都为0。
2.如果没有强连通区域包含互非的literal，那么根据无环有向图G'的拓扑排序关系，可以确定任意两个互非的literal l和!l间的先后关系，将在前的literal值置0，在后的literal置1，可以得出符合IF-THEN关系并且变量赋值不相互冲突的一个2-CNF解。由于0和1互非，明显literal对应的变量值不会相互冲突。因此只需证明这个赋值方法符合IF-THEN关系，证明分为两部分，一为强连通区域内的关系，二为强连通区域之间的关系：
（1）上面说过满足强连通区域内关系只可能有两种情况，literal都为1或者都为0。现假设使用的赋值方法使得某个强连通区域内出现了两个不同值的literal，l1 = 1、l2 = 0，那么在拓扑排序之前的某个强连通区域F中有!l1 = 0，之后的某个强连通区域B内有!l2 = 1。由于我们构造图G的方法决定如果有边(l1,l2)，那么必然有边(!l2,!l1)，因此由l1到l2有通路可以得出!l2到!l1有通路，得出拓扑排序中B在F之前的矛盾结论，因此强连通区域不可能有不同值的Literal。
（2）强连通区域间违反IF-THEN关系的情况如下：区域A到B是有通路的，但是区域A值为1而区域B为0，用反证法可以证明这种情况在采用指定的赋值方法时是不可能出现的。假设存在这么两个强连通区域A,B，且literal a属于A，literal b属于B，那么!a所属的强连通区域C值为0在A之前，!b所属的强连通区域D值为1在B之后，且由于a可以到达b，!b也可以到达!a，那么存在D>C>A>B>D的循环拓扑排序关系，这说明强连通区域间不可能出现违反IF-THEN关系的情况。
至此我们已经证明了该算法可以有效性，而且根据这个算法可以构造出可行的2-CNF解。至于形成强连通区域的算法可以在O(V+E)的时间内完成，因此整个算法是多项式时间复杂度的。

二.2-CNF-SAT算法的C++实现
实现该算法的关键之处在于如何寻找G的强连通区域，以及检查是否有两个互非的literal存在于同一个强连通区域中。寻找强连通区域的算法由以下几个步骤组成：
1. 对G进行深度优先搜索，记录下每个节点u搜索完毕的时间f[u]。
2. 对G的节点按照搜索完毕时间f由大到小排序，并形成G的转置图Gt（转置图是由G的所有边方向都调转形成的）。
3. 对Gt按排序好节点顺序进行深度优先搜索，此时每次搜索到的点组成的集合就为一个强连通区域。在搜索过程中可以检查是否有互非的literal出现在同一个强连通区域中。
简单解释一下：这个算法第2步的作用相当于为G的强连通区域进行拓扑排序，由于G和Gt的强连通区域相同，第3步按照拓扑排序搜索Gt时，每次搜索得到一个强连通区域，而不会搜索到其他区域（由于Gt所有的边已经反转，按照拓扑排序关系，如果搜索到其他区域，那么必定是已经搜索过的）。具体的证明请看算法导论关于强连通区域的章节。
表示2-CNF的类如下：
C++ 代码:
  1. struct Literal
  2. {
  3.     Literal() : pSmbl(0) {}
  4.  
  5.     Literal(Symbol* pSymbol, bool isNotSymbol)
  6.         : pSmbl(pSymbol), isNotSmbl(isNotSymbol)
  7.     {}
  8.  
  9.     bool Value() const
  10.     { return isNotSmbl ? !pSmbl->value : pSmbl->value; }
  11.  
  12.     Literal operator!() const
  13.     { return Literal(pSmbl, !isNotSmbl); }
  14.  
  15.  
  16.     Symbol* pSmbl;
  17.     bool isNotSmbl;
  18.  
  19. friend bool FindSCCAndCheckSatisfiability(LtrlGraph& transGraph, std::vector<StrCnnCmpnt>& sccs);
  20. private:
  21.     bool SetSymbolValue(StrCnnCmpnt *pSCC);
  22. };
  23.  
  24. ////////////////////////////////////
  25. struct Clause
  26. {
  27.     Clause(Literal const& literal1, Literal const& literal2, size_t numDummyLiterals)
  28.         : numDummyLtrl(numDummyLiterals)
  29.     {
  30.         ltrls&#91;0] = literal1;
  31.         ltrls&#91;1] = literal2;
  32.     }
  33.     Literal ltrls&#91;2];
  34.     size_t numDummyLtrl;
  35. };
  36.  
  37. struct TwoCNF
  38. {
  39.     std::vector<Clause> clauses;
  40.     std::set<Symbol> symbols;
  41.     std::vector<Symbol*> dummySmbls;
  42. };
其中TwoCNF中的dummySmbls指的是当clause中的literal数目小于2时生成的伪布尔变量。例如 l == (l OR RANDOM_SYMBOL) AND (l OR !RANDOM_SYMBOL)，这里的RANDOM_SYMBOL就是一个伪布尔变量。
表示由2-CNF生成的图类如下：
C++ 代码:
  1. /////////////////////////////////////////
  2. struct Node
  3. {
  4.     Node(Literal const& literal) : state(UNSEARCHED), ltrl(literal), pNewNode(0) {}
  5.     Node(Node const& other) : state(UNSEARCHED), tBgnSrch(other.tBgnSrch),
  6.         tEndSrch(other.tEndSrch), ltrl(other.ltrl), pNewNode(0)
  7.     {}
  8.  
  9.     enum STATE { SEARCHED, SEARCHING, UNSEARCHED } state;
  10.     size_t tBgnSrch, tEndSrch;
  11.     Literal ltrl;
  12.     std::vector<Node*> cnnNodes;
  13.  
  14. friend void TransposeAndSortGraph(LtrlGraph& graph, LtrlGraph& transGraph);
  15. private:
  16.     Node *pNewNode; //Used for transposing the graph
  17. };
  18.  
  19. struct LtrlGraph
  20. {
  21.     std::list<Node> nodes;
  22. };
上述算法的C++实现分为三部分，第一部分为深度优先搜索算法：
C++ 代码:
  1. void DepthFirstSearch(LtrlGraph& graph)
  2. {
  3.     InitNodesState(graph);
  4.  
  5.     stack<Node*> searchNodes;
  6.  
  7.     size_t time = 0;
  8.     for (list<Node>::iterator itorNode = graph.nodes.begin();
  9.         itorNode != graph.nodes.end(); ++itorNode)
  10.     {
  11.         Node& node = *itorNode;
  12.         if (node.state != Node::UNSEARCHED)
  13.             continue;
  14.  
  15.         searchNodes.push(&node);
  16.         while (!searchNodes.empty())
  17.         {
  18.             Node& node = *searchNodes.top();
  19.             if (node.state == Node::UNSEARCHED)
  20.             {
  21.                 node.state = Node::SEARCHING;
  22.                 node.tBgnSrch = ++time;
  23.                 for (vector<Node*>::iterator itorCnnNode = node.cnnNodes.begin();
  24.                     itorCnnNode != node.cnnNodes.end(); ++itorCnnNode)
  25.                 {
  26.                     Node *pCnnNode = *itorCnnNode;
  27.                     if (pCnnNode->state == Node::UNSEARCHED)
  28.                         searchNodes.push(pCnnNode);
  29.                 }
  30.             }
  31.             else if (node.state == Node::SEARCHING)
  32.             {
  33.                 node.state = Node::SEARCHED;
  34.                 node.tEndSrch = ++time;
  35.                 searchNodes.pop();
  36.             }
  37.             else
  38.             {
  39.                 //The node has already been searched, just pop it from the stack
  40.                 searchNodes.pop();
  41.             }
  42.         }
  43.     }
  44. }
这里使用栈searchNodes记录了搜索节点的顺序，以避免递归调用。searchNodes中的点如果未搜索，则将它标记为正搜索状态，然后搜寻所有相邻的未搜索点将其加入searchNodes中；如果该点的状态为正在搜索，那么说明它的所有子节点都已经搜索完毕，记录下搜索完毕时间并退栈；如果是以搜索状态，说明已经被纳入其他节点的搜索范围，直接退栈。这一步完成后我们得到了所有节点的搜索完毕时间。
接下来需要生成转置图Gt，并且按照搜索完毕时间排序节点。算法如下：
C++ 代码:
  1. struct SortingNode
  2. {
  3.     SortingNode(size_t endSearchTime, Node *pOrgNode)
  4.         : tEndSrch(endSearchTime), pNode(pOrgNode)
  5.     {}
  6.  
  7.     size_t tEndSrch;
  8.     Node *pNode;
  9. };
  10.  
  11. inline bool GreaterEndSearchTime(SortingNode const& n1, SortingNode const& n2)
  12. {
  13.     return n1.tEndSrch > n2.tEndSrch;
  14. }
  15.  
  16. void TransposeAndSortGraph(LtrlGraph& graph, LtrlGraph& transGraph)
  17. {
  18.     //Sort nodes by their end search time
  19.     vector<SortingNode> sortingNodes;
  20.     for (list<Node>::iterator itorNode = graph.nodes.begin();
  21.         itorNode != graph.nodes.end(); ++itorNode)
  22.     {
  23.         Node& node = *itorNode;
  24.         sortingNodes.push_back(SortingNode(node.tEndSrch, &node));
  25.     }
  26.     sort(sortingNodes.begin(), sortingNodes.end(), &GreaterEndSearchTime);
  27.  
  28.     //Add new nodes in the transposed graph
  29.     for (vector<SortingNode>::iterator itorSN = sortingNodes.begin();
  30.         itorSN != sortingNodes.end(); ++itorSN)
  31.     {
  32.         transGraph.nodes.push_back(*(itorSN->pNode));
  33.         itorSN->pNode->pNewNode = &transGraph.nodes.back();
  34.     }
  35.  
  36.     //Transpose the graph
  37.     for (list<Node>::iterator itorNode = graph.nodes.begin();
  38.         itorNode != graph.nodes.end(); ++itorNode)
  39.     {
  40.         Node& node = *itorNode;
  41.         for (vector<Node*>::iterator itorCnnNode = node.cnnNodes.begin();
  42.             itorCnnNode != node.cnnNodes.end(); ++itorCnnNode)
  43.         {
  44.             Node* pCnnNode = *itorCnnNode;
  45.             pCnnNode->pNewNode->cnnNodes.push_back(node.pNewNode);
  46.         }
  47.     }
  48. }
这里先使用了一个辅助排序的结构SortingNode按搜索完毕时间排序节点，然后对原图每个节点和连接节点形成的边，反转连接节点对该节点的边。
最后一步需要搜索强连通区域以及对变量赋值，同时检查是否有互非的两个literal在同一个强连通区域中。
C++ 代码:
  1. //Strongly Connected Component
  2. struct StrCnnCmpnt
  3. {
  4.     size_t rank;
  5.     std::vector<Literal> literals;
  6. };
  7.   
  8. bool FindSCCAndCheckSatisfiability(LtrlGraph& transGraph, vector<StrCnnCmpnt>& sccs)
  9. {
  10.     stack<Node*> searchNodes;
  11.     size_t strCnnCmptRank = 0;  //Lower number means higher rank
  12.     for (list<Node>::iterator itorNode = transGraph.nodes.begin();
  13.         itorNode != transGraph.nodes.end(); ++itorNode)
  14.     {
  15.         Node& node = *itorNode;
  16.         if