UVALive 6908 Electric Bike dp

Electric Bike

题目连接：

https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4920

Description

Two years ago, Putri bought an electric bike (e-bike). She likes e-bike a lot since it can assist her in

cycling through steep roads when commuting to work. Over time, the battery capacity decreases. Now,

her e-bike battery capacity is so low that she needs to carefully plan when to turn on the assist and at

which level; different level of assist consumes different amount of energy and produces different assist

power.

Putri divides the road that she travels from her home to her workplace into N segments where each

segment has a steepness level. For example, the figure below shows a road with N = 7 segments.

Segment #1 #2 #3 #4 #5 #6 #7

Steepness 10 3 0 1 2 15 9

From her home, Putri has to travel from the first road segment, to the second road segment, and so on,

until the last segment to reach her work place. In the example above, the first segment has steepness of

10 which means Putri has to pedal her bike with 10 unit of energy. Her e-bike has fixed 4 assist levels

where each level generates different power, as shown in the following table:

Assist Level 0 1 2 3

Assist Power 0 4 8 11

Assist level L will consume L unit of energy from the battery and will give Putri additional pedaling

assist power according to the table above. Putri can only change the assist level to level L if the battery

has at least L energy left and she is at the beginning of a road segment. Setting an assist level where

the generated power is higher than the road steepness will cause the excess energy power to be wasted.

For example, if Putri sets the assist level L = 2 at the beginning of the first road segment (with

steepness 10), then she only needs to pedal her bike with 2 unit of energy instead of 10 (since her ebike

is assisting her with 8 unit of energy) to advance to the second road segment. If Putri sets the assist

level L = 3, her e-bike generates more power to handle the steepness 10, thus she does not need to

pedal at all, and the excess energy is wasted.

Putri can change the assist level instantly before entering a road segment, however, she does not

want to change the assist level more than K times (it’s too tiring). If there is not enough energy in

the battery to support the selected assist level for the road segment, the e-bike will shutdown at the

beginning of the road segment and Putri has to pedal through the rest of the road segments, i.e. the

assist level automatically set to 0 for the rest of the journey. Note that Putri can change her e-bike

assist level (given it’s still less than K) at the beginning of the road segment to avoid shutdown by

force. Initially at her home, the assist level is set to 0 and the battery is fully charged with E unit of

energy. Putri wants to know the minimum energy she will need to pedal the bike to reach the workplace

if she utilizes her e-bike optimally.

Input

The first line of input contains T (T ≤ 100) denoting the number of cases. Each case begins with three

integers: N, K, and E in a line (1 ≤ N ≤ 1, 000; 0 ≤ K ≤ 10; 0 ≤ E ≤ 50) as described in the problem

statement above. The next line contains N non-negative integers denoting the steepness level of i-th

segment where i = 1 . . . N respectively. The steepness level of any road segment is at most 15.

Output

For each case, output ‘Case #X: Y ’, where X is the case number starts from 1 and Y is the minimum

energy Putri needs to pedal the e-bike from her home to her workplace.

Explanation for 1st sample case:

Putri changes the assist level to 1 at (the beginning of) road segment #2, then change the assist

level to 3 at road segment #6. Thus, she needs to pedal with 10 unit of energy for road segment #1 and

4 unit of energy for road segment #6. Note that if she changes the assist level to 1 at road segment #1

and then to assist level 3 at road segment #6, then at the beginning of road segment #7 the battery

only has 2 unit of energy left and will automatically shutdown to assist level 0, thus Putri has to pedal

with 9 energy for road segment #7.

Explanation for 2nd sample case:

Putri changes the assist level to 3 at road segment #1 and then changes to assist level 2 at road

segment #2. Thus, she only needs to pedal 7 unit of energy for road segment #6 and 1 unit of energy

for road segment #7.

Explanation for 3rd sample case:

Putri changes the assist level to 3 at road segment #1, then changes to assist level 1 at road segment

2, finally changes to assist level 3 at road segment #6. Thus, she only needs to pedal 4 unit of energy

for road segment #6.

Sample Input

5

7 2 10

10 3 0 1 2 15 9

7 2 15

10 3 0 1 2 15 9

7 3 15

10 3 0 1 2 15 9

5 2 5

11 15 1 14 12

15 8 30

2 14 6 1 2 13 14 12 13 12 7 12 1 2 10

Sample Output

Case #1: 14

Case #2: 8

Case #3: 4

Case #4: 34

Case #5: 18

Hint

题意

有n个线段，每个线段长a[i]米，然后你骑着一个电瓶车，电瓶车只有E的电，然后一档需要1能量，可以帮你爬4米，2档需要2能量，可以帮你爬8米，3档需要3能量，可以帮你爬11米。

然后你不够的时候，就只能自己骑上去。

你最多修改k次档位。

如果你能量不够的话，那么你就强行退回了0档，且不能变成其他档。

题解：

虽然是个DP，但实际上是一个模拟题，特别烦……

你就把题目中所有的变量，都当成dp状态跑一边就行了。……

其实可能写成记忆化搜索的形式，更好一点。

代码

#include<bits/stdc++.h>
using namespace std;
int dp[1005][11][51][4][2];
int p[4]={0,4,8,11};
int a[1005];
int cas;
//第i个位置,j次换档,花了k，当前档为t
void solve(){
    int n,k,e;
    scanf("%d%d%d",&n,&k,&e);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=0;i<1005;i++)
        for(int j=0;j<11;j++)
            for(int k=0;k<51;k++)
                for(int t=0;t<4;t++)
                    for(int i2=0;i2<2;i2++)
                        dp[i][j][k][t][i2]=1e9;
    dp[0][0][0][0][0]=0;
    dp[0][0][0][0][1]=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<=k;j++){
            for(int K=0;K<=e;K++){
                for(int t=0;t<4;t++){
                    for(int m=0;m<4;m++){
                        dp[i+1][j][K][0][1]=min(dp[i+1][j][K][0][1],dp[i][j][K][t][0]+a[i+1]);
                        dp[i+1][j][K][0][1]=min(dp[i+1][j][K][0][1],dp[i][j][K][0][1]+a[i+1]);
                        if(t==m){
                            if(K+m>e)
                                dp[i+1][j][K][0][1]=min(dp[i+1][j][K][0][1],dp[i][j][K][t][0]+a[i+1]);
                            else
                                dp[i+1][j][K+m][m][0]=min(dp[i+1][j][K+m][m][0],dp[i][j][K][t][0]+max(0,a[i+1]-p[m]));
                        }else{
                            if(j==k){
                                continue;
                            }else if(K+m>e)
                                dp[i+1][j+1][K][0][1]=min(dp[i+1][j+1][K][0][1],dp[i][j][K][t][0]+a[i+1]);
                            else
                                dp[i+1][j+1][K+m][m][0]=min(dp[i+1][j+1][K+m][m][0],dp[i][j][K][t][0]+max(0,a[i+1]-p[m]));
                        }
                    }
                }
            }
        }
    }
    int Ans = 1000000000;
    for(int j=0;j<=k;j++)
        for(int K=0;K<=e;K++)
            for(int t=0;t<4;t++)
                for(int i2=0;i2<2;i2++)
                Ans=min(Ans,dp[n][j][K][t][i2]);
    printf("Case #%d: %d\n",++cas,Ans);
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--)solve();
    return 0;
}