码迷,mamicode.com
首页 > 其他好文 > 详细

leetcode -day9 Candy & Gas Station & Binary Tree Maximum Path Sum

时间:2014-05-06 22:41:02      阅读:427      评论:0      收藏:0      [点我收藏+]

标签:leetcode   算法   

1、


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;
    }
};


leetcode -day9 Candy & Gas Station & Binary Tree Maximum Path Sum,布布扣,bubuko.com

leetcode -day9 Candy & Gas Station & Binary Tree Maximum Path Sum

标签:leetcode   算法   

原文地址:http://blog.csdn.net/kuaile123/article/details/25097803

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!