leetcode 337. 打家劫舍 III

1. 题目大意就是抢父节点就不能抢子节点，求一个小偷最多能抢到多少钱

2. 算法分析：

3. （1）当我们抢了某个节点之后，那么该节点的左右子节点不可以在抢了。但是可以抢该节点左右子节点的左右子节点。（这段代码要判断被抢的节点的左右子节点是否存在）

4. （2）当我们不抢某个节点之后，那么该节点的左右子节点可抢可不抢了

5. 实现代码如下：
   #include
   using namespace std;
   struct treeNode
   {
   int val;
   treeNode *lChild;
   treeNode *rChild;
   treeNode(int val, treeNode *lChild=nullptr, treeNode *rChild=nullptr)
   {
   this->val = val;
   this->lChild = lChild;
   this->rChild = rChild;
   }
   };
   int maxT(int a, int b)
   {
   if (a > b)
   {
   return a;
   }
   return b;
   }
   int robber(treeNode *node)
   {
   if (node == nullptr)
   {
   return 0;
   }

   int noRobberL = node->lChild ? (robber(node->lChild->lChild) + robber(node->lChild->rChild)):0;
   int noRobberR = node->rChild ? (robber(node->rChild->lChild) + robber(node->rChild->rChild)) : 0;
   int robberNode = node->val + noRobberL + noRobberR;
   int noRobberNode = robber(node->lChild) + robber(node->rChild);
   return maxT(robberNode, noRobberNode);
   }
   treeNode *createTree(int intarr[], int length, int i)
   {
   treeNode *node = nullptr;
   if (i < length && intarr[i] != -1 )
   {
   node = new treeNode(intarr[i]);
   node->lChild = createTree(intarr, length, i * 2 + 1);
   node->rChild = createTree(intarr, length, i * 2 + 2);
   }

   return node;
   }
   int main()
   {
   int intarr[7] = { 3,4,5,1,3,-1,1 };
   treeNode *root = createTree(intarr, 7, 0);
   cout << robber(root) << endl;
   system(“pause”);
   return 0;
   }
   另一种方法，我们可以一下把这个抢劫这个节点和不抢劫这个节点一起算出来。同一副返回上一层在做比较。
   （1）当我们抢了某个节点之后，那么该节点的左右子节点不可以在抢了。但是可以抢该节点左右子节点的左右子节点。（这段代码要判断被抢的节点的左右子节点是否存在）

6. （2）当我们不抢某个节点之后，那么该节点的左右子节点可抢可不抢了

7. 实现代码如下：
   算法分析（1）算法简析：
   rob（node）
   {
   left=rob(node->left)
   right=rob(node->right)
   nonrober=left[1]+right[1]//不抢该节点，可以抢孩子节点
   robber=max（node-val+left[0]+right[0],nonrober）//当我们进入某个节点之后，可以计算出不抢该节点和抢了给节点，哪个值最大。
   return [norobber,robber]
   }
   代码如下：
   #include
   #include
   using namespace std;
   struct treeNode
   {
   int val;
   treeNode *lChild;
   treeNode *rChild;
   treeNode(int val, treeNode *lChild=nullptr, treeNode *rChild=nullptr)
   {
   this->val = val;
   this->lChild = lChild;
   this->rChild = rChild;
   }
   };
   int maxT(int a, int b)
   {
   if (a > b)
   {
   return a;
   }
   return b;
   }
   treeNode *createTree(int intarr[], int length, int i)
   {
   treeNode *node = nullptr;
   if (i < length && intarr[i] != -1 )
   {
   node = new treeNode(intarr[i]);
   node->lChild = createTree(intarr, length, i * 2 + 1);
   node->rChild = createTree(intarr, length, i * 2 + 2);
   }

   return node;
   }
   typedef std::array<int,4> twoArray;
   twoArray robberHouse(treeNode *node)
   {
   if (!node)
   {
   return{ 0,0 };
   }
   twoArray left = robberHouse(node->lChild);
   twoArray right = robberHouse(node->rChild);

   int nonrobber = left[1] + right[1];
   int robber = maxT(node->val + left[0] + right[0],nonrobber);
   return{ nonrobber,robber };
   }
   int robberHouserSolution(treeNode *node)
   {
   auto num = robberHouse(node);
   return maxT(num[0], num[1]);
   }
   int main()
   {
   int intarr[7] = { 3,2,3,-1,3,-1,1 };
   treeNode *root = createTree(intarr, 7, 0);
   cout << robberHouserSolution(root) << endl;
   system(“pause”);
   return 0;
   }