leetcode题解日练--2016.6.18

编程新手，尽量保证每天至少3道leetcode题，仅此记录学习的一些题目答案与思路，尽量用多种思路来分析解决问题，不足之处还望指出。

今日题目：1、判断是否3的次方；2、判断是否2的次方；3、丑数；4、去除排序链表中的重复元素;5、快乐数

326. Power of Three | Difficulty: Easy

Given an integer, write a function to determine if it is a power of three.
Follow up:
Could you do it without using any loop / recursion?
题意：给定一个整数，判断是不是3的次方，能否不用任何的循环与递归实现？
思路：
1、对输入的n进行判断，等于0返回false，如果不为0，每次对n%3进行判断，等于0说明能除尽，n=n/3，否则直接返回false，一直循环到n==1结束循环
代码：

class Solution {
public:
    bool isPowerOfThree(int n) {
        if (n==0)
            return false;
        while(n!=0)
        {
            if(n==1)
                return true;
            if(n%3!=0)
               return false;
             n/=3;
        }
        return true;
    }
};

结果：116ms Your runtime beats 99.59% of cppsubmissions.
2、首先用一段python代码求出最大的int型的3的次方数是1162261467

max_3  = 0
for i in range(32):
    if (3**i<2**32):
        max_3 = 3**i
print max_3

然后再判断输入的数是否能被1162261467整除即可。
代码：

class Solution {
public:
    bool isPowerOfThree(int n) {
        return n>0&&(1162261467 % n == 0);
    }
};

结果：132ms，Your runtime beats 78.27% of cppsubmissions.

231. Power of Two | Difficulty: Easy

Given an integer, write a function to determine if it is a power of two.
描述：给定一个整数，判断是不是2的次方。
思路：
1、当然可以和上题判断3的次方一样的做法，但是这里不妨利用下2的次方的规律，2的幂次的规律是展开成二进制只有一个1.例如2：10；4:100;8:1000等等，那么知道了这个规律很快就能写出代码了。
代码：

class Solution {
public:
    bool isPowerOfTwo(int n) {

        return ((n&n-1)==0&&n>0);
    }
};

8ms Your runtime beats 12.81% of cppsubmissions.

class Solution {
public:
    bool isPowerOfTwo(int n) {
        if (n==0)
            return false;
        while(n!=0)
        {
            if(n==1)
                return true;
            if(n%2!=0)
               return false;
             n/=2;
        }
        return true;
    }
};

8ms Your runtime beats 12.81% of cppsubmissions.

263. Ugly Number | Difficulty: Easy

Write a program to check whether a given number is an ugly number.

Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7.

Note that 1 is typically treated as an ugly number.
题意：丑数是指的素因子只包含2,3,5的正数，1是一个特殊的丑数，因为其不包含2、3、5。
思路：
1、每次去判断是否能被2、3、5之间的一个数整除，如果可以就更新num，如果不行就直接返回false；
代码：

class Solution {
public:
    bool isUgly(int num) {

        while(num>0)
        {
            if(num==1)
            return true;
            else if (num%2==0)
            num/=2;
            else if(num%3==0)
            num/=3;
            else if(num%5==0)
            num/=5;
            else
            return false;
        }
        return false;
    }
};

结果：8ms Your runtime beats 8.34% of cppsubmissions.

83. Remove Duplicates from Sorted List | Difficulty: Easy

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.
题意：给定一个排好序的链表，删除所有连续出现的重复值保证每个值只出现一次。
思路：
从头开始遍历链表，如果当前节点的值和下一个节点相等，那么直接将当前节点指向下一个节点的下一个节点，如果不相等，就将当前节点切换为下一个节点，直到最后一个NULL节点结束循环返回head。

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==NULL) return head;
        ListNode* pNode = head;
        while(pNode)
        {
            if(pNode->next&&pNode->next->val==pNode->val)
                pNode->next = pNode->next->next;
            else
                pNode = pNode->next;
        }
        return head;
    }
};

结果：16ms Your runtime beats 12.68% of cppsubmissions.

202. Happy Number | Difficulty: Easy

Write an algorithm to determine if a number is “happy”.

A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.

题意：将数字各位的平方相加，然后得到的相加之后再循环上一步操作，如果最后能等于1就是Happy Number，也存在不会停下的的可能。
思路：
1、首先，观察两个例子，一个是题目给的19->82->68->100->1->1->1……
另外一个不是Happy Number的数字 9->81->65->61->37->58->89->145->42->20->4->16->37->58，注意到这里58又进入到了循环，因此可以考虑设置两个指针，一快一慢，然后如果不是丑数，相遇的时候一定不是1，相反如果是丑数那么相遇一定是1。

class Solution {
public:
    int digitSquareSum(int n) 
    {
        int sum = 0, tmp;
        while (n) {
            tmp = n % 10;
            sum += tmp * tmp;
            n /= 10;
        }
        return sum;
    }

    bool isHappy(int n) {
        int slow, fast;
        slow = fast = n;
        do {
            slow = digitSquareSum(slow);
            fast = digitSquareSum(fast);
            fast = digitSquareSum(fast);
        } while(slow != fast);
        if (slow == 1) return 1;
        else return 0;
    }

};

结果：4ms Your runtime beats 41.98% of cppsubmissions.
2、
1 : 1
2 : 4 -> … -> 4
3 : 9 -> … -> 4
4 : 4 -> … -> 4
5 : 25 -> … -> 4
6 : 4 -> … -> 4
7 : 49 -> … -> 1
8 : 4 -> … -> 4
9 : 25 -> … -> 4

利用1-9中只有1和7是Happy Number这一条件，写出如下代码

class Solution {
public:
    bool isHappy(int n) {
    while(n>9){
        int next = 0;
        while(n){next+=(n%10)*(n%10); n/=10;}
        n = next;
    }
    return n==1||n==7;
} 
};

结果：0ms Your runtime beats 98.88% of cppsubmissions
3、用一个集合来存出现过的情况
class Solution {
public:
bool isHappy(int n) {
set s;
while (n != 1) {
int t = 0;
while (n) {
t += (n % 10) * (n % 10);
n /= 10;
}
n = t;
if (s.count(n)) break;
else s.insert(n);
}
return n == 1;
}
};
结果： 4ms Your runtime beats 41.98% of cppsubmissions.

参考资料
1、https://leetcode.com/discuss/33055/my-solution-in-c-o-1-space-and-no-magic-math-property-involved
2、http://www.cnblogs.com/grandyang/p/4447233.html