468-82（142、199、509、70、746）

142. 环形链表 II

class Solution {
public:
	ListNode* detectCycle(ListNode* head)
	{
		ListNode* fast = head;
		ListNode* slow = head;

		while (fast != nullptr && fast->next != nullptr)
		{
			fast = fast->next->next;
			slow = slow->next;

			if (slow == fast)
			{
				ListNode* index1 = fast;
				ListNode* index2 = head;

				while (index1 != index2)
				{
					index1 = index1->next;
					index2 = index2->next;
				}
				return index1;
			}
		}
		return nullptr;
	}
};

199. 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);

        vector<int> res;

        while (!que.empty())
        {
            int size = que.size();

            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                
                if (i == size - 1)
                {
                    res.push_back(node->val);
                }

                if (node->left)  que.push(node->left);
                if (node->right)  que.push(node->right);
            }
        }
        return res;
    }
};

509. 斐波那契数

class Solution
{
public:
	int fib(int n)
	{
		//1、dp[i]的定义为：第i个数的斐波那契数值是dp[i]
		//2、确定递推公式 dp[i] = dp[i-1] + dp[i-2]

		if (n <= 1) return n;

		vector<int> dp(n + 1);

		dp[0] = 0;
		dp[1] = 1;

		for (int i = 2; i <= n; i++)
		{
			dp[i] = dp[i - 1] + dp[i - 2];
		}
		
		//for (int& j : dp)
		//{
		//	cout << j << " ";
		//}
		//cout << endl;

		return dp[n];
	}
};

70. 爬楼梯

class Solution
{
public:
	int climbStairs(int n)
	{
		if (n <= 1)  return n;
		vector<int> dp(n + 1);

		dp[1] = 1;
		dp[2] = 2;

		for (int i = 3; i <= n; i++)
		{
			dp[i] = dp[i - 1] + dp[i - 2];
		}

		return dp[n];
	}
};

746. 使用最小花费爬楼梯

class Solution
{
public:
	int minCostClimbingStairs(vector<int>& cost)
	{
		//dp[i]的定义：到达第i个台阶所花费的最少体力为dp[i]。
		vector<int> dp(cost.size());

		dp[0] = cost[0];
		dp[1] = cost[1];

		int size = cost.size();
		for (int i = 2; i < size; i++)
		{
			dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
		}

		return std::min(dp[size - 1], dp[size - 2]);
	}
};