【动态规划】【记忆化搜索】【状态压缩】1681. 最小不兼容性

news2025/1/12 5:51:35

作者推荐

【数位dp】【动态规划】【状态压缩】【推荐】1012. 至少有 1 位重复的数字

本文涉及知识点

动态规划汇总
状态压缩 记忆化搜索

1681. 最小不兼容性

给你一个整数数组 nums​​​ 和一个整数 k 。你需要将这个数组划分到 k 个相同大小的子集中，使得同一个子集里面没有两个相同的元素。
一个子集的 不兼容性 是该子集里面最大值和最小值的差。
请你返回将数组分成 k 个子集后，各子集 不兼容性 的 和 的 最小值 ，如果无法分成分成 k 个子集，返回 -1 。
子集的定义是数组中一些数字的集合，对数字顺序没有要求。
示例 1：
输入：nums = [1,2,1,4], k = 2
输出：4
解释：最优的分配是 [1,2] 和 [1,4] 。
不兼容性和为 (2-1) + (4-1) = 4 。
注意到 [1,1] 和 [2,4] 可以得到更小的和，但是第一个集合有 2 个相同的元素，所以不可行。
示例 2：
输入：nums = [6,3,8,1,3,1,2,2], k = 4
输出：6
解释：最优的子集分配为 [1,2]，[2,3]，[6,8] 和 [1,3] 。
不兼容性和为 (2-1) + (3-2) + (8-6) + (3-1) = 6 。
示例 3：
输入：nums = [5,3,3,6,3,3], k = 3
输出：-1
解释：没办法将这些数字分配到 3 个子集且满足每个子集里没有相同数字。
提示：
1 <= k <= nums.length <= 16
nums.length 能被 k 整除。
1 <= nums[i] <= nums.length

动态规划

对nums按升序排序。

动态规划的状态表示

pre[mask][end] 记录最小不兼容性和。mask表示nums中那些元素已经选择，选择的数优先放组号小的组。1组满了后，才放2组；2组满了，才放三组 ⋯ \cdots ⋯

动态规划的转移方程

mask1 = mask | (1 << j )
end1 = j
j必须符合以下条件：

  • j未被使用。
  • 如果是某个组的首元素，可以选择任意元素。
  • 如果不是某个组的首元素，j > end。且nums[j] != nums[end]
    { d p [ m a s k 1 ] [ j ] = d p [ m a s k ] [ e n d ] 某组的首元素 d p [ m a s k 1 ] [ j ] = d p [ m a s k ] [ e n d ] + n u m s [ j ] − n u m s [ e n d ] 非组首元素 \begin{cases} dp[mask1][j]= dp[mask][end] & 某组的首元素\\ dp[mask1][j]= dp[mask][end] + nums[j]-nums[end] & 非组首元素 \end{cases} {dp[mask1][j]=dp[mask][end]dp[mask1][j]=dp[mask][end]+nums[j]−nums[end]​某组的首元素非组首元素​

动态规划的初始值

dp[0][0]全部为0，其它全部为10000。

动态规划的填表顺序

mask从小到大，枚举前置条件。

动态规划的返回值

dp.back()的最小值。

代码

核心代码

class Solution {
public:
	int minimumIncompatibility(vector<int>& nums, int k) {
		m_c = nums.size();
		m_iMaskCount = 1 << m_c;
		sort(nums.begin(), nums.end());
		vector<int> vBitCount(m_iMaskCount);
		for (int i = 1; i < m_iMaskCount; i++)
		{
			vBitCount[i] = 1 + vBitCount[i & (i - 1)];
		}
		vector<vector<int>> dp(m_iMaskCount, vector<int>(m_c, m_iNotMay));
		dp[0][0] = 0;
		for (int mask = 0; mask < m_iMaskCount; mask++)
		{
			bool bGroupFirst = (0 == vBitCount[mask] % (m_c / k));
			for (int end = 0; end < m_c; end++)
			{
				for (int j = bGroupFirst ? 0 : (end + 1); j < m_c; j++)
				{
					if ((1 << j) & mask)
					{
						continue;//已经选择
					}
					if ((nums[j] == nums[end])&& (!bGroupFirst))
					{
						continue;//相同
					}	
					const int iNew = dp[mask][end] + (bGroupFirst ? 0 : (nums[j]-nums[end]));
					dp[mask | (1 << j)][j] = min(dp[mask | (1 << j)][j],iNew);
				}
			}
		}
		const int iRet = *std::min_element(dp.back().begin(), dp.back().end());
		return (iRet >= m_iNotMay) ? -1 : iRet;
	}
	int m_c, m_iMaskCount,m_iNotMay=10000;
};

测试用例


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 sln;
		nums = { 1 }, k = 1;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, 0);
	}
	{
		Solution sln;
		nums = { 1,1 }, k = 1;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, -1);
	}
	{
		Solution sln;
		nums = { 1, 2, 1, 4 }, k = 2;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, 4);
	}

	{
		Solution sln;
		nums = { 6, 3, 8, 1, 3, 1, 2, 2 }, k = 4;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, 6);
	}
	{
		Solution sln;
		nums = { 5,3,3,6,3,3 }, k = 3;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, -1);
	}
	{
		Solution sln;
		nums = { 11,11,3,4,2,16,14,13,6,14,2,5,10,13,5,7 }, k = 8;
		auto res = sln.minimumIncompatibility(nums, k);
		Assert(res, 12);
	}
}

记忆化搜索+动态规划

从后置条件倒推前置条件，可以省去大量不必要的状态。运行速度提高500%。缺点可理解性大幅降低。
mask 选择了那些数，end 是最一个数。如果本组只有一个数，则最小不兼容性和就是 除本数外 的前几个完整的组的最小不兼容性和。
如果完整的组，最后一个元素一定是最大值。最大值一定是某个组的最后一个。将此组调到最后一组，结果不变。
EndZeroCount 从右到左为1的第一个下标（从0开始）。为了一致，nums降序排序。
每组一个元素要特殊处理。

int EndZeroCount(unsigned x )
{
	for (int i = 0; i < 32; i++)
	{
		if ((1 << i) & x)
		{
			return i;
		}
	}
	return 32;
}

class Solution {
public:
	int minimumIncompatibility(vector<int>& nums, int k) {
		m_c = nums.size();
		m_iMaskCount = 1 << m_c;
		m_pre = m_c / k;
		if (1 == m_pre)
		{
			return 0;
		}		
		sort(nums.begin(), nums.end(),std::greater<>());
		m_nums = nums;
		m_vBitCount.resize(m_iMaskCount);
		for (int i = 1; i < m_iMaskCount; i++)
		{
			m_vBitCount[i] = 1 + m_vBitCount[i & (i - 1)];
		}
		m_dp.assign(m_iMaskCount, vector<int>(m_c, m_iNotMay));
		const int iRet = Rec(m_iMaskCount-1);
		return (iRet >= m_iNotMay) ? -1 : iRet;
	}
	int Rec(int mask, int end)
	{
		if (0 == mask)
		{
			return 0;
		}
		auto& res = m_dp[mask][end];
		if (m_iNotMay != res)
		{
			return res;
		}
		const int iPreMask = mask ^ (1 << end);
		const int cnt = m_vBitCount[mask] % m_pre;//最后一组数量
		if (1 == cnt )
		{
			return res = Rec(iPreMask);
		}
		for (int i = end+1 ; i < m_c; i++)
		{
			if ((1 << i) & mask)
			{
				if (m_nums[i] != m_nums[end])
				{
					res = min(res, Rec(iPreMask,i)+ m_nums[end]-m_nums[i]);
				}
			}
		}
		return res;
	}
	int Rec(int mask)
	{
		return Rec(mask, EndZeroCount(mask));
	}
	int m_c, m_iMaskCount,m_iNotMay=10000, m_pre;
	vector<int> m_vBitCount;
	vector<vector<int>> m_dp;
	vector<int> m_nums;
};

2023年2月版

class Solution {
public:
int minimumIncompatibility(vector& nums, int k) {
m_c = nums.size();
if (k == m_c)
{
return 0;
}
if (1 == k)
{
std::set setNums(nums.begin(), nums.end());
if (nums.size() != setNums.size())
{
return -1;
}
return *setNums.rbegin() - *setNums.begin();
}
std::sort(nums.begin(),nums.end());
m_iMaskNum = (1 << m_c )*m_c;
m_vMaskByBits.resize(m_c + 1);
m_vMaskByBits[0].push_back(0);
vector vMaskBits(m_iMaskNum);
for (int mask = 1; mask < m_iMaskNum; mask++)
{
const int iSelMask = mask / m_c;
vMaskBits[mask] = vMaskBits[(iSelMask&(iSelMask - 1))m_c] + 1;
m_vMaskByBits[vMaskBits[mask]].push_back(mask);
}
m_vMaskGroupFirstToMin.resize(m_iMaskNum, m_iNotMay);
m_vMaskGroupFirstToMin[0] = 0;
for (int i = 0; i < nums.size(); i++)
{
vector dp(m_iMaskNum, m_iNotMay);
for (int iMask : m_vMaskByBits[i])
{
if (m_iNotMay == m_vMaskGroupFirstToMin[iMask])
{
continue;
}
const int iSelMask = iMask / m_c;
const int iPreSel = iMask% m_c;
if (0 == i % (m_c/k))
{//新组
for (int j = 0; j < m_c; j++)
{
if (iSelMask & (1 << j))
{
continue;
}
const int iNewMask = JoinMask(iSelMask | (1 << j), j);
dp[iNewMask] = min(dp[iNewMask], min(m_vMaskGroupFirstToMin[iMask],dp[iMask]));
}
}
else
{
for (int j = iPreSel+1; j < m_c; j++)
{
if (iSelMask & (1 << j))
{
continue;
}
const int iAdd = nums[j] - nums[iPreSel];
if (0 == iAdd)
{
continue;
}
const int iNewMask = JoinMask(iSelMask | (1 << j), j);
dp[iNewMask] = min(dp[iNewMask], min(m_vMaskGroupFirstToMin[iMask], dp[iMask]) + iAdd);
}
}
}
m_vMaskGroupFirstToMin.swap(dp);
}
std::set setRet;
for (int iPre = 0; iPre < m_c; iPre++)
{
int iIndex = (1 << m_c) - 1;
iIndex = iIndexm_c + iPre;
setRet.insert(m_vMaskGroupFirstToMin[iIndex]);
}
int iMin = setRet.begin();
return (m_iNotMay == iMin) ? -1 : iMin;
}
int JoinMask(int iSelMask, int iNewSelIndex)
{
return iSelMaskm_c + iNewSelIndex;
}
vector m_vMaskGroupFirstToMin;
int m_c;
int m_iMaskNum;
vector<vector> m_vMaskByBits;
const int m_iNotMay = 1000 * 1000;
};

2023年9月版

class Solution {
public:
int minimumIncompatibility(vector& nums, int k) {
m_c = nums.size();
if (k == m_c)
{
return 0;
}
m_iMaskNum = 1 << m_c;
if (0 != m_c % k)
{
return -1;
}
const int iNumOfAGroup = m_c / k;
vector<vector> vBitMask(m_c+1);
vBitMask[0].emplace_back(0);
for (int mask = 1; mask < m_iMaskNum; mask++)
{
vBitMask[bitcount((unsigned int)mask)].emplace_back(mask);
}
std::unordered_map<int, int> mMaskCom;
for (int mask : vBitMask[iNumOfAGroup])
{
int iMax = INT_MIN, iMin = INT_MAX;
unordered_set setValues;
for (int j = 0; j < m_c; j++)
{
if (mask & (1 << j))
{
MaxSelf(&iMax, nums[j]);
MinSelf(&iMin, nums[j]);
setValues.emplace(nums[j]);
}
}
if (setValues.size() != iNumOfAGroup)
{
continue;
}
mMaskCom[mask] = iMax - iMin;
}
int pre[1 << 16] = { 0 };
for (const auto& it : mMaskCom)
{
pre[it.first] = it.second;
}
for (int i = 2; i <= k; i++)
{
int dp[1 << 16] = { 0 };
for (const int& mask : vBitMask[iNumOfAGroup*i])
{
for (int sub = mask; sub; sub = (sub - 1) & mask)
{
if ((0 != pre[sub])&& mMaskCom.count(mask - sub))
{
int iNew = pre[sub] + mMaskCom[mask - sub];
if (0 != dp[mask])
{
iNew = min(iNew, dp[mask]);
}
dp[mask] = iNew;
}
}
}
memcpy(pre, dp, sizeof(dp));
}
return pre[m_iMaskNum - 1] ? pre[m_iMaskNum - 1] : -1;
}
int m_c, m_iMaskNum;
};

扩展阅读

视频课程

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

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

相关文章

函数式编程的技巧

函数式编程的技巧

14.1.2 科里化 给出科里化的理论定义之前&#xff0c;让我们先来看一个例子。应用程序通常都会有国际化的需求将一套单位转换到另一套单位是经常碰到的问题。 单位转换通常都会涉及转换因子以及基线调整因子的问题。比如&#xff0c;将摄氏度转换到华氏度的公式是CtoF(x)x*9/…
阅读更多...
（2024|ICLR，SVD，软加权正则化，推理时文本嵌入优化）文本到图像扩散模型的图像内容抑制

（2024|ICLR，SVD，软加权正则化，推理时文本嵌入优化）文本到图像扩散模型的图像内容抑制

Get What You Want, Not What You Dont- Image Content Suppression for Text-to-Image Diffusion Models 公和众和号&#xff1a;EDPJ&#xff08;进 Q 交流群&#xff1a;922230617 或加 VX&#xff1a;CV_EDPJ 进 V 交流群&#xff09; 目录 0. 摘要 2. 相关工作 3. 方…
阅读更多...
IIC--集成电路总线

IIC--集成电路总线

目录 一、IIC基础知识 1、设计IIC电路的原因&#xff1a; 2、上拉电阻阻值怎么确定 3、IIC分类 4、IIC协议 二、单片机使用IIC读写数据 1、 IIC发送一个字节数据&#xff1a; 2、IIC读取一个字节数据&#xff1a; 一、IIC基础知识 1、设计IIC电路的原因&#xff1a; (…
阅读更多...
【JavaEE】_Fiddler抓包HTTP请求与响应

【JavaEE】_Fiddler抓包HTTP请求与响应

目录 1. Fiddler简介 2. Fiddler安装步骤 3. 抓包结果举例&#xff08;sogou.com&#xff09; 1. Fiddler简介 1. 要查看HTTP的请求和响应&#xff0c;需要使用抓包工具进行抓包&#xff1b; 抓包即获取网卡上经过的数据并显示出来&#xff0c;常用的抓包工具有wireshark和…
阅读更多...
Linux第57步_“linux系统镜像”和“根文件系统”重新打包小结

Linux第57步_“linux系统镜像”和“根文件系统”重新打包小结

实时总结是很重要的&#xff0c;时间久了&#xff0c;可能会遗忘。下面是“linux系统镜像”和“根文件系统”重新打包小结。 1、linux系统镜像重新打包 在第1次完成linux系统镜像打包后&#xff0c;再重新打包就很容易了 将“bootfs”重新打包 准备打包文件: 输入“cd /ho…
阅读更多...
专业140+总分400+华中科技大学824信号与系统考研经验华科华中大电子信息与通信工程，真题，大纲，参考书。

专业140+总分400+华中科技大学824信号与系统考研经验华科华中大电子信息与通信工程，真题，大纲，参考书。

今年考研落下帷幕&#xff0c;看到有人落寞&#xff0c;有人金榜题名&#xff0c;心里体会五谷杂陈&#xff0c;自己很幸运通过努力上岸华科&#xff0c;初试专业课824信号与系统140&#xff0c;数一130&#xff0c;总分400&#xff0c;对于这个成绩稍微有点超出自己预期&#…
阅读更多...
python-产品篇-游戏-象棋

python-产品篇-游戏-象棋

文章目录 代码效果 代码 import pygame import time import constants from button import Button import pieces import computerclass MainGame():window NoneStart_X constants.Start_XStart_Y constants.Start_YLine_Span constants.Line_SpanMax_X Start_X 8 * Lin…
阅读更多...
三种输入输出函数

三种输入输出函数

目录 printf函数 scanf函数 getchar函数 putchar函数 gets函数 puts函数 printf函数 当你需要将数据或文本输出到屏幕或其他输出设备时&#xff0c;C语言提供了一个非常有用的函数&#xff0c;即 printf() 函数。它是标准库中定义的函数&#xff0c;用于格式化输出。 pr…
阅读更多...
[力扣 Hot100]Day27 合并两个有序链表

[力扣 Hot100]Day27 合并两个有序链表

题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 出处 思路 简单题&#xff0c;两个指针就能解决。 代码 class Solution { public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {if(!list1)…
阅读更多...
蓝桥杯电子类单片机提升三——NE555

蓝桥杯电子类单片机提升三——NE555

目录 单片机资源数据包_2023 一、NE555和定时器工作模式 1.NE555的介绍 2.定时器的计数模式 二、NE555频率读取代码的实现 1.定时器0初始化 2.通过读取TH0和TL0来读取频率 3.通过中断读取频率 三、完整代码演示 通过读取TH0和TL0来读取频率 main.c 通过中断读取频…
阅读更多...
多模态基础---BERT

多模态基础---BERT

1. BERT简介 BERT用于将一个输入的句子转换为word_embedding&#xff0c;本质上是多个Transformer的Encoder堆叠在一起。 其中单个Transformer Encoder结构如下&#xff1a; BERT-Base采用了12个Transformer Encoder。 BERT-large采用了24个Transformer Encoder。 2. BERT的…
阅读更多...
【Algorithms 4】算法（第4版）学习笔记 08 - 3.1 符号表

【Algorithms 4】算法（第4版）学习笔记 08 - 3.1 符号表

文章目录 前言参考目录学习笔记1&#xff1a;API1.1&#xff1a;遵循的规则1.2&#xff1a;ST 用例举例1.2.1&#xff1a;行为测试用例1.2.2&#xff1a;性能测试用例2&#xff1a;基本实现2.1&#xff1a;无序链表处理2.2&#xff1a;初级ST实现小结2.3&#xff1a;有序数组的…
阅读更多...
Python 异常处理及程序调试

Python 异常处理及程序调试

Python 是一门功能强大而又易于学习的编程语言&#xff0c;它提供了丰富的工具和库来帮助开发者编写高效、稳定的程序。然而&#xff0c;在编写复杂的应用程序时&#xff0c;错误和异常是难以避免的。本文将介绍 Python 中的异常处理机制以及程序调试技巧&#xff0c;帮助读者提…
阅读更多...
Linux--编译器-gcc/g++使用

Linux--编译器-gcc/g++使用

目录 前言 1.看一段样例 2.程序的翻译过程 1.第一个阶段&#xff1a;预处理 2.第二个阶段&#xff1a;编译 3.第三个阶段&#xff1a;汇编 4.第四个阶段&#xff1a;链接 3.程序的编译为什么是这个样子&#xff1f; 4. 关于编译器 5.链接&#xff08;动静态链接&#x…
阅读更多...
Docker的常见命令以及命令别名

Docker的常见命令以及命令别名

常见命令 命令说明docker pull拉取镜像docker push推送镜像到DockerRegistrydocker images查看本地镜像docker rmi删除本地镜像docker run创建并允许容器docker stop停止指定容器docker start启动指定容器docker restart重新启动容器docker rm删除指定容器docker ps查看容器do…
阅读更多...
波奇学Linux:文件系统打开文件

波奇学Linux:文件系统打开文件

从文件系统来看打开文件 计算机系统和磁盘交互的大小是4kb 物理内存的4kb&#xff0c;磁盘的4kb文件叫做页帧 磁盘数据块的以4kb为单位。 减少IO的次数&#xff0c;减少访问外设的次数--硬件 基于局部性的原理&#xff0c;预加载机制--软件 操作系统管理内存 操作系统对…
阅读更多...
相机图像质量研究(19)常见问题总结：CMOS期间对成像的影响--Sensor Noise

相机图像质量研究(19)常见问题总结：CMOS期间对成像的影响--Sensor Noise

系列文章目录 相机图像质量研究(1)Camera成像流程介绍 相机图像质量研究(2)ISP专用平台调优介绍 相机图像质量研究(3)图像质量测试介绍 相机图像质量研究(4)常见问题总结&#xff1a;光学结构对成像的影响--焦距 相机图像质量研究(5)常见问题总结&#xff1a;光学结构对成…
阅读更多...
2.13日学习打卡----初学RocketMQ（四）

2.13日学习打卡----初学RocketMQ（四）

2.13日学习打卡 目录&#xff1a; 2.13日学习打卡一.RocketMQ之Java ClassDefaultMQProducer类DefaultMQPushConsumer类Message类MessageExt类 二.RocketMQ 消费幂消费过程幂等消费速度慢的处理方式 三.RocketMQ 集群服务集群特点单master模式多master模式多master多Slave模式-…
阅读更多...
使用Python生成二维码的完整指南

使用Python生成二维码的完整指南

无边落木萧萧下&#xff0c;不如跟着可莉一起游~ 可莉将这篇博客收录在了&#xff1a;《Python》 可莉推荐的优质博主首页&#xff1a;Kevin ’ s blog 本文将介绍如何使用Python中的qrcode库来生成二维码。通过简单的代码示例和详细解释&#xff0c;读者将学习如何在Python中轻…
阅读更多...
可变参数（c/c++）

可变参数（c/c++）

目录 一、C语言版本 二、C的实现方法 2.1数据包 2.2sizeof...运算符 2.3可变参数模板的使用 2.4emplace_back() 有时候我们在编写函数时&#xff0c;可能不知道要传入的参数个数&#xff0c;类型 。比如我们要实现一个叠加函数&#xff0c;再比如c语言中的printf,c中的emp…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023