leetcode题解日练--2016.6.18

来源：互联网发布：华为媒体算法工程师编辑：程序博客网时间：2024/05/18 10:04

编程新手，尽量保证每天至少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  = 0for i in range(32):    if (3**i<2**32):        max_3 = 3**iprint 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<int> 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

0 0