Insertion Sort List & Gas Station & Distinct Subsequences

(1) Insertion Sort List

class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        if(!head || !head->next)
            return head;
        
        ListNode begin(0);
        ListNode *cur,*precur,*is,*preis;
        
        begin.next=head;
        cur=is=head;
        precur=preis=&begin;
        
        while(cur)
        {
            while(is!=cur)
            {
                if(cur->val < is->val)
                    break;
                    
                preis=is;
                is=is->next;
            }
            
            if(is!=cur)
            {
                precur->next=cur->next;
                preis->next=cur;
                cur->next=is;
                
                cur=precur->next;
            }
            else
            {
                precur=cur;
                cur=cur->next;
            }
            
            preis=&begin;
            is=begin.next;
        }
        
        return begin.next;
    }
};

(2) Gas Station

如果所有站的代价和大于0，则所求的路线必定存在。如果总代价〉=0,从序号0开始求代价和，如果代价和小于0，则不是从本站或者本站之前的某一个代价大于0的站开始，必从下一站即之后的站开始，而且这样的站必定存在O(n)。[1]:

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        int cursum=0;
        int total=0;
        int ret=0;
        
        for(int i=0;i<gas.size();i++)
        {
            cursum+=gas[i]-cost[i];
            total+=gas[i]-cost[i];
            if(cursum<0)
            {
                cursum=0;
                ret=i+1;
            }
        }
        
        if(total<0)
            return -1;
        else
            return ret;
    }
};

(3) Distinct Subsequences 

遇到这种两个串的问题，很容易想到DP！！！[2]：假设S已经匹配了j - 1个字符，得到匹配个数为dp[i][j - 1].现在无论S[j]是不是和T[i]匹配，匹配的个数至少是dp[i][j - 1]。除此之外，当S[j]和T[i]相等时，我们可以让S[j]和T[i]匹配，然后让S[j - 1]和T[i - 1]去匹配。

class Solution {
public:
    int numDistinct(string S, string T) {
        int dp[T.size()+1][S.size()+1];
        
        for(int i=0;i<=T.size();i++)
            dp[i][0]=0;
        for(int j=0;j<=S.size();j++)
            dp[0][j]=1;
            
        for(int i=1;i<=T.size();i++)
            for(int j=1;j<=S.size();j++)
        {
            dp[i][j]=dp[i][j-1]+(T[i-1]==S[j-1]?dp[i-1][j-1]:0);
        }
        return dp[T.size()][S.size()];
    }
};

参考：

[1] http://blog.csdn.net/kenden23/article/details/14106137
[2] http://blog.csdn.net/abcbc/article/details/8978146