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;
}
