2022秋季《人工智能》_EOJ.F 字符路径

题目

思路

动态规划。
相当于构建一棵树，以坐标为节点，以在路径中的出现先后为层号，只不过树的根节点（起点）可能有多个坐标。题设即找最短权值路径，考虑使用动态规划。对每个坐标计算从起点到该坐标的最小代价，状态转移方程为
$$cost(curOrd)=\min (cost(fatherOrd)+calculateCost(curOrd,curFather))$$

代码

#include <bits/stdc++.h>

using namespace std;
#define MAXN 100
#define MAXM 100
#define INF 0x3ffff

char graph[MAXN][MAXM];

// 每个点对应的坐标
map<char,vector<pair<int,int>>> pointToOrd;

// 每个坐标对应的从起点到该坐标的最小代价
// 对于每个坐标，最小代价计算公式为min(cost(父坐标)+calculateCost(该点坐标，父坐标))
map<pair<int,int>,int> ordToCost;

int n,m,k;
string path;
int minCost=INF;

// 计算两坐标间的曼哈顿距离
int calculateCost(pair<int,int> a, pair<int,int> b)
{
    return abs(a.first-b.first)+abs(a.second-b.second);
}

// n:当前已搜索到0~t-1
void searchPath(int t)
{
    // 找到一条合法路径
    if(t==k-1)
    {
        return;
    }

    char cur=path[t];
    char next=path[t+1];
    // 对起点预处理，到起点的代价是0
    if(t==0)
    {
        for(auto i:pointToOrd[cur])
        {
            ordToCost[i]=0;
        }
    }

    for(auto itemNext:pointToOrd[next])
    {
        int iCost=INF;
        for(auto itemCur:pointToOrd[cur])
        {
            iCost=min(iCost,ordToCost[itemCur]+calculateCost(itemNext,itemCur));
        }
        ordToCost[itemNext]=iCost;
    }
    return searchPath(t+1);
}

int main()
{
    cin>>n>>m>>k;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            char tmp;cin>>tmp;
            graph[i][j]=tmp;
            pair<int,int> tmpOrd(i,j);
            pointToOrd[tmp].push_back(tmpOrd);
        }
    }

    cin>>path;

    searchPath(0);

    for(auto item:pointToOrd[path[k-1]])
    {
        minCost=min(ordToCost[item],minCost);
//        cout<<ordToCost[item]<<endl;
    }
    cout<<minCost<<endl;

    return 0;
}