470-82（200、1049、416、50）

200. 岛屿数量

class Solution
{
public:
	void dfs(vector<vector<char>>& grid, int i, int j)
	{
		int rows = grid.size();
		int cols = grid[0].size();

		if (i < 0 || j < 0 || i >= rows || j >= cols || grid[i][j] == '0')
			return;

		grid[i][j] = '0';
		dfs(grid, i-1, j);
		dfs(grid, i+1, j);
		dfs(grid, i, j-1);
		dfs(grid, i, j+1);

	}
public:
	int numIslands(vector<vector<char>>& grid)
	{
		int rows = grid.size();
		if (rows == 0)	return 0;

		int cols = grid[0].size();

		int res = 0;

		for (int i = 0; i < rows; i++)
		{
			for (int j = 0; j < cols; j++)
			{
				if (grid[i][j] == '1')
				{
					dfs(grid, i, j);
					res++;
				}
			}
		}
		return res;
	}
};

1049. 最后一块石头的重量 II

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for(int i = 0; i < stones.size(); i++)
        {
            sum += stones[i];
        }

        int target = sum/2;

        vector<int> dp(1501, 0);


        for(int i = 0; i < stones.size(); i++)
        {
            for(int j = target; j >= stones[i]; j--)
            {
                dp[j] = std::max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
};

416. 分割等和子集

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        vector<int> dp(10001,0);

        int sum = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
        }

        if(sum % 2 == 1)    return false;
        int target = sum/2;

        for(int i = 0; i < nums.size(); i++)
        {
            for(int j = target; j >= nums[i]; j--)
            {
                dp[j] = std::max(dp[j], dp[j-nums[i]] + nums[i]);
            }
        }
        return dp[target] == target ? true : false;
    }
};

50. Pow(x, n)

class Solution {
public:

    double quick_mul(double x, long long N)
    {
        if (N == 0)
        {
            return 1.0;
        }

        double y = quick_mul(x, N / 2);
        
        if (N % 2 == 0)
        {
            return y * y;
        }
        else
        {
            return y * y * x;
        }
    }

    double myPow(double x, int n) {
        long long N = n;

        if (N >= 0)
        {
            return quick_mul(x, N);
        }
        else
        {
            return 1.0/ quick_mul(x, -N);
        }
    }
};