Candy

There are N children standing in a line. Each child is assigned a rating value.

You are giving candies to these children subjected to the following requirements:

• Each child must have at least one candy.
• Children with a higher rating get more candies than their neighbors.

What is the minimum candies you must give?

分析：乍看这一题，真是无从下手，评分高的小孩比左右邻居高，那可以分为比左邻居高，比右邻居高，那可以分成两边遍历，用一个数组保存小孩分得的糖果数，第一遍从左到右，如果右边小孩比左边高则是左边小孩的糖果数加1，否则则为1，第二遍从右到左，如果左边小孩比右边小孩高并且保存的糖果数左边比右边低，则更新左边小孩的糖果数为右边小孩的糖果数加1，最后总和为所有的糖果数。这样用空间O(n)，来换得了时间复杂度O(n)。

代码如下：

class Solution {
public:
   int candy(vector<int> &ratings) {

		if(ratings.empty()){
			return 0;
		}

		int *candyNum = new int[ratings.size()];
		candyNum[0] = 1;
		for(int i=1; i<ratings.size();++i){
			if(ratings[i]>ratings[i-1]){
				candyNum[i] = candyNum[i-1]+1;
			}else{
				candyNum[i] = 1;
			}
		}
		int Total = candyNum[ratings.size()-1];
		for(int i=ratings.size()-2; i>=0; --i){
			if(ratings[i]>ratings[i+1] && candyNum[i]<=candyNum[i+1]){
				candyNum[i] = candyNum[i+1]+1;
			}
			Total += candyNum[i];
		}
		delete[] candyNum;
		return Total;
	}
};

改进，考虑到本题目只关心总数，不需要知道每个小孩所分得的糖果数，可以减少空间复杂度。请参考http://www.cnblogs.com/felixfang/p/3620086.html

2、Gas Station

There are N gas stations along a circular route, where the amount of gas at station i is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.

Return the starting gas station‘s index if you can travel around the circuit once, otherwise return -1.

Note:
The solution is guaranteed to be unique.

分析：首先想到的方法是从汽油站0开始遍历，依次判断是否是满足条件的起点（即每过一个站汽油是否够），但是此种方法时间复杂度为O(n^2)，显然太没有意思。想其他的方法，如何降低时间复杂度，当经过一个站汽油不够时，不是改变起点从头遍历，而是采取一种方法避免此种遍历，当汽油不够时，此时要想到此战的汽油够，就得将起点前移，再判断汽油够不够，这样减少了计算步骤。动态规划的判断还是挺有意思的。同时注意如何使之成为一个环形公路，即当起始点退到头时，再从尾开始。

代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        if(gas.empty()||cost.empty()||gas.size()!=cost.size()){
            return -1;
        }
        int stationAllNum = gas.size(); //总站数
        int gasInCar = 0; //车里剩余数量
        int startIndex = 0; //开始站索引
        int endIndex = 0; //结束站索引
        int goStationNum = 0;
        int index = 0;
        while(goStationNum < stationAllNum){
            gasInCar += gas[index] - cost[index];
            if(gasInCar >= 0){
                ++endIndex;
                index = endIndex;
            }else{
                --startIndex;
                if(startIndex < 0){
                    startIndex = stationAllNum - 1;
                }
                index = startIndex;
            }
            ++ goStationNum;
        }
        if(gasInCar >= 0){
            return startIndex;
        }else{
            return -1;
        }
    }
};

3、Binary Tree Maximum Path Sum

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

       1
      /      2   3

Return 6.

分析：看到二叉树，想到的方法肯定是递归，但是这个递归，感觉不太好想，纠结半天才弄出来。

递归的思路，求出左子树和右子树的最大路径和，如果左右子树的路径小于0，则最大和为当前根结点的值，如果大于0，则为左右子树中最大路径+当前根结点的值.

注意的点：（1）每次递归的值是从子节点到当前节点的路径的最大值，必须要包括当前节点。（2）递归当左右子树中最大路径的值都大于0时，此时返回值不是两者的和+根结点的值，而是其中大者的值+根结点的值，这点需要理解。（3）考虑到2，则需要设置一个全局变量，来更新最大路径值，尤其是左右子树的最大路径都大于0时，需要检测两者和加根结点的值是否大于全局变量。

代码如下：

class Solution {
public:
    int maxPathSumInt;
    int maxPathSum(TreeNode *root) {
        maxPathSumInt = INT_MIN;
        maxPathSumCore(root);
        return maxPathSumInt;
    }
    int maxPathSumCore(TreeNode *root){
         if(root->left==NULL && root->right==NULL){
            if(root->val > maxPathSumInt){
                maxPathSumInt = root->val;
            }
            return root->val;
        }
        int lSum = INT_MIN;
        int rSum = INT_MIN;
        if(root->left!=NULL){
            lSum = maxPathSumCore(root->left);
        }
        if(root->right!=NULL){
            rSum = maxPathSumCore(root->right);
        }
        int sum = INT_MIN;
        if(lSum<=0 && rSum<=0){
            sum = root->val;
        }else if( lSum<=0 ){
            sum = root->val+rSum;//root->val>0?
        }else if( rSum<=0 ){
            sum = root->val+lSum;
        }else{
            sum = max(lSum,rSum)+root->val;
            if(lSum+rSum+root->val > maxPathSumInt){
                maxPathSumInt = lSum+rSum+root->val;
            }
        }
        if(sum > maxPathSumInt){
            maxPathSumInt = sum;
        }
        return sum;
    }
};