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

coreBugZJ

此 blog 已棄。

EOJ 1780 Escape

/*
EOJ 1780 Escape


----問(wèn)題描述：

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


----分析：

搜索即可，只是注意擴(kuò)展方式，左或右可以時(shí)，不可向前。

*/



/**********************************************************
版本五：
AC 0MS
SPFA 求最短路。
出口不止一個(gè)，邊界上的可達(dá)點(diǎn)都是出口。
*/

#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
發(fā)現(xiàn)之前對(duì) “You never turn around and go back!”理解有誤，只是不能后退而已。
寬度優(yōu)先搜索。

*/
/*
#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 求最短路。
錯(cuò)誤“從目標(biāo)點(diǎn)可離開(kāi)地圖”修正。
*/
/*
#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 閱讀(657) 評(píng)論(0)  編輯 收藏 引用 所屬分類: ACM 、Algorithm 、課內(nèi)作業(yè)

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

    • <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>
            
日韩视频免费观看高清在线视频
|
亚洲一区一卡|
日韩午夜中文字幕|
欧美精品在线极品|
亚洲一级在线|
久久国产精品高清|
亚洲国产99精品国自产|
亚洲精品欧美日韩|
国产欧美一区二区精品秋霞影院
|
一本一本久久a久久精品综合麻豆
一本一本久久a久久精品牛牛影视
|
亚洲午夜精品视频|
激情综合久久|
日韩午夜高潮|
韩曰欧美视频免费观看|
亚洲激情电影在线|
欧美日韩在线一区二区|
久久手机免费观看|
欧美日本韩国一区|
久久久久国内|
欧美日韩在线亚洲一区蜜芽|
久久久九九九九|
免费人成精品欧美精品|
亚洲一区精品在线|
久久久亚洲精品一区二区三区
|
久热精品视频在线观看|
欧美日韩一区免费|
牛夜精品久久久久久久99黑人
|
韩国av一区二区三区|
亚洲精品美女在线观看播放|
国内精品久久久久久|
亚洲精品一区二区三区不|
精品99一区二区|
亚洲综合丁香|
亚洲小少妇裸体bbw|
欧美ab在线视频|
久久久久久亚洲精品杨幂换脸|
欧美日韩视频第一区|
欧美freesex8一10精品|
国产三级欧美三级日产三级99|
亚洲精品一区二区在线观看|
狠狠色香婷婷久久亚洲精品|
亚洲线精品一区二区三区八戒|
亚洲精品一区二区三|
久久久久.com|
久久久久久免费|
国产精品亚洲网站|
亚洲图片欧美午夜|
亚洲一区免费看|
欧美午夜精品久久久久久孕妇
|
欧美在线视频a|
久久黄色影院|
国产日产亚洲精品系列|
亚洲视频视频在线|
亚洲欧美日韩成人高清在线一区|
欧美日韩三级一区二区|
亚洲三级免费观看|
一区二区欧美亚洲|
欧美另类在线观看|
日韩视频免费大全中文字幕|
日韩视频在线免费|
欧美日韩国产精品自在自线|
亚洲精品国精品久久99热一|
一本久道久久久|
欧美日韩亚洲高清|
亚洲视频中文|
欧美在线一二三四区|
国产亚洲综合在线|
久久久精品国产一区二区三区
|
欧美中文字幕精品|
美脚丝袜一区二区三区在线观看
|
国产精品www|
亚洲伊人久久综合|
久久久一本精品99久久精品66|
精品不卡视频|
欧美国产成人精品|
在线午夜精品|
久久久久久久一区|
亚洲精品国产精品国产自|
欧美区一区二区三区|
亚洲欧美日韩国产另类专区|
久久久久久久综合色一本|
亚洲国产高清一区二区三区|
欧美精品日韩一区|
亚洲综合三区|
欧美激情视频在线播放|
正在播放亚洲|
国产手机视频一区二区|
欧美成人亚洲成人日韩成人|
一区二区三区 在线观看视频|
先锋影音久久久|
影音先锋中文字幕一区|
欧美日韩国产成人|
久久精品国产第一区二区三区最新章节|
欧美电影免费观看高清|
亚洲一区二区三区中文字幕|
国产婷婷色综合av蜜臀av|
免费黄网站欧美|
亚洲在线一区|
欧美高清视频免费观看|
亚洲在线视频|
亚洲国产高清在线|
国产欧美视频一区二区|
欧美激情亚洲自拍|
久久久精品欧美丰满|
亚洲婷婷在线|
亚洲精品乱码久久久久久蜜桃91|
久久久精品动漫|
一本色道久久综合亚洲精品不
|
国产精品嫩草久久久久|
欧美大学生性色视频|
午夜久久影院|
亚洲图片在区色|
亚洲黄色在线看|
免费国产一区二区|
久久精品色图|
欧美一级午夜免费电影|
一区二区三区四区蜜桃|
亚洲国产精品黑人久久久|
国产视频在线观看一区二区|
国产精品国产馆在线真实露脸|
欧美激情中文字幕一区二区|
久久久亚洲精品一区二区三区|
西西裸体人体做爰大胆久久久|
夜夜嗨av一区二区三区免费区|
亚洲国产精品一区|
免费美女久久99|
六月天综合网|
久久久久国产精品一区三寸|
欧美在线播放一区|
午夜精品久久久久久久99水蜜桃|
日韩一级大片在线|
一区二区免费在线视频|
一二三四社区欧美黄|
亚洲精品一区二|
日韩午夜av在线|
夜久久久久久|
亚洲四色影视在线观看|
亚洲视频免费观看|
亚洲一区二区三区免费在线观看
|
狠狠干综合网|
黄色成人免费网站|
在线精品在线|
亚洲国产小视频在线观看|
亚洲国产精品小视频|
亚洲韩国青草视频|
亚洲精品日韩精品|
亚洲最新视频在线|
亚洲一区二区三区视频|
亚洲欧美日韩综合|
久久精品一区四区|
欧美成人一区二区三区在线观看
|
久久嫩草精品久久久精品|
久久久www成人免费精品|
久久久夜精品|
欧美激情一区在线观看|
欧美日韩亚洲一区在线观看|
国产乱码精品一区二区三区忘忧草
|
黄色成人免费观看|
亚洲七七久久综合桃花剧情介绍|
日韩视频免费观看高清在线视频|
在线亚洲一区二区|
欧美综合国产|
亚洲国产精品成人综合色在线婷婷|
91久久精品美女高潮|
一区二区三区日韩在线观看|
久久国产黑丝|
欧美看片网站|
国产一区二区欧美日韩|
亚洲免费观看高清完整版在线观看|
亚洲一二三级电影|
免费观看在线综合|
一区二区三区色|
久久久伊人欧美|
国产精品成人一区二区三区吃奶|
黄色成人av在线|
亚洲女人av|
亚洲国产天堂久久国产91|
午夜精品久久久久久久白皮肤|
猛男gaygay欧美视频|
国产精品影视天天线|
亚洲人精品午夜在线观看|
久久不射2019中文字幕|
亚洲人成人77777线观看|
性视频1819p久久|
欧美日韩亚洲一区二区|
亚洲国产精品999|
欧美一区二区在线观看|
91久久精品国产|
久久久久国色av免费看影院|
欧美日韩欧美一区二区|
91久久精品日日躁夜夜躁欧美
|
夜夜精品视频|
欧美国产极速在线|
狠狠综合久久av一区二区小说|
一区二区三区精品视频在线观看|
牛牛影视久久网|
久久高清一区|
国产一级一区二区|
欧美一级一区|
亚洲一区影音先锋|