【Lintcode】300. Meeting Room IV

题目地址：

https://www.lintcode.com/problem/meeting-room-iv/description

给定一系列区间$A$，代表每个会议的开始、结束时间。每个会议有个价值，问参加哪些会议可以得到最大总价值。返回最大总价值。

思路是动态规划。这其实是个$0-1$背包问题，每个会议只有参加和不参加两种选择。我们先将会议按照结束时间排序，接着开一个数组$f$，$f[i]$表示如果在$A[0,...,i]$这些会议中选择，能达到的最大价值。那么$f[i]$有两种可能性，第一种，不参加当前会议，那么最大价值就是$f[i-1]$，第二种，参加当前会议，那么就要在$A[0,...,i-1]$这些会议里找到结束时间早于当前会议开始时间的最后一个会议（“早于”的含义里包括相等），比如其下标是$j$，那么这种情况下最大价值就是$f[j]+A[i]$。由于已经按照结束时间排好序，所以可以用二分。代码如下：

import java.util.ArrayList;
import java.util.List;

public class Solution {
    
    class Pair {
        int start, end, value;
        
        public Pair(int start, int end, int value) {
            this.start = start;
            this.end = end;
            this.value = value;
        }
    }
    
    /**
     * @param meeting: the meetings
     * @param value:   the value
     * @return: calculate the max value
     */
    public int maxValue(int[][] meeting, int[] value) {
        // write your code here
        // 因为如果直接对meeting的end排序的话，value不会跟着一起被排序，
        // 所以最好把时间和价值包装在一个对象里一起操作
        List<Pair> list = new ArrayList<>();
        for (int i = 0; i < meeting.length; i++) {
            list.add(new Pair(meeting[i][0], meeting[i][1], value[i]));
        }
        
        // 对会议的结束时间排序
        list.sort((p1, p2) -> Integer.compare(p1.end, p2.end));
        // dp[i]表示list[i]及其之前的会议的所有参加方案的最大价值
        int[] dp = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            Pair cur = list.get(i);
            if (i == 0) {
                dp[i] = cur.value;
            } else {
            	// 找到最后一个结束的且结束时间小于等于当前会议开始时间的会议的下标
                int idx = binarySearch(list, i - 1, cur.start);
                // 如果没找到，说明当前会议和所有前面的会议都冲突，
                // 所以将当前会议和前面会议的方案取一个最大；
                // 否则找到那个最后结束的与当前会议不冲突的会议下标，
                // 那么现在两种选择，其一是不参加当前会议，则答案是dp[i - 1]，如果参加，答案就是当前会议价值加上dp[idx]
                if (idx == -1) {
                    dp[i] = Math.max(dp[i - 1], cur.value);
                } else {
                    dp[i] = Math.max(dp[i - 1], dp[idx] + cur.value);
                }
            }
        }
        
        return dp[dp.length - 1];
    }
    
    // 求结束时间小于等于target的最后的一个会议
    private int binarySearch(List<Pair> list, int r, int target) {
        int l = 0;
        while (l < r) {
            int m = l + (r - l + 1 >> 1);
            if (list.get(m).end <= target) {
                l = m;
            } else {
                r = m - 1;
            }
        }
        
        return list.get(l).end <= target ? l : -1;
    }
}

时间复杂度$O(n\log n)$，空间$O(n)$。