leetcode题解日练--2016.7.23

日练三题，冰冻三尺非一日之寒。

今日题目：

1、最大整除子集；

2、链表插入排序；

3、链表排序 。

今日摘录：

我愿意深深地扎入生活，吮尽生活的骨髓，过得扎实，简单，把一切不属于生活的内容剔除得干净利落，把生活逼到绝处，用最基本的形式，简单，简单，再简单。
——梭罗《瓦尔登湖》

368. Largest Divisible Subset | Difficulty: Medium

Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies: Si % Sj = 0 or Sj % Si = 0.

If there are multiple solutions, return any subset is fine.

Example 1:

nums: [1,2,3]

Result: [1,2] (of course, [1,3] will also be ok)
Example 2:

nums: [1,2,4,8]

Result: [1,2,4,8]

tag：数学、DP

题意：从一个集合中去寻找满足集合内部每两个元素都存在非1公约数的子集。
思路：
1、本来想从前往后去找，后来发现不太对劲，又从后往前去找，好像又没找到什么规律。后面一怒之下打了两小时乒乓球加桌球，好像开窍了。
还是看一个栗子加深理解吧，也不举太复杂的栗子，就[0,1,2,3,4,5,6,7,8,9,10]其实本来不应该有0，但是为了表示的方便，暂时加进来，不考虑就是了。
从大到小遍历这个数组，dp[i]中代表以元素i作为结尾的最大集合长度。dp[10] = 1,然后逆推往回求dp[9]，从9一直到最后找能被10整除的数字，没这样的不存在，所以dp[9]=1,同理dp[8]=dp[7]=dp[6]=1.到dp[5]的时候，向后找找到了10能整除5，所以dp[5] = 2,同理dp[4]找到8、dp[3]找到6或者9，因为dp[6]=dp[9]=1，所以dp[3]找到他俩中的较大值再加1dp[3]=2，也等于2,dp[2]找到4\6\8\10,其中最大的dp[4]=2，所以dp[2] = 3，dp[1]后面的都能找到它的倍数，其中最大的dp[2]=3,所以dp[1]=4。到此为止，我们已经找到了最大的共存元素个数，这个时候就需要将其还原了，但是好像少了什么，没错，我找到dp[1]最大了，但是dp[1]是包含哪4个元素？好像找不到了，这就需要在找的过程顺便建立一种联系，可以想象成很多个链表。
1->2->4->8
5->10
3->9
所有dp值大于等于2的元素都将作为起始点指向它的父节点，也就是能整除它的父亲。

class Solution {
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<int> T(nums.size(),0);
        vector<int> parent(nums.size(),0);
        int max=0,maxIdx=0;
        for(int i=nums.size()-1;i>=0;--i)
        {
            for(int j=i;j<nums.size();++j)
            {
                if(nums[j]%nums[i]==0 && T[i]<1+T[j])
                {
                    T[i] = 1+T[j];
                    parent[i]=j;
                    if(T[i]>max)  
                    {
                        max = T[i];
                        maxIdx = i;
                    }
                }
            }
        }
        vector<int> res;
        for(int i=0;i<max;i++)
        {
            res.push_back(nums[maxIdx]);
            maxIdx = parent[maxIdx];
        }
        return res;
    }
};

结果：68ms

147. Insertion Sort List | Difficulty: Medium

Sort a linked list using insertion sort.

tag：链表、排序
题意：将一个链表按照插入排序的方法从小到达排列。
思路：
1、以4->2->3->1为例，来看看如何使用插入排序。
首先新建一个结果链表，设立一个左边界，然后去从结果链表中找到一个比待插入元素大的位置，将待插入元素插入。
具体来看，先从4开始访问 ，当访问到4的时候，将它加入结果数组中。结果数组中都是有序的，这个时候
结果链表中有一个左边界和元素4，这个时候再访问3的时候，需要遍历结果链表，给它找到应该放的位置，那怎么找呢？就是逐个访问结果链表，如果找到小于我们找的值，就跳到下一个，直到找到一个比插入值大的元素或者找到最后没找到，这里对应的是4，将插入值插入到左边界和4之间。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode res(INT_MIN);
        while(head)
        {
            ListNode*iter = &res;
            cout<<iter->val<<endl;
            while(iter->next && iter->next->val <head->val) iter = iter->next;
            //首先保存下来head的下一个节点，加入head之后好更改head的值
            ListNode*next = head->next;
            //然后准备插入head节点，对head和iter做一个比较看看是插入到前面还是后
                head->next = iter->next;
                iter->next = head;
                head = next;
        }
        return res.next;
    }
};

结果：168ms
第二次刷代码168ms

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(head==NULL || head->next==NULL)  return head;
        ListNode*res = new ListNode(INT_MIN);
        while(head)
        {
        ListNode*cur = res;
        ListNode*next  = head->next;
        while(cur->next && cur->next->val<head->val) cur = cur->next;
        head->next = cur->next;
        cur->next = head;
        head = next;
        }
        return res->next;
    }
};

结果：80ms

148. Sort List | Difficulty: Medium

Sort a linked list in O(n log n) time using constant space complexity.

tag：链表、排序
题意：nlogn时间，常数空间对链表进行排序。

思路：
1、因为链表直接访问下标不太方便，所以在排序的时候使用快排思想不太容易实现。那么，还要什么思路呢？桶排序不失为一种方法，当时空间复杂度过高，相当于时间复杂换空间复杂，还有哪些常见的排序呢？不难想到归并排序正是我们所想找的。
归并排序主要就是归和并两步骤，归用递归去解决，每次将连表分为前半部分和后半部分。直到平凡情况，即两部分都只有1个元素，这个时候就需要开始并了。
并的思路很简单，逐个比较两部分元素，创建一个新链表，哪边小就将结果加进去，最后肯定会剩下一部分元素，再给接到链表最后，最后返回这整个链表去处理上一层的递归调用。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head==NULL || head->next==NULL)  return head;
        ListNode *h1 = head;
        ListNode*h2 = head->next->next;
        while(h2 && h2->next)
        {
            h1 = h1->next;
            h2 = h2->next->next;
        }
        h2 = h1->next;
        h1->next = NULL;
        return merge(sortList(head),sortList(h2));
    }
    ListNode *merge(ListNode*h1,ListNode*h2)
    {
        ListNode  *newHead = new ListNode(INT_MIN);
        ListNode  *node =newHead ;
        while(h1 && h2)
        {
            if(h1->val<h2->val)
            {
                node->next = h1;
                node = node->next;
                h1 = h1->next;
            }
            else
            {
                node->next = h2;
                node = node->next;
                h2 = h2->next;
            }
        }
        if(h1)  node->next = h1;
        else    node->next= h2;
        return newHead->next;
    }
};

结果：60ms