LeetCode---377周赛---Floyd算法+字典树

题目列表

2974. 最小数字游戏

2975. 移除栅栏得到的正方形田地的最大面积

2976. 转换字符串的最小成本 I

2977. 转换字符串的最小成本 II

一、最小数字游戏

这题看懂题意就好，可以结合示例模拟一下，你就会发现规律，本质就是将数组排序，然后将相邻两个数字交换一下即可

代码如下

class Solution {
public:
    vector numberGame(vector& nums) {
        sort(nums.begin(),nums.end());
        int n=nums.size();
        for(int i=0;i

 二、移除栏杆得到的正方形田地的最大面积

这题就是单纯暴力求解两个栏杆之间的距离，代码如下

class Solution {
public:
    unordered_set f(vector&a,int mx){
        a.push_back(1);
        a.push_back(mx);
        sort(a.begin(),a.end());
        unordered_sets;
        for(int i=0;i& hFences, vector& vFences) {
        auto h=f(hFences,m);
        auto v=f(vFences,n);
        int ans=0;
        for(auto x:h){
            if(v.count(x))
                ans=max(ans,x);
        }
        return ans?1LL*ans*ans%1000000007:-1;
    }
};

 三、转换字符串的最小成本I

这题的关键是你的看出来这是求全源最短路问题，题目要求将source变成target的最小成本，也就是字符之间的相互转换的代价最小，同时，题目允许出现一个字符到另一个字符中间有其他"中转站"的情况，很明显在考Floyd算法，代码如下

class Solution {
public:
    long long minimumCost(string source, string target, vector& original, vector& changed, vector& cost) {
        map,int>mp;
        int n=source.size();
        int m=original.size();
        vector>g(26,vector(26,-1));
        for(int i=0;i

四、转换字符串的最小成本II

这题和上一题一样，只是重字符之间的转化，改成了字符串之间的转换，我们依旧是用Floyd算法，但问题是我们如何标识和处理字符串，这里要用到字典树(208. 实现 Trie (前缀树) 标准的字典树模型，不认识的可以先去写这道题)。

同时，这题还需要用到dp，而且题目都帮我们降低难度了，说我们每次修改的区域不能出现重合。

状态定义为dp[i]表示以i为起始位置的字符串从source变成target的最小代价

dp[i]=min( dp[j] + g[i][j] ) 前提是区间[i，j]内的source字符串能变成target对应部分的字符串

代码如下

struct Node{
    Node*child[26]={0};
    int sid=-1;//用来标识字符串，表示以该结点为结尾的字符串序号
};

class Solution {
public:
    long long minimumCost(string source, string target, vector& original, vector& changed, vector& cost) {
        Node*root=new Node();
        int sid=0;
        //字典树
        functionput=[&](string s)->int{ 
            Node*node=root;
            for(auto e:s){
                int x=e-'a';
                if(node->child[x]==nullptr)
                    node->child[x]=new Node();
                node=node->child[x];
            }
            if(node->sid==-1)
                node->sid=sid++;
            return node->sid;
        };

        int n=original.size();
        vector>g(2*n,vector(2*n,-1));
        for(int i=0;imemo(m,-1);
        // functiondfs=[&](int i)->long long{
        //     if(i>=m) return 0;
        //     auto& res=memo[i];
        //     if(res!=-1) return res;
        //     res=LLONG_MAX/2;
        //     if(source[i]==target[i])//不要改
        //         res=dfs(i+1);
        //     Node*q=root,*p=root;
        //     for(int j=i;jchild[source[j]-'a'];
        //         p=p->child[target[j]-'a'];
        //         if(q==nullptr||p==nullptr)
        //             break;
        //         if(q->sid<0||p->sid<0)
        //             continue;
        //         int d=g[q->sid][p->sid];
        //         if(d!=-1)
        //             res=min(res,dfs(j+1)+d);
        //     }
        //     return res;
        // };
        // long long ans = dfs(0);
        // return ans < LLONG_MAX / 2 ? ans : -1;

        //递推写法
        vectordp(m+1);
        for(int i=m-1;i>=0;i--){
            long long res=LLONG_MAX/2;
            if(source[i]==target[i])//不要改
                res=dp[i+1];
            Node*q=root,*p=root;
            for(int j=i;jchild[source[j]-'a'];
                p=p->child[target[j]-'a'];
                if(q==nullptr||p==nullptr)
                    break;
                if(q->sid<0||p->sid<0)
                    continue;
                int d=g[q->sid][p->sid];
                if(d!=-1)
                    res=min(res,dp[j+1]+d);
            }
            dp[i]=res;
        }
        return dp[0]