【单调栈】LeetCode:2818操作使得分最大

已于 2023-12-24 08:39:57 修改
阅读量1.3k 收藏 30
点赞数 38
分类专栏： 数据结构与算法 文章标签： leetcode 算法 c++ 最大 单调栈 质数 取余
于 2023-12-23 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/135144401
版权

作者推荐

map|动态规划|单调栈|LeetCode975:奇偶跳

本文涉及的基础知识点

单调栈分类、封装和总结

题目

给你一个长度为 n 的正整数数组 nums 和一个整数 k 。
一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：
选择一个之前没有选过的 非空 子数组 nums[l, …, r] 。
从 nums[l, …, r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。
将你的分数乘以 x 。
nums[l, …, r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。
一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 * 3 * 5 * 5 。
请你返回进行至多 k 次操作后，可以得到的 最大分数 。
由于答案可能很大，请你将结果对 109 + 7 取余后返回。
示例 1：
输入：nums = [8,3,9,3,8], k = 2
输出：81
解释：进行以下操作可以得到分数 81 ：

  • 选择子数组 nums[2, …, 2] 。nums[2] 是子数组中唯一的元素。所以我们将分数乘以 nums[2] ，分数变为 1 * 9 = 9 。
  • 选择子数组 nums[2, …, 3] 。nums[2] 和 nums[3] 质数分数都为 1 ，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 9 * 9 = 81 。
    81 是可以得到的最高得分。
    示例 2：
    输入：nums = [19,12,14,6,10,18], k = 3
    输出：4788
    解释：进行以下操作可以得到分数 4788 ：
  • 选择子数组 nums[0, …, 0] 。nums[0] 是子数组中唯一的元素。所以我们将分数乘以 nums[0] ，分数变为 1 * 19 = 19 。
  • 选择子数组 nums[5, …, 5] 。nums[5] 是子数组中唯一的元素。所以我们将分数乘以 nums[5] ，分数变为 19 * 18 = 342 。
  • 选择子数组 nums[2, …, 3] 。nums[2] 和 nums[3] 质数分数都为 2，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 342 * 14 = 4788 。
    4788 是可以得到的最高的分。
    参数范围：
    1 <= nums.length == n <= 105
    1 <= nums[i] <= 105
    1 <= k <= min(n * (n + 1) / 2, 109)

单调栈

时间复杂度😮(nlogn)
静态变量vPrime 记录所有质数。
vPriCount 记录nums各数的质量分数。vPriCount也可以弄成静态成员变量。
我们枚举各子数组的最大质量分数，如果有多个最大质量分数，取下标最小的。即：
left为从右向左第一个大于等于vPriCount[i]的下标，不存在为-1。
right为从左向右第一个大于vPriCount[i]的下标，不存在为m_c。
子数组(li,ri)就是符合条件的子数组，li取值范围(left,i]，ri取值范围[i,right)。
我们按的nums[i]降序操作 最大质量分数为vPriCount[i]的子数组。

代码

核心代码

class CRangIndex
{
public:
	template<class _Pr>
	CRangIndex(const vector<int>& nums, _Pr CurIndexCmpStackTopIndex)
	{
		m_c = nums.size();
		m_vLeft.assign(m_c, -1);
		m_vRight.assign(m_c, m_c);
		stack<int> sta;
		for (int i = 0; i < m_c; i++)
		{
			while (sta.size() && (CurIndexCmpStackTopIndex(i, sta.top())))
			{
				m_vRight[sta.top()] = i;
				sta.pop();
			}
			if (sta.size())
			{
				m_vLeft[i] = sta.top();
			}
			sta.emplace(i);
		}
	}
	int m_c;
	vector<int> m_vLeft, m_vRight;//vLeft[i] 从右向左第一个小于nums[i] ;vRight[i] 是第一个小于等于nums[i]。
};

vector<int> CreatePrime(int iMax)
{
	vector<int> vPrime = { 2 };
	for (int i = 3; i <= iMax; i++)
	{
		bool b = true;
		for (const auto& n : vPrime)
		{
			if (0 == i % n)
			{
				b = false;
				break;
			}
		}
		if (b)
		{
			vPrime.emplace_back(i);
		}
	}
	return vPrime;
}

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

class Solution {
public:
	int maximumScore(vector<int>& nums, int k) {
		m_c = nums.size();
		
		vector<int> vPriCount;
		{
			static vector<int> vPrime = CreatePrime(1000 * 100);
			for (const auto& n : nums)
			{
				int tmp = n;
				int iNum = 0;
				for (const auto& pr : vPrime)
				{
					if (pr * pr > tmp)
					{
						break;
					}
					if (0 == tmp % pr)
					{
						while (0 == tmp % pr)
						{
							tmp /= pr;
						}
						iNum++;
					}
				}
				vPriCount.emplace_back(iNum + (tmp > 1));
			}
		}
		
		CRangIndex ri(vPriCount, [&](int i1, int i2) {return vPriCount[i1] > vPriCount[i2]; });
		std::multimap<int, int, greater<int>> mValueIndex;
		for (int i = 0; i < ri.m_c; i++)
		{
			mValueIndex.emplace(nums[i], i);
		}
		C1097Int<> biRet=1;
		for (const auto& [value, i] : mValueIndex)
		{
			const long long llSubArrCount = ((long long)i - ri.m_vLeft[i]) * (ri.m_vRight[i] - i);
			const long long llOpeCount = min((long long)k, llSubArrCount);

			biRet *= C1097Int<>(value).pow(llOpeCount);
			k -= llOpeCount;
			if (0 == k)
			{
				break;
			}
		}
		return biRet.ToInt();
	}
	int m_c;
};

测试用例

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()
{
	vector<int> nums;
	int k;
	{
		Solution slu;
		nums = { 8, 3, 9, 3, 8 };
		k = 2;
		auto res = slu.maximumScore(nums, k);
		Assert(81, res);
	}
	{
		Solution slu;
		nums = { 19,12,14,6,10,18 };
		k = 3;
		auto res = slu.maximumScore(nums, k);
		Assert(4788, res);
	}
	
	//CConsole::Out(res);
}

2023年8月

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(int n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

template<int MOD = 1000000007>
int operator+(int iData, const C1097Int<MOD>& int1097)
{
	int iRet = int1097.operator+(C1097Int<MOD>(iData)).ToInt();
	return iRet;
}

template<int MOD = 1000000007>
int& operator+=(int& iData, const C1097Int<MOD>& int1097)
{
	iData = int1097.operator+(C1097Int<MOD>(iData)).ToInt();
	return iData;
}

template<int MOD = 1000000007>
int operator*(int iData, const C1097Int<MOD>& int1097)
{
	int iRet = int1097.operator*(C1097Int(iData)).ToInt();
	return iRet;
}

template<int MOD = 1000000007>
int& operator*=(int& iData, const C1097Int<MOD>& int1097)
{
	iData = int1097.operator*(C1097Int(iData)).ToInt();
	return iData;
}

class Solution {
public:
	int maximumScore(vector<int>& nums, int k) {
		m_c = nums.size();
		vector<int> vScore;
		for ( int n : nums)
		{
			int iScore = 0;
			for (int i = 2; i * i <= n; i++)
			{
				if (0 != n % i)
				{
					continue;
				}
				iScore++;
				while (0 == n % i)
				{
					n /= i;
				}
			}
			if (n > 1)
			{
				iScore++;
			}
			vScore.emplace_back(iScore);
		}

		stack<int> sta;
		vector<int> vLeft(m_c), vRight(m_c, m_c);
		for (int i = 0 ; i < m_c ; i++ )
		{
			while (sta.size() && (vScore[sta.top()] < vScore[i]))
			{
				vRight[sta.top()] = i;
				sta.pop();
			}
			vLeft[i] = sta.size() ? sta.top() : -1;
			sta.emplace(i);			
		}

		std::map<int, long long,std::greater<int>> mValueNum;
		for (int i = 0; i < m_c; i++)
		{
			mValueNum[nums[i]] += (i - vLeft[i])*(long long)(vRight[i] - i);
		}
		C1097Int<> biRet = 1;
		while (k > 0)
		{
			for (auto it : mValueNum)
			{
				long long llMulMul = min((long long)k, it.second);
				k -= llMulMul;
				auto cur = C1097Int<>(it.first).pow((int)llMulMul);
				biRet *= cur;
			}
		}
		return biRet.ToInt();
	}
	int m_c;
};

使用封装类后



template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

class CRangIndex
{
public:
	template<class _Pr>
	CRangIndex(int iVectorSize, _Pr CurIndexCmpStackTopIndex)
	{
		m_c = iVectorSize;
		m_vLeft.assign(m_c, -1);
		m_vRight.assign(m_c, m_c);
		stack<int> sta;
		for (int i = 0; i < m_c; i++)
		{
			while (sta.size() && (CurIndexCmpStackTopIndex(i, sta.top())))
			{
				m_vRight[sta.top()] = i;
				sta.pop();
			}
			if (sta.size())
			{
				m_vLeft[i] = sta.top();
			}
			sta.emplace(i);
		}
	}

	template<class _Pr>
	CRangIndex(const vector<int>& nums, _Pr CurValueCmpStackTopValue)
	{
		m_c = nums.size();
		m_vLeft.assign(m_c, -1);
		m_vRight.assign(m_c, m_c);
		stack<int> sta;
		for (int i = 0; i < m_c; i++)
		{
			while (sta.size() && (CurValueCmpStackTopValue(nums[i], nums[sta.top()])))
			{
				m_vRight[sta.top()] = i;
				sta.pop();
			}
			if (sta.size())
			{
				m_vLeft[i] = sta.top();
			}
			sta.emplace(i);
		}
	}
	int m_c;
	vector<int> m_vLeft, m_vRight;//vLeft[i] 从右向左第一个小于nums[i] ;vRight[i] 是第一个小于等于nums[i]。
};

vector<int> CreatePrime(int iMax)
{
	vector<int> vPrime = { 2 };
	for (int i = 3; i <= iMax; i++)
	{
		bool b = true;
		for (const auto& n : vPrime)
		{
			if (0 == i % n)
			{
				b = false;
				break;
			}
		}
		if (b)
		{
			vPrime.emplace_back(i);
		}
	}
	return vPrime;
}
class Solution {
public:
	int maximumScore(vector<int>& nums, int k) {
		m_c = nums.size();
		
		vector<int> vPriCount;
		{
			static vector<int> vPrime = CreatePrime(1000 * 100);
			for (const auto& n : nums)
			{
				int tmp = n;
				int iNum = 0;
				for (const auto& pr : vPrime)
				{
					if (pr * pr > tmp)
					{
						break;
					}
					if (0 == tmp % pr)
					{
						while (0 == tmp % pr)
						{
							tmp /= pr;
						}
						iNum++;
					}
				}
				vPriCount.emplace_back(iNum + (tmp > 1));
			}
		}
		
		CRangIndex ri(vPriCount, std::greater<>());
		std::multimap<int, int, greater<int>> mValueIndex;
		for (int i = 0; i < ri.m_c; i++)
		{
			mValueIndex.emplace(nums[i], i);
		}
		C1097Int<> biRet=1;
		for (const auto& [value, i] : mValueIndex)
		{
			const long long llSubArrCount = ((long long)i - ri.m_vLeft[i]) * (ri.m_vRight[i] - i);
			const long long llOpeCount = min((long long)k, llSubArrCount);

			biRet *= C1097Int<>(value).pow(llOpeCount);
			k -= llOpeCount;
			if (0 == k)
			{
				break;
			}
		}
		return biRet.ToInt();
	}
	int m_c;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步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++ 实现。

闻缺陷则喜何志丹
关注
  • 38
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
丢失的最小正整数leetcode-LeetCode:力码
06-30
丢失的最小正整数leetcode LeetCode leetcode 题目(共 65 题) 1 两数之和 2 两数相加 3 无重复字符的最长子串 4 寻找两个正序数组的中位数 7 整数反转 9 回文数 13 罗马数字转整数 14 最长公共前缀 15 三数之和 16 ...
最大公共字符串leetcode-leetCode:leetcode
07-01
最大公共字符串leetcode leetcode 数组 链表 二叉树 位操作 判断字符串的顺序排列 给定一个字符串数组，将字谜组合在一起。 例如，给定：["eat", "tea", "tan", "ate", "nat", "bat"], public class Solution { ...
leetcode 单调栈合集
peachzy的博客
01-10 185
一、(leetcode 239)滑动窗口最大值 题目描述： 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 思路： 单调栈 代码如下： class Solution { public: vector<int> maxSlidingWindow(vector<int>& nums, int k) { if(nums
LeetCode：496/503 下一个更大元素 I / II 单调栈及单调栈性质总结
AKGWSB 's blog
03-17 162
关于单调栈的其他题目： 单调栈的用处是快速找到左右边第一个小于/大于栈顶元素的元素 【LeetCode：402 移掉k位数字】 【LeetCode：84. 柱状图中最大的矩形】 下一个更大元素 I 给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。 nums1 中数字 x 的下一个更大...
单调栈：General
lyh20021209的博客
01-05 932
题面：设计一个算法收集某些股票的每日报价，并返回该股票当日价格的。当日股票价格的被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。实现price思路分析：现在假设我们先要统计第5天（索引从0开始），也就是价格为75的那一天的跨度。然后统计第6天，也就是价格为85的那一天的跨度。观察一下，可以发现85重复统计了第2到第4天（60，70，60）的数据，但实际上，如果我们明确知道了85≥75时，就可以复用75的统计，也就是自动筛掉(60,70,60)这组数据了。
leetcode刷题（javaScript）——栈、单调栈相关场景题总结
三月和九月的博客
02-29 888
栈的主要思想是“后进先出”（Last In First Out，LIFO），即最后进入栈的元素最先出栈。栈通常用于解决需要“回溯”或“撤销”操作的问题，以及需要维护“”的问题。给定一个只包括'('')''{''}''['']'的字符串s，判断字符串是否有效。主要思路是遇到左括号推入栈遇到右括号，将栈顶左括号移除，并和它进行对比。不相等return false否则继续比较，直到最后，判断是否还有没匹配上的左括号。
单调栈分类、封装和总结
闻缺陷则喜何志丹
12-23 1770
通过枚举最小（最大）值不重复、不遗漏枚举所有子数组 二分查找的进一步优化 最小（最大）字典序
LeetCode：每日一题【第二周】
qq_45249273的博客
08-08 150
8.8 ~ 8.14 尽量坚持刷力扣的每日一题，锻炼大脑思维。更新中~~
数据结构：栈 （leetcode 例题 【简】【中】【难】）
qq_62660119的博客
02-06 320
例一 每日温度（leetcode 793) https://leetcode-cn.com/problems/daily-temperatures/https://leetcode-cn.com/problems/daily-temperatures/题目描述：
LeetCode刷题-栈
zhi的博客
06-21 325
1.有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 解题思路： （1）判断字符串的长度是否为奇数，如果为奇数，返回false; （2）遍历字符串，遇到‘{’、‘[’、‘（’入栈； （3）如果栈顶元素与当前元素刚好匹配，将栈顶元素出栈；若不匹配，返回false; （4）栈最后为空，返回true，否则false. class So
leetcode_栈_简单
weixin_44911078的博客
10-18 144
两数之和 链接：https://leetcode-cn.com/problems/two-sum 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 解题思路 （我）： 循环遍历数组，用目标值
leetcode最大连通域-leetcode:leetcode
06-30
leetcode 最大连通域leetcode zigzag.py - 字符串“PAYPALISHIRING”在给定的行数上以锯齿形图案书写 delete_dup_nodes.py - 删除所有具有重复编号的节点 topn_toy.py - 来自推文的 Yopn 玩具 僵尸人类.py - 2D 网格...
LeetCode:每天零LeetCode使报价远离
03-07
LeetCode + _ + 下面是力扣题目的一些总结：编程语言主要是C++和Python，偶尔会有Java和C。- _ - 刷力扣题纯粹是兴趣，这里不光有力...>图论->高级数据结构桌子（待定）（待定）单调栈前序遍历中序遍历后续遍历层序遍历
leetcode：:notebook:算法学习笔记
02-01
简介力扣常见检查的知识点大概有一些种，包括：二分，滑动窗口，双指针，单调栈（单调栈），链表，二叉树，串处理，dfs +回溯，并查集，动态规划，贪心，位运算，数论（质数，约数，欧拉函数，欧几里得算法，中国...
Golang | Leetcode Golang题解之第149题直线上最多的点数
weixin_66442839的博客
06-14 391
Golang | Leetcode Golang题解之第149题直线上最多的点数
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 263
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 234
贪心第三天
Java | Leetcode Java题解之第149题直线上最多的点数
最新发布
m0_57195758的博客
06-14 300
Java | Leetcode Java题解之第149题直线上最多的点数
leetcode:Group Anagrams 用c语言
04-01
题目描述 给定一个字符串数组，将字母异位词组合在一起。 字母异位词指字母相同，但排列不同的字符串。 示例 1: 输入: ["eat", "tea", "tan", "ate", "nat", "bat"] ...本题的关键在于如何判断两个字符串是否是异位...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值