zoukankan      html  css  js  c++  java
  • 250E Mad Joe

    E. Mad Joe
    time limit per test
    2 seconds
    memory limit per test
    256 megabytes
    input
    standard input
    output
    standard output

    Joe has been hurt on the Internet. Now he is storming around the house, destroying everything in his path.

    Joe's house has n floors, each floor is a segment of m cells. Each cell either contains nothing (it is an empty cell), or has a brick or a concrete wall (always something one of three). It is believed that each floor is surrounded by a concrete wall on the left and on the right.

    Now Joe is on the n-th floor and in the first cell, counting from left to right. At each moment of time, Joe has the direction of his gaze, to the right or to the left (always one direction of the two). Initially, Joe looks to the right.

    Joe moves by a particular algorithm. Every second he makes one of the following actions:

    • If the cell directly under Joe is empty, then Joe falls down. That is, he moves to this cell, the gaze direction is preserved.
    • Otherwise consider the next cell in the current direction of the gaze.
      • If the cell is empty, then Joe moves into it, the gaze direction is preserved.
      • If this cell has bricks, then Joe breaks them with his forehead (the cell becomes empty), and changes the direction of his gaze to the opposite.
      • If this cell has a concrete wall, then Joe just changes the direction of his gaze to the opposite (concrete can withstand any number of forehead hits).

    Joe calms down as soon as he reaches any cell of the first floor.

    The figure below shows an example Joe's movements around the house.

    Determine how many seconds Joe will need to calm down.

    Input

    The first line contains two integers n and m (2 ≤ n ≤ 100, 1 ≤ m ≤ 104).

    Next n lines contain the description of Joe's house. The i-th of these lines contains the description of the (n - i + 1)-th floor of the house — a line that consists of m characters: "." means an empty cell, "+" means bricks and "#" means a concrete wall.

    It is guaranteed that the first cell of the n-th floor is empty.

    Output

    Print a single number — the number of seconds Joe needs to reach the first floor; or else, print word "Never" (without the quotes), if it can never happen.

    Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64dspecifier.

    Sample test(s)
    input
    3 5
    ..+.#
    #+..+
    +.#+.
    output
    14
    input
    4 10
    ...+.##+.+
    +#++..+++#
    ++.#++++..
    .+##.++#.+
    output
    42
    input
    2 2
    ..
    ++
    output
    Never

    分析:模拟每一层时,设置左右边界,避免重复耗时计算

    #include<cstdio>
    #include<cstring>
    #include<iostream>
    #include<cmath>
    using namespace std;
    char map[110][10010];
    long long ans;
    
    int main() {
        int m, n, i, j, p = 1, l, r, t = 0;
        scanf("%d%d", &m, &n);
        for (i = 0; i < m; ++i) {
            scanf("%s", map[i] + 1);
            map[i][0] = map[i][n + 1] = '#';
        }
        for (i = 0; i < m - 1; ++i) {
            //printf("i=%d p=%d\n",i,p);
            //  cout<<ans<<endl;
            if (map[i + 1][p] == '.') {
                ++ans;
                continue;
            }
            l = p - 1;
            r = p + 1;
            while (1) {
                //   cout<<ans<<endl;
                //printf("l=%d r=%d\n",l,r);
                if (map[i][l] == '#' && map[i][r] == '#') {
                    printf("Never\n");
                    return 0;
                }
                ans += r - l - 2;
                if (!t) {
                    //printf("right\n");
                    while (map[i][r] == '.' && map[i + 1][r] != '.') {
                        ++r;
                        ++ans;
                    }
                    if (map[i][r] == '.') {
                        ans += 2;
                        p = r;
                        break;
                    }
                    if (map[i][r] == '+') {
                        t = !t;
                        ++ans;
                        map[i][r] = '.';
                    } else if (map[i][r] == '#') {
                        t = !t;
                        ++ans;
                    }
                } else {
                    //printf("left\n");
                    while (map[i][l] == '.' && map[i + 1][l] != '.') {
                        --l;
                        ++ans;
                    }
                    if (map[i][l] == '.') {
                        ans += 2;
                        p = l;
                        break;
                    }
                    if (map[i][l] == '+') {
                        t = !t;
                        ++ans;
                        map[i][l] = '.';
                    } else if (map[i][l] == '#') {
                        t = !t;
                        ++ans;
                    }
                }
            }
    
        }
        cout << ans << endl;
        return 0;
    }
    这条路我们走的太匆忙~拥抱着并不真实的欲望~
  • 相关阅读:
    字符串与字典常用命令
    Python学习之路:字符串常用操作
    Python学习之路:购物车实例
    面试题2017
    c#语法学习
    结构化设计模式-桥接模式
    结构型设计模式-适配器模式
    .Net Cache
    设计模式的六大原则
    uml类图关系
  • 原文地址:https://www.cnblogs.com/baidongtan/p/2796565.html
Copyright © 2011-2022 走看看