请推荐带SPF的日霜 - 未名空间MITBBS历史存档

国际科技财经博客移民网络热点娱乐民生时事公众号

Redian新闻

>未名空间

>Fashion - 美丽时尚

请推荐带SPF的日霜

请推荐带SPF的日霜# Fashion - 美丽时尚

a*e2011-01-17 08:01

1 楼

Symmetric Tree一开始又把题理解错了。后来弄了个recursion之后，写了如下这个冗
长的 iterative version. 后来看了别人写的发现用一个stack要简洁好多好多。估计
是same tree那道题偷了懒，没认真看iterative的做法。
请问怎么样才能想到比较简洁的答案呢？是不是还是得多练？
从2月中就断断续续的刷，151道做了77道，希望年底能搞完一遍。N年前的今天来到美
国，雄心壮志要当教授，开公司，现在备受打击后，只是很实际的希望找个喜欢的工作
，能够在不爽的时候快点离开！
bool isSymmetric(TreeNode *root) {
if (root==NULL||(root->left==NULL &&root->right==NULL)) return true;

if ((root->left==NULL && root->right!=NULL)||(root->left!=NULL&&root
->right==NULL))
{
return false;
}

queue left, right;
queue leftN, rightN;
left.push(root->left);
right.push(root->right);

while(1)
{
while(!left.empty()&&!right.empty())
{
TreeNode *tmpLeft = left.front();

TreeNode *tmpRight = right.front();

if (tmpLeft==tmpRight && tmpLeft==NULL)
{
left.pop();
right.pop();
continue;
}
if (tmpLeft==NULL||tmpRight==NULL)
{
return false;
}

if (tmpLeft->val!=tmpRight->val)
return false;
else
{
leftN.push(tmpLeft->left);
leftN.push(tmpLeft->right);

rightN.push(tmpRight->right);
rightN.push(tmpRight->left);
left.pop();
right.pop();
}
}
if (leftN.empty() &&rightN.empty())
break;

swap(left,leftN);
swap(right,rightN);
}

return true;
}

w*92011-01-17 08:01

2 楼

如题，最近找工作还没找到，最好价钱实惠一些，像Sisley那些我有点承受不起
谢谢！

s*i2011-01-17 08:01

3 楼

这个题如果用iterative的方法，我觉得可以这么理解：
如果这个树是对称的，那么用对称的方法去遍历，一个是 parent-> left -> right，
另一个 parent-> right -> left，那么每一个node必须一样才能对称。
具体到实现，可以用DFS preorder traversal。最多两个stack够了。

true;

【在 a***e 的大作中提到】

: Symmetric Tree一开始又把题理解错了。后来弄了个recursion之后，写了如下这个冗
: 长的 iterative version. 后来看了别人写的发现用一个stack要简洁好多好多。估计
: 是same tree那道题偷了懒，没认真看iterative的做法。
: 请问怎么样才能想到比较简洁的答案呢？是不是还是得多练？
: 从2月中就断断续续的刷，151道做了77道，希望年底能搞完一遍。N年前的今天来到美
: 国，雄心壮志要当教授，开公司，现在备受打击后，只是很实际的希望找个喜欢的工作
: ，能够在不爽的时候快点离开！
: bool isSymmetric(TreeNode *root) {
: if (root==NULL||(root->left==NULL &&root->right==NULL)) return true;
:

h*e2011-01-17 08:01

4 楼

雅诗兰黛价钱可以接受吧
不觉得它的东西油的话如果年纪不大day wear plus可以试试看

【在 w*****9 的大作中提到】

: 如题，最近找工作还没找到，最好价钱实惠一些，像Sisley那些我有点承受不起
: 谢谢！

s*i2011-01-17 08:01

5 楼

recursive的话，下面这个解法更简洁些。
bool isSymmetric(Node n)
{
return isMirror(n, n);
}
bool isMirrow(Node left, Node right)
{
if(left == null && right == null) return true;
if(left == null || right == null) return false;
if(left.val != right.val) return false;
if(!isMirrow(left.left, right.right)) return false;
if(!isMirrow(left.right, right.left)) return false;
return true;
}

w*92011-01-17 08:01

6 楼

谢谢！其实用day wear plus 已经有两年，可是最近好像慢慢地不行，感觉不吸收，
也许是时候换一下别的。

【在 h***e 的大作中提到】

: 雅诗兰黛价钱可以接受吧
: 不觉得它的东西油的话如果年纪不大day wear plus可以试试看

y*n2011-01-17 08:01

7 楼

you are right, i didn't read carefully.

【在 s*i 的大作中提到】

: recursive的话，下面这个解法更简洁些。
: bool isSymmetric(Node n)
: {
: return isMirror(n, n);
: }
: bool isMirrow(Node left, Node right)
: {
: if(left == null && right == null) return true;
: if(left == null || right == null) return false;
: if(left.val != right.val) return false;

h*e2011-01-17 08:01

8 楼

换她二姐time zone?

【在 w*****9 的大作中提到】

: 谢谢！其实用day wear plus 已经有两年，可是最近好像慢慢地不行，感觉不吸收，
: 也许是时候换一下别的。

m*k2011-01-17 08:01

9 楼

return isMirror(n, n); ????
I guess you mean
return isMirror(n.left, n.right); 吧？though isMirror(n, n) works too.
>>if(!isMirrow(left.left, right.right)) return false;
>>if(!isMirrow(left.right, right.left)) return false;
>>return true;
return isMirrow(left.left, right.right) && isMirrow(left.right, right.left)

【在 s*i 的大作中提到】

w*92011-01-17 08:01

10 楼

试过sample, 太油

【在 h***e 的大作中提到】

: 换她二姐time zone?

g*32011-01-17 08:01

11 楼

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
struct TreeNodePair {
TreeNode *front;
TreeNode *rear;
TreeNodePair(TreeNode *front1, TreeNode *rear1) : front(front1), rear(
rear1){}
};
class Solution {
public:
bool isSymmetric(TreeNode *root) {
if(root == NULL) return true;
if((root->left == NULL && root->right != NULL) ||
(root->right == NULL && root->left != NULL))
return false;

if(root->left == NULL && root->right == NULL) return true;

queue myQueue;
myQueue.push(new TreeNodePair(root->left, root->right));
while(myQueue.size() > 0)
{
TreeNodePair* node = myQueue.front();
if(node->front != NULL && node->rear != NULL)
{
if(node->front->val != node->rear->val) return false;
myQueue.push(new TreeNodePair(node->front->left, node->rear-
>right));
myQueue.push(new TreeNodePair(node->front->right, node->rear
->left));
myQueue.pop();
}
else if(node->front == NULL && node->rear == NULL)
{
myQueue.pop();continue;
}
else
return false;
}
return true;
}
};