最大不相交间隔

给定一组N 个区间，任务是找到相互不相交的区间的最大集合。如果两个区间[i, j]和[k, l]没有任何公共点，则称它们不相交。

例子：

Input: intervals[][] = {{1, 4}, {2, 3}, {4, 6}, {8, 9}} 
Output: 
[2, 3] 
[4, 6] 
[8, 9] 
Intervals sorted w.r.t. end points = {{2, 3}, {1, 4}, {4, 6}, {8, 9}} 
Intervals [2, 3] and [1, 4] overlap. 
We must include [2, 3] because if [1, 4] is included then 
we cannot include [4, 6].
Input: intervals[][] = {{1, 9}, {2, 3}, {5, 7}} 
Output: 
[2, 3] 
[5, 7]  

方法：

1. 根据它们的端点对间隔进行排序。
2. 现在，遍历所有的区间，如果我们得到两个重叠的区间，那么贪婪地选择具有较低端点的区间，因为选择它将确保可以进一步容纳区间而没有任何重叠。
3. 对所有区间应用相同的程序并打印所有满足上述条件的区间。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
#define ll long long int
 
// Function to sort the vector elements
// by second element of pairs
bool sortbysec(const pair& a,
               const pair& b)
{
    return (a.second < b.second);
}
 
// Function to find maximal disjoint set
void maxDisjointIntervals(vector > list)
{
 
    // Sort the list of intervals
    sort(list.begin(), list.end(), sortbysec);
 
    // First Interval will always be
    // included in set
    cout << "[" << list[0].first << ", "
         << list[0].second << "]" << endl;
 
    // End point of first interval
    int r1 = list[0].second;
 
    for (int i = 1; i < list.size(); i++) {
        int l1 = list[i].first;
        int r2 = list[i].second;
 
        // Check if given interval overlap with
        // previously included interval, if not
        // then include this interval and update
        // the end point of last added interval
        if (l1 > r1) {
            cout << "[" << l1 << ", "
                 << r2 << "]" << endl;
            r1 = r2;
        }
    }
}
 
// Driver code
int main()
{
    int N = 4;
    vector > intervals = { { 1, 4 },
                                          { 2, 3 },
                                          { 4, 6 },
                                          { 8, 9 } };
    maxDisjointIntervals(intervals);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
class GFG
{
    static class Pair implements Comparable
    {
        int first, second;
          
        Pair(int f, int s)
        {
            first = f;
            second = s;
        }
  
        @Override
       
     // Function to sort the vector elements
     // by second element of Pairs
        public int compareTo(Pair o)
        {
            if(this.second > o.second)
                return 1;
            else if(this.second == o.second)
                return 0;
            return -1;
        }
    }
 
// Function to find maximal disjoint set
static void maxDisjointIntervals(Pair []list)
{
 
    // Sort the list of intervals
    Collections.sort(Arrays.asList(list));
 
    // First Interval will always be
    // included in set
    System.out.print("[" +  list[0].first+ ", "
         + list[0].second+ "]" +"\n");
 
    // End point of first interval
    int r1 = list[0].second;
 
    for (int i = 1; i < list.length; i++) {
        int l1 = list[i].first;
        int r2 = list[i].second;
 
        // Check if given interval overlap with
        // previously included interval, if not
        // then include this interval and update
        // the end point of last added interval
        if (l1 > r1) {
            System.out.print("[" +  l1+ ", "
                 + r2+ "]" +"\n");
            r1 = r2;
        }
    }
}
 
// Driver code
public static void main(String[] args)
{
    int N = 4;
    Pair []intervals = { new Pair(1, 4 ),
            new Pair( 2, 3 ),
            new Pair( 4, 6 ),
            new Pair( 8, 9 ) };
    maxDisjointIntervals(intervals);
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 implementation of the approach
 
# Function to find maximal disjoint set
def maxDisjointIntervals(list_):
     
    # Lambda function to sort the list 
    # elements by second element of pairs
    list_.sort(key = lambda x: x[1])
     
    # First interval will always be
    # included in set
    print("[", list_[0][0], ", ", list_[0][1], "]")
     
    # End point of first interval
    r1 = list_[0][1]
     
    for i in range(1, len(list_)):
        l1 = list_[i][0]
        r2 = list_[i][1]
         
        # Check if given interval overlap with
        # previously included interval, if not
        # then include this interval and update
        # the end point of last added interval
        if l1 > r1:
            print("[", l1, ", ", r2, "]")
            r1 = r2
             
 
# Driver code
if __name__ == "__main__":
     
    N = 4
    intervals = [ [ 1, 4 ], [ 2, 3 ],
                  [ 4, 6 ], [ 8, 9 ] ]
     
    # Call the function
    maxDisjointIntervals(intervals)
 
# This code is contributed by Tokir Manva

Javascript

 
// Javasript implementation of the approach
 
 
// Function to find maximal disjoint set
function maxDisjointIntervals(list)
{
 
    // Sort the list of intervals
    list.sort((a,b)=> a[1]-b[1]);
 
    // First Interval will always be
    // included in set
    document.write( "[" + list[0][0] + ", "
         + list[0][1] + "]" + "<br>");
 
    // End point of first interval
    var r1 = list[0][1];
 
    for (var i = 1; i < list.length; i++) {
        var l1 = list[i][0];
        var r2 = list[i][1];
 
        // Check if given interval overlap with
        // previously included interval, if not
        // then include this interval and update
        // the end point of last added interval
        if (l1 > r1) {
            document.write( "[" + l1 + ", "
                 + r2 + "]" + "<br>");
            r1 = r2;
        }
    }
}
 
// Driver code
var N = 4;
var intervals = [ [ 1, 4 ],
                                      [ 2, 3 ],
                                      [ 4, 6 ],
                                      [ 8, 9 ] ];
maxDisjointIntervals(intervals);
 

输出：

[2, 3]
[4, 6]
[8, 9]

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。