贪心算法(lc406和lc763)

        今天来分享两个算法，分别是LeetCode406和LeetCode763。

        LeetCode406的解法比较巧妙，将身高从高到低进行排序，后将所处的位置从到高进行排序，之后使用java中List，按照所处位置进行插入。（这是我认为结题比较巧妙的地方，巧用数据结构进行结题）。

        LeetCode406的解题为：

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, new Comparator<int[]>(){
            public int compare(int[] person1, int[] person2) {
                if(person1[0] != person2[0]) {
                    return person1[0] > person2[0] ? -1 : 1;
                } else {
                      return person1[1] > person2[1] ? 1 : (person1[1] == person2[1] ? 0 : -1);
                }
            }
        });

        List<int[]> ans = new ArrayList<>();
        for(int[] person: people) {
            ans.add(person[1], person);
        }
        return ans.toArray(new int[ans.size()][]);
    }
}

　　  LeetCode763的解题我归为了两种方案，第一种方案为，首先对字符串进行遍历，遍历出每个字符出现的第一次位置以及最后一次出现的位置。之后只需要对这26个二维数据进行排序。（但是此方案在耗时的地方不如第二种方案，如果字符串的长度非常大的话，还是建议使用第一种方案。）

    方案一：

class Solution {
    public List<Integer> partitionLabels(String s) {
        int[][] pos = new int[26][2];
        for(int i = 0 ; i < 26; i++) {
            pos[i][0] = Integer.MAX_VALUE;
            pos[i][1] = Integer.MIN_VALUE;
        }
        for(int i = 0; i < s.length(); i++) {
            int x = s.charAt(i) - 'a';
            pos[x][0] = Math.min(i, pos[x][0]);
            pos[x][1] = Math.max(i, pos[x][1]);
        }
        Arrays.sort(pos, new Comparator<int[]>(){
            public int compare(int[] p1, int[] p2) {
                if(p1[0] != p2[0]) {
                    return p1[0] < p2[0] ? -1 : 1;
                } else {
                    return p1[1] < p2[1] ? -1 : (p1[1] == p2[1] ? 0 : 1);
                }
            }
        });
        List<Integer> list = new ArrayList<>();
        int l = pos[0][0];
        int r = pos[0][1];
        for(int i = 1; i < 26; i++) {
            if(pos[i][0] == Integer.MAX_VALUE) break;
            if(pos[i][0] <= r) {
                r = Math.max(pos[i][1], r);
            } else {
                list.add(r -l +1);
                l = pos[i][0];
                r = pos[i][1];
            }
        }
        list.add(r - l + 1);
        return list;
    }
}

　　方案二：

class Solution {
    public List<Integer> partitionLabels(String s) {
        int [] last = new int [26];
        int len = s.length();
        for(int i = 0; i < len; i++) {
            last[s.charAt(i) - 'a'] = i;
        }
        List<Integer> list = new ArrayList<>();
        int l = 0;
        int r = 0;
        for(int i = 0; i < len; i++) {
            r = Math. max(r, last[s.charAt(i) - 'a']);
            if(r == i) {
                list.add(r - l + 1);
                l = r + 1;
            }
        }
        return list;
    }
}