vector<vector<int> > pathSum(TreeNode *root, int sum) { // Start typing your C/C++ solution below // DO NOT write int main() function vector<vector<int> > result; vector<vector<int> > leftResult; vector<vector<int> > rightResult; if (root==NULL) return result; if (root->left==NULL && root->right==NULL) { if (root->val==sum) { vector<int> onePath; onePath.push_back(root->val); result.push_back(onePath); return result; } else return result; } leftResult = pathSum(root->left, sum-root->val); rightResult = pathSum(root->right, sum-root->val); for (int i=0;i<leftResult.size();i++) { leftResult[i].insert(leftResult[i].begin(),root->val); result.push_back(leftResult[i]); } for (int i=0;i<rightResult.size();i++) { rightResult[i].insert(rightResult[i].begin(),root->val); result.push_back(rightResult[i]); } return result; }
int pathSum(TreeNode* root){ if(!root) return 0; int left = max(0,pathSum(root->left)); int right = max(0,pathSum(root->right)); sum = max(sum,left+right+root->val); return max(left,right)+root->val; }
int pathSum(TreeNode* root, int sum) { if(root == NULL) return 0; int res=rootPathSum(root, sum); if(root -> left) res += pathSum(root->left, sum); if(root -> right) res += pathSum(root->right, sum); return res; }
int pathSum(TreeNode* root, int sum) { if (root == NULL) return 0; int count = 0; count += trace(root, sum); count += pathSum(root->left, sum); count += pathSum(root->right, sum); return count; }
int pathSum(TreeNode* root, int& maxSum) { if(!root) return 0; int leftMax = pathSum(root->left, maxSum); int rightMax = pathSum(root->right, maxSum); int top = root->val + (leftMax > 0 ? leftMax : 0) + (rightMax > 0 ? rightMax : 0); maxSum = max(maxSum, top); return max(leftMax, rightMax) > 0 ? max(leftMax, rightMax) + root->val : root->val; }
void pathSum(TreeNode* root, int sum, vector<vector<int>> &vec, vector<int> v, int total) { if(!root) return ; v.push_back(root->val); if(!root->left && !root->right && sum == total + root->val) vec.push_back(v); pathSum(root->left, sum, vec, v, total + root->val); pathSum(root->right, sum, vec, v, total + root->val); }
int pathSum(TreeNode* root, int sum) { if (root == nullptr) return 0; int rootval = pathSumRec(root, sum); int lefttree = pathSum(root->left, sum); int righttree = pathSum(root->right, sum); return (rootval + lefttree + righttree); }
int pathSum (TreeNode *node) { if (!node) return 0; int leftPath = pathSum(node -> left); int rightPath = pathSum(node -> right); //leftPath = leftPath; //rightPath = rightPath; sum = max(sum, leftPath + rightPath + node ->val); return max(leftPath, rightPath)+ node -> val; }
vector<vector<int> > pathSum(TreeNode *root, int sum) { // Note: The Solution object is instantiated only once and is reused by each test case. vector<vector<int> > result; if(root == NULL) { return result; } int i; vector<vector<int> > temp; vector<int> l; if(root->left != NULL || root->right != NULL) { if(root->left != NULL) { temp = pathSum(root->left,sum-root->val); if(temp.size()!=0) { for(i = 0; i<temp.size();i++) { l = temp[i]; l.insert(l.begin(),root->val); result.push_back(l); } } } if(root->right != NULL) { temp = pathSum(root->right,sum-root->val); if(temp.size()!=0) { for(i = 0; i<temp.size();i++) { l = temp[i]; l.insert(l.begin(),root->val); result.push_back(l); } } } } else { l.clear(); if(root->val == sum) { l.push_back(root->val); result.push_back(l); } else { } } return result; }
void pathSum(TreeNode *root, vector<int> &cur, int gap, vector<vector<int> > &result) { if (root == NULL) return; cur.push_back(root->val); if (root->left == NULL && root->right == NULL && gap == root->val) result.push_back(cur); pathSum(root->left, cur, gap - root->val, result); pathSum(root->right, cur, gap - root->val, result); cur.pop_back(); }
void process(TreeNode* root, int sum){ if(root == NULL) return; vi.push_back(root->val); if(root->val == sum && root->left == NULL && root->right == NULL){ vvi.push_back(vi); vi.pop_back(); return; } if(root->left != NULL) pathSum(root->left,sum-(root->val)); if(root->right != NULL) pathSum(root->right,sum-(root->val)); vi.pop_back(); }
void pathSum(TreeNode *root, int sum, vector<int> &prefix) { if (root == NULL) return; prefix.push_back(root->val); if (root->left == NULL && root->right == NULL) { // leaf node if (sum == root->val) { result.push_back(prefix); } } else { pathSum(root->left, sum - root->val, prefix); pathSum(root->right, sum - root->val, prefix); } prefix.pop_back(); }
void pathSum(TreeNode *root, int gap, vector<int> &cur, vector<vector<int>> &result){ if(root == nullptr) return; cur.push_back(root->val); if(root->left == nullptr && root->right==nullptr){ if(gap == root->val) result.push_back(cur); } pathSum(root->left, gap-root->val, cur, result); pathSum(root->right, gap-root->val, cur, result); cur.pop_back(); }
vector<vector<int> > pathSum(TreeNode *root, int sum) { vector<vector<int> > res; vector<int> cur; pathSum(root, cur, sum, res); return res; }
vector<vector<int> > pathSum(TreeNode *root, int sum) { vector<vector<int> > ans; if(root == NULL) return ans; if(root->val == sum && root->left == NULL && root->right == NULL) { vector<int> temp; temp.push_back(root->val); ans.push_back(temp); return ans; } vector<vector<int> > leftPath = pathSum(root->left, sum - root->val), rightPath = pathSum(root->right, sum - root->val); for(int i = 0; i < leftPath.size(); ++ i) { vector<int> temp; temp.push_back(root->val); for(int j = 0; j < leftPath[i].size(); ++ j) temp.push_back(leftPath[i][j]); ans.push_back(temp); } for(int i = 0; i < rightPath.size(); ++ i) { vector<int> temp; temp.push_back(root->val); for(int j = 0; j < rightPath[i].size(); ++ j) temp.push_back(rightPath[i][j]); ans.push_back(temp); } return ans; }
/** * Using DP to solve it. * The time is O(m*n) and space is O(n). */ int minPathSum(vector<vector<int> > &grid) { int rows = grid.size(); if( rows < 1 ) return -1; int cols = grid[0].size(); vector<int> pathSum(cols, 0); pathSum[0] = grid[0][0]; for( int i = 1; i < cols; i++ ) pathSum[i] = pathSum[i-1] + grid[0][i]; for( int rp = 1; rp < rows; rp++ ){ pathSum[0] += grid[rp][0]; for( int cp = 1; cp < cols; cp++ ){ if( pathSum[cp] > pathSum[cp-1] )// left pos to current pos is shorter pathSum[cp] = pathSum[cp-1] + grid[rp][cp]; else // up pos to current pos is shorter pathSum[cp] += grid[rp][cp]; } } return pathSum[cols-1]; }
int maxPathSum(TreeNode *root) { if (root) { maxSum = INT_MIN; pathSum(root); } return maxSum; }
void pathSum(TreeNode *root, int sum, vector<vector<int> >& v, vector<int> path){ if(root != NULL){ if(root->left == NULL && root->right == NULL){ if(sum == root->val){ path.push_back(root->val); v.push_back(path); } } else{ path.push_back(root->val); sum -= root->val; pathSum(root->left, sum, v, path); pathSum(root->right, sum, v, path); } } }
int main(int argc, const char * argv[]) { TreeNode *root1 = TreeCreate(2,1,2); // IntVector2DPrint(pathSum(root1, 1)); TreeNode *root2 = TreeCreate(13, 5,4,8,11,INT_MAX,13,4,7,2,INT_MAX,INT_MAX,5,1); TreePrint(root2); IntVector2DPrint(pathSum(root2, 22)); return 0; }
bool pathSum(TreeNode *root, int sum, const int ans) { if(root == NULL) return false; sum += root->val; bool isLeaf = true; if(root->left) { isLeaf = false; if(pathSum(root->left, sum, ans)) return true; } if(root->right) { isLeaf = false; if(pathSum(root->right, sum, ans)) return true; } if(isLeaf && sum == ans) return true; return false; }
void pathSum(vector<vector<int> > &collection, vector<int> &trace, TreeNode *root, int curSum, int target) { if (root == NULL) return; trace.push_back(root->val); curSum += root->val; if (root->left == NULL && root->right == NULL) { if (curSum == target) collection.push_back(trace); } else { pathSum(collection, trace, root->left, curSum, target); pathSum(collection, trace, root->right, curSum, target); } trace.pop_back(); }
int main(){ // string trees[] = {"1","2"}; string trees[] = {"5","4","8","11","#","13","4","7","2","#","#","#","#","#","5","1"}; TreeNode * root = init_complete_binary_tree_from_nodes(trees,0, sizeof(trees)/ sizeof(string)); vector<vector<int> > vecs = pathSum(root, 22); for(int i=0; i <vecs.size(); i ++){ printVector(vecs[i]); } return 0; }
vector<vector<int>> pathSum(TreeNode* root, int sum) { vector<vector<int>> ret; if(root){ if(NULL == root->left && NULL == root->right){ if(root->val == sum) ret.push_back({root->val}); }else{ auto sleft = pathSum(root->left, sum - root->val); auto sright = pathSum(root->right, sum - root->val); for(auto aux : {sleft, sright}){ for(auto s : aux){ vector<int> t(1, root->val); t.insert(t.begin() + 1, s.begin(), s.end()); ret.push_back(t); } } } } return ret; }
int pathSum(TreeNode *root) { if (!root) { return 0; } int left = pathSum(root->left); int right = pathSum(root->right); int sum = root->val; if (left > 0) { sum += left; } if (right > 0) { sum += right; } maxSum = max(maxSum, sum); if (left < 0 && right < 0) { return root->val; } else { return root->val + max(left, right); } }
vector<vector<int> > pathSum(TreeNode *root, int sum) { // Start typing your C/C++ solution below // DO NOT write int main() function vector<vector<int> > collection; vector<int> trace; pathSum(collection, trace, root, 0, sum); return collection; }
int pathSum(TreeNode* root, int& maxSum) { if(!root) return 0; if(!root->left && !root->right) { maxSum = max(maxSum, root->val); return root->val; } int leftMax = INT_MIN, rightMax = INT_MIN; if(root->left) leftMax = pathSum(root->left); if(root->right) rightMax = pathSum(root->right); if(leftMax <= 0 && rightMax <= 0) { maxSum = max(maxSum, root->val); return root->val; } else if(leftMax > 0 && rightMax > 0) { maxSum = max(maxSum, leftMax+rightMax+root->val); return max(leftMax, rightMax) + root->val; } else { maxSum = max(maxSum, max(leftMax, rightMax)+root->val); return max(leftMax, rightMax)+root->val; } }
int main() { int nums[] = {1, -2, 1, -1, 0, 0, 0, 3, 0, 0, -3, -2, 0, 0, 0}; int *ptr_nums = nums; TreeNode* root = treeCreate(&ptr_nums); treeShow(root, 0); int **ans, *columnSizes, returnSize; ans = pathSum(root, -1, &columnSizes, &returnSize); for (int i = 0; i < returnSize; ++i) { for (int j = 0; j < columnSizes[i]; ++j) printf("%d ", ans[i][j]); printf("\n"); } system("pause"); return 0; }
int minPathSum(vector<vector<int>>& grid){ int n = grid.size(), m = grid.front().size(); vector<vector<int>> pathSum(n, vector<int>(m, 0)); pathSum[0][0] = grid[0][0]; for(int i = 1; i < n; i++){ pathSum[i][0] = pathSum[i-1][0] + grid[i][0]; } for(int j = 1; j < m; j++){ pathSum[0][j] = pathSum[0][j-1] + grid[0][j]; } for(int i = 1; i < n; i++){ for(int j = 1; j < m; j++){ pathSum[i][j] = min(pathSum[i-1][j], pathSum[i][j-1]) + grid[i][j]; } } return pathSum[n-1][m-1]; }
bool hasPathSum(TreeNode *root, int sum) { // Note: The Solution object is instantiated only once and is reused by each test case. return pathSum(root, 0, sum); }
int pathSum(TreeNode* root, int sum) { return root ? pathSum(root, sum, 0) + pathSum(root->left, sum) + pathSum(root->right, sum) : 0; }