int d(int mat[], int i, int j, int n, int m) {
int mn = m * n;
int iter;
int ans = 0;
int c;
if (mat[i * m + j] == 1) {
return 0;
}
int mark[34225];
for (iter = 0; iter < 34225; iter++) {
mark[iter] = 0;
}
struct Queue* Q = Queue_Create();
Queue_Enqueue(Q, i * m + j);
Queue_Enqueue(Q, -1);
mark[i * m + j] += 1;
while (1) {
c = Queue_Dequeue(Q);
if (c == -1) {
Queue_Enqueue(Q, -1);
ans += 1;
continue;
}
if ((c % m) && (!mark[c - 1])) {
if (mat[c - 1] == 1) {
return ans + 1;
}
Queue_Enqueue(Q, c - 1);
mark[c - 1] += 1;
}
if (((c + 1) % m) && (!mark[c + 1])) {
if (mat[c + 1] == 1) {
return ans + 1;
}
Queue_Enqueue(Q, c + 1);
mark[c + 1] += 1;
}
if (((0 <= (c + m)) && ((c + m) < mn)) && (!mark[c + m])) {
if (mat[c + m] == 1) {
return ans + 1;
}
Queue_Enqueue(Q, c + m);
mark[c + m] += 1;
}
if (((0 <= (c - m)) && ((c - m) < mn)) && (!mark[c - m])) {
if (mat[c - m] == 1) {
return ans + 1;
}
Queue_Enqueue(Q, c - m);
mark[c - m] += 1;
}
}
}
/*******************************************************************************
* @函数名称 Init_Timer_Cnt
* @函数说明 给全局计数器清零
* @输入参数 无
* @输出参数 无
* @返回参数 无
*******************************************************************************/
void Init_Timer_Cnt(void)
{
Pile_State.Open_Flag = 1;
Pile_State.Close_Flag = true;
Pcak_Pile_State_All_Flag = 0;
Can1_Rev_Flag = false;
debug = 0;
log_w = 0;
Stitic_Time_Cnt = 0;
Queue_Create(&Q_dir,Q_DIR);
//Flash_Read_Inside(PROG_DATA_ADDR,Only_ID,12);
//static uint8_t buf[20] = {'0','1','2','3','4','5','6','7','8','9','10','11'};
//at24cxx_write(0, buf, 12);
eep_read(0, Only_ID, 12); /* read only ID */
/* RTC 判断时间是否合法 */
if(!RTC_IsTimeValid())
{
RTC_DateTime_Type td = {0};
td.year = 2011;
td.month = 11;
td.day = 11;
td.hour = 11;
td.minute = 11;
td.second = 11;
RTC_SetTime(&td);
}
#if DEBUG
RTC_DateTime_Type td = {0};
RTC_GetTime(&td);
printf("first:%d-%d-%d %d:%d:%d\r\n", td.year, td.month, td.day, td.hour, td.minute, td.second);
/* 设置闹钟在当前3秒后 */
/*
RTC_GetTime(&td);
td.second += 3;
RTC_SetAlarm(&td);
*/
#endif
}
/* ss_sendfiles:
Send a response naming the data pipe, collect further names
from further client messages, all according to the protocol above.
Start the data pipe and arrange that all the files are sent
by getting them all enqueued on the first queue.
Destroy PackQueue at the end. Arrange for the other queues
to be destroyed by the usual Queue mechanism, or destroy them
explicitly if they never get started.
*/
BOOL
ss_sendfiles(HANDLE hPipe, long lVersion)
{ /* Create the queues and set about filling the first one */
QUEUE PackQueue, ReadQueue, SendQueue;
#ifdef SOCKETS
SOCKET hpSend;
static BOOL SocketsInitialized = FALSE;
#else
HANDLE hpSend; /* the data pipe */
#endif /* SOCKETS */
char PipeName[80]; /* The name of the new data pipe */
BOOL Started = FALSE; /* TRUE if something enqueued */
#ifdef SOCKETS
if( !SocketsInitialized )
{
WSADATA WSAData;
if( ( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) ) == 0 )
{
SocketsInitialized = TRUE;
}
else
{
printf("WSAStartup failed");
}
}
#endif
{
/****************************************
We need security attributes for the pipe to let anyone other than the
current user log on to it.
***************************************/
/* Allocate DWORDs for the ACL to get them aligned. Round up to next DWORD above */
DWORD Acl[(sizeof(ACL)+sizeof(ACCESS_ALLOWED_ACE)+3)/4+4]; // + 4 by experiment!!
SECURITY_DESCRIPTOR sd;
PSECURITY_DESCRIPTOR psd = &sd;
PSID psid;
SID_IDENTIFIER_AUTHORITY SidWorld = SECURITY_WORLD_SID_AUTHORITY;
PACL pacl = (PACL)(&(Acl[0]));
SECURITY_ATTRIBUTES sa;
BOOL brc;
DWORD lasterr;
if (!AllocateAndInitializeSid( &SidWorld, 1, SECURITY_WORLD_RID
, 1, 2, 3, 4, 5, 6, 7
, &psid
)
) {
Error("AllocateAndInitializeSid");
return FALSE;
}
if (!InitializeAcl(pacl, sizeof(Acl), ACL_REVISION)){
Error("InitializeAcl");
return FALSE;
}
if (!AddAccessAllowedAce(pacl, ACL_REVISION, GENERIC_WRITE|GENERIC_READ, psid)){
Error("AddAccessAllowedAce");
return FALSE;
}
if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION)){
Error("InitializeSecurityDescriptor");
return FALSE;
}
if (!SetSecurityDescriptorDacl(psd, TRUE, pacl, FALSE)){
Error("SetSecurityDescriptorDacl");
return FALSE;
}
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = psd;
sa.bInheritHandle = TRUE;
/* We now have a good security descriptor! */
/* Create the (new, unique) name of the pipe and then create the pipe */
/* I am finding it hard to decide whether the following line (++PpipeCount)
actually needs a critical section or not. The worst that could happen
would be that we got an attempt to create a pipe with an existing name.
*/
++PipeCount;
sprintf(PipeName, "\\\\.\\pipe\\%s%d", PIPEPREFIX, PipeCount);
#ifdef SOCKETS
if (!ss_sendnewresp( hPipe, SS_VERSION, SSRESP_PIPENAME
, 0, 0, 0, TCPPORT, "")) {
dprintf1(( "Failed to send response on pipe %x naming new pipe.\n"
, hPipe));
return FALSE; /* Caller will close hPipe */
}
if( !SocketListen( TCPPORT, &hpSend ) )
{
dprintf1(("Could not create socket\n"));
return FALSE;
}
FreeSid(psid);
#else
hpSend = CreateNamedPipe(PipeName, /* pipe name */
PIPE_ACCESS_DUPLEX, /* both read and write */
PIPE_WAIT|PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE,
1, /* at most one instance */
10000, /* sizeof(SSNEWPACK) + some for luck */
0, /* dynamic inbound buffer allocation */
5000, /* def. timeout 5 seconds */
&sa /* security descriptor */
);
FreeSid(psid);
if (hpSend == INVALID_HANDLE_VALUE) {
dprintf1(("Could not create named data pipe\n"));
return FALSE;
}
dprintf1(("Data pipe %x called '%s' created for main pipe %x.\n", hpSend, PipeName, hPipe));
#endif /* SOCKETS */
}
/* Send the response which names the data pipe */
#ifndef SOCKETS
if (!ss_sendnewresp( hPipe, SS_VERSION, SSRESP_PIPENAME
, 0, 0, 0, 0, PipeName)) {
dprintf1(( "Failed to send response on pipe %x naming new pipe.\n"
, hPipe));
CLOSEHANDLE(hpSend);
return FALSE; /* Caller will close hPipe */
}
if (!ConnectNamedPipe(hpSend, NULL)) {
CLOSEHANDLE(hpSend);
return FALSE;
}
#endif /* NOT SOCKETS */
//dprintf1(("Client connected to data pipe -- here we go...\n"));
/* Create all the queues: Allow up to 10K file names to be queued
up to 10 files to be packed in advance and 6 buffers of data to be
read into main storage in advance:
proc MxMT MnQS MxQ Event InstData Name*/
SendQueue = Queue_Create(SendData, 1, 0, 6, NULL, (DWORD)hpSend, "SendQueue");
ReadQueue = Queue_Create(ReadInFile, 1, 0, 10, NULL, (DWORD)SendQueue, "ReadQueue");
PackQueue = Queue_Create(PackFile, 3, 0, 99999, NULL, (DWORD)ReadQueue, "PackQueue");
/* Abort unless it all worked */
if (PackQueue==NULL || ReadQueue==NULL || SendQueue==NULL) {
dprintf1(("Queues for pipe %x failed to Create. Aborting...\n", hPipe));
if (PackQueue) Queue_Destroy(PackQueue);
if (ReadQueue) Queue_Destroy(ReadQueue);
if (SendQueue) Queue_Destroy(SendQueue);
CLOSEHANDLE(hpSend);
return FALSE; /* Caller will close hPipe */
}
/* Collect names from client and enqueue each one */
for (; ; )
{ SSNEWREQ Request; /* message from client */
DWORD ActSize; /* bytes read from (main) pipe */
if (ReadFile(hPipe, &Request, sizeof(Request), &ActSize, NULL)){
if (Request.lVersion>SS_VERSION) {
dprintf1(("Bad version %d in file list request on pipe %x\n"
, Request.lVersion, hPipe));
break;
}
if (Request.lRequest!=LREQUEST) {
dprintf1(("Bad LREQUEST from pipe %x\n", hPipe));
break;
}
if (Request.lCode == -SSREQ_ENDFILES) {
dprintf1(("End of client's files list on pipe %x\n", hPipe));
/* This is the clean way to end */
Queue_Destroy(PackQueue);
if (!Started) {
/* OK - so the clever clogs requested zero files */
Queue_Destroy(ReadQueue);
Queue_Destroy(SendQueue);
/* Send a No More Files response */
#ifdef SOCKETS
{
SSNEWRESP resp;
resp.lVersion = SS_VERSION;
resp.lResponse = LRESPONSE;
resp.lCode = SSRESP_END;
resp.ulSize = 0;
resp.ulSum = 0;
resp.ft_lastwrite.dwLowDateTime = 0;
resp.ft_lastwrite.dwHighDateTime = 0;
send(hpSend, (PSTR) &resp, sizeof(resp), 0);
}
#else
ss_sendnewresp( hpSend, SS_VERSION, SSRESP_END
, 0,0, 0,0, NULL);
#endif /* SOCKETS */
CLOSEHANDLE(hpSend);
}
return TRUE;
}
if (Request.lCode != -SSREQ_NEXTFILE) {
dprintf1(( "Bad code (%d) in files list from pipe %x\n"
, Request.lCode, hPipe));
break;
}
}
else { DWORD errorcode = GetLastError();
switch(errorcode) {
case ERROR_NO_DATA:
case ERROR_BROKEN_PIPE:
/* pipe connection lost - forget it */
dprintf1(("main pipe %x broken on read\n", hPipe));
break;
default:
dprintf1(("read error %d on main pipe %x\n", errorcode, hPipe));
break;
}
break;
}
if (!EnqueueName( PackQueue, Request.szPath
, (UINT)((LPBYTE)(&Request) + ActSize - (LPBYTE)(&Request.szPath))
)
){
break;
}
Started = TRUE;
} /* loop */
/* only exit this way on error */
/* Close the queues down. Allow what's in them to run through */
Queue_Destroy(PackQueue);
if (!Started) {
Queue_Destroy(ReadQueue);
Queue_Destroy(SendQueue);
}
return FALSE;
} /* ss_sendfiles */
