貪心算法----區間選點問題(POJ1201)

題目：

　　

　　題目的大致意思是，給定n個閉區間，並且這個閉區間上的點都是整數，現在要求你使用最少的點來覆蓋這些區間並且每個區間的覆蓋的點的數量滿足輸入的要求點覆蓋區間的數量。

　　輸入：

　　　　第一行輸入n，代表n個區間。

　　　　接下來的n行每行的第一個數代表區間起點，第二個數代表區間終點，第三個數代表這個區間必須要選取的點的數量。

　　輸出：

　　　　輸出最少的點的數量，這些最少的點要覆蓋全部區間。

　　這個題是區間選點問題的一種變體，但是我們對於區間選點問題清楚之后那么這種題目也是一樣解決的，只不過需要在某些地方特別處理一下。這道題目跟區間調度的問題非常類似，我們也可以采用區間調度問題的策略運用到這道題目上面，盡量往結束時間的端點來選點因為這樣做我們可以使盡量少的點覆蓋更多的區間，之后就是選點的問題了，當我們選擇了這個點之后需要標記一下，定義一個數軸來記錄其中標記過的點，以防下一次在選點的時候重復選擇。而且在for循環中依次掃描這些給定的區間，看這個區間需要覆蓋的點的數量是多少（有可能這個區間的標記的點出現在另外的區間上那么這個時候我們就選擇跳過這個點）

　　代碼：

import java.util.Arrays;
import java.util.Scanner;

public class 區間選點問題1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Interval[] intervals = new Interval[n];
        for (int i = 0; i < n; i++) {
            intervals[i] = new Interval(sc.nextInt(), sc.nextInt(), sc.nextInt());
        }
        Arrays.sort(intervals);// 按區間右端點排序

        int max = intervals[n - 1].t;// 右端最大值
        int[] axis = new int[max + 1];// 標記數軸上的點是否已經被選中
        // int[] sums = new int[max + 1];
        for (int i = 0; i < n; i++) {
            // 1.查閱區間中有多少個點
            int s = intervals[i].s;// 起點
            int t = intervals[i].t;// 終點
            int cnt = sum(axis, s, t);// 找到這個區間已經選點的數量，
                                        //sums[t] - sums[s - 1]; 效率低
            // 2.如果不夠，從區間右端開始標記，遇標記過的就跳過
            intervals[i].c -= cnt;// 需要新增的點的數量
            while (intervals[i].c > 0) {
                if (axis[t] == 0) {// 從區間終點開始選點
                    axis[t] = 1;
                    // updateSums(t,sums);//更新前綴和
                    intervals[i].c--;// 進一步減少需要新增的點的數量
                    t--;
                } else {// 這個點已經被選過了
                    t--;
                }
            }

        }
        System.out.println(sum(axis, 0, max));
    }

    /**
     * 統計數軸axis上s-t區間已經有多少個點被選中
     * 
     * @param axis
     * @param s
     * @param t
     * @return
     */
    private static int sum(int[] axis, int s, int t) {
        int sum = 0;
        for (int i = s; i <= t; i++) {
            sum += axis[i];
        }
        return sum;
    }

    private static void updateSums(int t, int[] sums) {
        for (int i = t; i < sums.length; i++) {
            sums[i]++;
        }
    }

    private static class Interval implements Comparable<Interval> {
        int s;
        int t;
        int c;

        public Interval(int s, int t, int c) {
            this.s = s;
            this.t = t;
            this.c = c;
        }

        @Override
        public int compareTo(Interval other) {
            int x = this.t - other.t;
            if (x == 0)
                return this.s - other.s;
            else
                return x;
        }
    }
}

　　結果：

　　　　

　　但是上面這個代碼提交到OJ上面會發生超時，代碼邏輯本身沒有什么問題，關鍵是在掃描每個區間的時候消耗的時間比較多導致了超時，但是我們可以使用另外的一種數據結構來解決，那就是樹狀數組，降低掃描區間的時間復雜度。關於樹狀數組現在不太懂，而且也脫離了貪心算法的范疇，現在把代碼記錄下來，留作以后再看。

　　代碼：

import java.util.Arrays;
import java.util.Scanner;

public class 區間選點問題2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Interval[] intervals = new Interval[n];
        for (int i = 0; i < n; i++) {
            intervals[i] = new Interval(sc.nextInt(), sc.nextInt(), sc.nextInt());
        }
        Arrays.sort(intervals);// 按區間右端點排序

        int max = intervals[n - 1].t;// 右端最大值
        int[] axis = new int[max + 1];
        int[] c = new int[max + 2];
        // int[] sums = new int[max + 1];
        for (int i = 0; i < n; i++) {
            // 1.查閱區間中有多少個點
            int s = intervals[i].s;// 起點
            int t = intervals[i].t;// 終點
            int cnt = sum(t + 1, c, max + 1) - sum(s, c, max + 1);// sum(axis,s,t);//sums[t]
                                                                    // - sums[s
                                                                    // -
                                                                    // 1];//效率低
            // 2.如果不夠，從區間右端開始標記，遇標記過的就跳過
            intervals[i].c -= cnt;
            while (intervals[i].c > 0) {
                if (axis[t] == 0) {
                    axis[t] = 1;
                    update(t + 1, 1, c, max + 1);
                    intervals[i].c--;
                    t--;
                } else {
                    t--;
                }
            }

        }
        System.out.println(sum(max + 2, c, max + 1));
    }

    /**
     * 更新樹狀數組c，注意i是項數，不是下標，而是下標+1
     */
    private static void update(int i, int delta, int[] c, int n) {
        for (; i <= n; i += lowbit(i)) {
            c[i] += delta;
        }
    }

    /**
     * 前i項和，注意：i不是下標
     * 
     * @param i
     * @return
     */
    private static int sum(int i, int[] c, int n) {
        int sum = 0;
        if (i > n)
            i = n;
        for (; i > 0; i -= lowbit(i)) {
            sum += c[i];
        }
        return sum;
    }

    /**
     * 它通過公式來得出k，其中k就是該值從末尾開始1的位置。 然后將其得出的結果加上x自身就可以得出當前節點的父親節點的位置
     * 或者是x減去其結果就可以得出上一個父親節點的位置。
     * 比如當前是6，二進制就是0110，k為2，那么6+2=8，C(8)則是C(6)的父親節點的位置；
     * 相反，6-2=4，則是C(6)的上一個父親節點的位置。
     */
    static int lowbit(int x) {
        return x - (x & (x - 1));
    }

    private static class Interval implements Comparable<Interval> {
        int s;
        int t;
        int c;

        public Interval(int s, int t, int c) {
            this.s = s;
            this.t = t;
            this.c = c;
        }

        @Override
        public int compareTo(Interval other) {
            int x = this.t - other.t;
            if (x == 0)
                return this.s - other.s;
            else
                return x;
        }
    }
}