yxsh01的专栏

class Solution { public: bool wordBreak(string s, unordered_set &dict) { int n = s.length(); if(n == 0) return true; bool * canBreak = new bool[n]; mems

#include using namespace std; struct TreeNode { int val; TreeNode * left; TreeNode * right; TreeNode(int v):val(v),left(NULL),right(NULL){} }; void InorderTraversal(TreeNode * root) { if(ro

class Solution { public: vector searchRange(int A[], int n, int target) { vector result; result.push_back(leftBound(A,n,target)); result.push_back(rightBound(A,n,target));

class Solution { public: int searchInsert(int A[], int n, int target) { int ans = n; int begin = 0, end = n-1; while(begin <= end) { int mid = begin + (

class Solution { public: int search(int A[], int n, int target) { int begin = 0, end = n-1; int ans = -1; while(begin <= end) { int mid = begin + (end -

class Solution { public: bool isValidSudoku(vector > &board) { int n = board.size(); if(n != 9) return false; int m = board[0].size(); if(m != 9)

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring. For "(()", the longest valid parentheses substring is "()",

class Solution { public: int firstMissingPositive(int A[], int n) { for(int i =0 ;i < n;i++) { if(A[i] 0) { int temp = A[i];

class Solution { public: int trap(int A[], int n) { if(n <= 0) return 0; int * water = new int[n]; int current =0; for(int i=0 ;i<n;i++) {

Follow up for "Find Minimum in Rotated Sorted Array": What if duplicates are allowed? Would this affect the run-time complexity? How and why? Suppose a sorted array is rotated at some pivot unk

Suppose a sorted array is rotated at some pivot unknown to you beforehand. (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2). Find the minimum element. You may assume no duplicate exists in

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *de

class Solution { public: int candy(vector &ratings) { int n = ratings.size(); int c = 1; int * num = new int[n]; num[0] = 1; for(int i = 1; i < n; i++)

/** * Definition for singly-linked list with a random pointer. * struct RandomListNode { * int label; * RandomListNode *next, *random; * RandomListNode(int x) : label(x), next(NULL),

class MinStack { public:     stack ele;     stack minStack;     void push(int x) {         int minVal = x;         if(minStack.empty() == false)             minVal = min(x, minStack.top());  

#include using namespace std; struct Node { int val; Node * left; Node * right; Node(int v):val(v),left(NULL),right(NULL){} }; Node * lca(Node * a, Node * b, Node * root, int & appNum ) { i

/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Soluti

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void reorder

#include #include #include #include using namespace std; struct Node { int val; vector chlidren; Node(int v):val(v){} }; class UnSet { public: UnSet(int n):capacity(n) { father = new int

/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Soluti

class Solution { public: int singleNumber(int A[], int n) { int sign = 0; long long ret = 0; for(int i = 0; i < n ;i++) { long long c = A[i];

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T. Each number in C may only be used once in the combina