CF 793D Presents in Bankopolis

D. Presents in Bankopolis

一个有向图，节点“有序”，找一条长度为k的最短路径，额外要求是当前边不能“跃过”已经经过的节点。
起点的选择范围是[1,n]然后每经过一个点，下一个能到达的点的范围就会缩小，注意到总可以用一个连续的范围表示之，记为[l,r]。那么用dp解决，状态dp[l][r][k]表示可达范围是[l,r]，已经走了k步。
貌似dp写成记忆化搜索更符合我的思维，但是这题写记忆化会T。。改递推还改了半天。。
以后能写递推的题，我再写记忆化我就是SB！！！

#include <bits/stdc++.h>

using namespace std;

#define ll long long

const int INF = 1e9;

int n,k;
int m;
const int Max = 88;

int e[Max][Max];

int dp[Max][Max][Max][2];

inline void ckMin(int &x,int y){
    if(x>y){
        x=y;
    }
}

int main(){
    cin>>n>>k;
    cin>>m;

    for(int i=0;i<Max;i++){
        for(int j=i;j<Max;j++){
            for(int kk=0;kk<Max;kk++){
                if(kk==k){
                    dp[i][j][kk][0] = dp[i][j][kk][1] = 0;
                }else{
                    dp[i][j][kk][0] = dp[i][j][kk][1] = INF;
                }
            }
        }
    }

    for(int i=1;i<=m;i++){
        int u,v,c;
        cin>>u>>v>>c;
        if(e[u][v] == 0){
            e[u][v] = c;
        }else{
            e[u][v] = min(e[u][v],c);
        }
    }

    if(k>n){
        cout<<-1<<endl;
        return 0;
    }

    for(int kk=k;kk>0;kk--){
        for(int l=1;l<=n;l++){
            for(int r=l;r<=n;r++){
                for(int pre=1;pre<l;pre++){
                    if(e[pre][l]){
                        ckMin(dp[pre][r][kk-1][1],dp[l][r][kk][1]+e[pre][l]);
                    }
                    if(e[pre][r]){
                        ckMin(dp[pre][r][kk-1][1],dp[l][r][kk][0]+e[pre][r]);
                    }

                }
                for(int pre=r+1;pre<=n;pre++){
                    if(e[pre][r]){
                        ckMin(dp[l][pre][kk-1][0],dp[l][r][kk][0]+e[pre][r]);
                    }
                    if(e[pre][l]){
                        ckMin(dp[l][pre][kk-1][0],dp[l][r][kk][1]+e[pre][l]);
                    }
                }
            }
        }
    }

    int ans = INF;
    for(int l=1;l<=n;l++){
        for(int r=l;r<=n;r++){
            ckMin(ans,dp[l][r][1][0]);
            ckMin(ans,dp[l][r][1][1]);
        }
    }

    if(ans<INF){
        cout<<ans<<endl;
    }else{
        cout<<-1<<endl;
    }
    return 0;
}