coreBugZJ
coreBugZJ

EOJ 1780 Escape

EOJ 1780 Escape

/**/ /*
EOJ 1780 Escape


----问题描述：

You find yourself trapped in a large rectangular room, made up of large square tiles; some
are accessible, others are blocked by obstacles or walls. With a single step, you can move
from one tile to another tile if it is horizontally or vertically adjacent (i.e. you cannot move
diagonally).
To shake off any people following you, you do not want to move in a straight line. In fact,
you want to take a turn at every opportunity, never moving in any single direction longer
than strictly necessary. This means that if, for example, you enter a tile from the south,
you will turn either left or right, leaving to the west or the east. Only if both directions
are blocked, will you move on straight ahead. You never turn around and go back!
Given a map of the room and your starting location, figure out how long it will take you
to escape (that is: reach the edge of the room).


----输入：

On the first line an integer t (1 <= t <= 100): the number of test cases. Then for each test
case:
1. a line with two integers separated by a space, h and w (1 <= h,w <= 80), the height
and width of the room;
2. then h lines, each containing w characters, describing the room. Each character is one
of . (period; an accessible space), # (a blocked space) or @ (your starting location).
There will be exactly one @ character in each room description.


----输出：

For each test case:
1. A line with an integer: the minimal number of steps necessary to reach the edge of
the room, or -1 if no escape is possible.


----样例输入：

2
9 13
#############
#@.#
#####.#.#.#.#
#..#
#.#.#.#.#.#.#
#.#.#.#
#.#.#.#.#.#.#
#..#
#####.#######
4 6
#.####
#.#.##
#@#
######


----样例输出：

31
-1


----分析：

搜索即可，只是注意扩展方式，左或右可以时，不可向前。

*/



/**/ /**********************************************************
版本五：
AC 0MS
SPFA 求最短路。
出口不止一个，边界上的可达点都是出口。
*/

#include  < stdio.h >
#include  < string .h >


#define   L    89
#define   INF  0x3f3f3f3f

#define   CAN   '.'


#define   T  4
int  di[]  =   { -1, 0, 1, 0 } ;
 int  dj[]  =   { 0, 1, 0, -1 } ;


 int   h, w;
 int   srcI, srcJ, dstI, dstJ;
 char  map[ L ][ L ];

 int  spfa()  {
#define  QL  (L*L*T)
        static int queI[ QL ], queJ[ QL ], queD[ QL ], inq[ L ][ L ][ T ], dist[ L ][ L ][ T ];
        int qh = 0, qt = 0, i, j, d, chg, ni, nj, nd, ans;
        memset( dist, 0x3f, sizeof(dist) );
        memset( inq,  0,    sizeof(inq)  );
        for ( i = 0; i < T; ++i ) {
                queI[ qt ] = srcI;
                queJ[ qt ] = srcJ;
                queD[ qt ] = i;
                inq[ srcI ][ srcJ ][ i ] = 1;
                dist[ srcI ][ srcJ ][ i ] = 0;
                qt = (qt + 1) % QL;
        }
        while ( qh != qt ) {
                i = queI[ qh ];
                j = queJ[ qh ];
                d = queD[ qh ];
                inq[ i ][ j ][ d ] = 0;
                qh = (qh + 1) % QL;

                chg = 0;

#define  UPDATE if ( dist[ i ][ j ][ d ] + 1 < dist[ ni ][ nj ][ nd ] ) { \
                        dist[ ni ][ nj ][ nd ] = dist[ i ][ j ][ d ] + 1; \
                        if ( ! inq[ ni ][ nj ][ nd ] ) { \
                                inq[ ni ][ nj ][ nd ] = 1; \
                                queI[ qt ] = ni; \
                                queJ[ qt ] = nj; \
                                queD[ qt ] = nd; \
                                qt = (qt + 1) % QL; \
                        } \
                }
                
#define  MOD    ni = i + di[ nd ]; \
                nj = j + dj[ nd ]; \
                if ( CAN == map[ ni ][ nj ] ) { \
                        chg = 1; \
                        UPDATE \
                }

                nd = (d + 1) % T;
                MOD

                nd = (d + T - 1) % T;
                MOD

                if ( 0 == chg ) {
                        nd = d;
                        MOD
                }
        }

#define   UPANS \
         for  ( d  =   0 ; d  <  T;  ++ d )  { \
                if ( ans > dist[ dstI ][ dstJ ][ d ] ) { \
                        ans = dist[ dstI ][ dstJ ][ d ]; \
                } \
        }

        ans  =  INF;
         for  ( j  =   1 ; j  <=  w;  ++ j )  {
                if ( '.' == map[ 1 ][ j ] ) {
                        dstI = 1;
                        dstJ = j;
                        UPANS
                }
                if ( '.' == map[ h ][ j ] ) {
                        dstI = h;
                        dstJ = j;
                        UPANS
                }
        }
         for  ( i  =   1 ; i  <=  h;  ++ i )  {
                if ( '.' == map[ i ][ 1 ] ) {
                        dstI = i;
                        dstJ = 1;
                        UPANS
                }
                if ( '.' == map[ i ][ w ] ) {
                        dstI = i;
                        dstJ = w;
                        UPANS
                }
        }

         if  ( INF  ==  ans )  {
                ans = -1;
        }
         return  ans;
}

 int  main()  {
        int td;
        int i, j;
        scanf( "%d", &td );
        while ( td-- > 0 ) {
                scanf( "%d%d", &h, &w );
                gets( map[ 0 ] );
                memset( map, '#', sizeof(map) );
                for ( i = 1; i <= h; ++i ) {
                        gets( map[ i ] + 1 );
                        for ( j = 1; j <= w; ++j ) {
                                if ( '@' == map[ i ][ j ] ) {
                                        srcI = i;
                                        srcJ = j;
                                        map[ i ][ j ] = '.';
                                }
                        }
                }

                printf( "%d\n", spfa() );
        }
        return 0;
}


/**/ /**********************************************************
版本四：
WA
发现之前对 “You never turn around and go back!”理解有误，只是不能后退而已。
宽度优先搜索。

*/
/**/ /*
#include <stdio.h>
#include <string.h>


#define  L    89
#define  INF  0x3f3f3f3f

#define  CAN   '.'


#define  T  4
int di[] = { -1, 0, 1, 0 };
int dj[] = { 0, 1, 0, -1 };


int  h, w;
int  srcI, srcJ, dstI, dstJ;
char map[ L ][ L ];

int bfs() {
#define  QL  (L*L*T)
        static int queI[ QL ], queJ[ QL ], queD[ QL ], inq[ L ][ L ][ T ], dist[ L ][ L ][ T ];
        int qh = 0, qt = 0, i, j, d, chg, ni, nj, nd, ans;
        memset( dist, 0x3f, sizeof(dist) );
        memset( inq,  0,    sizeof(inq)  );
        i = srcI;
        j = srcJ;
        for ( nd = 0; nd < T; ++nd ) {
                ni = i + di[ nd ];
                nj = j + dj[ nd ];
                if ( CAN == map[ ni ][ nj ] ) {
                        queI[ qt ] = ni;
                        queJ[ qt ] = nj;
                        queD[ qt ] = nd;
                        inq[ ni ][ nj ][ nd ] = 1;
                        dist[ ni ][ nj ][ nd ] = 1;
                        ++qt;
                }
        }
        while ( qh != qt ) {
                i = queI[ qh ];
                j = queJ[ qh ];
                d = queD[ qh ];
                ++qh;

                chg = 0;

#define  UPDATE do { \
                        dist[ ni ][ nj ][ nd ] = dist[ i ][ j ][ d ] + 1; \
                        inq[ ni ][ nj ][ nd ] = 1; \
                        queI[ qt ] = ni; \
                        queJ[ qt ] = nj; \
                        queD[ qt ] = nd; \
                        ++qt; \
                } while (0)

#define  MOD    do { \
                        ni = i + di[ nd ]; \
                        nj = j + dj[ nd ]; \
                        if ( CAN == map[ni][nj] ) { \
                                chg = 1; \
                                if ( ! inq[ni][nj][nd] ) { \
                                        UPDATE; \
                                } \
                        } \
                } while (0)

                nd = (d + 1) % T;
                MOD;

                nd = (d + T - 1) % T;
                MOD;

                if ( 0 == chg ) {
                        nd = d;
                        MOD;
                }
        }

        ans = dist[ dstI ][ dstJ ][ 0 ];
        for ( d = 1; d < T; ++d ) {
                if ( ans > dist[ dstI ][ dstJ ][ d ] ) {
                        ans = dist[ dstI ][ dstJ ][ d ];
                }
        }
        if ( INF == ans ) {
                ans = -1;
        }
        return ans;
}

int solve() {
        if ( (srcI == dstI) && (srcJ == dstJ) ) {
                return 0;
        }
        return bfs();
}

int main() {
        int td;
        int i, j;
        scanf( "%d", &td );
        while ( td-- > 0 ) {
                scanf( "%d%d", &h, &w );
                gets( map[ 0 ] );
                memset( map, '#', sizeof(map) );
                for ( i = 1; i <= h; ++i ) {
                        gets( map[ i ] + 1 );
                        map[ i ][ w+1 ] = '#';
                        for ( j = 1; j <= w; ++j ) {
                                if ( '@' == map[ i ][ j ] ) {
                                        srcI = i;
                                        srcJ = j;
                                        map[ i ][ j ] = '.';
                                }
                        }
                }
                dstI = -1;
                for ( j = 1; (0 > dstI) && (j <= w); ++j ) {
                        if ( '.' == map[ 1 ][ j ] ) {
                                dstI = 1;
                                dstJ = j;
                        }
                        if ( '.' == map[ h ][ j ] ) {
                                dstI = h;
                                dstJ = j;
                        }
                }
                for ( i = 1; (0 > dstI) && (i <= h); ++i ) {
                        if ( '.' == map[ i ][ 1 ] ) {
                                dstI = i;
                                dstJ = 1;
                        }
                        if ( '.' == map[ i ][ w ] ) {
                                dstI = i;
                                dstJ = w;
                        }
                }

                printf( "%d\n", solve() );
        }
        return 0;
}
*/


/**/ /**********************************************************
版本三：
WA
SPFA 求最短路。
错误“从目标点可离开地图”修正。
*/
/**/ /*
#include <stdio.h>
#include <string.h>


#define  L    89
#define  INF  0x3f3f3f3f

#define  CAN   '.'


#define  T  4
int di[] = { -1, 0, 1, 0 };
int dj[] = { 0, 1, 0, -1 };


int  h, w;
int  srcI, srcJ, dstI, dstJ;
char map[ L ][ L ];

int spfa() {
#define  QL  (L*L*T)
        static int queI[ QL ], queJ[ QL ], queD[ QL ], inq[ L ][ L ][ T ], dist[ L ][ L ][ T ];
        int qh = 0, qt = 0, i, j, d, chg, ni, nj, nd, ans;
        memset( dist, 0x3f, sizeof(dist) );
        memset( inq,  0,    sizeof(inq)  );
        for ( i = 0; i < T; ++i ) {
                queI[ qt ] = srcI;
                queJ[ qt ] = srcJ;
                queD[ qt ] = i;
                inq[ srcI ][ srcJ ][ i ] = 1;
                dist[ srcI ][ srcJ ][ i ] = 0;
                qt = (qt + 1) % QL;
        }
        while ( qh != qt ) {
                i = queI[ qh ];
                j = queJ[ qh ];
                d = queD[ qh ];
                inq[ i ][ j ][ d ] = 0;
                qh = (qh + 1) % QL;

                chg = 0;

#define  UPDATE if ( dist[ i ][ j ][ d ] + 1 < dist[ ni ][ nj ][ nd ] ) { \
                        dist[ ni ][ nj ][ nd ] = dist[ i ][ j ][ d ] + 1; \
                        if ( ! inq[ ni ][ nj ][ nd ] ) { \
                                inq[ ni ][ nj ][ nd ] = 1; \
                                queI[ qt ] = ni; \
                                queJ[ qt ] = nj; \
                                queD[ qt ] = nd; \
                                qt = (qt + 1) % QL; \
                        } \
                }
                
#define  MOD    ni = i + di[ nd ]; \
                nj = j + dj[ nd ]; \
                if ( CAN == map[ ni ][ nj ] ) { \
                        chg = 1; \
                        UPDATE \
                }

                nd = (d + 1) % T;
                MOD

                nd = (d + T - 1) % T;
                MOD

                if ( 0 == chg ) {
                        nd = d;
                        MOD
                }
        }

        ans = dist[ dstI ][ dstJ ][ 0 ];
        for ( d = 1; d < T; ++d ) {
                if ( ans > dist[ dstI ][ dstJ ][ d ] ) {
                        ans = dist[ dstI ][ dstJ ][ d ];
                }
        }
        if ( INF == ans ) {
                ans = -1;
        }
        return ans;
}

int main() {
        int td;
        int i, j;
        scanf( "%d", &td );
        while ( td-- > 0 ) {
                scanf( "%d%d", &h, &w );
                gets( map[ 0 ] );
                memset( map, '#', sizeof(map) );
                for ( i = 1; i <= h; ++i ) {
                        gets( map[ i ] + 1 );
                        for ( j = 1; j <= w; ++j ) {
                                if ( '@' == map[ i ][ j ] ) {
                                        srcI = i;
                                        srcJ = j;
                                        map[ i ][ j ] = '.';
                                }
                        }
                }
                dstI = -1;
                for ( j = 1; (0 > dstI) && (j <= w); ++j ) {
                        if ( '.' == map[ 1 ][ j ] ) {
                                dstI = 1;
                                dstJ = j;
                        }
                        if ( '.' == map[ h ][ j ] ) {
                                dstI = h;
                                dstJ = j;
                        }
                }
                for ( i = 1; (0 > dstI) && (i <= h); ++i ) {
                        if ( '.' == map[ i ][ 1 ] ) {
                                dstI = i;
                                dstJ = 1;
                        }
                        if ( '.' == map[ i ][ w ] ) {
                                dstI = i;
                                dstJ = w;
                        }
                }

                printf( "%d\n", spfa() );
        }
        return 0;
}
*/


/**/ /**********************************************************
版本二：
WA
SPFA 求最短路。
*/
/**/ /*
#include <stdio.h>
#include <string.h>


#define  L    89
#define  INF  0x3f3f3f3f

#define  CAN   '.'


#define  T  4
int di[] = { -1, 0, 1, 0 };
int dj[] = { 0, 1, 0, -1 };


int  h, w;
int  srcI, srcJ, dstI, dstJ;
char map[ L ][ L ];

int spfa() {
#define  QL  (L*L*T)
        static int queI[ QL ], queJ[ QL ], queD[ QL ], inq[ L ][ L ][ T ], dist[ L ][ L ][ T ];
        int qh = 0, qt = 0, i, j, d, chg, ni, nj, nd, ans;
        memset( dist, 0x3f, sizeof(dist) );
        memset( inq,  0,    sizeof(inq)  );
        for ( i = 0; i < T; ++i ) {
                queI[ qt ] = srcI;
                queJ[ qt ] = srcJ;
                queD[ qt ] = i;
                inq[ srcI ][ srcJ ][ i ] = 1;
                dist[ srcI ][ srcJ ][ i ] = 0;
                qt = (qt + 1) % QL;
        }
        while ( qh != qt ) {
                i = queI[ qh ];
                j = queJ[ qh ];
                d = queD[ qh ];
                inq[ i ][ j ][ d ] = 0;
                qh = (qh + 1) % QL;

                chg = 0;

#define  UPDATE if ( dist[ i ][ j ][ d ] + 1 < dist[ ni ][ nj ][ nd ] ) { \
                        dist[ ni ][ nj ][ nd ] = dist[ i ][ j ][ d ] + 1; \
                        if ( ! inq[ ni ][ nj ][ nd ] ) { \
                                inq[ ni ][ nj ][ nd ] = 1; \
                                queI[ qt ] = ni; \
                                queJ[ qt ] = nj; \
                                queD[ qt ] = nd; \
                                qt = (qt + 1) % QL; \
                        } \
                }
                
#define  MOD    ni = i + di[ nd ]; \
                nj = j + dj[ nd ]; \
                if ( CAN == map[ ni ][ nj ] ) { \
                        chg = 1; \
                        UPDATE \
                }

                nd = (d + 1) % T;
                MOD

                nd = (d + T - 1) % T;
                MOD

                if ( 0 == chg ) {
                        nd = d;
                        MOD
                }
        }

        ans = dist[ dstI ][ dstJ ][ 0 ];
        for ( d = 1; d < T; ++d ) {
                if ( ans > dist[ dstI ][ dstJ ][ d ] ) {
                        ans = dist[ dstI ][ dstJ ][ d ];
                }
        }
        if ( INF == ans ) {
                ans = -1;
        }
        return ans;
}

int main() {
        int td;
        int i, j;
        scanf( "%d", &td );
        while ( td-- > 0 ) {
                scanf( "%d%d", &h, &w );
                gets( map[ 0 ] );
                for ( i = 0; i < h; ++i ) {
                        gets( map[ i ] );
                        for ( j = 0; j < w; ++j ) {
                                if ( '@' == map[ i ][ j ] ) {
                                        srcI = i;
                                        srcJ = j;
                                }
                        }
                }
                dstI = -1;
                for ( j = 0; (0 > dstI) && (j < w); ++j ) {
                        if ( '.' == map[ 0 ][ j ] ) {
                                dstI = 0;
                                dstJ = j;
                        }
                        if ( '.' == map[ h-1 ][ j ] ) {
                                dstI = h - 1;
                                dstJ = j;
                        }
                }
                for ( i = 0; (0 > dstI) && (i < h); ++i ) {
                        if ( '.' == map[ i ][ 0 ] ) {
                                dstI = i;
                                dstJ = 0;
                        }
                        if ( '.' == map[ i ][ w-1 ] ) {
                                dstI = i;
                                dstJ = w - 1;
                        }
                }

                printf( "%d\n", spfa() );
        }
        return 0;
}
*/



/**/ /**********************************************************
版本一：
TLE
DFS 穷举所有，取最小值。
*/
/**/ /*
#include <stdio.h>
#include <string.h>


#define  L    89
#define  INF  0x3f3f3f3f

#define  CAN   '.'


#define  T  4
int di[] = { -1, 0, 1, 0 };
int dj[] = { 0, 1, 0, -1 };


int  h, w;
int  srcI, srcJ, dstI, dstJ;
char map[ L ][ L ];
int  ans, tmp;
int  walk[ L ][ L ];

void dfs( int i, int j, int dir ) {
        int ni, nj, chg = 0;
        if ( (walk[ i ][ j ]) || (tmp >= ans) ) {
                return;
        }
        if ((i == dstI) && (j == dstJ)) {
                if (tmp < ans) {
                        ans = tmp;
                }
                return;
        }
        walk[ i ][ j ] = 1;
        ++tmp;

        dir = (dir + 1) % T;
        ni = i + di[ dir ];
        nj = j + dj[ dir ];
        if ( CAN == map[ ni ][ nj ] ) {
                chg = 1;
                dfs( ni, nj, dir);
        }

        dir = (dir + T - 2) % T;
        ni = i + di[ dir ];
        nj = j + dj[ dir ];
        if ( CAN == map[ ni ][ nj ] ) {
                chg = 1;
                dfs( ni, nj, dir);
        }

        if ( 0 == chg ) {
                dir = (dir + 1) % T;
                ni = i + di[ dir ];
                nj = j + dj[ dir ];
                if ( CAN == map[ ni ][ nj ] ) {
                        dfs( ni, nj, dir);
                }
        }

        --tmp;
        walk[ i ][ j ] = 0;
}

int main() {
        int td;
        int i, j;
        scanf( "%d", &td );
        while ( td-- > 0 ) {
                scanf( "%d%d", &h, &w );
                gets( map[ 0 ] );
                for ( i = 0; i < h; ++i ) {
                        gets( map[ i ] );
                        for ( j = 0; j < w; ++j ) {
                                if ( '@' == map[ i ][ j ] ) {
                                        srcI = i;
                                        srcJ = j;
                                }
                        }
                }
                dstI = -1;
                for ( j = 0; (0 > dstI) && (j < w); ++j ) {
                        if ( '.' == map[ 0 ][ j ] ) {
                                dstI = 0;
                                dstJ = j;
                        }
                        if ( '.' == map[ h-1 ][ j ] ) {
                                dstI = h - 1;
                                dstJ = j;
                        }
                }
                for ( i = 0; (0 > dstI) && (i < h); ++i ) {
                        if ( '.' == map[ i ][ 0 ] ) {
                                dstI = i;
                                dstJ = 0;
                        }
                        if ( '.' == map[ i ][ w-1 ] ) {
                                dstI = i;
                                dstJ = w - 1;
                        }
                }

                memset( walk, 0, sizeof(walk) );
                ans = INF;
                tmp = 0;
                for ( i = 0; i < T; ++i ) {
                        dfs( srcI, srcJ, i );
                }
                printf( "%d\n", ((INF != ans) ? ans : (-1)) );
        }
        return 0;
}
*/

你可能感兴趣的:(EOJ 1780 Escape)

  • python编码处理：unicode字节串转成中文 各种字符串举例说明 sdlcwangsong
    python编码处理：unicode字节串转成中文各种字符串举例说明编码问题一直是很头痛的问题：当字符串是：'\u4e2d\u56fd'>>>s=['\u4e2d\u56fd','\u6e05\u534e\u5927\u5b66']>>>str=s[0].decode('unicode_escape')#.encode("EUC_KR")>>>printstr中国当字符串是:'东&#
  • 计算机键盘按键功能说明,电脑键盘各个按键功能分别是什么 电脑键盘各个按键功能介绍... Aurora曙光 计算机键盘按键功能说明
    1、Esc键：退出键。英文Escape的缩写，中文意思是逃脱、出口等。在电脑的应用中主要的作用是退出某个程序。例如，我们在玩游戏的时候想退出来，就按一下这个键。2、Tab键：表格键。可能大家比较少用这一个键。它是Table的缩写，中文意思是表格。在电脑中的应用主要是在文字处理软件里(如Word)起到等距离移动的作用。例如我们在处理表格时，我们不需要用空格键来一格一格地移动，只要按一下这个键就可以等
  • java实现unescape函数功能（附带源码） Katie。 Java实战项目javapython开发语言
    一、项目背景详细介绍在Web开发、数据交换和日志处理等诸多场景中，我们经常会遇到各种转义（escaping）与反转义（unescaping）的需求。例如，在HTML中，为了防止用户输入影响页面结构或引发XSS攻击，需要将特殊字符（如,&等）替换成实体（<,>,&等）；在JSON、XML，以及各种配置文件和日志中，也有类似的转义要求。与之对应的是，当我们需要将这些被转义的文本还原
  • Python 中的转义字符和空字符串以及在 Django 中的注意事项 程序梦想征途 pythondjangosqlite编程
    Python中的转义字符和空字符串以及在Django中的注意事项转义字符和空字符串是Python编程中常用的概念。在本文中，我们将详细讨论这些概念，并探讨它们在Django中的一些注意事项。转义字符（EscapeCharacters）：在Python中，转义字符用于表示一些特殊字符，例如换行符、制表符等。其中，\x是用来表示十六进制字符的转义字符。它后面紧跟着两个十六进制数字，用于表示对应的字符。
  • 针对Element 2.8.2 Escape 级联选择器的懒加载功能扩充 玖夜Kty vue.jsjavascript前端
    鬼项目老旧的很还不愿意迁移成新版，只能以旧制新了组件代码/***###介绍**-本组件是对Element(2.8.2)版本ElCascader组件的功能补充**-该组件只支持通过props属性进行初始化赋值，详情查看Element(2.15.14)[动态加载]：*https://element.eleme.cn/2.15/#/zh-CN/component/cascader#dong-tai-ji
  • Python html 库用法详解 高质量海王哦 python开发语言python
    html是Python的标准库之一，主要用于处理HTML相关的编码和解码操作。它提供了两个核心函数：escape()和unescape()。基本功能1、html.escape()-HTML编码将特殊字符转换为HTML实体，防止XSS攻击或确保HTML正确显示importhtmltext='alert("XSS")'escaped=html.escape(text)print(escaped)#输出
  • iOS 系统自带的表情输出与获取 YourReference 系统自带表情的编码转换系统自带表情转码系统自带表情显示在控件上
    先将表情编码转码存放到一个NSString里；再将NSString进行转码，转回来显示在控件上即可。转码操作：表情转码：NSString*str=[表情编码stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];NSString转码：NSString*string=[strstringByReplacingPercentEsc
  • 【golang】逃逸分析 Spring-wind 开发语言golang
    在Go语言中，逃逸分析（EscapeAnalysis）是编译器的一种优化技术，用于决定变量是分配在栈上还是堆上。通过逃逸分析，Go编译器可以减少不必要的堆分配，从而提高程序的性能。1.什么是逃逸分析？逃逸：当变量的生命周期超出其作用域（如函数）时，该变量会被认为“逃逸”到堆上。逃逸分析：编译器在编译时分析变量的使用情况，判断它是否会逃逸到堆上。2.为什么需要逃逸分析？栈vs堆：栈上的变量分配和释放
  • [请关注]VC++ Edit组件重绘实用分享 DoWeixin6 MFCVC
    VCEdit组件重绘---------------------关键注释说明：1.**自定义消息机制**：-通过`RegisterWindowMessage`注册自定义消息`WM_XEDIT_KILL_FOCUS`和`WM_XEDIT_VK_ESCAPE`，用于通知父窗口编辑框的状态变化（如失去焦点、按下ESC）。-`SendRegisteredMessage`函数确保消息仅发送一次（通过`m_bM
  • go内存逃逸有害吗 leijmdas golang
    Go语言中的内存逃逸（MemoryEscape）本身并不一定“有害”，但它可能对程序的性能和内存使用产生一定影响。是否“有害”取决于具体的场景和需求。以下是详细的分析：---1.什么是内存逃逸？内存逃逸是指编译器在编译期间发现某个变量（通常是局部变量）的生命周期超出了当前函数的作用域，因此必须将其分配到堆（Heap）上，而不是栈（Stack）上。例如：gofuncfoo()*int{x:=42//
  • signature=0e936ad5c99bd8d603e71fa74e787bee,JavaScript 的 BASE64 算法 实现 完美解决中文乱码... Bobby陈兴博
    收藏的Base64编码/解码.在一个外国网站看到的.不过对中文不支持.自己加入了escape,.对中文也支持了.先用escape()对中文进行编码.然后再进行base64编码.解码时,再加入()对中文进行解码./p>"-//W3C//DTDHTML4.01Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">NewDocumentconte
  • 深入理解Kubescape: Kubernetes安全平台与容器镜像漏洞修复 ivwdcwso 安全kubernetes安全容器Kubescape
    1.引言在云原生时代，Kubernetes已成为容器编排的标准选择。然而，随着Kubernetes的广泛应用，其安全性也成为了一个日益重要的话题。Kubescape应运而生，为Kubernetes用户提供了一个强大的开源安全平台。本文将深入探讨Kubescape，特别关注其在容器镜像漏洞修复方面的能力，帮助读者全面了解这一工具如何增强Kubernetes环境的安全性。2.Kubescape概述Ku
  • Unity按键表大全 鹿野素材屋 unity游戏引擎
    Unity键值对应表#KeyCode是由Event.keyCode返回的。这些直接映射到键盘上的物理键，以下是键值对应列表：常用键#Backspace退格键DeleteDelete键TabTab键ClearClear键Return回车键Pause暂停键EscapeESC键Space空格键小键盘#Keypad0小键盘0Keypad1小键盘1Keypad2小键盘2Keypad3小键盘3Keypad4小
  • 【Rust笔记】04-表达式 phial03 rustrust开发语言后端
    04-表达式4.1-表达式语言在C语言中，表达式有值，而语句没有。//表达式5*（fahr-32）/9//语句for(;begin!=end;++begin){if(*begin==target)break;}Rust是表达式语言if和match可以产生值pixels[r*bounds.0+c]=matchescapes(Complex{re:point.0,im:point.1},255){No
  • 【高频考点精讲】XSS攻击全解析：从原理到防御，手把手教你打造安全前端应用 全栈老李技术面试 前端高频考点精讲前端javascripthtmlcss面试题reactvue
    XSS攻击全解析：从原理到防御，手把手教你打造安全前端应用最近在给团队做安全审计时，发现不少项目对XSS的防御还停留在"用escapeHtml就万事大吉"的阶段。今天全栈老李就带大家彻底搞懂这个前端安全的头号敌人——连某大厂都曾因XSS漏洞导致千万用户数据泄露，你确定不认真看看？一、XSS的本质：你的网页在替黑客写代码想象你在奶茶店点单，服务员问："要加什么料？"你突然说："再加10杯最贵的，打包
  • 【PostgreSQL数据分析实战：从数据清洗到可视化全流程】2.4 正则表达式与文本处理（LIKE/REGEXP_MATCHES） 言析数智 postgresql数据分析正则表达式REGEXP_MATCHESILIKEESCAPE
    点击关注不迷路点击关注不迷路点击关注不迷路文章大纲PostgreSQL数据分析实战：正则表达式与文本处理（LIKE/REGEXP_MATCHES）2.4正则表达式与文本处理2.4.1LIKE运算符：基础模式匹配1.语法与通配符2.大小写敏感与ESCAPE子句3.性能特点2.4.2REGEXP_MATCHES函数：正则表达式引擎1.语法与核心功能2.正则表达式语法示例3.高级用法2.4.3深度对比：
  • 使用C++向mysql中插入二进制数据（图片）方法一 小米的修行之路 C++/mySqlmysql二进制数据
    方法二：https://zhangzc.blog.csdn.net/article/details/1241369961、使用到的主要函数说明：（1）mysql_real_escape_string()：unsignedlongmysql_real_escape_string(MYSQL*mysql,char*to,constchar*from,unsignedlonglength)该函数用于创建
  • 关于windows API 的键鼠可控可测 LAOLONG-C 单片机stm32嵌入式硬件
    相关函数解释GetAsyncKeyState是WindowsAPI中的一个函数，用于判断某个虚拟键是否被按下。GetAsyncKeyState(VK_ESCAPE)专门用于检测Esc键的状态。下面为你详细介绍其用法：函数原型cppSHORTGetAsyncKeyState(intvKey);参数vKey：虚拟键码，对于Esc键，使用VK_ESCAPE作为参数。返回值返回一个SHORT类型的值，其含
  • java html字符串转义_java转换 HTML字符实体，java特殊字符转义字符串 鲸拍房 javahtml字符串转义
    为什么要用转义字符串？HTML中，&等有特殊含义(，用于链接签，&用于转义)，不能直接使用。这些符号是不显示在我们最终看到的网页里的，那如果我们希望在网页中显示这些符号，该怎么办呢？这就要说到HTML转义字符串(EscapeSequence)了。转义字符串(EscapeSequence)也称字符实体(CharacterEntity)。在HTML中，定义转义字符串的原因有两个：第一个原因是像“”这类
  • HTML字符实体与转义字符串 hgq_csdn 前端html转义字符字符实体
    1、为什么要用转义字符串？HTML中，&等有特殊含义（，用于链接签，&用于转义），不能直接使用。这些符号是不显示在我们最终看到的网页里的，那如果我们希望在网页中显示这些符号，该怎么办呢？这就要说到HTML转义字符串（EscapeSequence）了。转义字符串（EscapeSequence）也称字符实体(CharacterEntity)。在HTML中，定义转义字符串的原因有两个：第一个原因是像“”
  • Java 通过Soap方式调用WebService接口 Fisher3652 Java
    importorg.apache.commons.lang3.StringEscapeUtils;importorg.apache.http.HttpEntity;importorg.apache.http.client.config.RequestConfig;importorg.apache.http.client.methods.CloseableHttpResponse;importorg
  • 《OWASP Top 10--跨站脚本(XSS)》 a378177461 信息安全
    说明：本文章仅限于对跨站脚本漏洞的学习和了解跨站脚本漏洞，即XSS发生在当应用程序发送给浏览器的页面中包含用户提供的数据，而这些数据没有经过适当的验证或转义(Escape)或没有使用安全的JavaScriptAPI。1、定义跨站脚本攻击（CrossSiteScripting），缩写为XSS（为了避免与样式CSS混淆,缩写为XSS），恶意攻击者往Web页面里插入恶意Script代码，当用户浏览该页之
  • vue导出excel加一个进度条_vue导出excel数据表格功能 水门miao
    /*eslint-disable*//*Blob.js*//*globalself,unescape*//*jslintbitwise:true,regexp:true,confusion:true,es5:true,vars:true,white:true,plusplus:true*//*!@sourcehttp://purl.eligrey.com/github/Blob.js/blob/m
  • Flask入门教程(非常详细)，从零基础入门到精通，看完这一篇就够了 2401_87361386 flaskiospython
    **转义字符**转义字符过滤器转义前的数据是：{{info|safe}}{%autoescapetrue%}{{info}}{%endautoescape%}**其它过滤器**其它过滤器绝对值：{{-6|abs}}小数:{{6|float}}字符串：{{6|string}}格式化:{{'%s--%s'|format('我','你')}}长度：{{'我是九，你是三，除了你，还是你'|length}}
  • 为什么我不应该在 PHP 中使用 mysql_* 函数？ HuntsBot gitgithubogrec++phpstorm
    问：想要改进这篇文章？提供这个问题的详细答案，包括引文和解释为什么你的答案是正确的。没有足够细节的答案可能会被编辑或删除。为什么不应该使用mysql_*函数的技术原因是什么？（例如mysql_query()、mysql_connect()或mysql_real_escape_string()）？即使它们在我的网站上工作，我为什么还要使用其他东西？如果他们在我的网站上不起作用，为什么我会收到类似的错
  • PreTranslateMessage()函数捕获键盘按键消息 bookish_2010_prj VC/MFCmenumfc
    01.PreTranslateMessage函数，常用于屏蔽MFC对话框中默认的Enter和ESC消息函数原型：BOOLPreTranslateMessage(MSG*pMsg)用法举例：BOOLCTestDlg::PreTranslateMessage(MSG*pMsg){if(pMsg->message==WM_KEYDOWN){if(pMsg->wParam==VK_ESCAPE){retu
  • 【C#】特殊字符（$、@、{}、[]）和转义字符Escape character（\字符） hmywillstronger c#开发语言
    可能的疑问Query：为什么会将escape这个单词翻译为“转义”。或许与本身“逃跑”的这个含义相差过远Answer:在计算机编程和文本处理中,“escape"的含义是"脱离常规解释或处理”,表示某些字符需要被特殊对待。这种特殊对待就是通过在字符前加上反斜杠"“来实现的。因此,这个过程被称为"转义”。尽管"转义"与"escape"的字面意思"逃跑"有所差异,但它在计算机领域凸显了"脱离常规解释或处
  • javascript对url特殊字符转义 勇敢滴哥哥 javascripturl
    做页面开发的时候有时候，会使用Javascript的escape()，encodeURIComponent(),encodeURI()这三个函数进行URL编码,防止特殊字符接收不到。解决方法：就是把客服端中带有特殊字符的参数替换成另一些代替的参数，如下所示1、+URL中+号表示空格%2B2、空格URL中的空格可以用+号或者编码%203、/分隔目录和子目录%2F4、?分隔实际的URL和参数%3F5、
  • ORACLE进阶（十二）union(all)学习总结_oracle的union all底层算法 2401_85124682 oracle学习数据库
    innerjoincdeorgontb.ibkcde=cdeorg.ibkcdewhere1=1AND(FNAUTMISNULLorfnautm=0)AND(tb.FLWSTS!='3'ortb.FLWSTSISNULL)andUPPER(tb.customername)like'%'||'shq\_test\_20180302'||'%'ESCAPE'/'andtb.biztypin('1','
  • java字符串转义反转义,把< >转换成大于小于字符 @郭小茶 成长之路java字符串
    文章参考：https://blog.csdn.net/qq_34288630/article/details/83654415java字符串转义,把”转换成“"符号转义后保存到库里，列表导出的时候还是转义字符，需要把“”等字符，我需要原始的。处理方法：使用的是commons-lang3-3.4中的StringEscapeUtils类：packagedemo;importjava.io.IOExce
  • TOMCAT在POST方法提交参数丢失问题 357029540 javatomcatjsp
    摘自http://my.oschina.net/luckyi/blog/213209 昨天在解决一个BUG时发现一个奇怪的问题，一个AJAX提交数据在之前都是木有问题的，突然提交出错影响其他处理流程。 检查时发现页面处理数据较多，起初以为是提交顺序不正确修改后发现不是由此问题引起。于是删除掉一部分数据进行提交，较少数据能够提交成功。 恢复较多数据后跟踪提交FORM DATA ，发现数
  • 在MyEclipse中增加JSP模板 删除-2008-08-18 ljy325 jspxmlMyEclipse
    在D:\Program Files\MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.wizards_6.0.1.zmyeclipse601200710\templates\jsp  目录下找到Jsp.vtl，复制一份，重命名为jsp2.vtl,然后把里面的内容修改为自己想要的格式，保存。 然后在 D:\Progr
  • JavaScript常用验证脚本总结 eksliang JavaScriptjavaScript表单验证
         转载请出自出处：http://eksliang.iteye.com/blog/2098985        下面这些验证脚本，是我在这几年开发中的总结，今天把他放出来，也算是一种分享吧，现在在我的项目中也在用！包括日期验证、比较，非空验证、身份证验证、数值验证、Email验证、电话验证等等...! &nb
  • 微软BI（4） 18289753290 微软BI SSIS
    1） Q:查看ssis里面某个控件输出的结果：  A MessageBox.Show(Dts.Variables["v_lastTimestamp"].Value.ToString()); 这是我们在包里面定义的变量 2):在关联目的端表的时候如果是一对多的关系，一定要选择唯一的那个键作为关联字段。 3) Q：ssis里面如果将多个数据源的数据插入目的端一
  • 定时对大数据量的表进行分表对数据备份 酷的飞上天空 大数据量
    工作中遇到数据库中一个表的数据量比较大，属于日志表。正常情况下是不会有查询操作的，但如果不进行分表数据太多，执行一条简单sql语句要等好几分钟。。   分表工具：linux的shell + mysql自身提供的管理命令 原理：使用一个和原表数据结构一样的表，替换原表。   linux shell内容如下： =======================开始 
  • 本质的描述与因材施教 永夜-极光 感想随笔
             不管碰到什么事,我都下意识的想去探索本质,找寻一个最形象的描述方式。        我坚信,世界上对一件事物的描述和解释,肯定有一种最形象,最贴近本质,最容易让人理解        &
  • 很迷茫。。。 随便小屋 随笔
    小弟我今年研一，也是从事的咱们现在最流行的专业（计算机）。本科三流学校，为了能有个更好的跳板，进入了考研大军，非常有幸能进入研究生的行业（具体学校就不说了，怕把学校的名誉给损了）。   先说一下自身的条件，本科专业软件工程。主要学习就是软件开发，几乎和计算机没有什么区别。因为学校本身三流，也就是让老师带着学生学点东西，然后让学生毕业就行了。对专业性的东西了解的非常浅。就那学的语言来说
  • 23种设计模式的意图和适用范围 aijuans 设计模式
    Factory Method 意图 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。 　　适用性 当一个类不知道它所必须创建的对象的类的时候。 　　当一个类希望由它的子类来指定它所创建的对象的时候。 　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。 Abstr
  • Java中的synchronized和volatile aoyouzi javavolatilesynchronized
    说到Java的线程同步问题肯定要说到两个关键字synchronized和volatile。说到这两个关键字，又要说道JVM的内存模型。JVM里内存分为main memory和working memory。 Main memory是所有线程共享的，working memory则是线程的工作内存，它保存有部分main memory变量的拷贝，对这些变量的更新直接发生在working memo
  • js数组的操作和this关键字 百合不是茶 js数组操作this关键字
    js数组的操作;   一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]
  • 别人的阿里面试感悟 bijian1013 面试分享工作感悟阿里面试
    原文如下：http://greemranqq.iteye.com/blog/2007170         一直做企业系统，虽然也自己一直学习技术，但是感觉还是有所欠缺，准备花几个月的时间，把互联网的东西，以及一些基础更加的深入透析，结果这次比较意外，有点突然，下面分享一下感受吧！    &nb
  • 淘宝的测试框架Itest Bill_chen springmaven框架单元测试JUnit
    Itest测试框架是TaoBao测试部门开发的一套单元测试框架，以Junit4为核心， 集合DbUnit、Unitils等主流测试框架，应该算是比较好用的了。 近期项目中用了下，有关itest的具体使用如下： 1.在Maven中引入itest框架： <dependency>   <groupId>com.taobao.test</groupId&g
  • 【Java多线程二】多路条件解决生产者消费者问题 bit1129 java多线程
    package com.tom; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.locks.Condition; import java.util.concurrent.loc
  • 汉字转拼音pinyin4j 白糖_ pinyin4j
    以前在项目中遇到汉字转拼音的情况，于是在网上找到了pinyin4j这个工具包，非常有用，别的不说了，直接下代码：   import java.util.HashSet; import java.util.Set; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin
  • org.hibernate.TransactionException: JDBC begin failed解决方案 bozch ssh数据库异常DBCP
    org.hibernate.TransactionException: JDBC begin failed:     at org.hibernate.transaction.JDBCTransaction.begin(JDBCTransaction.java:68)    at org.hibernate.impl.SessionImp
  • java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合 bylijinnan java
    import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.ut
  • Java PrintWriter打印乱码 chenbowen00 java
    一个小程序读写文件，发现PrintWriter输出后文件存在乱码，解决办法主要统一输入输出流编码格式。 读文件： BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因
  • [天气与气候]极端气候环境 comsci 环境
          如果空间环境出现异变...外星文明并未出现,而只是用某种气象武器对地球的气候系统进行攻击,并挑唆地球国家间的战争,经过一段时间的准备...最大限度的削弱地球文明的整体力量,然后再进行入侵......      那么地球上的国家应该做什么样的防备工作呢?  &n
  • oracle order by与union一起使用的用法 daizj UNIONoracleorder by
    当使用union操作时，排序语句必须放在最后面才正确，如下： 只能在union的最后一个子查询中使用order by，而这个order by是针对整个unioning后的结果集的。So： 如果unoin的几个子查询列名不同，如 Sql代码  select supplier_id, supplier_name  from suppliers  UNI
  • zeus持久层读写分离单元测试 deng520159 单元测试
    本文是zeus读写分离单元测试,距离分库分表,只有一步了.上代码: 1.ZeusMasterSlaveTest.java package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Assert; import org.j
  • Yii 截取字符串(UTF-8) 使用组件 dcj3sjt126com yii
    1.将Helper.php放进protected\components文件夹下。 2.调用方法：   Helper::truncate_utf8_string($content,20,false);   //不显示省略号  Helper::truncate_utf8_string($content,20);  //显示省略号  &n
  • 安装memcache及php扩展 dcj3sjt126com PHP
    安装memcache    tar zxvf memcache-2.2.5.tgz     cd memcache-2.2.5/     /usr/local/php/bin/phpize (?)    ./configure --with-php-confi
  • JsonObject 处理日期 feifeilinlin521 javajsonJsonOjbectJsonArrayJSONException
        写这边文章的初衷就是遇到了json在转换日期格式出现了异常 net.sf.json.JSONException: java.lang.reflect.InvocationTargetException  原因是当你用Map接收数据库返回了java.sql.Date 日期的数据进行json转换出的问题话不多说  直接上代码  &n
  • Ehcache（06）——监听器 234390216 监听器listenerehcache
    监听器          Ehcache中监听器有两种，监听CacheManager的CacheManagerEventListener和监听Cache的CacheEventListener。在Ehcache中，Listener是通过对应的监听器工厂来生产和发生作用的。下面我们将来介绍一下这两种类型的监听器。  
  • activiti 自带设计器中chrome 34版本不能打开bug的解决 jackyrong Activiti
      在acitivti modeler中，如果是chrome 34，则不能打开该设计器，其他浏览器可以， 经证实为bug，参考 http://forums.activiti.org/content/activiti-modeler-doesnt-work-chrome-v34 修改为，找到 oryx.debug.js 在最头部增加 if (!Document.
  • 微信收货地址共享接口-终极解决 laotu5i0 微信开发
       最近要接入微信的收货地址共享接口，总是不成功，折腾了好几天，实在没办法网上搜到的帖子也是骂声一片。我把我碰到并解决问题的过程分享出来，希望能给微信的接口文档起到一个辅助作用，让后面进来的开发者能快速的接入，而不需要像我们一样苦逼的浪费好几天，甚至一周的青春。各种羞辱、谩骂的话就不说了，本人还算文明。    如果你能搜到本贴，说明你已经碰到了各种 ed
  • 关于人才 netkiller.github.com 工作面试招聘netkiller人才
    关于人才 每个月我都会接到许多猎头的电话，有些猎头比较专业，但绝大多数在我看来与猎头二字还是有很大差距的。 与猎头接触多了，自然也了解了他们的工作，包括操作手法，总体上国内的猎头行业还处在初级阶段。 总结就是“盲目推荐，以量取胜”。 目前现状 许多从事人力资源工作的人，根本不懂得怎么找人才。处在人才找不到企业，企业找不到人才的尴尬处境。 企业招聘，通常是需要用人的部门提出招聘条件，由人
  • 搭建 CentOS 6 服务器 - 目录 rensanning centos
    (1) 安装CentOS ISO（desktop/minimal）、Cloud（AWS/阿里云）、Virtualization（VMWare、VirtualBox） 详细内容 (2) Linux常用命令 cd、ls、rm、chmod...... 详细内容 (3) 初始环境设置 用户管理、网络设置、安全设置...... 详细内容 (4) 常驻服务Daemon
  • 【求助】mongoDB无法更新主键 toknowme mongodb
      Query query = new Query();          query.addCriteria(new Criteria("_id").is(o.getId()));                &n
  • jquery 页面滚动到底部自动加载插件集合 xp9802 jquery
    很多社交网站都使用无限滚动的翻页技术来提高用户体验，当你页面滑到列表底部时候无需点击就自动加载更多的内容。下面为你推荐 10 个 jQuery 的无限滚动的插件： 1. jQuery ScrollPagination jQuery ScrollPagination plugin 是一个 jQuery 实现的支持无限滚动加载数据的插件。 2. jQuery Screw S
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他