Ben Chou bunnyadad

## merge-k-sorted-lists.cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:

## generate-parentheses.cpp
class Solution
{
public:
    vector<string> generateParenthesis(int n)
    {
        vector<string> rst;
        string str;
        gpdfs(n, n, str, rst);
        return rst;
    }

## merge-two-sorted-lists.cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{

## valid-parentheses.cpp
#include <string>
#include <vector>
using namespace std;

class Solution {
public:
    bool isValid(string s)
    {
        vector<char> queue;
        for (auto c : s)

## remove-nth-node-from-end-of-list.cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:

## 4sum.cpp
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int> nums, int target)
    {

## letter-combinations-of-a-phone-number.cpp

class Solution
{
public:
    vector<string> letterCombinations(string digits)
    {
        if (digits.empty()) return{};

        static vector<string>dict = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };
        vector<string> output;

## 3sum-closest.cpp
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    int threeSumClosest(vector<int> nums, int target)
    {

## 3sum.cpp
#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    vector<vector<int>> threeSum(vector<int> nums)
    {
        if (nums.size() < 3) return{};

## longest-common-prefix.cpp
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

class Solution {
public:
	/**
	* Definition for singly-linked list.
	* struct ListNode {
	* int val;
	* ListNode *next;
	* ListNode(int x) : val(x), next(NULL) {}
	* };
	*/
	class Solution {
	public:
	class Solution
	{
	public:
	vector<string> generateParenthesis(int n)
	{
	vector<string> rst;
	string str;
	gpdfs(n, n, str, rst);
	return rst;
	}
	#include <string>
	#include <vector>
	using namespace std;

	class Solution {
	public:
	bool isValid(string s)
	{
	vector<char> queue;
	for (auto c : s)
	#include <string>
	#include <vector>
	#include <algorithm>

	using namespace std;

	class Solution {
	public:
	vector<vector<int>> fourSum(vector<int> nums, int target)
	{

	class Solution
	{
	public:
	vector<string> letterCombinations(string digits)
	{
	if (digits.empty()) return{};

	static vector<string>dict = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };
	vector<string> output;
	#include <iostream>
	#include <vector>
	#include <algorithm>

	using namespace std;

	class Solution {
	public:
	int threeSumClosest(vector<int> nums, int target)
	{