直线上最多的点数
给定一个二维平面,平面上有 n 个点,求最多有多少个点在同一条直线上。
示例 1:
输入: [[1,1],[2,2],[3,3]] 输出: 3 解释: ^ | | o | o | o +-------------> 0 1 2 3 4
示例 2:
输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]] 输出: 4 解释: ^ | | o | o o | o | o o +-------------------> 0 1 2 3 4 5 6
这道题的解题思路是利用斜率来判断两点在不在同一条直线上,时间复杂度为O(n2)。因为会有斜率为无穷大的情况(x值相等),所以判断dy和dx是否相等,dy和dx需要化简,求它们的公倍数。同时要考虑重复的点的情况。
class Solution {
public:
int maxPoints(vector<vector<int>>& points) {
int n = points.size();
int count = 0;
for(int i = 0; i < n; i++)
{
int duplicates = 1;
map<pair<int, int>, int> num;
for(int j = i + 1; j < n; j++)
{
if(points[i][0] == points[j][0] && points[i][1] == points[j][1])
{
duplicates++; //计算重复的点的个数
continue;
}
int dx = points[i][0] - points[j][0];
int dy = points[i][1] - points[j][1];
int d = gcd(dx, dy);//计算公倍数
num[{dy/d, dx/d}]++;
}
count = max(count, duplicates);
for(auto it = num.begin(); it != num.end(); it++)
{
count = max(count, it->second+duplicates);
}
}
return count;
}
int gcd(int a, int b)
{
return (b == 0) ? a : gcd(b, a % b);
}
};
分数到小数
给定两个整数,分别表示分数的分子 numerator 和分母 denominator,以字符串形式返回小数。
如果小数部分为循环小数,则将循环的部分括在括号内。
示例 1:
输入: numerator = 1, denominator = 2 输出: "0.5"
示例 2:
输入: numerator = 2, denominator = 1 输出: "2"
示例 3:
输入: numerator = 2, denominator = 3 输出: "0.(6)"
这道题的问题在于怎么去判断结果是不是无限循环小数,这里采用余数来判断,余数如果出现重复,就可以判断出现了无限循环小数。
class Solution {
public:
string fractionToDecimal(int numerator, int denominator) {
if(numerator==INT_MIN && denominator==-1)//边界条件,没法直接除,因为除完结果溢出
return "2147483648";
if(numerator==-1 && denominator==INT_MIN)//边界条件,都是int类型,没法除
return "0.0000000004656612873077392578125";
int div = numerator / denominator, remainder = numerator % denominator;
string ret = "";
if(double(numerator) / double(denominator) < 0)//两个数符号不相同
{
if(div == 0)//相除等于0,前面要加一个负号,大于0不用加
ret = '-' + to_string(div);
else
ret = to_string(div);
}
else//两个数符号相同
ret = to_string(div);
if(remainder == 0)//余数为0直接返回
return ret;
ret = ret + '.';
remainder = abs(remainder);
denominator = abs(denominator);
unordered_map<int, int> num;
num[remainder] = ret.size();//记录余数的位置
while(remainder != 0)//余数不为0继续除
{
remainder = remainder*10;
div = remainder / denominator;
remainder = remainder % denominator;
ret = ret + to_string(div);
if(num.count(remainder))//出现相同的余数,将小数点后的不循环的小数和
//循环的小数连起来
{
int start = num[remainder], end = ret.size();
ret = ret.substr(0, start) + '(' + ret.substr(start, end-start)+')';
return ret;
}
num[remainder] = ret.size();
}
return ret;
}
};
阶乘后的零
给定一个整数 n,返回 n! 结果尾数中零的数量。
示例 1:
输入: 3 输出: 0 解释: 3! = 6, 尾数中没有零。
示例 2:
输入: 5 输出: 1 解释: 5! = 120, 尾数中有 1 个零.
阶乘结尾的0的个数,要判断里面5的个数,同时要注意25有两个5,125有3个5,,,,一直叠加
class Solution {
public:
int trailingZeroes(int n) {
int count = 0;
for(long i = 5; i <= n; i=i*5)
{
count = count + n/i;
}
return count;
}
};
颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。
示例 1:
输入: 00000010100101000001111010011100 输出: 00111001011110000010100101000000 解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596, 因此返回 964176192,其二进制表示形式为 00111001011110000010100101000000。
示例 2:
输入:11111111111111111111111111111101 输出:10111111111111111111111111111111 解释:输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293, 因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。
使用位移,将数往右移i位(0<= i <= 31)和1相与,同时将结果左移 32-i 位 与结果相或。
class Solution {
public:
uint32_t reverseBits(uint32_t n) {
uint32_t result = 0;
for(int i = 0; i < 32;i++)
{
int temp = (n>>i) & 1;
if(temp)
result = result | (1 << (31-i));
}
return result;
}
};
位1的个数
编写一个函数,输入是一个无符号整数,返回其二进制表达式中数字位数为 ‘1’ 的个数(也被称为汉明重量)。
示例 1:
输入:00000000000000000000000000001011
输出:3
解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。
示例 2:
输入:00000000000000000000000010000000 输出:1 解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。
示例 3:
输入:11111111111111111111111111111101 输出:31 解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
for(int i = 0; i < 32; i++)
{
count += (n>>i) & 1;
}
return count;
}
};
计数质数
统计所有小于非负整数 n 的质数的数量。
示例:
输入: 10 输出: 4 解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
遍历,使用函数判断n是不是质数,同时将n的倍数设为非质数,超时了
class Solution {
public:
int countPrimes(int n) {
bool pArray[n + 1] = {0};
int cnt = 0;
for (int i = 2; i < n; ++i) {
if (!pArray[i] && isPrime(i)) {
++cnt;
for (int j = i; j < n; j += i) pArray[j] = true;
}
}
return cnt;
}
bool isPrime(int m) {
for (int i = 2; i <= sqrt(m); ++i) {
if (m % i == 0) return false;
}
return true;
}
};
第二种方法,使用埃拉托斯特尼筛法,我们从2开始遍历到根号n,先找到第一个质数2,然后将其所有的倍数全部标记出来,然后到下一个质数3,标记其所有倍数,一次类推,直到根号n,此时数组中未被标记的数字就是质数。我们需要一个n长度的bool型数组来记录每个数字是否被标记,长度为n的原因是题目说是小于n的质数个数,并不包括n。
class Solution {
public:
int countPrimes(int n)
{
int count = 0;
vector<bool> prime(n, true);
for(int i = 2; i < n; i++)
{
if(prime[i])
{
count++;
}
for(int j = 2; i*j < n ; j ++)
prime[i*j] = false;
}
return count;
}
};
缺失数字
给定一个包含 0, 1, 2, ..., n
中 n 个数的序列,找出 0 .. n 中没有出现在序列中的那个数。
示例 1:
输入: [3,0,1] 输出: 2
示例 2:
输入: [9,6,4,2,3,5,7,0,1] 输出: 8
class Solution {
public:
int missingNumber(vector<int>& nums) {
int n = nums.size();
int sum = 0;
for(int i = 0; i <= n; i++)
sum += i;
for(int i = 0; i < n; i++)
sum -= nums[i];
return sum;
}
};
3的幂
给定一个整数,写一个函数来判断它是否是 3 的幂次方。
示例 1:
输入: 27 输出: true
示例 2:
输入: 0 输出: false
示例 3:
输入: 9 输出: true
示例 4:
输入: 45 输出: false
使用循环或者递归
class Solution {
public:
bool isPowerOfThree(int n) {
if(n == 3 || n == 1)
return true;
else if(n > 3)
{
if(n % 3 == 0)
return isPowerOfThree(n/3);
else
return false;
}
return false;
}
};
class Solution {
public:
bool isPowerOfThree(int n) {
if(n < 1)
return false;
while(n > 1)
{
int remain = n % 3;
if(remain != 0)
return false;
n = n / 3;
}
return true;
}
};
第二种方法:使用对数,一个数是3的次方,那么以3为底n的对数一定是个整数。实现上可利用换底公示
class Solution {
public:
bool isPowerOfThree(int n) {
if(n < 1)
return false;
double temp = log10(n) / log10(3.0);
if(int(temp) - temp == 0)
return true;
return false;
}
};