Kiritow
Kiritow

区间调度问题详解

今天给大家介绍一下区间调度问题。区间调度是一类难度比较大，但同时应用比较广的问题，经常会在面试中以各种形式出现。本文将会介绍区间调度的各种变形，希望能使大家在面临区间调度问题时得心应手，并可以在实际工作中巧妙应用。

1. 相关定义

       在数学里，区间通常是指这样的一类实数集合：如果x和y是两个在集合里的数，那么，任何x和y之间的数也属于该集合。区间有开闭之分，例如(1,2)和[1,2]的表示范围不同，后者包含整数1和2。

       在程序世界，区间的概念和数学里没有区别，但是往往有具体的含义，例如时间区间，工资区间或者音乐中音符的开始结束区间等，图一给出了一个时间区间的例子。区间有了具体的含义之后，开闭的概念就显得非常重要，例如时间区间[8:30,9:30]和[9:30,10:30]两个区间是有重叠的，但是[8:30,9:30)和[9:30,10:30)没有重叠。在不同的问题中，区间的开闭往往不同，有时是闭区间，有时是半开半闭区间。时间区间往往是闭区间，但是音符中的开始结束区间则是半开半闭区间，所以在重叠的定义上大家需要具体问题具体分析。稍后你会发现，开闭的区别其实只是差一个等号而已。

区间调度问题详解_第1张图片

图1 时间区间示例

       假设区间是闭合的，并定义为[start,end]。我们首先看一下区间重叠的定义。给定两个区间[s1,e1]和[s2,e2]，它们重叠的可能性有四种：

区间调度问题详解_第2张图片

可以看出，如果直接考虑区间重叠，判断条件比较复杂，我们从相反的角度考虑，考虑区间不重叠的情况。区间不重叠时的判断条件为：

区间调度问题详解_第3张图片

也即：(e1e2)，所以区间重叠的判断条件为：


经过化简之后，区间重叠的判断条件只有两个，也很好理解，不再赘述。如果区间是半开半闭的，则只需要将判断条件中的等号去掉。

       现在考虑这样一个问题，如何判断一个区间是否和其他的区间重叠。最坏情况下，我们可能需要和剩下的所有n-1个区间比较一次才能知道结果，每和一个区间比较都需要两次判断。所以完成n个区间相互之间比较的复杂度为O(n2)，常系数为2。为了加快比较的速度，通常会先对区间进行一个排序，可以按照开始时间或者结束时间进行排序，需要根据实际情况选择。排序之后每个区间再和其他的n-1个区间进行比较。为什么要排序，排序之后的比较复杂度不还是O(n2)吗?原因在于，区间经过排序之后，其实已经有了一个先后顺序，后续再进行重叠判断的时候只需要比较一次即可，这时的复杂度其实变为O(nlogn+n2)，常系数为1，比不排序要快一些。例如，假设所有的区间都按照结束时间进行排序，就会有，这是两个重叠判断条件中的后一个，所以我们只需要再判断前一个即可。在涉及区间重叠的问题上，一般都会先进行排序。

2. 区间调度问题分类

       上面介绍了相关基本概念，这节介绍区间调度问题的两个维度，所有的区间调度问题都是从这两个维度上展开的。给定N个区间，如果我们在x坐标轴上将它们都画出，则可能由于重叠的原因而显示很乱。为了避免重叠，我们需要将区间在y轴上进行扩展，将重叠的区间画在纵坐标不同的行上，如图二。区间在两个维度上的扩展也即在横轴时间和纵轴行数上的扩展。几乎所有的区间调度问题都是从这两个维度上展开的。

区间调度问题详解_第4张图片

图2 区间的两个维度

x轴上的扩展，可能会让我们计算一行中最多可以不重叠地放置多少个区间，或者将区间的时间累加最大可以到多少，或者用最少的区间覆盖一个给定的大区间；y轴上的扩展，可能会让我们计算为了避免区间重叠，最少需要多少行；还可以将y轴的行数固定，然后考虑为了完成n个工作最短需要多少时间，也即机器调度问题。更复杂一些，有时区间还会变成带权的，例如酒店竞标的最大收益等等。区间调度问题的种类非常多，后面会一一展开详细介绍。

3. x轴上的区间调度

       x轴上的区间调度主要关注一行中的区间情况，比如最多可以放入多少不重叠的区间，或者最少可以用多少区间覆盖一个大区间等等。该类区间调度问题应用很广，经常会以各种形式出现在笔试面试题中。

3.1 最多区间调度

       有n项工作，每项工作分别在 时间开始，在 时间结束。对于每项工作，你都可以选择参与与否。如果选择了参与，那么自始至终都必须全程参与。此外，参与工作的时间段不能重叠（闭区间）。你的目标是参与尽可能多的工作，那么最多能参与多少项工作？其中 并且 。（from《挑战程序设计竞赛 P40》）
区间调度问题详解_第5张图片

图3 最多区间调度

       这个区间问题就是大家熟知的区间调度问题或者叫最大区间调度问题。在此我们进行细分，将该问题命名为最多区间调度问题，因为该问题的目标是求不重叠的最多区间个数，而不是最大的区间长度和。

       这个问题可以算是最简单的区间调度问题了，可以通过贪心算法求解，贪心策略是：在可选的工作中，每次都选取结束时间最早的工作。其他贪心策略都不是最优的。

       下面是一个简单的实现：

[cpp]  view plain  copy
 print ?
  1. const int MAX_N=100000;  
  2. //输入  
  3. int N,S[MAX_N],T[MAX_N];  
  4.   
  5. //用于对工作排序的pair数组  
  6. pair<int,int> itv[MAX_N];  
  7.   
  8. void solve()  
  9. {  
  10.     //对pair进行的是字典序比较，为了让结束时间早的工作排在前面，把T存入first，//把S存入second  
  11.     for(int i=0;i
  12.     {  
  13.         itv[i].first=T[i];  
  14.         itv[i].second=S[i];  
  15.     }  
  16.   
  17.     sort(itv,itv+N);  
  18.   
  19.     //t是最后所选工作的结束时间  
  20.     int ans=0,t=0;  
  21.     for(int i=0;i
  22.     {  
  23.         if(t//判断区间是否重叠  
  24.         {  
  25.             ans++;  
  26.             t=itv[i].first;  
  27.         }  
  28.     }  
  29.   
  30.     printf(“%d\n”,ans);  
  31. }  

时间复杂度：排序 O(nlogn) +扫描O(n)  =O(nlogn) 。该问题已给出最优解，也即用贪心法可以解决。但是思考的思路如何得来呢？我们一步步分析，看看能不能最终得到和贪心法一样的结果。

最优化问题都可以通过某种搜索获得最优解，最多区间调度问题也不例外。该问题无非就是选择几个不重叠的区间而已，看看最多能选择多少个，其解空间为一棵二叉子集树，某个区间选或者不选构成了两个分支，如图四所示。我们的目标就是遍历这棵子集树，然后看从根节点到叶节点的不重叠区间的最大个数为多少。可以看出，该问题的解就是n位二进制的某个0/1组合。子集树共有2 n种组合，每种组合都需要判断是否存在重叠区间，如果不重叠则获得1的个数。
区间调度问题详解_第6张图片

图4 区间调度的子集树

假设我们不对区间进行排序，则每种组合判断是否有重叠区间的复杂度为O(n2)，从而整个算法复杂度为O(2n n2)。复杂度相当高！进行各种剪枝也无济于事！下面我们开始对算法进行优化。

让我们感到奇怪的是，只是判断n个区间是否存在重叠最坏居然也需要O(n2)的复杂度。这是因为在区间无序的情况下，每个区间都要顺次和后面的所有区间进行比较，没有合理利用区间的两个时间点。我们考虑对区间进行一下排序会有什么不同。假设我们按照开始时间进行排序，排序之后有，然后从第一个区间开始判断。第一个区间只需要和第二个区间进行判断即可。如果重叠，则这n个区间存在重叠，后面无需再进行判断；如果不重叠，我们只需要再将第二个和第三个进行同样的判断即可。所以按照开始时间进行排序之后，判断n个区间是否存在重叠的复杂度将为O(n)，所以整个算法复杂度降为O(n2n)。按照结束时间进行排序也会有同样的结论。

虽然排序可以降低复杂度，但是遍历子集树的代价还是太大。我们换个角度考虑问题，看能不能避免遍历子集树。突破点在哪呢?我们不妨从第一个区间是否属于最优解开始。首先假设区间按照开始时间排序，并且已经求出最优解对应的所有区间。如果最优解中开始时间最小的区间不是所有区间中开始时间最小的区间，我们看看能否进行替换。和肯定是重叠的，否则就可以将添加到最优解中获得更好的最优解。能否将替换成呢？和满足，但是结束时间不确定，这就可能出现的情况，从而也会出现（i>1）的情况，从而替换可能会引入重叠，最优解变成非最优解。所以在按照开始时间排序的情况下，第一个区间不一定属于最优解。

我们再考虑一下按照结束时间排序的情况，也已经求出最优解对应的所有区间。如果最优解中结束时间最小的区间 不是所有区间中结束时间最小的区间 ，我们看看能否进行替换。 和 肯定是重叠的，否则就可以将 添加到最优解中获得更好的最优解。能否将 替换成 呢？ 和 满足 ， 和 满足 （两个区间不重叠），所以有 ，从而 和 不重叠。所以我们可以用 来替换 。这就得出一个结论： 在按照结束时间排序的情况下，第一个区间必定属于最优解。按照这个思路继续推导剩下的区间我们就会发现： 每次选结束时间最早的区间就可以获得最优解。这就和我们一开始给出的结论一致。

经过上面的分析，我们就明白为啥选择结束时间最早的工作就可以获得最优解。虽然我们并没有遍历子集树，但是它为我们思考和优化问题给出了一个很好的模型，希望大家能好好掌握这种构造问题解空间的方法。

下面我们再换个角度考虑上面的问题。很多最优化深搜问题都可以巧妙地转化成动态规划问题，可以转化的根本原因在于存在重复子问题，我们看图四就会发现最多区间调度问题也存在重复子问题，所以可以利用动态规划来解决。假设区间已经排序，可以尝试这样设计递归式：前i个区间的最多不重叠区间个数为dp[i]。dp[i]等于啥呢？我们需要根据第i个区间是否选择这两种情况来考虑。如果我们选择第i个区间，它可能和前面的区间重叠，我们需要找到不重叠的位置k，然后计算最多不重叠区间个数dp[k]+1（如果区间按照开始时间排序，则前i+1个区间没有明确的分界线，我们必须按照结束时间排序）；如果我们不选择第i个区间，我们需要从前i-1个结果中选择一个最大的dp[j]；最后选择dp[k]+1和dp[j]中较大的。伪代码如下：

[cpp]  view plain  copy
 print ?
  1. void solve()  
  2. {  
  3.     //1. 对所有的区间进行排序  
  4.     sort_all_intervals();  
  5.   
  6.     //2. 按照动态规划求最优解  
  7.     dp[0]=1;  
  8.     for (int i = 1; i < intervals.size(); i++)   
  9.        {  
  10.         //1. 选择第i个区间  
  11.         k=find_nonoverlap_pos();  
  12.         if(k>=0) dp[i]=dp[k]+1;  
  13.         //2. 不选择第i个区间  
  14.         dp[i]=max{dp[i],dp[j]};  
  15.     }  
  16. }  

选择或者不选择第i个区间都需要去查找其他的区间，顺序查找的复杂度为O(n)，总共有n个区间，每个区间都需要查找，所以动态规划部分最初的算法复杂度为O(n2)，已经从指数级降到多项式级，但是经过后面的优化还可以降到O(n)，我们一步步来优化。

可以看出dp[i]是非递减的，这可以通过数学归纳法证明。也即当我们已经求得前i个区间的最多不重叠区间个数之后，再求第i+1个区间时，我们完全可以不选择第i+1个区间，从而使得前i+1个区间的结果和前i个区间的结果相同；或者我们选择第i+1个区间，在不重叠的情况下有可能获得更优的结果。dp[i]是非递减的对我们有什么意义呢？首先，如果我们在计算dp[i]时不选择第i个区间，则我们就无需遍历前i-1个区间，直接选择dp[i-1]即可，因为它是前i-1个结果中最大的（虽然不一定是唯一的），此时伪代码中的dp[j]就变成了dp[i-1]。其次，在寻找和第i个区间不重叠的区间时，我们可以避免顺序遍历。如果我们将dp[i]的值列出来，肯定是这样的：

1,1,…,1,2,2,…,2,3,3,…,3,4……

即dp[i]的值从1开始，顺次递增，每一个值的个数不固定。dp[0]肯定等于1，后面几个区间如果和第0个区间重叠，则的dp值也为1；当出现一个区间不和第0个区间重叠时，其dp值变为2，依次类推。由此我们可以得到一个快速获得不重叠位置的方法：重新开辟一个新的数组，用来保存每一个不同dp值的最开始位置，例如pos[1]=0,pos[2]=3,…。这样我们就可以利用O(1)的时间实现find_nonoverlap_pos函数了，然后整个动态规划算法的复杂度就降为O(n)了。

其实从dp的值我们已经就可以发现一些端倪了：dp值发生变化的位置恰是出现不重叠的位置！再仔细思考一下就会出现一开始提到的贪心算法了。所以可以说，贪心算法是动态规划算法在某些问题中的一个特例。该问题的特殊性在于只考虑区间的个数，也即每次都是加1的操作，后面会看到，如果变成考虑区间的长度，则贪心算法不再适用。

3.2 最大区间调度

       该问题和上面最多区间调度问题的区别是不考虑区间个数，而是将区间的长度和作为一个指标，然后求长度和的最大值。我们将该问题命名为最大区间调度问题。

       WAP某年的笔试题就考察了该问题(下载)。看这样一个例子：现在有n个工作要完成，每项工作分别在 时间开始，在 时间结束。对于每项工作，你都可以选择参与与否。如果选择了参与，那么自始至终都必须全程参与。此外，参与工作的时间段不能重叠（闭区间）。求你参与的所有工作最大需要耗费多少时间。

图5 最大区间调度

       该问题和最多区间调度很相似，一个考虑区间个数的最大值，一个考虑区间长度的最大值，但是该问题的难度要比最多区间调度大些，因为它必须要用动态规划来高效解决。在最多区间调度问题中，我们用动态规划的方法给大家解释了贪心算法可以解决问题的缘由，而最大区间调度问题则是直接利用上面提到的动态规划算法:首先按照结束时间排序区间，然后按照第i个区间选择与否进行动态规划。我们先给出WAP笔试题的核心代码：

[java]  view plain  copy
 print ?
  1. public int getMaxWorkingTime(List intervals) {  
  2.     /* 
  3.      * 1 check the parameter validity 
  4.      */  
  5.           
  6.     /* 
  7.      * 2 sort the jobs(intervals) based on the end time 
  8.      */  
  9.     Collections.sort(intervals, new EndTimeComparator());  
  10.   
  11.     /* 
  12.      * 3 calculate dp[i] using dp 
  13.      */  
  14.     int[] dp = new int[intervals.size()];  
  15.     dp[0] = intervals.get(0).getIntervalMinute();  
  16.   
  17.     for (int i = 1; i < intervals.size(); i++) {  
  18.         int max;  
  19.   
  20.         //select the ith interval  
  21.         int nonOverlap = below_lower_bound(intervals,   
  22.                 intervals.get(i).getBeginMinuteUnit());  
  23.         if (nonOverlap >= 0)  
  24.             max = dp[nonOverlap] + intervals.get(i).getIntervalMinute();  
  25.         else  
  26.             max = intervals.get(i).getIntervalMinute();  
  27.   
  28.         //do not select the ith interval  
  29.         dp[i] = Math.max(max, dp[i-1]);  
  30.     }  
  31.   
  32.     return dp[intervals.size() - 1];  
  33. }  
  34.   
  35. public int below_lower_bound(List intervals, int startTime) {  
  36.     int lb = -1, ub = intervals.size();  
  37.   
  38.     while (ub - lb > 1) {  
  39.         int mid = (ub + lb) >> 1;  
  40.         if (intervals.get(mid).getEndMinuteUnit() >= startTime)  
  41.             ub = mid;  
  42.         else  
  43.             lb = mid;  
  44.     }  
  45.     return lb;  
  46. }  

代码和最多区间调度最大的不同在选择第i个区间时。在这里用了一个二分查找来搜索不重叠的位置，然后判断该位置是否存在。如果不重叠位置存在，则算出当前的最大区间长度和；如果不存在，表明第i个区间和前面的所有区间均重叠，但由于我们还要选择第i个区间，所以暂时的最大区间和也即第i个区间自身的长度。在最多区间调度中，如果该位置不存在，我们直接将dp[i]赋值成dp[i-1]，在这里我们却要将第i个区间本身的长度作为结果。从图五我们可以清楚地看到解释，在计算左下角的区间时，它和前面的两个区间都重合，但是它却包含在最优解中，因为它的长度比前面两个的和还要长。

这里求不重叠位置的时候，用了一个和c++中lower_bound函数类似的实现，和lower_bound的唯一差别在于返回的结果位置相差1。所以上述代码如果用C++来实现会更简单：
[cpp]  view plain  copy
 print ?
  1. const int MAX_N=100000;  
  2. //输入  
  3. int N,S[MAX_N],T[MAX_N];  
  4.   
  5. //用于对工作排序的pair数组  
  6. pair<int,int> itv[MAX_N];  
  7.   
  8. void solve()  
  9. {  
  10.     //对pair进行的是字典序比较，为了让结束时间早的工作排在前面，把T存入first，//把S存入second  
  11.     for(int i=0;i
  12.     {  
  13.         itv[i].first=T[i];  
  14.         itv[i].second=S[i];  
  15.     }  
  16.   
  17.     sort(itv,itv+N);  
  18.   
  19.     dp[0] = itv[0].first-itv[0].second;  
  20.     for (int i = 1; i < N; i++)  
  21.     {  
  22.         int max;  
  23.   
  24.         //select the ith interval  
  25.         int nonOverlap = lower_bound(itv, itv[i].second)-1;  
  26.         if (nonOverlap >= 0)  
  27.             max = dp[nonOverlap] + (itv[i].first-itv[i].second);  
  28.         else  
  29.             max = itv[i].first-itv[i].second;  
  30.   
  31.         //do not select the ith interval  
  32.         dp[i] = max>dp[i-1]?max:dp[i-1];  
  33.     }  
  34.     printf(“%d\n”,dp[N-1]);  
  35. }  
通过上面的分析，我们可以看出最大区间问题是一个应用范围更广的问题，最多区间调度问题是最大区间调度问题的一个特例。如果区间的长度都一样，则最大区间调度问题就退化为最多区间调度问题，进而可以利用更优的算法解决。一般的最大区间调度问题复杂度为: 排序O( nlog n)+扫描 O( nlog n)=O( nlog n)。

3.3 带权的区间调度

       该问题可以看作最大区间调度问题的一般化，也即我们不只是求区间长度和的最大值，而是再在每个区间上绑定一个权重，求加权之后的区间长度最大值。先看一个例子：某酒店采用竞标式入住，每一个竞标是一个三元组（开始，入住时间，每天费用）。现在有N个竞标，选择使酒店效益最大的竞标。（美团2013年）

该问题的目标变成了求收益的最大值，区间不重叠只是伴随必须满足的一个条件。但这不影响算法的适用性，最大区间调度问题的动态规划算法依旧适用于该问题，只不过是目标变了而已：最大区间调度考虑的是区间长度和，而带权区间调度考虑的是区间的权重和，就是在区间的基础上乘以一个权重，就这点差别。所以代码就很简单咯：

[cpp]  view plain  copy
 print ?
  1. const int MAX_N=100000;  
  2. //输入  
  3. int N,S[MAX_N],T[MAX_N];  
  4.   
  5. //用于对工作排序的pair数组  
  6. pair<int,int> itv[MAX_N];  
  7.   
  8. void solve()  
  9. {  
  10.     //对pair进行的是字典序比较，为了让结束时间早的工作排在前面，把T存入first，//把S存入second  
  11.     for(int i=0;i
  12.     {  
  13.         itv[i].first=T[i];  
  14.         itv[i].second=S[i];  
  15.     }  
  16.   
  17.     sort(itv,itv+N);  
  18.   
  19.     dp[0] = (itv[0].first-itv[0].second)*V[0];  
  20.     for (int i = 1; i < N; i++)  
  21.     {  
  22.         int max;  
  23.   
  24.         //select the ith interval  
  25.         int nonOverlap = lower_bound(itv, itv[i].second)-1;  
  26.         if (nonOverlap >= 0)  
  27.             max = dp[nonOverlap] + (itv[i].first-itv[i].second)*V[i];  
  28.         else  
  29.             max = (itv[i].first-itv[i].second)*V[i];  
  30.   
  31.         //do not select the ith interval  
  32.         dp[i] = max>dp[i-1]?max:dp[i-1];  
  33.     }  
  34.     printf(“%d\n”,dp[N-1]);  
  35. }  

博客介绍到这里，我们已经比较清楚上述三个问题的关系，带权区间调度应用最广，最大区间调度其次，最多区间调度应用范围最小。算法从通用的DP到特殊的DP再到贪心算法，难度逐渐降低。图六展示了三个问题的关系。

区间调度问题详解_第7张图片

图6 三种调度问题的关系

3.4 最小区间覆盖

问题定义如下：有n 个区间，选择尽量少的区间，使得这些区间完全覆盖某给定范围[s,t]。

初次遇到该问题，大家可能会把该问题想得很复杂，是不是需要用最长的区间去覆盖给定的范围，然后将给定范围分割成两个更小的子问题，用递归去解决。这时我们就需要获得在给定范围内的最长区间，但是如何判断最长区间却有太多的麻烦，而且即使选择了在给定范围内的最长区间，也不见得能获得最优值。其实该问题根本就没有想象中麻烦，可能很容易地解决。

解决问题的关键在于，我们不要一开始就考虑整个范围，而是从给定范围的左端点入手。我们选择一个可以覆盖左端点的区间之后，就可以将左端点往右移动得到一个新的左端点。只要我们不停地选择可以覆盖左端点的区间就一定可以到达右端点，除非问题无解。关键是我们应该选择什么样的区间来覆盖左端点。由于我们要用选择区间的右端点和给定范围的左端点比较，所以第一想法会是先对所有的区间按照结束时间排序，然后按照结束时间从小到大和左端点比较。啥时候停止比较然后修改左端点呢？肯定是到了某个区间的开始时间大于给定范围的左端点的时候。这是因为如果我们继续遍历，可能就会不能完全覆盖给定范围。但是这样也可能会得不到最优解，如图七所示。

区间调度问题详解_第8张图片

图7 按照结束时间排序的最小区间覆盖错误示意图

       在上图中，三个区间按照结束时间排序，第一个区间和给定范围的左端点相交，接着遍历第二个区间。这时发现第二个区间的左端点大于给定范围的左端点，这时我们就需要停止继续比较，修改给定范围新的左端点为end1。接着遍历第三个区间，按照上述规则我们就会将第三个区间也保留下来，但其实只需要第三个区间就满足要求了，第一个区间没有保留的意义，也即我们获得不了最优解。

       既然按照结束时间获得不了最优解，我们再尝试按照开始时间排序看看。区间按照开始时间排序之后，我们从最小开始时间的区间开始遍历，每次选择覆盖左端点的区间中右端点坐标最大的一个，并将左端点更新为该区间的右端点坐标，直到选择的区间已包含右端点。按照这种方法我们就可以获得最优解，但是为什么呢？算法其实根据区间开始时间的值将区间进行了分组：在给定范围左端点左侧的和在左端点右侧的。由于我们按照开始时间排序，所以这两组区间的分界线很明确。而为了覆盖给定的范围，我们必须要从分界线左侧的区间中选一个（否则就不能覆盖整个范围）。上述算法选择了能覆盖给定范围左端点中右端点最大的区间，这是一个最优的选择。对剩余的区间都执行这样的选择显然可以获得最优解。

区间调度问题详解_第9张图片

图8 按照开始时间排序的最小区间覆盖示意图

       图八给出一个示例。四个区间已经按照开始时间排序，我们从I1开始遍历。I1和I2都覆盖左端点，I3不覆盖，选择右端点最大的一个end1作为新的左端点，并且将I1添加到最小覆盖区间中。然后重复上述步骤，将剩余的区间和新的左端点比较并选择右端点最大的区间，修改左端点，这时左端点就会变为end4，I4添加到最小覆盖区间中。依次处理剩余的区间，我们就获得了最优解。代码实现如下：

[cpp]  view plain  copy
 print ?
  1. const int MAX_N=100000;  
  2. //输入  
  3. int N,S[MAX_N],T[MAX_N];  
  4.   
  5. //用于对工作排序的pair数组  
  6. pair<int,int> itv[MAX_N];  
  7.   
  8. int solve(int s,int t)  
  9. {  
  10.     for(int i=0;i
  11.     {  
  12.         itv[i].first=S[i];  
  13.         itv[i].second=T[i];  
  14.     }  
  15.   
  16.     //按照开始时间排序  
  17.     sort(itv,itv+N);  
  18.   
  19.     int ans=0,max_right=0;  
  20.     for (int i = 0; i < N; )  
  21.     {  
  22.         //从开始时间在s左侧的区间中挑出最大的结束时间  
  23.         while(itv[i].first<=s)  
  24.         {  
  25.             if(max_right
  26.             i++;  
  27.         }     
  28.   
  29.         if(max_right>s)   
  30.         {  
  31.              s=max_right;  
  32.              ans++;  
  33.             if(s>=t) return ans;  
  34.         }  
  35.         else //如果分界线左侧的区间不能覆盖s，则不可能有区间组合覆盖给定范围  
  36.         {  
  37.                 return -1;  
  38.         }  
  39.     }  
  40. }  

时间复杂度：排序O(nlogn)  +扫描O(n) =O(nlogn) 。

4. y轴上的区间调度

       x轴上的区间调度关注的是区间在一维空间上的摆放（重叠或者不重叠），而y轴上的区间调度则将问题扩展到二维。虽然维度增加了，但是解决问题的难度没有增大多少。

4.1 最大区间重叠（最少工人调度）

       该问题似乎有两个矛盾的描述，既是最大又是最少，但其实是从不同的方面描述同一个问题。先看最大的一方面，问题可以这样描述：给定的n个区间，在任意时刻最多有几个重叠的区间，如图九所示，在12:00到12:30的范围内，最多有三个区间重叠，没有其他时刻超过三个区间重叠。WAP2013年的笔试题是从该角度考察该问题的（下载）。再看最少的一方面，假设我们将这些区间认为是一些工作，然后将这些工作分配给一些工人，每个工人不能同时干两件工作，最少需要几名工人。也即将所有的区间不重叠地摆在二维平面上，最少能够占据几行（很显然，可以一个工人干一件工作，这时n个工作就需要n个工人，也即在二维平面上一个工作占据一行，但显然不是最优的）。虽然该问题有两种理解方式，但是它们要解决的是同一个问题，所以解决方法相同。我们从最少工人调度角度看看如何解决该问题。

区间调度问题详解_第10张图片

图9 最大区间重叠

4.1.1 解法一

在最多区间调度中，我们分配尽可能多的不重叠工作给工人，这启发我们是否可以沿着这个思路去解决问题。按照最多区间调度分配不重叠工作给第一个工人，如果还有剩余工作，肯定需要别的工人来完成，我们继续按照最多区间调度问题来解，并分配一个新的工人，…，直到没有工作为止。很可惜，上面的策略不可行，请看图十。如果按照最多区间调度的策略分配工作，下面四个工作需要分配三个工人，但实际最少只需要两个工人即可。问题出在最多区间调度采用的是贪心算法，只要是下一个工作和目前的最大结束时间不重叠就选择该工作，这就导致在判断I3时将该工作分配给了第一个工人。

区间调度问题详解_第11张图片

图10 按照最多区间调度的策略实现最少工人调度

       这是否意味着上述策略就彻底不行呢？只要稍微改改选择工人的策略还是可以的。当我们在判断一个工作该分配给哪个工人时，我们需要选择可以接受该工作同时完成之前的工作最晚的工人。例如，图十中判断I3该分配哪个工人。这时前两个工人都可以选择该工作，但是第二个工人完成之前的工作更晚，所以需要将I3分配给第二个工人，而不是第一个工人。这样分配工作的目的是让结束时间早的工人能处理后面未知的工作，而不是浪费在一个已知工作上。上述思路需要我们保存每个工人的上一个工作结束时间，也即下一个工作可以开始的时间。由于工作都按照结束时间排序，所以在添加新的工人时，我们会产生一个非递减的序列。但是当可以将新的工作分配给现有工人时，我们需要在有序序列中找到合适的位置，并修改该工人的可工作时间。为了维持序列的单调性，我们需要移动不少元素。按这种策略实现的java代码如下：

[java]  view plain  copy
 print ?
  1. public int getMaxIntervalOverlapCount(List intervals) {  
  2.         int maxWorkers = 0;  
  3.           
  4.         Collections.sort(intervals, new EndTimeComparator());  
  5.           
  6.         int[] endTime=new int[intervals.size()];          
  7.         for(int i=0;i
  8.         {  
  9.             int startTime=intervals.get(i).getBeginMinuteUnit();  
  10.             int pos=below_lower_bound(endTime, maxWorkers, startTime);  
  11.               
  12.             if(pos==-1)  
  13.             {  
  14.                 endTime[maxWorkers++]=intervals.get(i).getEndMinuteUnit();  
  15.             }  
  16.             else  
  17.             {  
  18.                 for(int j=pos;j1;j++)  
  19.                 {  
  20.                     endTime[j]=endTime[j+1];  
  21.                 }  
  22.                 endTime[maxWorkers-1]=intervals.get(i).getEndMinuteUnit();  
  23.             }  
  24.         }  
  25.           
  26.         return maxWorkers;  
  27.     }  
  28.       
  29.     public int below_lower_bound(int[] a,int n,int k) {  
  30.         int lb = -1, ub = n;  
  31.   
  32.         while (ub - lb > 1) {  
  33.             int mid = (ub + lb) >> 1;  
  34.             if (a[mid] >= k)  
  35.                 ub = mid;  
  36.             else  
  37.                 lb = mid;  
  38.         }  
  39.         return lb;  
  40.     }  
  41.       
  42.     class EndTimeComparator implements Comparator {  
  43.         public int compare(Object arg0, Object arg1) {  
  44.             Interval i1 = (Interval) arg0;  
  45.             Interval i2 = (Interval) arg1;  
  46.   
  47.             return i1.getEndHour() != i2.getEndHour() ? i1.getEndHour()  
  48.                     - i2.getEndHour() : i1.getEndMinute() - i2.getEndMinute();  
  49.         }  
  50.     }  
    51. 上述算法可以获得最优解，复杂度为：排序O( nlog n)  +查找O( nlog n)  +扫描 O(n2)=  O(n2)。上述算法虽然可以获得最优解，但是复杂度和其他问题相比显然上升了一个量级，导致复杂度为 O(n2)的关键在于采用数组这种数据结构，找到合适的位置之后进行插入操作需要移动元素。如果采用平衡二叉树则会进一步降低复杂度到O( nlog n) ，具体的实现大家可以自己尝试。

    4.1.2 解法二

        前面的解法按照结束时间排序，我们再看看按照开始时间排序是否可行。如图十一，四个工作已按照开始时间排序，我们看看如何将其分配给工人。既然按照开始时间排序，我们就从开始时间最小的工作开始分配。前三个工作肯定需要三个工人，关键是第四个工作该分配给谁。按照之前的策略，我们最好将I4和I2分配给同一个工人，这样分配I1工作的工人就可以分配其他未知的工作。如果采用这种策略，我们还是需要选择可以接受该工作同时完成之前的工作最晚的工人，这就意味着我们还是需要O(n2)的复杂度来解决问题。事实上，由于我们按照开始时间排序，所以后面未知工作的开始时间肯定会越来越晚，所以我们就不用担心该选择哪个工人的问题了，直接选择完成之前的工作结束时间最早的工人即可，也即将I1和I4分配给同一个工人。这样有什么好处呢？由于每次都是选择结束时间最早的工人，所以我们就可以选择一个最小堆来加速工人的寻找，从而降低整个算法的复杂度。

    区间调度问题详解_第12张图片

    图11 按照开始时间排序实现最少工人调度

           具体的流程如下。我们用最小堆来维护一个工人完成之前工作的时间。当给新工作分配工人时，我们只需要将该工作的开始时间和堆顶的元素进行比较：如果堆顶的元素小于给定工作的开始时间，则可以将该工作分配给之前已经分配工作的工人，同时将堆顶元素修改成新工作的结束时间并重新调整堆；如果堆顶元素大于给定工作的开始时间，则表明目前分配工作的工人没有一个可以接受这个新工作，我们需要增加一个新的工人才行，同时往堆中增加该新工作的结束时间。按照这个思路实现的代码如下：
    [java]  view plain  copy
     print ?
    1. public int getMaxIntervalOverlapCount(List intervals) {  
    2.     int maxWorkers = 0;  
    3.     /* 
    4.     * 1 check the parameter validity 
    5.     */  
    6.           
    7.     /* 
    8.      * 2 sort the jobs(intervals) based on the start time 
    9.     */  
    10.     Collections.sort(intervals, new StartTimeComparator());  
    11.   
    12.     /* 
    13.     * 3 check the least number of needed workers 
    14.     */  
    15.     PriorityQueue pq = new PriorityQueue(intervals.size());  
    16.   
    17.     // add the first job to the heap  
    18.     pq.add(intervals.get(0).getEndMinuteUnit());  
    19.     maxWorkers++;  
    20.   
    21.     for (int i = 1; i < intervals.size(); i++) {  
    22.         // no allocated workers can do the next job  
    23.         if (pq.peek() >= intervals.get(i).getBeginMinuteUnit()) {  
    24.             maxWorkers++;  
    25.         } else {  
    26.             pq.poll();  
    27.         }  
    28.         pq.add(intervals.get(i).getEndMinuteUnit());  
    29.     }  
    30.   
    31.     return maxWorkers;  
    32. }  
    33.   
    34. class StartTimeComparator implements Comparator {  
    35.     public int compare(Object arg0, Object arg1) {  
    36.         Interval i1 = (Interval) arg0;  
    37.         Interval i2 = (Interval) arg1;  
    38.   
    39.         return i1.getBeginHour() != i2.getBeginHour() ? i1.getBeginHour()  
    40.                     - i2.getBeginHour() : i1.getBeginMinute()  
    41.                     - i2.getBeginMinute();  
    42.     }  
    43. }  

      44. 上述算法可以获得最优解，复杂度为：排序O(nlogn) +扫描O(nlogn)=O(nlogn)。和按照结束时间排序相比，复杂度并没有变化，但是理解上更容易了，所以往后遇到该问题如果对复杂度没有进一步的要求，解决方案就是：开始时间排序+最小堆。

      4.1.3 解法三

      算法的优化是永无止境的，该问题还有一个复杂度更低的解法，可以在排序之后将扫描的复杂度降到O(n)。核心的思想是将区间的开始和结束时间分开考虑，然后采用顺序扫描的方法即可获得最优解。具体的步骤为：将每个区间拆成两个事件点，按坐标从小到大排序，顺序处理每个区间。记录一个值 ，表示当前点被包含次数。每次遇到区间的左端点就+1，遇到右端点就-1。需要工人的数量就是在该过程中 的最大值。时间复杂度为排序O(nlogn)+扫描O(n)=O(nlogn)。这种解法的思路其实是从最大区间重叠的角度来考虑问题的，就介绍这么多，请自己实现代码。

      上面的三种解法都可以处理工人数没有限制的情况，但是如果限定工人的数目，然后看能选择多少区间（工作），则按照解法一会更方便。因为当只有一个工人的时候，该问题等价于最多区间调度，所以按照最多区间调度的思路去解决该问题会更容易。

      5. 综合区间调度

      在此我们简单介绍一下机器调度问题。机器调度问题和前面的区间调度问题很不一样。之前的调度问题中，给定的区间有一个固定的开始和结束时间，但是在机器调度中，每个区间或者叫任务都只包含一段执行时间，但是没有固定的开始时间。具体的问题描述如下：

      机器调度是指有m台机器需要处理n个作业，设作业i的处理时间为ti，则对n个作业进行机器分配，使得： 

      1. 一台机器在同一时间内只能处理一个作业；
      2. 一个作业不能同时在两台机器上处理；
      3. 作业i一旦运行，则需要ti个连续时间单位。 

      设计算法进行合理调度，使得在m台机器上处理n个作业所需要的处理时间最短。如图十二，有三台机器，七个作业所需时间分别为(2,14,4,16,6,5,3)，给出的调度最少需要17个单位时间。

      区间调度问题详解_第13张图片

      图12 三台机器的调度

             机器调度问题是一个NP-复杂问题，我们可以认为不存在多项式复杂度的解法获得最优解。如果非要获得最优解，我们必须要采用深搜策略遍历解空间，机器调度的解空间是一个k叉树，表示某个作业分配给哪一个机器；树共有n层，每一个叶节点表示一个可能的任务分配，最小的叶节点即是最优解，算法复杂度是O(kn)。

      针对NP复杂的问题，一般也不会让我们获得最优解，求个近似最优就好了。在机器调度中，采用一个称为最长处理时间优先（longest processing time first, LPT）的调度策略会获得较理想的调度方案。在LPT算法中，作业按照它们所需处理时间的递减顺序排序。在分配一个作业时，总是将其分配给最先变为空闲的机器。具体实现比较简单，就是先排序，然后采用最小堆维护一个最小开始时间即可，和最大区间重叠的方法二比较相似，具体不再赘述。

      采用LPT策略有个定理：

      令 为在m台机器上执行作业集合I的最佳调度完成时间，F(I)为采用LPT调度策略所得到的调度完成时间，则

      可以看出，LPT策略和最优解很相近，是种比较好的近似策略。

      6. 总结

             本博客详细介绍了几类区间调度问题，给出了最优解的思路和代码。虽然并没有完全覆盖区间调度问题，但是已足以让大家应对各种笔试面试。关于尚未触及的区间调度问题及相关例题，大家可进一步参考算法合集之《浅谈信息学竞赛中的区间问题》。下表给出了每个问题的最优解法以及复杂度（由于所有的问题都要先进行排序，所以我们只关注扫描的复杂度）。

      区间调度问题详解_第14张图片

      你可能感兴趣的:(算法学习)

      • c语言输入两个字符串 按字典数序比较大小,算法学习笔记（一）C++排序函数、映射技巧与字典树... Nature自然科研 c语言输入两个字符串按字典数序比较大小
        1.头文件algorithm中有函数sort()用于排序，参数为：排序起始地址，排序结束地址，排序规则(返回bool型)例如，要将array[]={5,7,1,2,9}升序排列，则使用：boolcmp(inta,intb);intmain(){intarray[]={5,7,1,2,9};sort(array,array+5,cmp);for(inti=0;icoutb)returnfalse;e
      • 推荐算法学习记录2.2——kaggle数据集的动漫电影数据集推荐算法实践——基于内容的推荐算法、协同过滤推荐 萱仔学习自我记录 推荐算法学习pythonmatplotlib开发语言
        1、基于内容的推荐：这种方法根据项的相关信息（如描述信息、标签等）和用户对项的操作行为（如评论、收藏、点赞等）来构建推荐算法模型。它可以直接利用物品的内容特征进行推荐，适用于内容较为丰富的场景。‌#1.基于内容的推荐算法fromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.metrics.pairwiseimport
      • 邓俊辉数据结构与算法学习笔记-第五章 xiaodidadada 数据结构与算法
        文章目录树aa1树a2应用a3有根树a4有序树a5路径a6连通图无环图a7深度层次b在计算机中表示b1树的表示b2父节点b3孩子节点b4父亲孩子表示法b5长子兄弟表示法c二叉树c1二叉树概述c2真二叉树c3描述多叉树d二叉树d1BinNode类d2BinNode接口d3BinTree类d4高度更新d5节点插入e相关算法e1-1先序遍历转化策略e1-2遍历规则e1-3递归实现e1-4迭代实现e1-5
      • 2024.8.14-算法学习（原创+转载） 蓝纹绿茶 算法学习人工智能
        一、投机采样图源自投机采样推理原理-66Ring'sBlog投机采样（SpeculativeDecoding）是Google和DeepMind在2022年同时发现的大模型推理加速方法。它可以在不损失生成效果前提下，获得3x以上的加速比。大型语言模型（LLM）的推理通常需要使用自回归采样。它们的推理过程相当缓慢，需要逐个token地进行串行解码。生成每个标记都需要将所有参数从存储单元传输到计算单元，
      • 算法学习-2024.8.16 蓝纹绿茶 学习
        一、Tensorrt学习补充TensorRT支持INT8和FP16的计算。深度学习网络在训练时，通常使用32位或16位数据。TensorRT则在网络的推理时选用不这么高的精度，达到加速推断的目的。TensorRT对于网络结构进行了重构，把一些能够合并的运算合并在了一起，针对GPU的特性做了优化。一个深度学习模型，在没有优化的情况下，比如一个卷积层、一个偏置层和一个reload层，这三层是需要调用三
      • 算法学习每日一题数位不同的组合 故里 算法学习
        Problem:3153.所有数对中数位不同之和思路本题关键在于如何处理数位不同的个数，其实就是组合问题，两个不同数字的不同数位只能算一对，所以我们不妨把后方元素与前方元素数位不同算作一对，保持单调性避免重复计数。那么后方元素不同的数位应该如何统计呢，我们不妨使用哈希表，一维表示统计的数位位数，二维表示数位0~9。某一数位位数下数位与前方元素不同的个数，就是当前遍历到的所有元素数目-该数位相同的元
      • 算法学习笔记-复杂度分析上 胖琪的升级之路
        如何分析、统计算法的执行效率和资源消耗为什么需要复杂度分析首先我们很多程序都可以通过统计，监控等方式帮助我们得到程序执行的时间与占用的内存大小。但是这些统计方法有很大的局限性。测试结果非常依赖测试环境。不同的测试机器，同样的代码执行效率就不同。测试结果数受数据规模的影响很大。数据规模大，我们的代码执行效率低。测试结果不能真正的反应我们的内容大O复杂度表示法我们假设一行代码执行一次的时间是unit_
      • 粒子群优化算法和强化算法的优缺点对比，以表格方式进行展示。详细解释 资源存储库 笔记笔记
        粒子群优化算法（PSO）和强化学习算法（RL）是两种常用的优化和学习方法。以下是它们的优缺点对比，以表格的形式展示：特性粒子群优化算法（PSO）强化学习算法（RL）算法类型优化算法学习算法主要用途全局优化问题，寻找最优解学习和决策问题，优化策略以最大化长期奖励计算复杂度较低，通常不需要梯度信息；计算复杂度与粒子数量和迭代次数有关较高，涉及到策略网络的训练和环境交互；复杂度取决于状态空间、动作空间以
      • 算法学习6——贪心算法 零 度° 算法学习算法学习贪心算法
        什么是贪心算法？贪心算法是一种在每一步选择中都采取当前状态下最优或最有利的选择的算法。其核心思想是通过一系列局部最优选择来达到全局最优解。贪心算法广泛应用于各种优化问题，如最短路径、最小生成树、背包问题等。贪心算法的特点局部最优选择：每一步都做出在当前情况下最优的选择。无后效性：一旦某个状态被确定，就不会再被改变或回溯。逐步构造解决方案：通过一系列的选择逐步构建出最终的解决方案。经典例子及其Pyt
      • 代码随想录算法训练营第三十五天| 121. 买卖股票的最佳时机，122.买卖股票的最佳时机II，123.买卖股票的最佳时机III 无敌的平衡步兵 算法打卡算法数据结构动态规划贪心算法leetcode
        今天是动态规划算法学习的第八天，也是买卖股票的一天。涉及到了使用多维数组来表示不同的状态，然后进行状态转移。121.买卖股票的最佳时机题目链接：121.买卖股票的最佳时机-力扣（LeetCode）这个题目是给出一个数组表示股票每天的价格，只能进行一次股票的买卖。求解所能获得的最大利润。我自己的做法是用前缀和，求每个数右边最大的数，然后求最大的差值。具体代码如下所示：classSolution{pu
      • 代码随想录算法训练营第二十一天| 39. 组合总和, 40.组合总和II, 131.分割回文串 无敌的平衡步兵 算法打卡算法数据结构leetcode职场和发展剪枝
        今天是回溯算法学习的第二天，主要的学习内容包括：1.组合问题的重复使用2.组合问题的去重3.分割问题的处理方法。39.组合总和题目链接：39.组合总和-力扣（LeetCode）这个组合问题的特点是，集合内的元素可以重复使用。与前面组合问题的区别在于，在每一次回溯中，不是从i+1的位置开始穷举，而是从i开始穷举。这样就满足元素重复使用的要求。对于剪枝操作，这个题的做法是如果求和的结果已经大于目标值，
      • 算法学习07：KMP算法 Lhz326568 学习打卡算法学习笔记c++开发语言
        算法学习07：KMP算法文章目录算法学习07：KMP算法前言一、KMP算法1.kmp匹配过程：2.求解next数组（kmp算法重点）3.代码总结前言提示：以下是本篇文章正文内容：一、KMP算法1.kmp匹配过程：2.求解next数组（kmp算法重点）3.代码#includeusingnamespacestd;constintN=10000+10,m=100000+10;intn,m;intp[N]
      • c++算法学习，力扣刷题笔记 黒№ c++算法
        c++算法学习，力扣刷题笔记目录c++算法学习，力扣刷题笔记新手村1480.一维数组的动态和1480.一维数组的动态和C++中的位运算符例子更多位运算用法具体示例1672.最富有客户的资产总量新手村力扣新手村题目及解析，我的疑问和解答1480.一维数组的动态和题目给你一个数组nums。数组「动态和」的计算公式为：runningSum[i]=sum(nums[0]…nums[i])。请返回nums的
      • 不错链接整理 xushuanglu_csdn 提升学习开源
        不错链接整理算法https://github.com/MisterBooo/LeetCodeAnimation手把手撕LeetCode题目，扒各种算法套路的裤子https://github.com/labuladong/fucking-algorithm算法学习笔记https://github.com/nonstriater/Learn-Algorithms常用数据结构及其算法的Java实现，包括
      • 【Java】零基础蓝桥杯算法学习——二分查找 xioaobai_huan 蓝桥杯算法入门学习算法java蓝桥杯
        算法模板一://数组arr的区间[0,left-1]满足arr[i]=k;Scannerscan=newScanner(System.in);int[]arr={1,2,3,4,5};intleft=0,right=arr.length-1;intk=scan.nextInt();while(left=k)right=mid;elseleft=mid+1;}算法模板二：//数组arr的区间[0,l
      • 【Java】零基础蓝桥杯算法学习——动态规划例题 xioaobai_huan 蓝桥杯算法入门学习算法java蓝桥杯
        例题：2023年第十四届蓝桥杯Java软件开发B组E题蜗牛参考解答：参考代码示例：importjava.util.Scanner;publicclassMain{staticintN=100010;staticint[]arr=newint[N];staticint[]a=newint[N];//传送带的起始坐标staticint[]b=newint[N];//第i-1根杆子的传送带的坐标stat
      • 【Java】零基础蓝桥杯算法学习——线性动态规划（一维dp） xioaobai_huan 蓝桥杯算法入门学习算法蓝桥杯学习java
        线性dp——一维动态规划1、考虑最后一步可以由哪些状态得到，推出转移方程2、考虑当前状态与哪些参数有关系，定义几维数组来表示当前状态3、计算时间复杂度，判断是否需要进行优化。一维动态规划例题：最大上升子序列问题Java参考代码：importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannerscan
      • 算法学习|Day17-二叉树|Leetcode110.平衡二叉树，Leetcode257. 二叉树的所有路径，Leetcode404.左叶子之和 ambitious_Rgr 算法python数据结构leetcode广度优先深度优先学习
        目录一、Leetcode110.平衡二叉树题目描述解题思路方法:递归总结二、Leetcode257.二叉树的所有路径题目描述解题思路方法:递归总结三、Leetcode404.左叶子之和题目描述解题思路方法一:递归方法二:层序遍历总结一、Leetcode110.平衡二叉树题目描述给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点的左右两个子树的高度差的
      • 数据结构与算法学习笔记（训练营三）-经典面试四 剑侠李逍遥
        给你一个字符串类型的数组arr，譬如:String[]arr={"b\st","d\","a\d\e","a\b\c"};把这些路径中蕴含的目录结构给打印出来，子目录直接列在父目录下面，并比父目录向右进两格，就像这样:abcdebcstd同一级的需要按字母顺序排列不能乱。利用前缀树，让后深度优先遍历/***给你一个字符串类型的数组arr，譬如:*String[]arr={"b\st","d\","
      • 机器学习-近邻KNN算法学习笔记 不会敲代码的陈序员 机器学习算法人工智能
        目录一、算法定义KNN算法性能：欠拟合和过拟合KNN算法优缺点二、算法原理算法通俗解释算法的公式欧氏距离曼哈顿距离三、算法实现与应用模型搭建思路KNN算法模型源码代码运行效果图四、总结一、算法定义K最近邻（K-NearestNeighbors，KNN）算法是一种用于分类和回归的监督学习算法。KNN算法的主要思想可以简单概括如下：训练阶段：在训练阶段，KNN算法将所有的训练样本和它们对应的标签存储在
      • 算法学习笔记 4-3 深搜（DFS）与广搜（BFS）：初识问题状态空间 与 LeetCode真题（Java） 小成同学_ 数据结构与算法算法leetcodedfsbfsjava
        喜欢该类型文章可以给博主点个关注，博主会持续输出此类型的文章，知识点很全面，再加上LeetCode的真题练习，每一个LeetCode题解我都写了详细注释，比较适合新手入门数据结构与算法，后续也会更新进阶的文章。课件参考—开课吧《门徒计划》4-3深搜（DFS）与广搜（BFS）：初识问题状态空间搜索的核心概念首先给大家拓展一个概念，这个概念就是我们学习搜索算法中非常重要的一环：这个问题求解树是一个抽象
      • 算法学习：双指针进阶之滑动窗口算法 2301_76884895 算法leetcode数据结构
        文章目录一、认识滑动窗口算法二、算法运用1.最小覆盖子串2.字符串排列3.找所有字母异位词4.最长无重复字串总结一、认识滑动窗口算法本文讲的滑动窗口算法基于前面的基本的双指针技巧。在滑动窗口算法中，可以使用左右指针来记录窗口的左右边界，以及使用快慢指针来同时从两端向中间遍历数据流，从而加速算法的执行效率。滑动窗口算法的核心在于通过维护一个窗口来记录满足条件的数据，并在窗口移动的过程中更新窗口记录的
      • 算法学习——LeetCode力扣贪心篇1 拉依达不拉胯 算法学习leetcodec++c语言
        算法学习——LeetCode力扣贪心篇1455.分发饼干455.分发饼干-力扣（LeetCode）描述假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸s[j]。如果s[j]>=g[i]，我们可以将这个饼干j分配给孩子i，这个孩子会得到满足。你的目标是尽可能
      • 2.7数据结构与算法学习日记（动态规划01背包和并查集） 祺580 学习动态规划算法
        题目描述辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”如果你是辰辰，你
      • 2.8数据结构与算法学习日记（bfs和01背包和完全背包） 祺580 学习
        P8673[蓝桥杯2018国C]迷宫与陷阱题目描述小明在玩一款迷宫游戏，在游戏中他要控制自己的角色离开一间由N×N个格子组成的二维迷宫。小明的起始位置在左上角，他需要到达右下角的格子才能离开迷宫。每一步，他可以移动到上下左右相邻的格子中（前提是目标格子可以经过）。迷宫中有些格子小明可以经过，我们用.表示；有些格子是墙壁，小明不能经过，我们用#表示。此外，有些格子上有陷阱，我们用X表示。除非小明处于
      • 2.14数据结构与算法学习日记 祺580 学习算法
        洛谷P1934封印题目背景很久以前，魔界大旱，水井全部干涸，温度也越来越高。为了拯救居民，夜叉族国王龙溟希望能打破神魔之井，进入人界“窃取”水灵珠，以修复大地水脉。可是六界之间皆有封印，神魔之井的封印由蜀山控制，并施有封印。龙溟作为魔界王族，习有穿行之术，可任意穿行至任何留有空隙的位置。然而封印不留有任何空隙！龙溟无奈之下只能强行破除封印。破除封印必然消耗一定的元气。为了寻找水灵珠，龙溟必须减少体
      • 算法学习#32 第一个错误的版本 0daydreamer0
        题目详情你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有n个版本[1,2,...,n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用boolisBadVersion(version)接口来判断版本号version是否在单元测试中出错。实现一个函数来查找
      • [算法学习] 贝祖定理 Waldeinsamkeit41 学习
        裴蜀定理://设a,b是不全为0的整数,则存在整数x,y使得ax+by=gcd(a,b)//扩展裴蜀定理://a,b为不小于0的整数,n为整数,是否存在不小于0的x和y使得ax+by=n有解?//1、若n>ab-a-b,有解//2、若n=0,有解(x=y=0)//3、若n0//设a和b的最大公约数为gcd(a,b),因为a,b,x,y均为整数,其线性组合同样是gcd(a,b)的倍数//故ax+by
      • 算法学习——LeetCode力扣二叉树篇7 拉依达不拉胯 LeetCode算法学习算法学习leetcodec++c
        算法学习——LeetCode力扣二叉树篇7236.二叉树的最近公共祖先236.二叉树的最近公共祖先-力扣（LeetCode）描述给定一个二叉树,找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树T的两个节点p、q，最近公共祖先表示为一个节点x，满足x是p、q的祖先且x的深度尽可能大（一个节点也可以是它自己的祖先）。”示例示例1：输入：root=[3,5,1,6,2,
      • 算法学习——LeetCode力扣二叉树篇6 拉依达不拉胯 LeetCode算法学习算法学习leetcodec++clinux
        算法学习——LeetCode力扣二叉树篇6617.合并二叉树617.合并二叉树-力扣（LeetCode）描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。
      • Spring的注解积累 yijiesuifeng spring注解
        用注解来向Spring容器注册Bean。   需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 如：在base-package指明一个包    <context:component-sc
      • 传感器 百合不是茶 android传感器
        android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件   下面就以重力传感器为例;   1,在onCreate中获得传感器服务   private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
      • [光磁与探测]金吕玉衣的意义 comsci
              这是一个古代人的秘密:现在告诉大家       信不信由你们:       穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星       这就是为什么古代
      • 精简的反序打印某个数 沐刃青蛟 打印
        以前看到一些让求反序打印某个数的程序。 比如：输入123，输出321。   记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。   似乎最后是用到%和/方法解决的。   而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）   代码如下： long num, num1=0;
      • PHP：6种方法获取文件的扩展名 IT独行者 PHP扩展名
          PHP：6种方法获取文件的扩展名   1、字符串查找和截取的方法   1 $extension = substr ( strrchr ( $file ,  '.' ), 1); 2、字符串查找和截取的方法二   1 $extension = substr
      • 面试111 文强chu 面试
        1事务隔离级别有那些 ，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器 （一次） 4 过滤器和拦截器的区别 （频率也挺高） 5 final，finally final
      • XML的四种解析方式 小桔子 domjdomdom4jsax
        在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
      • wordpress中常见的操作 aichenglong 中文注册wordpress移除菜单
        1 wordpress中使用中文名注册解决办法   1)使用插件   2)修改wp源代码      进入到wp-include/formatting.php文件中找到       function sanitize_user( $username, $strict = false
      • 小飞飞学管理-1 alafqq 管理
        项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 结合我自己经历写下心得 对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
      • IO输入输出部分探讨 百合不是茶 IO
         //文件处理  在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */   //1，运用File类对文件目录和属性进行操作   //在工程中线创建一个text.txt
      • getElementById的用法 bijian1013 element
                getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。        返回具有指定ID属性值的第一个对象的一个引用。        语法： &n
      • 励志经典语录 bijian1013 励志人生
        经典语录1:   哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
      • [MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
        MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 本篇介绍MongoDB的切片(Sharding)   1.何时需要分片 &nbs
      • 【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
        1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
      • yum方式部署zabbix ronin47 yum方式部署zabbix
        安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
      • Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EEHibernate4
        今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码 在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
      • Netty源码学习-FrameDecoder bylijinnan javanetty
        Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
      • SQL行列转换方法 chicony 行列转换
        create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
      • 中文编码测试 ctrain 编码
        循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
      • hive 客户端查询报堆内存溢出解决方法 daizj hive堆内存溢出
        hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space   问题原因： hive堆内存默认为256M   这个问题的解决方法为： 修改/us
      • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
          卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。   在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
      • Eclipse简单有用的配置 dcj3sjt126com eclipse
        1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers   2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
      • 在tomcat上面安装solr4.8.0全过程 eksliang Solrsolr4.0后的版本安装solr4.8.0安装
        转载请出自出处： http://eksliang.iteye.com/blog/2096478       首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了         第一步：当然是下载去官网上下载最新的solr版本，下载地址
      • Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞androidAPP分析
        点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  针对序列化对象而出现的拒绝服务主要
      • HoverTree项目已经实现分层 hvt 编程.netWebC#ASP.ENT
        HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
      • Google Maps API v3: Remove Markers 移除标记 天梯梦 google maps api
        Simply do the following:   I. Declare a global variable: var markersArray = [];   II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
      • jQuery选择器总结 lq38366 jquery选择器
          1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
      • 基础数据结构和算法六：Quick sort sunwinner AlgorithmQuicksort
        Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
      • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作 刘星宇 htmlWeb
        今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 方法如下：
      • Mybatis实用Mapper SQL汇总示例 wdmcygah sqlmysqlmybatis实用
        Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，