青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品

coreBugZJ

此 blog 已棄。

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;
}
*/

posted on 2012-04-21 16:40 coreBugZJ 閱讀(662) 評論(0)  編輯 收藏 引用 所屬分類: ACM 、Algorithm 、課內作業

青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品

    • <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>

    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>

            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            
亚洲电影第1页|
欧美77777|
亚洲欧美精品|
亚洲视频你懂的|
中文在线不卡视频|
一区二区三区高清不卡|
亚洲视频一区二区在线观看|
一区二区三区国产在线|
亚洲网站在线播放|
午夜精品理论片|
欧美在线三级|
久久色在线观看|
欧美gay视频|
亚洲欧洲美洲综合色网|
亚洲精品国产精品国自产观看|
亚洲免费福利视频|
亚洲综合精品自拍|
欧美在线关看|
老司机免费视频一区二区|
欧美高清一区|
国产精品久久久999|
国产一区二区三区电影在线观看
|
日韩亚洲欧美中文三级|
亚洲综合成人在线|
久久精品视频va|
欧美国产免费|
国产精品久久看|
在线精品一区二区|
一区二区三区.www|
欧美中文字幕在线播放|
免费中文字幕日韩欧美|
亚洲伦理在线|
午夜亚洲精品|
欧美成人激情视频免费观看|
欧美日韩一区二区在线视频|
国产亚洲精品久久久久动|
伊人成人开心激情综合网|
亚洲精品四区|
欧美在线观看视频|
欧美激情一区二区三级高清视频
|
国产精品美女黄网|
国内伊人久久久久久网站视频|
亚洲国产综合在线|
亚洲在线不卡|
模特精品在线|
在线亚洲欧美专区二区|
久久九九国产精品|
欧美日韩在线高清|
一区二区三区无毛|
亚洲一区二区日本|
免费在线成人av|
一区二区三区高清在线观看|
久久精品一区二区三区不卡|
欧美日韩精品一区二区|
韩日精品中文字幕|
亚洲一区黄色|
欧美黑人在线播放|
亚洲欧美日韩国产综合|
欧美va天堂在线|
国产网站欧美日韩免费精品在线观看|
亚洲日本欧美天堂|
久久精品国产欧美亚洲人人爽|
亚洲日本乱码在线观看|
欧美在线观看天堂一区二区三区|
欧美日韩一区自拍|
亚洲黄色影片|
久久男人资源视频|
中国女人久久久|
欧美国产亚洲精品久久久8v|
国产亚洲精品v|
亚洲综合视频网|
亚洲欧洲日本专区|
久久久久国产一区二区三区四区
|
欧美激情中文字幕在线|
黑人巨大精品欧美黑白配亚洲|
亚洲视频一区二区|
亚洲激情成人|
另类酷文…触手系列精品集v1小说|
国产精品区一区二区三区|
亚洲麻豆av|
亚洲第一精品久久忘忧草社区|
欧美一区亚洲一区|
国产精品夜色7777狼人|
中国成人黄色视屏|
亚洲激情一区二区|
欧美成人黑人xx视频免费观看|
在线播放视频一区|
久久久噜噜噜久久|
亚洲欧美国产另类|
国产精品日韩精品欧美精品|
亚洲午夜一区二区三区|
亚洲精品日韩综合观看成人91|
欧美高清在线视频观看不卡|
亚洲欧洲日韩在线|
欧美电影在线|
麻豆精品视频|
亚洲激情黄色|
亚洲国产精品精华液2区45|
久久这里只有精品视频首页|
一区二区视频免费在线观看|
久久蜜桃香蕉精品一区二区三区|
香港久久久电影|
国产情侣久久|
久久久久国产精品www|
欧美一区二区性|
国内精品嫩模av私拍在线观看|
欧美专区日韩视频|
欧美一区二区视频在线观看|
国内精品美女在线观看|
老司机精品视频网站|
久久久久国内|
亚洲经典视频在线观看|
亚洲国产日韩欧美在线动漫|
欧美电影在线观看完整版|
亚洲精品国产欧美|
亚洲精品视频免费观看|
欧美日韩在线看|
午夜精品福利在线观看|
香蕉av777xxx色综合一区|
国内精品久久久久久久果冻传媒|
久久免费国产精品|
欧美aaa级|
亚洲一区免费网站|
午夜精品视频在线观看一区二区|
韩国成人精品a∨在线观看|
免费人成网站在线观看欧美高清|
欧美成年人视频网站欧美|
av不卡在线观看|
亚洲午夜久久久久久久久电影院|
国产欧美一区二区精品秋霞影院|
久久精品夜色噜噜亚洲a∨
|
久久久久久久久久久久久久一区|
久久精品国产999大香线蕉|
亚洲激情av|
中文国产亚洲喷潮|
国产自产女人91一区在线观看|
欧美岛国激情|
欧美日韩一区二区在线观看视频
|
亚洲欧洲日韩在线|
国产精品午夜春色av|
毛片一区二区|
欧美日韩一区二|
久久久精品国产免费观看同学|
欧美bbbxxxxx|
午夜精品在线观看|
老司机久久99久久精品播放免费|
中文国产成人精品|
久久精品国产亚洲高清剧情介绍|
亚洲精品久久久久中文字幕欢迎你|
一区二区三区欧美在线|
黄色精品一区|
夜夜精品视频|
激情久久婷婷|
夜夜嗨av一区二区三区|
一区二区视频在线观看|
一本色道久久|
亚洲国产精品va在线观看黑人|
一本色道久久|
亚洲日本无吗高清不卡|
欧美一区2区三区4区公司二百
|
国产一区二区三区在线观看免费|
亚洲国产日韩精品|
国产一区亚洲|
日韩一级裸体免费视频|
1024亚洲|
欧美一区二区在线播放|
亚洲精品视频中文字幕|
久久av最新网址|
中文在线不卡视频|
免费亚洲网站|
久久久久国产精品一区三寸|
欧美日韩一区二区高清|
欧美国产欧美亚洲国产日韩mv天天看完整|
国产精品美女黄网|
亚洲激情一区二区三区|
在线精品视频免费观看|
亚洲欧美在线x视频|
亚洲视频成人|
欧美承认网站|
女生裸体视频一区二区三区|
国产日韩高清一区二区三区在线|
亚洲伦理精品|
av不卡在线观看|
欧美成人一区二区|
噜噜噜在线观看免费视频日韩|
国产精品亚洲成人|
亚洲视频视频在线|
夜夜精品视频一区二区|
欧美gay视频激情|
欧美成人首页|
在线观看日韩av电影|
欧美一级一区|
久久国产主播精品|
国产精品一区二区久激情瑜伽|
99在线精品视频在线观看|
99精品视频网|
欧美精品综合|
亚洲精品美女91|
一区二区三区欧美|
欧美人与性动交cc0o|