## Wednesday, June 29, 2016

### LeetCode 367 - Valid Perfect Square

https://leetcode.com/problems/valid-perfect-square/
Given a positive integer num, write a function which returns True if num is a perfect square else False.
Note: Do not use any built-in library function such as `sqrt`.
Example 1:
```Input: 16
Returns: True
```
Example 2:

```Input: 14
Returns: False
```
X. Binary Search
https://www.hrwhisper.me/leetcode-valid-perfect-square/

public boolean isPerfectSquare(int num) {
long L = 1, R = (num >> 1) + 1;
while (L <= R) {
long  m = L + ((R - L) >> 1);
long  mul = m * m;
if (mul == num) return true;
else if (mul > num) R = m - 1;
else L = m + 1;
}
return false;
}
http://blog.csdn.net/u014688145/article/details/69388673

public boolean isPerfectSquare(int num) { if (num == 0) return false; int end = binarySearch(num, num); return end == -1 ? false : true; } private int binarySearch(int num, int target){ int lf = 1, rt = num; //闭区间 while (lf < rt){ int mid = lf + (rt - lf) / 2; //防止溢出 if (target / mid > mid){ lf = mid + 1; }else{ rt = mid; } } if (target % rt == 0 && target / rt == rt) return rt; return -1; }
http://blog.csdn.net/qq508618087/article/details/51762492
```    bool isPerfectSquare(int num) {
if(num < 1) return false;
if(num == 1) return true;
int left = 0, right = num/2;
while(left <= right)
{
long mid = (left+right)/2;
long val = mid*mid;
if(val == num) return true;
else if(val > num) right = mid-1;
else left = mid+1;
}
return false;
}
```
```    bool isPerfectSquare(int num) {
long left = 0, right = num;
while (left <= right) {
long mid = left + (right - left) / 2, t = mid * mid;
if (t == num) return true;
else if (t < num) left = mid + 1;
else right = mid - 1;
}
return false;
}```
X. Newton's method
long r = x; while (r*r > x) r = (r + x/r) / 2; return r*r == x;
Apparently, using only integer division for the Newton method works. And I guessed that if I start at x, the root candidate will decrease monotonically and never get too small.
int mySqrt(int x) { long long r = x; while (r*r > x) r = (r + x/r) / 2; return r; }

def isPerfectSquare(self, num): """ :type num: int :rtype: bool """ x = num while x * x > num: x = (x + num / x) / 2 return x * x == num
This is a math problem：
1 = 1
4 = 1 + 3
9 = 1 + 3 + 5
16 = 1 + 3 + 5 + 7
25 = 1 + 3 + 5 + 7 + 9
36 = 1 + 3 + 5 + 7 + 9 + 11
....
so 1+3+...+(2n-1) = (2n-1 + 1)n/2 = nn
public boolean isPerfectSquare(int num) { int i = 1; while (num > 0) { num -= i; i += 2; } return num == 0; }
Let x be the number of iterations needed to solve the problem, and let Σ be the sum from i = 1 to x. Σ(1 + 2i) = n => x + 2Σi = n => x + 2(x(x+1)) = n => 2x^2 + 3x = n => x = [-3 +/- sqrt(9 + 8n)]/4 => you can see that n is in a square root term, so the complexity should be O(sqrt(n)).

```    bool isPerfectSquare(int num) {
if (num == 1) return true;
long x = num / 2, t = x * x;
while (t > num) {
x /= 2;
t = x * x;
}
for (int i = x; i <= 2 * x; ++i) {
if (i * i == num) return true;
}
return false;
}```

```    bool isPerfectSquare(int num) {
for (int i = 1; i <= num / i; ++i) {
if (i * i == num) return true;
}
return false;
}```

https://leetcode.com/discuss/110659/o-1-time-c-solution-inspired-by-q_rsqrt
bool isPerfectSquare(int num) { if (num < 0) return false; int root = floorSqrt(num); return root * root == num; } int32_t floorSqrt(int32_t x) { double y=x; int64_t i=0x5fe6eb50c7b537a9; y = *(double*)&(i = i-(*(int64_t*)&y)/2); y = y * (3 - x * y * y) * 0.5; y = y * (3 - x * y * y) * 0.5; i = x * y + 1; return i - (i * i > x); }
From https://en.wikipedia.org/wiki/Fastinversesquare_root
The following code is the fast inverse square root implementation from Quake III Arena, stripped of C preprocessor directives, but including the exact original comment text:
`````` ...
i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
...``````