动态规划 多源路径 字典树 LeetCode2977:转换字符串的最小成本

news2025/1/20 18:29:19

涉及知识点

动态规划 多源最短路径 字典树

题目

给你两个下标从 0 开始的字符串 source 和 target ，它们的长度均为 n 并且由 小写 英文字母组成。
另给你两个下标从 0 开始的字符串数组 original 和 changed ，以及一个整数数组 cost ，其中 cost[i] 代表将字符串 original[i] 更改为字符串 changed[i] 的成本。
你从字符串 source 开始。在一次操作中，如果 存在 任意 下标 j 满足 cost[j] == z 、original[j] == x 以及 changed[j] == y ，你就可以选择字符串中的 子串 x 并以 z 的成本将其更改为 y 。 你可以执行 任意数量 的操作，但是任两次操作必须满足 以下两个 条件 之一 ：
在两次操作中选择的子串分别是 source[a…b] 和 source[c…d] ，满足 b < c 或 d < a 。换句话说，两次操作中选择的下标 不相交 。
在两次操作中选择的子串分别是 source[a…b] 和 source[c…d] ，满足 a == c 且 b == d 。换句话说，两次操作中选择的下标 相同 。
返回将字符串 source 转换为字符串 target 所需的 最小 成本。如果不可能完成转换，则返回 -1 。
注意，可能存在下标 i 、j 使得 original[j] == original[i] 且 changed[j] == changed[i] 。
示例 1：
输入：source = “abcd”, target = “acbe”, original = [“a”,“b”,“c”,“c”,“e”,“d”], changed = [“b”,“c”,“b”,“e”,“b”,“e”], cost = [2,5,5,1,2,20]
输出：28
解释：将 “abcd” 转换为 “acbe”，执行以下操作：

  • 将子串 source[1…1] 从 “b” 改为 “c” ，成本为 5 。
  • 将子串 source[2…2] 从 “c” 改为 “e” ，成本为 1 。
  • 将子串 source[2…2] 从 “e” 改为 “b” ，成本为 2 。
  • 将子串 source[3…3] 从 “d” 改为 “e” ，成本为 20 。
    产生的总成本是 5 + 1 + 2 + 20 = 28 。
    可以证明这是可能的最小成本。
    示例 2：
    输入：source = “abcdefgh”, target = “acdeeghh”, original = [“bcd”,“fgh”,“thh”], changed = [“cde”,“thh”,“ghh”], cost = [1,3,5]
    输出：9
    解释：将 “abcdefgh” 转换为 “acdeeghh”，执行以下操作：
  • 将子串 source[1…3] 从 “bcd” 改为 “cde” ，成本为 1 。
  • 将子串 source[5…7] 从 “fgh” 改为 “thh” ，成本为 3 。可以执行此操作，因为下标 [5,7] 与第一次操作选中的下标不相交。
  • 将子串 source[5…7] 从 “thh” 改为 “ghh” ，成本为 5 。可以执行此操作，因为下标 [5,7] 与第一次操作选中的下标不相交，且与第二次操作选中的下标相同。
    产生的总成本是 1 + 3 + 5 = 9 。
    可以证明这是可能的最小成本。
    示例 3：
    输入：source = “abcdefgh”, target = “addddddd”, original = [“bcd”,“defgh”], changed = [“ddd”,“ddddd”], cost = [100,1578]
    输出：-1
    解释：无法将 “abcdefgh” 转换为 “addddddd” 。
    如果选择子串 source[1…3] 执行第一次操作，以将 “abcdefgh” 改为 “adddefgh” ，你无法选择子串 source[3…7] 执行第二次操作，因为两次操作有一个共用下标 3 。
    如果选择子串 source[3…7] 执行第一次操作，以将 “abcdefgh” 改为 “abcddddd” ，你无法选择子串 source[1…3] 执行第二次操作，因为两次操作有一个共用下标 3 。
    参数范围：
    1 <= source.length == target.length <= 1000
    source、target 均由小写英文字母组成
    1 <= cost.length == original.length == changed.length <= 100
    1 <= original[i].length == changed[i].length <= source.length
    original[i]、changed[i] 均由小写英文字母组成
    original[i] != changed[i]
    1 <= cost[i] <= 106

分析

将s按顺序拆分成若干子串，任何字符都在一个子串中，且只在一个字串中。求这些子串全部转成t的最小成本。

动态规划

动态规划之状态表示dp[i]表示将s[0,i)转化成t[0,i)的最小成本
动态规划之状态转移方程dp[j]=min(dp[i]+s[i,j)转化成t[i,j)成本), i取值范围[0,j)
动态规划之状态之初始化dp[0]=0
动态规划之状态之填表顺序两层循环枚举i,j ，先枚举i,再枚举j。s[i,j)是最后一个子串
动态规划之状态之返回值dp.back()

字符经过多次转化的最小成本

本质就是最短多源路径。

将字符串转成整数（节点编号）

如果用哈希map，每次是O(n)，就超时了。可以自写哈希或用字典树，从查询s[i,j)到s[i+j+1)时间复杂度是O(1)。总时间复杂度是O(n2)。

测试用例

template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}
}


int main()
{

	string source, target;
	vector<string> original, changed;
	vector<int> cost;

	{
		Solution sln;
		source = "abcdefgh", target = "acdeeghh", original = { "bcd", "fgh", "thh" }, changed = { "cde", "thh", "ghh" }, cost = { 1, 3, 5 };
		auto res = sln.minimumCost(source, target, original, changed, cost);
		Assert(9LL, res);
	}
	{
		Solution sln;
		source = "abcd", target = "acbe";
		original = { "a", "b", "c", "c", "e", "d" }, changed = { "b", "c", "b", "e", "b", "e" };
		cost = { 2, 5, 5, 1, 2, 20 };
		auto res = sln.minimumCost(source, target, original, changed, cost);
		Assert(28LL, res);
	}
	{
		Solution sln;
		source = "abbaacddcbacbddcbdbddcadbadbbdbaabcdbdbdcaccacaddcabadadaccabbddbbdacaacdbdcaaddcacbcbcaaacaddabcabc";
		target = "abbaacdbcbabcadcbdbddcadbadbbddaabcdbdddcacadbacabcbdbbbbdaabbddbbdaabbcdbdcaaddcacbcbcadadccdcbcbcb";
		original = { "b", "c", "a", "cbd", "adc", "ddb", "dcb", "dbd", "b", "caac", "acdc", "cbbd", "bcdb", "ddbc", "aacadda", "cbadbbd", "aaabcad", "bacdccc", "ddabdaa", "abc", "bbc", "cdd", "ddb", "cacaddcabad", "bdcdccabdcb", "bddbbabdcac", "adacc", "bbdca", "dabad", "cddcba" };
		changed = { "c", "a", "d", "adc", "ddb", "dcb", "dbd", "bca", "d", "acdc", "cbbd", "bcdb", "ddbc", "abbc", "cbadbbd", "aaabcad", "bacdccc", "ddabdaa", "dadccdc", "bbc", "cdd", "ddb", "bcb", "bdcdccabdcb", "bddbbabdcac", "adbacabcbdb", "bbdca", "dabad", "bbbda", "cdbcba" };
		cost = { 63, 87, 77, 94, 100, 73, 99, 16, 89, 94, 76, 43, 76, 84, 83, 38, 96, 87, 34, 98, 33, 53, 58, 90, 61, 51, 92, 76, 91, 70 };
		auto res = sln.minimumCost(source, target, original, changed, cost);
		Assert(2044LL, res);
	}
		
	{
		Solution sln;
		source = "aaaddcaaccbabaaccbabbaadcccadbaacbddbaccabddbdbaaddbbacbddddbbdbccaadcaccacdbcbddbacabadaaccbadbbdbc";
		target = "abaddcabcdbabcbadcaccaadabbadddbcacaaabdabbdcbbdbcbaaabbbcddcbddcbccadacddcbdcbacadbbadbdabcbadbbdac";
		original = { "ddddb", "dccbb", "dadac", "dbdbb", "ddbacabadaac", "bcbccdcadabd", "dacabcdaacca", "dcdadacacbbd", "dcccadbaacbddbacc", "dcdcbccdccdbaaaac", "bbbcccdbcdcadaabc", "bccaadcaccacdb", "bbcabcbcbaddbd", "dbadadaddcddad", "badaddbcddacca", "bc", "da", "cb", "ddbdbaaddbbac", "dbcadcdbabddd", "abdadacbbbcca", "adaaabcabdbcc", "caaccbabaaccbabba", "abaadddbaaccbbacc", "bbddaaadcbccccbac", "cdbdbddaadbbbdbdd", "bcbdaabaddbdcdcaa", "aa", "cb", "dd" };
		changed = { "dccbb", "dadac", "dbdbb", "bcddc", "bcbccdcadabd", "dacabcdaacca", "dcdadacacbbd", "acadbbadbdab", "dcdcbccdccdbaaaac", "bbbcccdbcdcadaabc", "dabbadddbcacaaabd", "bbcabcbcbaddbd", "dbadadaddcddad", "badaddbcddacca", "dcbccadacddcbd", "da", "cb", "ac", "dbcadcdbabddd", "abdadacbbbcca", "adaaabcabdbcc", "bdcbbdbcbaaab", "abaadddbaaccbbacc", "bbddaaadcbccccbac", "cdbdbddaadbbbdbdd", "bcbdaabaddbdcdcaa", "cabcdbabcbadcacca", "cb", "dd", "ba" };
		cost = { 67, 56, 64, 83, 100, 73, 95, 97, 100, 98, 20, 92, 58, 70, 95, 77, 95, 93, 69, 92, 77, 53, 96, 68, 83, 96, 93, 64, 81, 100 };
		auto res = sln.minimumCost(source, target, original, changed, cost);
		Assert(2405LL, res);
	}

	

	

//CConsole::Out(res);
}

代码

我写了N版都超时，单个用例不超时，总用例超时。用题解的代码运行了错误和超时用例，速度比我的速度快了近一半。算了，不继续优化了，许多比赛的技巧是工作的灾难，比如用原生数组代替vector。

第六版超时

template<class TData, TData defData,int iTypeNum = 26, TData cBegin = 'a'>
class CTrie
{
public:
	CTrie() 
	{
		m_iID = s_ID++;
	}
	int GetLeadCount()
	{
		return m_iLeafCount;
	}
	template<class IT>
	int Add(IT begin, IT end)
	{
		int iLeve = 0;
		CTrie* pNode = this;
		for (; begin != end; ++begin)
		{
			pNode = pNode->AddChar(*begin);			
			pNode->m_iLeve = iLeve++;
		}
		if (-1 == pNode->m_iLeafID)
		{
			pNode->m_iLeafID = m_iLeafCount++;
		}
		return pNode->m_iLeafID;
	}
	template<class IT>
	CTrie* Search(IT begin, IT end)
	{
		if (begin == end)
		{
			return this;
		}

		if ('.' == *begin)
		{
			for (auto& ptr : m_vPChilds)
			{
				if (!ptr)
				{
					continue;
				}
				auto pSearch = ptr->Search(begin + 1, end);
				if (pSearch)
				{
					return pSearch;
				}
			}
			return nullptr;
		}

		auto ptr = GetChild(*begin);
		if (nullptr == ptr)
		{
			return nullptr;
		}
		return ptr->Search(begin + 1, end);
	}
	TData m_data = defData;

	CTrie* AddChar(TData ele)
	{
		if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
		{
			return nullptr;
		}
		const int index = ele - cBegin;
		auto ptr = m_vPChilds[index];
		if (!ptr)
		{
			m_vPChilds[index] = new CTrie();
		}
		return m_vPChilds[index];
	}
	CTrie* GetChild(TData ele)const
	{
		if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
		{
			return nullptr;
		}
		return m_vPChilds[ele - cBegin];
	}
protected:
	int m_iID;
public:
	int m_iLeafID=-1;
protected:
	int m_iLeve=-1;
	
	inline static int s_ID = 0;
	 int m_iLeafCount = 0;
	CTrie* m_vPChilds[iTypeNum] = { nullptr };
};

template<char defData='a', int iTypeNum = 26, char cBegin = 'a'>
class CStrTrieHelp 
{
public:
	int Add(const string& s)
	{
		return m_trie.Add(s.begin(), s.begin() + s.length());
	}
	CTrie<char, defData, iTypeNum, cBegin>* Search(const string& s)
	{
		return m_trie.Search(s.begin(), s.begin() + s.length());
	}
	CTrie<char, defData, iTypeNum, cBegin>* SearchSub(const string& s,int iPos,int len)
	{
		return m_trie.Search(s.begin()+ iPos, s.begin() + iPos + len );
	}
	CTrie<char, defData, iTypeNum, cBegin> m_trie;
};
template<char defData = 'a', int iTypeNum = 26, char cBegin = 'a'>
class CStrIndexs
{
public:
	void Add(const string& s)
	{
		m_trie.Add(s);
	}
	int Seach(const string& s)
	{
		auto p = m_trie.Search(s);
		if (nullptr == p)
		{
			return -1;
		}
		return p->m_iLeafID;
	}
	int SearchSub(const string& s, int iPos, int len)
	{
		auto p = m_trie.SearchSub(s, iPos, len);
		if (nullptr == p)
		{
			return -1;
		}
		return p->m_iDebug;
	}

	CStrTrieHelp<defData, iTypeNum, cBegin> m_trie;
};

//多源码路径
template<class T,T INF = 1000*1000*1000>
class CFloyd
{
public:
	CFloyd(const  vector<vector<T>>& mat)
	{
		m_vMat = mat;
		const int n = mat.size();
		for (int i = 0; i < n; i++)
		{//通过i中转
			for (int i1 = 0; i1 < n; i1++)
			{
				for (int i2 = 0; i2 < n; i2++)
				{
					//此时：m_vMat[i1][i2] 表示通过[0,i)中转的最短距离
					m_vMat[i1][i2] = min(m_vMat[i1][i2], m_vMat[i1][i] + m_vMat[i][i2]);
					//m_vMat[i1][i2] 表示通过[0,i]中转的最短距离
				}
			}
		}		
	};
	vector<vector<T>> m_vMat;
};

class Solution {
public:
	long long minimumCost(string source, string target, vector<string>& original, vector<string>& changed, vector<int>& cost) {
		CStrIndexs strIndexs;
		for (const auto& s : original)
		{
			strIndexs.Add(s);
		}
		for (const auto& s : changed)
		{
			strIndexs.Add(s);
		}
		const int iNotMay = 1000 * 1000 * 1000;
		vector<vector<int>> vMat(strIndexs.m_trie.m_trie.GetLeadCount(), vector<int>(strIndexs.m_trie.m_trie.GetLeadCount(), iNotMay));
		for (int j = 0; j < original.size(); j++)
		{
			const int iSrc = strIndexs.Seach(original[j]);
			const int iDest = strIndexs.Seach(changed[j]);			
			auto& n = vMat[iSrc][iDest];
			n = min(n, cost[j]);
		}
		for (int i = 0; i < strIndexs.m_trie.m_trie.GetLeadCount(); i++)
		{
			vMat[i][i] = 0;
		}
		CFloyd floyd(vMat);
		vector<long long> vRet(source.length() + 1, LLONG_MAX / 1000);
		vRet[0] = 0;
		for (int i = 0; i < source.length(); i++)
		{
			bool bSame = true;
			auto pSrc = &strIndexs.m_trie.m_trie;
			auto pDst = &strIndexs.m_trie.m_trie;
			for (int len = 1; len + i <= source.length(); len++)
			{
				const char ch1 = source[len + i - 1];
				const char ch2 = target[len + i - 1];				
				bSame &= (ch1 == ch2);
				if (nullptr != pSrc)
				{
					pSrc = pSrc->GetChild(ch1);
				}
				if (nullptr != pDst)
				{
					pDst = pDst->GetChild(ch2);
				}
				if (bSame)
				{
					vRet[i + len] = min(vRet[i + len], vRet[i]);
					continue;
				}					
				if ((nullptr == pSrc) || (nullptr == pDst))
				{
					break;
				}
				const int iSrc = pSrc->m_iLeafID;
				const int iDest = pDst->m_iLeafID;
				if ((-1 == iSrc) || (-1== iDest))
				{
					continue;
				}
				const int iDist = floyd.m_vMat[iSrc][iDest];
				if (iDist >= iNotMay)
				{
					continue;
				}
				vRet[i + len] = min(vRet[i + len], vRet[i] + iDist);
			}
		}
		return (vRet.back() >= LLONG_MAX / 1000) ? -1 : vRet.back();
	}
};

第一版超时

//多源码路径
template<class T,T INF = 100010001000>
class CFloyd
{
public:
CFloyd(const vector<vector>& mat)
{
m_vMat = mat;
const int n = mat.size();
for (int i = 0; i < n; i++)
{//通过i中转
for (int i1 = 0; i1 < n; i1++)
{
for (int i2 = 0; i2 < n; i2++)
{
//此时：m_vMat[i1][i2] 表示通过[0,i)中转的最短距离
m_vMat[i1][i2] = min(m_vMat[i1][i2], m_vMat[i1][i] + m_vMat[i][i2]);
//m_vMat[i1][i2] 表示通过[0,i]中转的最短距离
}
}
}
};
vector<vector> m_vMat;
};

class Solution {
public:
long long minimumCost(string source, string target, vector& original, vector& changed, vector& cost) {
vector strs(original.begin(), original.end());
strs.insert(strs.end(), changed.begin(), changed.end());
sort(strs.begin(),strs.end());
strs.erase(std::unique(strs.begin(), strs.end()), strs.end());
std::unordered_map<string, int> mStrToNode;
for (int i = 0; i < strs.size(); i++)
{
mStrToNode[strs[i]] = i;
}
const int iNotMay = 1000 * 1000 * 1000;
vector<vector> vMat(strs.size(), vector(strs.size(), iNotMay));
vector vOriNode;
for (int j = 0; j < original.size(); j++)
{
vOriNode.emplace_back(mStrToNode[original[j]]);
auto& n = vMat[vOriNode.back()][mStrToNode[changed[j]]];
n = min(n,cost[j]);
}
for (int i = 0; i < strs.size(); i++)
{
vMat[i][i] = 0;
}
CFloyd floyd(vMat);
vector vRet(source.length() + 1,LLONG_MAX/1000 );
vRet[0]=0;
for (int i = 0; i < source.length(); i++)
{
if (source[i] == target[i])
{
vRet[i + 1] = min(vRet[i+1],vRet[i]);
//continue; 相等也可以替换
}
for (int j = 0; j < original.size(); j++)
{
const int len = original[j].length();
if (i + len > source.length())
{
continue;
}
if (source.substr(i, len) != original[j])
{
continue;
}
string sDst = target.substr(i, len);
if (!mStrToNode.count(sDst))
{
continue;
}
const int iDest = mStrToNode[sDst];
const int iDist = floyd.m_vMat[vOriNode[j]][iDest];
if (iDist >= iNotMay)
{
continue;
}
vRet[i + len] = min(vRet[i + len],vRet[i]+iDist);
}
}
return (vRet.back() >= LLONG_MAX / 1000) ? -1 : vRet.back();
}
};

第二版超时

//多源码路径
template<class T,T INF = 100010001000>
class CFloyd
{
public:
CFloyd(const vector<vector>& mat)
{
m_vMat = mat;
const int n = mat.size();
for (int i = 0; i < n; i++)
{//通过i中转
for (int i1 = 0; i1 < n; i1++)
{
for (int i2 = 0; i2 < n; i2++)
{
//此时：m_vMat[i1][i2] 表示通过[0,i)中转的最短距离
m_vMat[i1][i2] = min(m_vMat[i1][i2], m_vMat[i1][i] + m_vMat[i][i2]);
//m_vMat[i1][i2] 表示通过[0,i]中转的最短距离
}
}
}
};
vector<vector> m_vMat;
};

class Solution {
public:
long long minimumCost(string source, string target, vector& original, vector& changed, vector& cost) {
vector strs(original.begin(), original.end());
strs.insert(strs.end(), changed.begin(), changed.end());
sort(strs.begin(),strs.end());
strs.erase(std::unique(strs.begin(), strs.end()), strs.end());
std::unordered_map<string, int> mStrToNode;
for (int i = 0; i < strs.size(); i++)
{
mStrToNode[strs[i]] = i;
}
const int iNotMay = 1000 * 1000 * 1000;
vector<vector> vMat(strs.size(), vector(strs.size(), iNotMay));
for (int j = 0; j < original.size(); j++)
{
auto& n = vMat[mStrToNode[original[j]]][mStrToNode[changed[j]]];
n = min(n,cost[j]);
}
for (int i = 0; i < strs.size(); i++)
{
vMat[i][i] = 0;
}
CFloyd floyd(vMat);
vector vRet(source.length() + 1,LLONG_MAX/1000 );
vRet[0]=0;
for (int i = 0; i < source.length(); i++)
{
for (int len = 1; len + i <= source.length(); len++)
{
const string sSrc = source.substr(i, len);
const string sDst = target.substr(i, len);
if (sSrc == sDst)
{
vRet[i + len] = min(vRet[i + len], vRet[i] );
continue;
}
if (!mStrToNode.count(sDst)|| !mStrToNode.count(sSrc))
{
continue;
}
const int iSrc = mStrToNode[sSrc];
const int iDest = mStrToNode[sDst];
const int iDist = floyd.m_vMat[iSrc][iDest];
if (iDist >= iNotMay)
{
continue;
}
vRet[i + len] = min(vRet[i + len], vRet[i] + iDist);
}
}
return (vRet.back() >= LLONG_MAX / 1000) ? -1 : vRet.back();
}
};

第四版超时

template<class TData, TData defData,int iTypeNum = 26, TData cBegin = ‘a’>
class CTrie
{
public:
CTrie()
{

}
template<class IT>
CTrie* Add(IT begin, IT end,const int iDebug)
{
	int iLeve = 0;
	CTrie* pNode = this;
	for (; begin != end; ++begin)
	{
		pNode = pNode->AddChar(*begin);			
		pNode->m_iLeve = iLeve++;
	}
	pNode->m_iDebug = iDebug;
	return pNode;
}
template<class IT>
CTrie* Search(IT begin, IT end)
{
	if (begin == end)
	{
		return this;
	}

	if ('.' == *begin)
	{
		for (auto& ptr : m_vPChilds)
		{
			if (!ptr)
			{
				continue;
			}
			auto pSearch = ptr->Search(begin + 1, end);
			if (pSearch)
			{
				return pSearch;
			}
		}
		return nullptr;
	}

	auto ptr = GetChild(*begin);
	if (nullptr == ptr)
	{
		return nullptr;
	}
	return ptr->Search(begin + 1, end);
}
TData m_data = defData;

CTrie* AddChar(TData ele)
{
	if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
	{
		return nullptr;
	}
	const int index = ele - cBegin;
	auto ptr = m_vPChilds[index];
	if (!ptr)
	{
		m_vPChilds[index] = new CTrie();
	}
	return m_vPChilds[index];
}

CTrie* GetChild(TData ele)const
{
	if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
	{
		return nullptr;
	}
	return m_vPChilds[ele - cBegin];
}

int m_iDebug=-1;

protected:
int m_iLeve=-1;
CTrie* m_vPChilds[iTypeNum] = { nullptr };
};

template<char defData, int iTypeNum = 26, char cBegin = ‘a’>
class CStrTrieHelp
{
public:
CTrie<char, defData, iTypeNum, cBegin>* Add(const string& s,int iDebug)
{
return m_trie.Add(s.begin(), s.begin() + s.length(), iDebug);
}
CTrie<char, defData, iTypeNum, cBegin>* Search(const string& s)
{
return m_trie.Search(s.begin(), s.begin() + s.length());
}
CTrie<char, defData, iTypeNum, cBegin>* SearchSub(const string& s,int iPos,int len)
{
return m_trie.Search(s.begin()+ iPos, s.begin() + iPos + len );
}
CTrie<char, defData, iTypeNum, cBegin> m_trie;
};
template<char defData = ‘a’, int iTypeNum = 26, char cBegin = ‘a’>
class CStrIndexs
{
public:
void Add(const string& s, int iDebug)
{
m_trie.Add(s, iDebug);
}
int Seach(const string& s)
{
auto p = m_trie.Search(s);
if (nullptr == p)
{
return -1;
}
return p->m_iDebug;
}
int SearchSub(const string& s, int iPos, int len)
{
auto p = m_trie.SearchSub(s, iPos, len);
if (nullptr == p)
{
return -1;
}
return p->m_iDebug;
}
protected:
CStrTrieHelp<defData, iTypeNum, cBegin> m_trie;
};

//多源码路径
template<class T,T INF = 100010001000>
class CFloyd
{
public:
CFloyd(const vector<vector>& mat)
{
m_vMat = mat;
const int n = mat.size();
for (int i = 0; i < n; i++)
{//通过i中转
for (int i1 = 0; i1 < n; i1++)
{
for (int i2 = 0; i2 < n; i2++)
{
//此时：m_vMat[i1][i2] 表示通过[0,i)中转的最短距离
m_vMat[i1][i2] = min(m_vMat[i1][i2], m_vMat[i1][i] + m_vMat[i][i2]);
//m_vMat[i1][i2] 表示通过[0,i]中转的最短距离
}
}
}
};
vector<vector> m_vMat;
};

class Solution {
public:
long long minimumCost(string source, string target, vector& original, vector& changed, vector& cost) {
vector strs(original.begin(), original.end());
strs.insert(strs.end(), changed.begin(), changed.end());
sort(strs.begin(), strs.end());
strs.erase(std::unique(strs.begin(), strs.end()), strs.end());
CStrIndexs strIndexs;
for (int i = 0; i < strs.size(); i++)
{
strIndexs.Add(strs[i], i);
}
const int iNotMay = 1000 * 1000 * 1000;
vector<vector> vMat(strs.size(), vector(strs.size(), iNotMay));
for (int j = 0; j < original.size(); j++)
{
const int iSrc = strIndexs.Seach(original[j]);
const int iDest = strIndexs.Seach(changed[j]);
auto& n = vMat[iSrc][iDest];
n = min(n, cost[j]);
}
for (int i = 0; i < strs.size(); i++)
{
vMat[i][i] = 0;
}
CFloyd floyd(vMat);
vector vRet(source.length() + 1, LLONG_MAX / 1000);
vRet[0] = 0;
for (int i = 0; i < source.length(); i++)
{
bool bSame = true;
for (int len = 1; len + i <= source.length(); len++)
{
bSame &= (source[len + i - 1] == target[len + i - 1]);
if (bSame)
{
vRet[i + len] = min(vRet[i + len], vRet[i]);
continue;
}
const int iSrc = strIndexs.SearchSub(source, i, len);
const int iDest = strIndexs.SearchSub(target, i, len);
if ((-1 == iSrc) || (-1== iDest))
{
continue;
}
const int iDist = floyd.m_vMat[iSrc][iDest];
if (iDist >= iNotMay)
{
continue;
}
vRet[i + len] = min(vRet[i + len], vRet[i] + iDist);
}
}
return (vRet.back() >= LLONG_MAX / 1000) ? -1 : vRet.back();
}
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用C++ 实现。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1339745.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FreeRTOS基础知识（一）任务调度

FreeRTOS基础知识（一）任务调度

1任务调度器简介&#xff08;熟悉&#xff09; 1.1抢占式调度 特点&#xff1a; 1、 高优先级抢占低优先级 2、高优先级任务不停止&#xff0c;低优先级无法运行 3、被抢占的任务会进入就绪态 举例 阐述一下啊Task1 2 3 任务优先级分别为1 2 3 &#xff08;freertos中数值越…
阅读更多...
C1189#error: WinSock.h has already been included解决方案

C1189#error: WinSock.h has already been included解决方案

最近在做项目移植过程中遇到这个报错&#xff0c;解决了半天。简单记录下解决方案&#xff0c;以供给大家提供一个思路。 原因&#xff1a; 在工程中使用了Boot库之后&#xff0c;使用了socket、tcp相关的头文件&#xff0c;在其他地方还是包括了头文件<windows.h>&…
阅读更多...
leetcode的vscode插件无法登陆问题及解决办法

leetcode的vscode插件无法登陆问题及解决办法

最近打算使用leetcode的vscode提升一下写代码的体验以及尝试debug。但是发现死活登录不上去&#xff0c;无论是账号登录还是cookies登录&#xff0c;尝试百遍都不行&#xff0c;在查阅资料之后&#xff0c;找到了解决办法。 文章目录 1.账号密码正确&#xff0c;插件无法登陆&a…
阅读更多...
16-网络安全框架及模型-BiBa完整性模型

16-网络安全框架及模型-BiBa完整性模型

目录 BiBa完整性模型 1 背景概述 2 模型原理 3 主要特性 4 优势和局限性 5 应用场景 BiBa完整性模型 1 背景概述 Biba完整性模型是用于保护数据完整性的模型&#xff0c;它的主要目标是确保数据的准确性和一致性&#xff0c;防止未授权的修改和破坏。在这个模型中&#…
阅读更多...
Apache Jackrabbit漏洞浅析

Apache Jackrabbit漏洞浅析

Apache Jackrabbit是一个Java开源内容存储库&#xff0c;1.0.0 < 版本 < 2.20.11、2.21.0 < 版本 < 2.21.18存在RMI功能导致的远程代码执行漏洞。 补丁分析 对比补丁前后两个版本&#xff08;https://github.com/apache/jackrabbit/compare/jackrabbit-2.20.10..…
阅读更多...
LSTM Siamese neural network

LSTM Siamese neural network

本文中的代码在Github仓库或Gitee仓库中可找到。 Hi, 你好。我是茶桁。 大家是否还记得&#xff0c;在「核心基础」课程中&#xff0c;我们讲过CNN以及LSTM。 卷积神经网络&#xff08;CNN&#xff09;已经在计算机视觉处理中得到广泛应用&#xff0c;不过&#xff0c;2017年…
阅读更多...
事务管理解析：掌握Spring事务的必备技能！

事务管理解析：掌握Spring事务的必备技能！

AOP事务管理 1.1 Spring事务简介1.1.1 相关概念介绍1.1.2 转账案例-需求分析1.1.3 转账案例-环境搭建步骤1:准备数据库表步骤2:创建项目导入jar包步骤3:根据表创建模型类步骤4:创建Dao接口步骤5:创建Service接口和实现类步骤6:添加jdbc.properties文件步骤7:创建JdbcConfig配置…
阅读更多...
axios配置请求头content-type 和 get/post请求方式

axios配置请求头content-type 和 get/post请求方式

axios配置请求头content-type https://blog.csdn.net/wojiushiwo945you/article/details/107653962 axios 是Ajax的一个插件&#xff0c;axios虽然是一个插件&#xff0c;但是我们不需要通过Vue.use(axios)来使用&#xff0c;下载完成后&#xff0c;只需在项目中引入即可。(一…
阅读更多...
用Html和js和layui写一个简单猜拳小游戏

用Html和js和layui写一个简单猜拳小游戏

简单学习技术&#xff0c;写了一个小游戏&#xff0c;用html和js写一个简单的小游戏。玩家点击按钮出拳&#xff0c;玩家胜利结果显示绿色&#xff0c;玩家输了结果显示红色&#xff0c;平局结果显示蓝色。 页面效果&#xff1a; 代码&#xff1a; <!DOCTYPE html> <…
阅读更多...
【C语言】数组

【C语言】数组

㊙️小明博客主页&#xff1a;➡️ 敲键盘的小明 ㊙️ ✅关注小明了解更多知识☝️ 文章目录 前言一、什么是数组&#xff1f;二、一维数组的创建和初始化2.1 一维数组的创建2.2 一维数组的初始化2.3 一维数组的使用3.3 一维数组的存储 三、二维数组的创建和初始化3.1 二维数组…
阅读更多...
深度学习 | DRNN、BRNN、LSTM、GRU

深度学习 | DRNN、BRNN、LSTM、GRU

1、深度循环神经网络 1.1、基本思想 能捕捉数据中更复杂模式并更好地处理长期依赖关系。 深度分层模型比浅层模型更有效率。 Deep RNN比传统RNN表征能力更强。 那么该如何引入深层结构呢&#xff1f; 传统的RNN在每个时间步的迭代都可以分为三个部分&#xff1a; 1.2、三种深层…
阅读更多...
虚函数的讲解

虚函数的讲解

文章目录 虚函数的声明与定义代码演示基类Person派生类Man派生类Woman 测试代码动态绑定静态绑定访问私有虚函数总结一下通过成员函数指针调用函数的方式 虚函数的声明与定义 虚函数存在于C的类、结构体等中&#xff0c;不能存在于全局函数中&#xff0c;只能作为成员函数存在…
阅读更多...
❀My小学习之排序算法❀

❀My小学习之排序算法❀

目录 排序算法&#xff08;Sorting algorithm&#xff09;:) 一、定义 二、分类 三、评价标准 排序算法&#xff08;Sorting algorithm&#xff09;:) 一、定义 所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的…
阅读更多...
【网络技术】【Kali Linux】Wireshark嗅探（一）ping和ICMP

【网络技术】【Kali Linux】Wireshark嗅探（一）ping和ICMP

一、实验目的 本次实验使用wireshark流量分析工具进行网络嗅探&#xff0c;旨在了解ping命令的原理及过程。 二、网络环境设置 本系列实验均使用虚拟机完成&#xff0c;主机操作系统为Windows 11&#xff0c;虚拟化平台选择Oracle VM VirtualBox&#xff0c;组网模式选择“N…
阅读更多...
c语言的数组

c语言的数组

#在这一篇中介绍三个数组 1.一维数组 2.字符数组 3.二维数组 1.一维数组 数组的定义&#xff1a; 类型 数组名[元素个数] ----这个为数组的定义 #include <stdio.h> int main() {int a[4];//在这里&#xff0c;我定义了一个只能装载4个整数类型元素的数组char b[5…
阅读更多...
WPF+Halcon 培训项目实战(1-5):Halcon安装,图像处理,Halcon简单模板匹配

WPF+Halcon 培训项目实战(1-5):Halcon安装,图像处理,Halcon简单模板匹配

文章目录 前言相关链接项目专栏我个人对就业市场的评价Halcon安装实战1-4&#xff1a;Halcon基础实战5&#xff1a;模板匹配[形状匹配]实战代码 结尾 前言 为了更好地去学习WPFHalcon&#xff0c;我决定去报个班学一下。原因无非是想换个工作。相关的教学视频来源于下方的Up主…
阅读更多...
IDEA 开发中常用的快捷键

IDEA 开发中常用的快捷键

目录 Ctrl 的快捷键 Alt 的快捷键 Shift 的快捷键 Ctrl Alt 的快捷键 Ctrl Shift 的快捷键 其他的快捷键 Ctrl 的快捷键 Ctrl F 在当前文件进行文本查找 &#xff08;必备&#xff09; Ctrl R 在当前文件进行文本替换 &#xff08;必备&#xff09; Ctrl Z 撤…
阅读更多...
excel 函数技巧

excel 函数技巧

1&#xff1a;模糊查询 LOOKUP(1,0/FIND(F1062,Sheet1!C$2:Sheet1!C$9135),Sheet1!B$2:Sheet1!B$9135) 函数含义&#xff1a;寻找F列1062行和sheet1中的C2行到C9135行进行模糊查询&#xff0c;返回该行对应的B2行到B9135行的结果。未查到返回结果0 函数公式&#xff1a; LO…
阅读更多...
基于Mbed Studio环境下开发STM32

基于Mbed Studio环境下开发STM32

基于Mbed Studio环境下开发STM32 &#x1f4cd;Mbed官网&#xff1a;https://os.mbed.com/ ✨mbed OS是ARM出的一个免费开源的&#xff0c;面向物联网的操作系统。提供了一个定义良好的API来开发C应用程序&#xff1b;集成度很高&#xff0c;类似Arduino&#xff0c;目前并不兼…
阅读更多...
Flink on K8S生产集群使用StreamPark管理

Flink on K8S生产集群使用StreamPark管理

&#xff08;一&#xff09;直接部署&#xff08;手动测试用&#xff0c;不推荐&#xff09; Flink on Native Kubernetes 目前支持 Application 模式和 Session 模式&#xff0c;两者对比 Application 模式部署规避了 Session 模式的资源隔离问题、以及客户端资源消耗问题&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023