ZOJ3555 Ice Climber(dp)

转载请注明出处： http://www.cnblogs.com/fraud/           ——by fraud

Ice Climber

---

Time Limit: 2 Seconds      Memory Limit: 32768 KB

---

Maybe many one have played or at least heard of The Family Computer(FC). And this problem is mainly about a classical game named "Ice Climber"

In this game, our little Eskimo wants to climb higher and catch the big bird at last. In the climbing, little Eskimo may be faced with many troubles, like enemy or wall.

The game field made up with several floors and floors are seperated by many pieces of bricks. The number of pieces between different floors and different positions are different. There may also be enimies and walls on these bricks. By jumping up Eskimo can decrease the number of pieces on the ceiling of his position or even jump to another floor.

Each time Eskimo can choose on of the following steps:

• Move left or right one block as long as the block is empty and the block has supporting pieces of bricks, using t1 time.(That is, there will not be an enemy or a wall on the block and the block has at least one bricks)
• Jump up and destroy one piece of brick of the ceil just above little Eskimo or Jump up to an upper floor if all bricks on the ceiling of his current position have been cleared. If he jumps to the next floor he can choose to land on either the left or the right adjacent position as long as there are no enimies or walls on them (Of course there must also be at least a supporting brick at that position). Both kind of jumping takes t2 time.
• Knock off one little enemy just next to little Eskimo in t3 time, and the enemy will disappear.

Each block has several pieces. And only if the number of the pieces of the block is 0 can little Eskimo jump up through it to the next floor. Sometimes Eskimo may clear all the bricks of ceiling of a position where there is an enemy standing on it, in these cases this unlucky enemy will be cleared at once. If on the next floor, above one block there is a wall, then Eskimo can never jump up through this block no matter how much pieces it has even zero. If little Eskimo jumped up to the next floor successfully, for instance through the ith position, he can choose to land on either to the left, the i-1_th block or to the right, the i+1_th block as you like, but not the i_th block itself. And you can never jump over the enemy or the wall or the zero pieces blocks.

And in the whole process, little Eskimo can not land on to the side, that is, he can not land on to the 0_th block or the w+1_th block. Also, he cannot land on to where there are only zero pieces blocks or blocks with an enemy or blocks with a wall. And while moving, he cannot get to the 1_st block from the n_th block, or get to the n_th block from the 1_st block.

And just like the picture below, the 2_nd floor's floor is the 1_st floor's ceil:

Now, we have n floors, and each floor has the same width of w blocks, but the number of the pieces of each block can be different. Thus, we can get a map of these floors. Little Eskimo starts from the leftest block on the first floor, unlike the picture above, and we want to use the minimum time to get to the n_th floor.(Any block on the n_th is all right)

Input

The input contains multiple cases.

In each case, the first line contains two integers represents n and w.(1<=n<=2000 , 1<=w<=100)

The second line contains three integers represents t1, t2, andt3.(0<=t1,t2,t3<=100)

Then the 2n lines, the odd lines contains w characters, describing what is on the floor: '#' represents the enemy, which we assume does not move, '|' represents wall, and '0' represents the block is empty. While the even lines contains w digits from '0' to '9' representing the number of the pieces of each block.

[Notice]: the map inputs from the n_th floor downto the 1_st floor, that is, the first line of this map describes what is on the n_th floor, and the second line of this map describes the number of the pieces of each block of n_th floor, or the n-1_th floor's ceil.

Output

In each case, output one line with an integer representing the minimum time little Eskimo can get to the n_th floor. If there is no way to get to the n_th floor, output -1.

Sample Input

This sample input just describe the picture above.

5 22
1 2 3
0000000000000000000000
2222212222122222221222
0000000000000000000000
2122222122222221112222
000000000000000000000#
2222212221222222222111
0000000000000000000000
2222222222112222222221
0000#00000000000000000
1111111111111111111111

Sample Output

23

题目很长，大致规则和游戏中差不多，从最下面一层的左边出发，不能越过墙‘|’，打掉一个怪的时间是t3,水平走一步的时间是t1，往左上或者右上跳，并且打掉上方一个砖块的时间是t2，不能碰到怪，不能踩在空中，另外还有一些细节，然后要求到达最上面一层最少需要多少时间

dp[i][j] 表示走到第i层最少花费时间，这个点可以从下面一层任意一个可达的地方转移过来，所以复杂度就是n*w*w

/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author xyiyy @https://github.com/xyiyy
 */

#include <iostream>
#include <fstream>

//#####################
//Author:fraud
//Blog: http://www.cnblogs.com/fraud/
//#####################
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <sstream>
#include <ios>
#include <iomanip>
#include <functional>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <cctype>

using namespace std;
#define INF 0x3FFFFFFF
#define rep(X, N) for(int X=0;X<N;X++)
#define rep2(X, L, R) for(int X=L;X<=R;X++)
#define dep(X, R, L) for(int X=R;X>=L;X--)

char f[2010][110], s[2010][110];
int dp[2010][110];

class TaskG {
public:
    void solve(std::istream &in, std::ostream &out) {
        int n, w;
        while (in >> n >> w) {
            int t1, t2, t3;
            in >> t1 >> t2 >> t3;
            rep2(i, 1, n) {
                in >> f[i] + 1;
                in >> s[i] + 1;
            }
            rep(i, n + 10) {
                rep(j, w + 10)dp[i][j] = INF;
            }
            dp[n][1] = 0;
            int num = 0;
            if (f[n][1] == '|' || s[n][1] == '0')dp[n][1] = INF;
            rep2(i, 2, w) {
                if (f[n][i] == '|' || s[n][i] == '0')break;
                if (f[n][i] == '#')num += t3;
                num += t1;
                dp[n][i] = dp[n][1] + num;
            }
            dep(i, n - 1, 1) {
                rep2(j, 1, w) {
                    if (f[i][j] == '|' || s[i][j] == '0')continue;
                    num = 0;
                    if (f[i][j] == '#')num += t3;
                    bool ok = 0;
                    dep(k, j - 1, 1) {
                        if (f[i][k] == '|')break;
                        if (s[i][k] == '0')ok = 1;
                        if (f[i][k + 1] != '#') dp[i][j] = min(dp[i][j], dp[i + 1][k] + num + (s[i][k] - '0' + 1) * t2);
                        if (f[i][k] == '#')num += t3;
                        num += t1;
                        if (ok)break;
                    }
                    ok = 0;
                    num = 0;
                    if (f[i][j] == '#')num += t3;
                    rep2(k, j + 1, w) {
                        if (f[i][k] == '|')break;
                        if (s[i][k] == '0')ok = 1;
                        if (f[i][k - 1] != '#')dp[i][j] = min(dp[i][j], dp[i + 1][k] + num + (s[i][k] - '0' + 1) * t2);
                        if (f[i][k] == '#')num += t3;
                        num += t1;
                        if (ok)break;
                    }
                }
            }
            int ans = INF;
            rep2(i, 1, w)ans = min(ans, dp[1][i]);
            if (ans == INF)ans = -1;
            out << ans << endl;
        }
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    TaskG solver;
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    solver.solve(in, out);
    return 0;
}