$BEGINCUT$
$PROBLEMDESC$
$ENDCUT$
#line $NEXTLINENUMBER$ "$FILENAME$"
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>

#include <iostream>
#include <sstream>
#include <queue>
#include <set>
#include <map>
#include <list>

#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cassert>

#include <cmath>
#include <complex>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define PB push_back
#define ALL i.begin(),i.end()
#define rALL i.rbegin(),i.rend()
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define SIZE(t) ((int)((t).size()))
class $CLASSNAME$
{
        public:
        $RC$ $METHODNAME$($METHODPARMS$)
        {
                $CARETPOSITION$
        }
        $TESTCODE$
};

// BEGIN CUT HERE
int main()
{
        $CLASSNAME$ ___test;
        ___test.run_test(-1);
        return 0;
}
// END CUT HERE

sudo tar xjvf virtualbox*.bz2

cd modules/virtualbox-ose

sudo ./build_in_tmp install

然后再重新安装virtualbox

    今天的话题是：如何在得到子进程的异常呢？？？？？众所周知，在WIN32中可以通过SEH来进行结构化异常处理。但是，如果启动的进程不是我们写的，当 然不能给他的代码强行加上_try   _catch...然后它崩掉的时候就会弹出一个华丽丽的非法操作对话框。。。然后就囧了。。。

当然，这是因为M$的__try, __expect,__final只限于处理进程内部，同一个线程内，位于 __try {}block内部产生的异常。而我们需要的是启动的新进程~！

    不知道你有没有注意过，使用vc的时候。。调试模式运行程序，它会在runtime error的时候提前弹出一个对话框提示出现访问异常~哦！我们不正是需要这个效果吗？nice，我们就仿照vc做一个调试器好了~~显然VC也是通过调用Windows API函数完成调试器的任务，而且，这些函数显然可以实现我们的要求。 我们 需要作的事情就是自己利用这些API函数，写一个简单的调试器。

    如何编写实现我们的程序？需要哪些调试函数？有两种方法。。。。

    对于一个已经启动的进程而言，利用DebugActiveProcess函数就可以捕获目标进程，将目标进程进入被调试状态。

    BOOL DebugActiveProcess(DWORD dwProcessId);

    参数dwProcessId是目标进程的进程ID。如何通过ToolHelp系列函数或Psapi库函数获得一个运行程序的进程ID在很多文章中介 绍过，这里就不再重复。对于服务器程序而言，由于没有权限无法捕获目标进程，可以通过提升监视程序的权限得到调试权限进行捕获目标进程（用户必须拥有调试 权限）。

   而另外一种就是我们做oj所需要的，CreateProcess函数，设置必要的参数就可以将目标程序进入被调试状态。

BOOL CreateProcess(LPCTSTR lpApplicationName, LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES
lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID
lpEnvironment, LPCTSTR lpCurrentDirectory, LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation );

    该函数的具体说明请参考MSDN，在这 里我仅介绍我们感兴趣的参数。这里和一般的用法不同，作为被调试程序dwCreationFlags必须设置为DEBUG_PROCESS或 DEBUG_ONLY_THIS_PROCESS。这样启动的目标程序就会进入被调试状态。这里说明一下DEBUG_PROCESS和 DEBUG_ONLY_THIS_PROCESS。DEBUG_ONLY_THIS_PROCESS就是只调试目标进程，而DEBUG_PROCESS参 数则不仅调试目标进程，而且调试由目标进程启动的所有子进程。比如：在A.exe中启动B.exe，如果用 DEBUG_ONLY_THIS_PROCESS启动，监视进程只调试A.exe不会调试B.exe，如果是DEBUG_PROCESS就会调试 A.exe和B.exe。 当然，我们是做oj,不允许用户使用多进程，所以我们只讨论启动参数为DEBUG_ONLY_THIS_PROCESS的情况。

一个小例子：

    STARTUPINFO si;   
    PROCESS_INFORMATION pi;   
    si.cb = sizeof(STARTUPINFO);   
    GetStartupInfo(&si);   
    si.wShowWindow = SW_HIDE;   
    si.dwFlags = STARTF_USESHOWWINDOW |STARTF_USESTDHANDLES;   
    char *Dir = "d:\\1.exe";     //这个程序是一个除零的程序。
    if(!CreateProcess(NULL,Dir,NULL,NULL,TRUE,DEBUG_ONLY_THIS_PROCESS,NULL,NULL,&si,&pi))
    {   
            cout<<"Error on CreateProcess()";   
            return;   
    }

    如果你直接运行上面的代码，毫无疑问还是会崩掉。。。。我们需要的是捕获异常~~~

    当目标进程进入了被调试状态，调试程序 （这里调试程序就是我们的主程序）就负责对被调试的程序进行调试操作的调度。调试程序通过WaitForDebugEvent函数获得来 自被调试程序的调试消息，调试程序根据得到的调试消息进行处理，被调试进程将暂停操作，直到调试程序通过ContinueDebugEvent函数通知被 调试程序继续运行。当然，我们不需要continue了，因为这时候直接给用户返回RE，然后kill掉它就好了。。。。

BOOL WaitForDebugEvent(
LPDEBUG_EVENT lpDebugEvent, // debug event information
DWORD dwMilliseconds         // time-out value
);

在参数lpDebugEvent中可以获得调试消息，需要注意的是该函数必须和让目标程序进入调试状态的线程是同一线程。也就是说和CreateProcess调用的线程是一个线程。

DEBUG_EVENT会保存子进程的调试信息。

typedef struct _DEBUG_EVENT {
DWORD dwDebugEventCode;
DWORD dwProcessId;
DWORD dwThreadId;
union {
        EXCEPTION_DEBUG_INFO Exception;
    CREATE_THRECheck the input
        System.out.println("\nREQUEST:\n");
        message.writeTo(System.out);
        System.out.println();
         //Close the connection           
         connection.close();
        } catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

其中我们关心的是union中的 Exception,这里保存这异常调试信息~~~它的ExceptionCode常用的以下取值：

EXCEPTION_INT_DIVIDE_BY_ZERO

EXCEPTION_INT_OVERFLOW

EXCEPTION_ACCESS_VIOLATION

EXCEPTION_DATATYPE_MISALIGNMENT

EXCEPTION_FLT_STACK_CHECK

EXCEPTION_INVALID_DISPOSITION

EXCEPTION_STACK_OVERFLOW

是不是感觉很熟悉啊~~~呵呵~~~~~~~

于是有了上面的这些东西，我们似乎就可以完成我们的程序了~~！！！之前还需要注意一点，无论子进程正确与否，总是要先抛出EXCEPTION_BREAKPOINT 异常，然后再弹出其他异常

所以，我们不能在抛出EXCEPTION_BREAKPOINT 异常的时候结束进程，还需要等待抛出第二个异常的时候，得到真正的异常信息。

下面给出测试代码：

这个程序可以捕获子进程的任何异常，并提示，而且子进程不会出现讨厌的对话框。。。。太久不写代码了。。。。写得很难看。。将就一下。。。

//by c4pt0r~~~~任意转载~~随意转载~~

#include <iostream>
#include<windows.h>
using namespace std;
int main()
{
    STARTUPINFO si;   
    PROCESS_INFORMATION pi;   
    si.cb = sizeof(STARTUPINFO);   
    GetStartupInfo(&si);   
    si.wShowWindow = SW_HIDE;   
    si.dwFlags = STARTF_USESHOWWINDOW |STARTF_USESTDHANDLES;   
    char *Dir = "d:\\1.exe";
    if(!CreateProcess(NULL,Dir,NULL,NULL,TRUE,DEBUG_ONLY_THIS_PROCESS,NULL,NULL,&si,&pi))
    {   
            printf("Error on CreateProcess()");   
            return;   
    }   
    DEBUG_EVENT de;
    while (WaitForDebugEvent(&de,INFINITE)!=0)
    {
        if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
                printf("create\n");
        if (de.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
        {
                switch   (de.u.Exception.ExceptionRecord.ExceptionCode)
                {
                    case   EXCEPTION_INT_DIVIDE_BY_ZERO:
                           printf("zero\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                    case   EXCEPTION_INT_OVERFLOW:
                           printf("INT\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                   case   EXCEPTION_ACCESS_VIOLATION:
                           printf("ACCESS\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                    case   EXCEPTION_DATATYPE_MISALIGNMENT:
                           printf("DATATYPE\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                    case   EXCEPTION_FLT_STACK_CHECK:
                           printf("DATATYPE\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                    case   EXCEPTION_INVALID_DISPOSITION:
                           printf("DISPOSITION\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                    case   EXCEPTION_STACK_OVERFLOW:
                           printf("OVERFLOW\n");
                           TerminateProcess(pi.hProcess,1);
                           break;
                     default:
                            printf("exception\n");
                    }   
        }
        if   (de.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
        {
                  printf("exit\n");
                break;
        }
        ContinueDebugEvent(pi.dwProcessId,pi.dwThreadId,DBG_CONTINUE);
    }  
}

   上面的理论是很简单的，接下来就到关键的了，如何使得两个内网的ip互相通讯呢？现在我们有Client A和Client B两个内网用户。直接通讯是不可能的，因为互相都不可能知道NAT分配的端口，那该如何是好呢？很好，我们需要添加一个中转的Server C。。有点类似目录服务器。。。。。首先Client A向Server C发送连接请求，也就是向Server C方向打个洞，Server C将记录Client A的外网ip和端口，然后通知Client B，Client B是不是这个时候就可以通过这个地址肆无忌惮的向Client A发信息了呢？答案是否定的。。。。。基于安全方面的因素，Client A的NAT一般会丢弃这样的包。。。。那该如何是好呢？？？？？？那好，我们可以让Client A往Client B的NAT方向打洞。。。具体是这样的，Server C通知Client A，告诉他Client B的外网地址和端口，然后Client A向这个地址发送一个打洞包，发送完毕后，Client B就可以通过从Server C那里拿到的地址肆无忌惮的给Client A发东西了。。。。

     大概就是这个意思。。。最最通俗的语言了。看不懂我就没办法了。。。。。。以前高中的时候写过一份代码，现在估计一时半会写不出来了。。。。老了。。。。囧。。。。。。

/*
written by c4pt0r
for studing WaitForMultipleObjects
*/

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

DWORD WINAPI ThreadFunc(LPVOID);

#define THREAD_POOL_SIZE 3
#define MAX_THREAD_INDEX THREAD_POOL_SIZE-1
#define NUM_TASK 6

int main()
{
HANDLE hThread[THREAD_POOL_SIZE];
int slot=0;
DWORD threadID;
int i;
DWORD exitcode;

for (i=1;i<=NUM_TASK;i++)
{
   if (i > THREAD_POOL_SIZE) //if the number of the running thread is more than the pool size,then we wait
   {
    int rc=WaitForMultipleObjects(THREAD_POOL_SIZE,hThread,false,INFINITE);
    slot=rc - WAIT_OBJECT_0 ;
    printf("slot %d terminated!\n",slot);

   }
   hThread[slot++]=CreateThread(NULL,0,ThreadFunc,(LPVOID)slot,NULL,&threadID);
   printf("Launch %d \n",slot);
  
}
WaitForMultipleObjects(THREAD_POOL_SIZE,hThread,true,INFINITE); //the main thread,wait for every thread

for (slot=0 ; slot<THREAD_POOL_SIZE ; slot++)  
   CloseHandle(hThread[slot]);
printf("All thread terminated!\n");
return EXIT_SUCCESS;
}

DWORD WINAPI ThreadFunc(LPVOID n)
{
srand(GetTickCount());
Sleep((rand()%8*500)+500);
printf("Slot %d idle\n",n);
return (DWORD)n;

}

只二分i以前的字符串~~~

#include <iostream>
#include <cstring>
#define MAXX 25000
using namespace std;
char dict[MAXX][20];
char CH[]={'z','z','a'};
void add(char *src,int k,char ch,char *res)
{
 int i;
 for(i=0;i<k;i++) res[i]=src[i];
 res[k]=ch;
 for(i=k;src[i];i++) res[i+1]=src[i];
 res[i+1]='\0';
 return;
}
void change(char *src,int k,char ch,char *res)
{
 int i;
 for(i=0;src[i];i++) res[i]=src[i];
 res[k]=ch;
 res[i]='\0';
}
void del(char *src,int k,char *res)
{
 int i;
 for(i=0;i<k;i++) res[i]=src[i];
 for(i=k+1;src[i];i++) res[i-1]=src[i];
 res[i-1]='\0';
 return;
}
void edit(char *src,int k,char ch,char *res,int type)
{
 switch(type)
 {
 case 0:
  add(src,k,ch,res);
  break;
 case 1:
  change(src,k,ch,res);
  break;
 case 2:
  del(src,k,res);
  break;
 }
 return ;
}

int bsearch(char *str,int n)
{
 int l=0,r=n-1,mid,k;
 if(l>r) return -1;
 while(l<=r)
 {
  mid=(l+r)/2;
  k=strcmp(dict[mid],str);
  if(k==0) return mid;
  if(k>0) r=mid-1;
  else l=mid+1;
 }
 return -1;

}
int main()
{
 int n=0;
 int f[MAXX]={0};
 int maxx=1;
 int i,j,k,z;
 while(scanf("%s",dict[n])!=EOF)
  n++;
 f[0]=1;
 for(i=0;i<n;i++)
 {
  f[i]=1;
  for(j=0;j<3;j++)   //3种变换~~~~
  {
   for(k=0;dict[i][k];k++)
   {
    char tmp[20];
    int resi;
       for(int ch='a';ch<=CH[j];ch++)
    {
       edit(dict[i],k,ch,tmp,j);
        
       if(strcmp(tmp,dict[i])>=0) break;
       resi=bsearch(tmp,n);
        
       if(resi>=0 && f[i]<f[resi]+1)
       {
        f[i]=f[resi]+1;
        if(maxx<f[i]) maxx=f[i];
       }
    }
   }
  }
 }
 printf("%d\n",maxx);
 
}

#define MAXN 100
#define inf 1000000000

int max_flow(int n,int mat[][MAXN],int source,int sink,int flow[][MAXN]){
int pre[MAXN],que[MAXN],d[MAXN],p,q,t,i,j;
if (source==sink) return inf;
for (i=0;i<n;i++)
   for (j=0;j<n;flow[i][j++]=0);
for (;;){
   for (i=0;i<n;pre[i++]=0);
   pre[t=source]=source+1,d[t]=inf;
   for (p=q=0;p<=q&&!pre[sink];t=que[p++])
    for (i=0;i<n;i++)
     if (!pre[i]&&j=mat[t][i]-flow[t][i])
      pre[que[q++]=i]=t+1,d[i]=d[t]<j?d[t]:j;
     else if (!pre[i]&&j=flow[i][t])
      pre[que[q++]=i]=-t-1,d[i]=d[t]<j?d[t]:j;
   if (!pre[sink]) break;
   for (i=sink;i!=source;)
    if (pre[i]>0)
     flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
    else
     flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
}
for (j=i=0;i<n;j+=flow[source][i++]);
return j;
}

最小费用最大流

//求网络最小费用最大流,邻接阵形式
//返回最大流量,flow返回每条边的流量,netcost返回总费用
//传入网络节点数n,容量mat,单位费用cost,源点source,汇点sink

#define MAXN 100
#define inf 1000000000

int min_cost_max_flow(int n,int mat[][MAXN],int cost[][MAXN],int source,int sink,int flow[][MAXN],int& netcost){
int pre[MAXN],min[MAXN],d[MAXN],i,j,t,tag;
if (source==sink) return inf;
for (i=0;i<n;i++)
   for (j=0;j<n;flow[i][j++]=0);
for (netcost=0;;){
   for (i=0;i<n;i++)
    pre[i]=0,min[i]=inf;
   //通过bellman_ford寻找最短路，即最小费用可改进路
   for (pre[source]=source+1,min[source]=0,d[source]=inf,tag=1;tag;)
    for (tag=t=0;t<n;t++)
     if (d[t])
      for (i=0;i<n;i++)
       if (j=mat[t][i]-flow[t][i]&&min[t]+cost[t][i]<min[i])
        tag=1,min[i]=min[t]+cost[t][i],pre[i]=t+1,d[i]=d[t]<j?d[t]:j;
       else if (j=flow[i][t]&&min[t]<inf&&min[t]-cost[i][t]<min[i])
        tag=1,min[i]=min[t]-cost[i][t],pre[i]=-t-1,d[i]=d[t]<j?d[t]:j;
   if (!pre[sink]) break;
   for (netcost+=min[sink]*d[i=sink];i!=source;)
    if (pre[i]>0)
     flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
    else
     flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
}
for (j=i=0;i<n;j+=flow[source][i++]);
return j;
}

//求上下界网络最小流,邻接阵形式
//返回最大流量,-1表示无可行流,flow返回每条边的流量
//传入网络节点数n,容量mat,流量下界bf,源点source,汇点sink
//MAXN应比最大结点数多2,无可行流返回-1时mat未复原!

#define MAXN 100
#define inf 1000000000

void _max_flow(int n,int mat[][MAXN],int source,int sink,int flow[][MAXN]){
int pre[MAXN],que[MAXN],d[MAXN],p,q,t,i,j;
for (;;){
   for (i=0;i<n;pre[i++]=0);
   pre[t=source]=source+1,d[t]=inf;
   for (p=q=0;p<=q&&!pre[sink];t=que[p++])
    for (i=0;i<n;i++)
     if (!pre[i]&&j=mat[t][i]-flow[t][i])
      pre[que[q++]=i]=t+1,d[i]=d[t]<j?d[t]:j;
     else if (!pre[i]&&j=flow[i][t])
      pre[que[q++]=i]=-t-1,d[i]=d[t]<j?d[t]:j;
   if (!pre[sink]) break;
   for (i=sink;i!=source;)
    if (pre[i]>0)
     flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
    else
     flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
}
}

int limit_min_flow(int n,int mat[][MAXN],int bf[][MAXN],int source,int sink,int flow[][MAXN]){
int i,j,sk,ks;
if (source==sink) return inf;
for (mat[n][n+1]=mat[n+1][n]=mat[n][n]=mat[n+1][n+1]=i=0;i<n;i++)
   for (mat[n][i]=mat[i][n]=mat[n+1][i]=mat[i][n+1]=j=0;j<n;j++)
    mat[i][j]-=bf[i][j],mat[n][i]+=bf[j][i],mat[i][n+1]+=bf[i][j];
sk=mat[source][sink],ks=mat[sink][source],mat[source][sink]=mat[sink][source]=inf;
for (i=0;i<n+2;i++)
   for (j=0;j<n+2;flow[i][j++]=0);
_max_flow(n+2,mat,n,n+1,flow);
for (i=0;i<n;i++)
   if (flow[n][i]<mat[n][i]) return -1;
flow[source][sink]=flow[sink][source]=0,mat[source][sink]=sk,mat[sink][source]=ks;
_max_flow(n,mat,sink,source,flow);
for (i=0;i<n;i++)
   for (j=0;j<n;j++)
    mat[i][j]+=bf[i][j],flow[i][j]+=bf[i][j];
for (j=i=0;i<n;j+=flow[source][i++]);
return j;
}

//求上下界网络最大流,邻接阵形式
//返回最大流量,-1表示无可行流,flow返回每条边的流量
//传入网络节点数n,容量mat,流量下界bf,源点source,汇点sink
//MAXN应比最大结点数多2,无可行流返回-1时mat未复原!

#define MAXN 100
#define inf 1000000000

void _max_flow(int n,int mat[][MAXN],int source,int sink,int flow[][MAXN]){
int pre[MAXN],que[MAXN],d[MAXN],p,q,t,i,j;
for (;;){
   for (i=0;i<n;pre[i++]=0);
   pre[t=source]=source+1,d[t]=inf;
   for (p=q=0;p<=q&&!pre[sink];t=que[p++])
    for (i=0;i<n;i++)
     if (!pre[i]&&j=mat[t][i]-flow[t][i])
      pre[que[q++]=i]=t+1,d[i]=d[t]<j?d[t]:j;
     else if (!pre[i]&&j=flow[i][t])
      pre[que[q++]=i]=-t-1,d[i]=d[t]<j?d[t]:j;
   if (!pre[sink]) break;
   for (i=sink;i!=source;)
    if (pre[i]>0)
     flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
    else
     flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
}
}

int limit_max_flow(int n,int mat[][MAXN],int bf[][MAXN],int source,int sink,int flow[][MAXN]){
int i,j,sk,ks;
if (source==sink) return inf;
for (mat[n][n+1]=mat[n+1][n]=mat[n][n]=mat[n+1][n+1]=i=0;i<n;i++)
   for (mat[n][i]=mat[i][n]=mat[n+1][i]=mat[i][n+1]=j=0;j<n;j++)
    mat[i][j]-=bf[i][j],mat[n][i]+=bf[j][i],mat[i][n+1]+=bf[i][j];
sk=mat[source][sink],ks=mat[sink][source],mat[source][sink]=mat[sink][source]=inf;
for (i=0;i<n+2;i++)
   for (j=0;j<n+2;flow[i][j++]=0);
_max_flow(n+2,mat,n,n+1,flow);
for (i=0;i<n;i++)
   if (flow[n][i]<mat[n][i]) return -1;
flow[source][sink]=flow[sink][source]=0,mat[source][sink]=sk,mat[sink][source]=ks;
_max_flow(n,mat,source,sink,flow);
for (i=0;i<n;i++)
   for (j=0;j<n;j++)
    mat[i][j]+=bf[i][j],flow[i][j]+=bf[i][j];
for (j=i=0;i<n;j+=flow[source][i++]);
return j;
}