【LeetCode】Math

[263] Ugly Number [Easy]

一个数的质因子只有2，3，5就叫丑数，写个函数判断丑数。

 //Author: Wanying
 //注意 0 和 1 的corner case， 你居然还没一次AC==
 //想好了再写，不然等着挂吧==！！！！！
 class Solution {
 public:
     bool isUgly(int num) {
         if (num ==  || num == ) {
             return num;
         }
         while(num %  == ) {
             num = num /  ;
         }
         while(num %  == ) {
             num = num / ;
         }
         while(num %  == ) {
             num = num / ;
         }
         return num == ;
     }
 };

[264] Ugly Number II [Medium]

第一个丑数是1，返回第n个丑数是多少。

思路：dp， 第u个丑数一定是 min(vec[idx2]*2, vec[idx3]*3, vec[idx5] *5） || 所以，要存idx2，idx3，idx5， 而且vec里面不能有重复的丑数.

 //Author: Wanying
 //DP: idx2, idx3, idx5

 class Solution {
 public:
     int nthUglyNumber(int n) {
         vector<int> vec(,);
         int idx2 = , idx3 = , idx5 = ;
         for(size_t i = ; i <= n; ++i) {
             int v2 = vec[idx2] * , v3 = vec[idx3] * , v5 = vec[idx5] * ;
             int ith = min(v2, min(v3, v5));
             if (ith == v2) {
                 idx2++;
             }
             if (ith == v3) {
                 idx3++;
             }
             if (ith == v5) {
                 idx5++;
             }
             vec.push_back(ith);
         }
         return vec[n-];
     }
 };

[313] Super Ugly Number [Medium]

跟Ugly Number II类似， 变化在于质因子不是[2,3,5]了，变成了透传进来的数组。 所以思路就从用3个idx变成了用一个数组的idx，其他一样，注意bug-free.

 //Author: Wanying
 class Solution {
 public:
     int nthSuperUglyNumber(int n, vector<int>& primes) {
         vector<int> idx(primes.size(), );
         vector<int> ans(, );
         for (size_t i = ; i <= n; ++i) {
             int ith = INT_MAX;
             for (int j = ; j < primes.size(); ++j) {
                 int tmp = ans[idx[j]] * primes[j];
                 ith = min(tmp, ith);
             }
             for (int j = ; j < primes.size(); ++j) {
                 int tmp = ans[idx[j]] * primes[j];
                 if (ith == tmp) {
                     idx[j] ++;
                 }
             }
             ans.push_back(ith);
         }
         return ans[n-];
     }
 };

[172] Factorial Trailing Zeroes [Easy]

给定一个数n， 求出n!中结尾0的个数。

考虑到造成结尾0的，只有5*2的倍数， 或者直接10， 100这种，所以，我们就用 n/5 得到n中5的个数，但是可能还有25,125这种含有不止一个5的情况，所以公式如下：

ans = n/5 + n/25 + n/125 + ......

n/5 是移除所有单个的5， n/25是移除多余的5， 同理.....

 /*
  *    Author: Wanying
  *    Language: C++
  *    Date: 2017/03/11
  *    考虑到25, 125 这种数字中不止一个5， 所以公式如下： ans = n/5 + n/25 + n/125 + ......
  *    n/5 是移除所有单个的5， n/25是移除多余的5， 同理.....
 */
 class Solution {
 public:
     int trailingZeroes(int n) {
         int ans = ;
         long long  x = ; //x一直乘5， int会溢出
         while (n >= x) {
             ans += n / x;
             x *= ;
             //cout << x << " ";
         }
         return ans;
     }
 };

[166] Fraction to Recurring Decimal [Medium]

给两个数，分别代表分子，分母，求小数的表示形式，可能有循环节

• Given numerator = 1, denominator = 2, return "0.5".
• Given numerator = 2, denominator = 1, return "2".
• Given numerator = 2, denominator = 3, return "0.(6)".

模拟竖式除法， 用个map记录循环节，还是不懂的话，自己在草稿纸上写个 3/444 你就懂了 ：）

注意corner case， int可能越界， 全用long long 表示

 /*
  * author: Wanying
  * Date: 2017/03/11
  * 思路就是模拟竖式除法，用个map记录循环节
  * company： google
 */

 class Solution {
 public:
     string fractionToDecimal(int numerator, int denominator) {
         long long n = numerator, d = denominator; //不能用int, corner case: n = INT_MIN, d = -1; 除完了越界
         string ans = "";
         if (n == ) return "";
         if (n <  ^ d < ) {
             ans += "-";
         }
         n = abs(n), d = abs(d);
         ans += to_string(n/d);
         //能整除直接返回整数部分
         if (n % d == ) {
             return ans;
         }
         ans += ".";
         long long r = (n % d);  // 余数也要用 long long, 不然(-1, -2147483648) 这组会溢出
         map<int, int> mp; //模拟竖式除法，找循环节
         while (r) {
             if (mp.count(r) > ) {
                 ans.insert(mp[r], "(");
                 ans += ")";
                 break;
             }
             mp[r] = ans.size();
             cout << r << " ";
             r *= ;
             ans += to_string(r/d);
             r = r % d;
         }
         return ans;
     }
 };